Accept a set of line ranges to format

[kamalmarhubi]

rustfmt should accept a set of line ranges, and would restrict reformatting to code in those ranges.

Motivation: it should be possible to format new or modified code without needing to format an entire file. This helps both projects adding rustfmt to their process, as well projects—or rustfmt itself—changing style configuration. Keeping formatting changes localized to actual code changes can make code review and history inspection easier.

A way to specify lines would allow formatting a patch by parsing diff output. Examples for other format tools: clang-format-diff, google-java-format-diff.

[kamalmarhubi]

Thinking in terms of implementation, a first attempt could be as simple as only formatting nodes if their Span lies entirely within one of the specified ranges.

This will have some issues with AST nodes that cross a boundary, such as adding an argument to a multiline function declaration: this approach wouldn't reformat the declaration, even though that would be desirable. It should be possible to identify all the node types that should be formatted if they cross a specified range.

[kamalmarhubi]

One thing that I'm a little unsure of: the design document says

Eventually, we should reformat everything and we shouldn't need the visit module.

My imagined implementation involves either changing the current visitor to skip subtrees that fall outside the range, or having a first visit pass that collects all nodes to be formatted. What would the rustfmt implementation without a visitor look like? Would that push this choice in either direction?

[nrc]

This would not be too hard - the easy way to implement would be to take the snippet for the span of the range (or get the text directly from the source file) and then parse it. Then replace the range with the parsed and formatted output.

The hardest bit of this is not dropping in to submodules, but there is a separate isssue for that, so if it gets fixed it would just be setting a flag. In any case, fixing that is not too hard (we used to do it all the time!).

The downside of this approach is if the range doesn't parse perfectly then rustfmt will fail.

I'm not sure if we will in fact dump the visitor. We are nearly complete and still use it. I don't think it would affect the design of this feature either way though.

[kamalmarhubi]

This would not be too hard - the easy way to implement would be to take the snippet for the span of the range (or get the text directly from the source file) and then parse it. Then replace the range with the parsed and formatted output.
[...]
The downside of this approach is if the range doesn't parse perfectly then rustfmt will fail.

Looking at a quick sample of recent commits on this project, most have ranges that straddle syntactic elements. So I'm not sure how well that would work. Or am I misunderstanding?

[nrc]

Hmm, that is a little trickier than I was imagining. I guess you would have an initial rounding out phase where you look at the AST for the file and try to find the smallest item which entirely includes the requested span, then you reformat just that item, replacing the rounded out span. This shouldn't be too hard and because the AST is ordered by span start point, could be very quick.

[kamalmarhubi]

Even there I think there could be issues. A range that spans two top level items could result in the entire module being reformatted.

[nrc]

That seems not too bad - it shouldn't happen very often and it's not the end of the world if it does. Given that we must do something like this, I think it's an acceptable trade-off.

[kamalmarhubi]

I'm working on this at the moment :-)