To make more clear that one formats and the other one only checks

Tests mostly imported from Alejandra

- Disallow single-line if statements
- Handle multi-line conditions differently (indent instead of absorb)

- The (from) case needs to be improved
- Somehow it indents the comments *after* the statement now, no idea why or how to fix

The file was identical to diff/idioms_nixos_1 and therefore redundant.
Moreover, we need to also keep a look on the *really* big packages in there,
and Mozilla is a prime example.

Except when that item is another list or attribute set

This is nixos/modules/services/web-apps/nextcloud.nix, so that we have a
big NixOS module in our suite

There is now the choice whether to pull whitespace just before/at the start of a group
in or out. This allows to fix an outstanding issue with inherit statements, and is also
used in the bindings format

They now get expanded and indented more liberally, with some exceptions.
Things still look weird at places because of parentheses formatting.

With a couple of exceptions, multiline parentheses are now
forced to start on the next line.

- Trailing commas were missing on parameters with default values
- Moving comments around to better migrate from leading-comma to trailing-comma style

Also make sure that comments do not accidentally force-expand expressions

- Nested operations don't get absorbed, start on new line instead
- First element of parenthesized operation is not absorbed anymore

If we know that there are going to be two arguments at most, using a more compact form is fine

Even if this is an "internal" error that requires users to file a bug report,
at the end there still will be some developer who has to debug it.
(It's me, I'm a developer who has to debug it)

- Introduced the concept of "priority" groups
  - If a group does not fit into one line but contains a priority group,
    try to expand that first and see how much fits into the line.
- Some whitespaces in groups are not automatically moved out anymore.
  - This allows us to drop the two boolean attributes on Group which previously
    controlled the move-in behavior.
  - This required some small fixes around existing code, who worked under the previous
    assumption of this not making any difference
  - To reduce error potential, groups are forbidden to start or end with whitespace.
    group' needs to be used as an opt-in instead.
- Refactored nesting indentation handling
  - This fixes the issue that indentation might be wrong if the indentation block
    ends with some newline whitespace. In that case, the token following it would
    get the indentation of the block, despite being outside of it.
  - This is solved by not applying indentation on newlines right away. Instead, that
    is deferred until actually writing the first token in that line. That way, we
    are guaranteed to use the correct indentation for that token.
- Those changes made the `moveLinesIn` method redundant, as the layouting algorithm
  now is powerful enough to properly work without that normalization step.

Performance impact has not been evaluated.

This is a no-op, but will make tracking changes of coming refactorings easier

- Parenthesized function applications with comments
- Operations with comments on the operator

Also apparently empty inherit statements are allowed in Nix and I hate everything about it

Mainly try to be smarter about comments around their start

even if all items would fit onto one line.
We already do so for lists and attribute sets with more than one element, so this is only consistent.
The motivation is to keep the line length and contraction at bay even with large maximum line sizes.
The limit of 3 was chosen imperically.

Because it contains some pretty nasty vertical alignment examples, which nixfmt does not deal with well currently.

If a supposedly trailing comment is directly followed by a line of same indentation,
treat it as part of that instead of as a trailing comment to the previous token.

When the function application hit exactly the line length limit, the closing
parenthesis or semicolon (depending on context) would be rendered weirdly onto
the next line.

This was looking especially weird with some kinds of strings

Since we don't enforce line limits on comments anyways, all they currently do is to
accidentally expand some content before them. This makes the code uglier, without meaningfully
reducing the line length in practice. Therefore, we are better of just ignoring them.

This makes that lines don't get squished more if they are indented more,
resulting in a more uniform look. Eventually, there should be a configurable
limit for ignoring indentation, to still have *some* bound on the line length.

It now also takes into account whether post fits onto a single line or not.
Previously this did not matter, as all instances only had whitespace in there,
so force-unexpanding worked as a hack. But now it is time to fully implement the feature.

No big changes to the layouting algorithm itself were made, however it needed to be
refactored such that the interface it provides only processes one item at a time.
(The algorithm already did that, it's just that the function always also processed the rest.)
This has been done by making use of the State monad.

This should cause no changes to the output format.

The existing special treatment of the entire operator got removed.
Instead, it is mostly treated like any other operator, except for a handful
of carefully picked special cases around binders.

We want trailing commas, but only in expanded argument lists.
This change allows us to do that.

Keep up to two arguments compact, which benefits a lot of small functions
operating on key-value pairs.

It is now even more powerful, although there is still a bit of room for improvement in the future.
In short, it defers merging spacing across group boundaries, allowing groups to start/end with spacing
even if the previous/next token is a whitespace too. Previously, they would get merged, causing weird results.

- Removed mergeSpacings', as it is not needed anymore
- Merged moveLinesOut and mergeSpacings into a single pass "fixup"
- layoutGreedy can now handle some consecutive spacings across group boundaries
  - It still does not handle all cases, only the ones needed for the current features.
    More will be added as needed.

Only place the semicolon onto a new line if the last expression
of the body is an if statement or an operator chain.

Instead of extracting comments from tokens with a lot of special cases, we now move them out of groups
as part of the fixup processing.
This fixes comment handling in all the remaining cases which were previously forgotten.

As was empirically determined in #3 and piegamesde/nixpkgs#3

It contains some good corner cases for function declarations with comments

This will be required for migrating some comments in function declarations

The previous code was missing quite a few important edge cases, now most should be handled

Interpolations in strings that are shorter than 30 characters will be rendered inline,
even if the string exeeds the line length limit.

Function applications up to two simple arguments are now
counted as "simple" and written on a single line

"Simple" function applications will always be rendered on a single line.

This is a manual partial revert of b86d8ea

The basic issue is that we must not emit a trailing comment at +2 of the current indentation.
This is because, that comment will then be parsed as a leading comment to the next line,
instead of a trailing comment to the current line, leading to a different output.

Input:

```nix
foo bar baz ( # comment
  b
)
```

Output 1:

```nix
foo
  bar
  baz
  ( # comment
    b
  )
```

Output 2:

```nix
foo
  bar
  baz
  (
    # comment
    b
  )
```

Simply guaranteeing that all comments will be moved up such that such an emission never happens is not feasible,
due to a large number of edge cases.

Instead, the currently implemented solution is to track trailing comments specially in the intermediate representation,
and let the renderer handle this. The render will check for such a situation, and insert an additional space to avoid it:

```nix
foo
  bar
  baz
  (  # comment
    b
  )
```

This may look ugly, but in real-world code it should be sufficiently rare. Most of the time, moving comments up already
happens and thus eliminates a lot of potential cases entirely. This is merely a fallback. Most of the time, the output
code will look like this instead:

```nix
foo
  bar
  baz
  # comment
  (b)
```

The double space before a trailing comment is most likely to occur with single-letter identifiers.

This reverts commit 206653b.

For some reasons instead of one condition it was split into two conditions, which covered everything necessery minus one edge case

- Bindings where the RHS is a parenthesized expression are now
  handled explicitly.
- Function argument default values now use the same logic as
  bindings, making it prettier and more consistent.
- Attribute sets in a `with` are now force-expanded in bindings.
  This is consistent with current attrset handling in bindings.
- Improved parenthesized with statements.

This should not change the output format

This allows force-compaction in more situations