Partial file formatting?

[rpost]

Hi there!

Does topiary allow formatting only part of the file? I mean something like enumeration of line ranges. I find such feature of formatter especially useful in context of legacy projects where it allows to gradually reformat content as it is changed: only vcs alterd lines are formatted each commit. Something known for Eclipse users as:

Of course I'm not expecting vcs integration to check for changed lines - just additional argument with line ranges to take into account.

[Xophmeister]

Topiary works by formatting known subtrees, per the language's grammar, which won't necessarily correspond with line ranges. For example, consider the following:

1 | if x
2 |   then
3 |     (if y then a else b)
4 |   else c

The formatting of lines 2-4 depend on the context introduced in line 1. As such, at the very least, such a functionality would have to ascend the tree. My gut feeling is that the answer to "how far up the tree will it need go?" will be arbitrary. For example, L3 in the above, in isolation, takes its indentation ultimately from the if on L1 and the fact that there's a line break after the then on L2; if that if were within some other block, Topiary would have to ascend to the next parent to get the indentation right, etc., etc.

Maybe an option would be:

1. Parse all the way from the root node (i.e., per the model outlined in my previous paragraph: ascend to the top from the range of interest).
2. Generate the appropriate formatting for every matching subtree up to the end of the intersecting line range.
3. Only apply the formatting against the nodes whose original coordinates (i.e., before formatting) are within that range.

In the pathological case -- where the line range is the last line in a file -- Topiary would generate the formatting for the entire file and throw almost all of it away. Regardless, it feels like a wasteful operation.

I assume this option exists in Eclipse for legacy reasons; when formatting an entire file could take some time. Given that Topiary is relatively fast, outside its startup overhead (which we're thinking of ways to mitigate), I'm not sure this achieves much. That said, I understand your use-case and, on top of that, the same mechanism could be used to achieve incremental formatting, which is another point that's come up (but I can't find the issue/discussion now 😅)

It would be interesting to know how Eclipse does this; maybe it can be done without wasting so much effort. (Or, maybe, given how fast formatting tends to be, that wasted effort isn't worth worrying about!)

Other thoughts, @tweag/topiary-core-team?

[nbacquey]

Unfortunately @Xophmeister, I think even the option you're suggesting would introduce problems: "belonging to a given line" is a property that isn't preserved by formatting. For example, consider the following incorrectly formatted code:

1 | if x then
2 |     foo
3 |   else bar

Assume the correctly formatted version is:

1 | if x
2 |   then foo
3 |   else bar

What would it mean to format only line 2? If we're naive about this and use the method above, it would give us something like:

1 | if x then
2 |   then foo
3 |   else bar

That's not even valid code. I suppose we could do something like formatting the smallest subset of lines containing the input range, whose content is preserved by formatting. I'm not even sure that can be properly defined, though.