Recursive Topiary call until fixed point is reached

[nbacquey]

Hey folks!
Yesterday on Discord, we discussed the possibility of having a new, optional execution mode to Topiary, in which idempotency would not be checked, but instead we would recursively call Topiary on its own output, until a fixed point is reached (or some hardcoded limit is hit).

The rationale is that some "natural" formatting operations are not possible with Topiary's current semantics, due to the locality of the tree-sitter queries, but would be possible with the execution mode I described above. It would be an escape hatch, and could be very costly in worst-case scenarios (e.g. formatting loops), but it shouldn't be very costly to implement.

For the record, the use case we discussed was something like the following:

(foo (foo (bar baz qux)))

The problem was that foos are supposed to be followed with a softline, while bars are supposed to be followed by a hardline.
Ideally, the code above would be formatted as:

(foo
  (foo
    (bar
      baz
      qux)))

The rules that immediately come to mind don't work:

(foo
  (_) @prepend_softline
)

(bar
  (_) @prepend_hardline
)

Indeed, on the first pass the softlines wouldn't get expanded, and the result would be

(foo (foo (bar
      baz
      qux)))

The formatting would only be correct after the second pass.

I believe there currently is no way for Topiary to get the correct result in one pass, nor do I see any easy addition/modification to the engine to make it possible.

Do you have opinions on the matter?

[nbacquey]

See also #1073 for additional examples and context