Format switch expressions, guards, and patterns in switches. (#1174)

* Format object patterns, const constructors, and constant expressions.

The latter two were already implemented as part of keeping the existing
switch tests passing, but this adds tests for their splitting and
other behavior.

For object patterns, I had to decide whether to split them like
collections (like other patterns) or like argument lists (which they
mirror). I went collection-like because they will appear mixed with
other patterns. Also, if we migrate to a consistent flutter-like style
at some point, it will be one less thing to change.

Let me know what you think.

* Format patterns in variables, assignments, and for loops.

* Format switch expressions, guards, and patterns in switches.

This also changes how regular cases in switch statements are formatted.
Previously, a case's body was always moved to the next line:

    switch (obj) {
      case 1:
        body;
      case 2:
        body;
    }

I honestly never really loved that style, but it worked OK. With
switch expressions, it obviously makes sense to keep the expression
inline if it fits:

    switch (obj) {
      1 => body,
      2 => body
    }

I think people will generally prefer that style. I don't want them to
use a switch expression where all they need is a switch statement just
because it fits tighter, so I also allow switch statement case bodies
to go next to the case if they fit now:

    switch (obj) {
      case 1: body;
      case 2: body;
    }

I think this will be nice, especially since switch statements will
likely become more common.

Guards appear in three place: switch statement cases, switch expression
cases, and if-case statements. There is little code reuse for how they
are formatted in those three contexts. This is unfortunate, but
deliberate. The indentation rules for guards are slightly different in
all of those places because the surrounding context is different. I
tried to make each context look as best as I could, which leads to
unique formatting in each.

Author: munificent

CHANGELOG.md

@@ -1,6 +1,7 @@
 # 2.2.5-dev
 
 * Format patterns and related features.
+* Allow switch statement case bodies on the same line as the case.
 * Don't split after `<` in collection literals.
 * Format record expressions and record type annotations.
 * Better indentation of multiline function types inside type argument lists. 

lib/src/nesting_builder.dart

@@ -80,10 +80,10 @@ class NestingBuilder {
     assert(_pendingNesting == null);
     assert(_nesting.indent == 0);
 
+    _stack.removeLast();
+
     // If this fails, an unindent() call did not have a preceding indent() call.
     assert(_stack.isNotEmpty);
-
-    _stack.removeLast();
   }
 
   /// Begins a new expression nesting level [indent] deeper than the current

lib/src/source_visitor.dart

@@ -1482,7 +1482,7 @@ class SourceVisitor extends ThrowingAstVisitor {
     builder.endRule();
     builder.unnest();
 
-    builder.nestExpression(indent: 2, now: true);
+    builder.nestExpression(indent: Indent.block, now: true);
 
     if (isSpreadBody) {
       space();
@@ -2747,73 +2747,147 @@ class SourceVisitor extends ThrowingAstVisitor {
   }
 
   @override
-  void visitSwitchCase(SwitchCase node) {
-    _visitLabels(node.labels);
-    token(node.keyword);
-    space();
-    visit(node.expression);
-    token(node.colon);
+  void visitSwitchExpression(SwitchExpression node) {
+    // Start the rule for splitting between the cases before the value. That
+    // way, if the value expression splits, the cases do too. Avoids:
+    //
+    //     switch ([
+    //        element,
+    //     ]) { inline => caseBody };
+    builder.startRule();
 
-    builder.indent();
-    newline();
+    _visitSwitchValue(node.switchKeyword, node.leftParenthesis, node.expression,
+        node.rightParenthesis);
 
-    visitNodes(node.statements, between: oneOrTwoNewlines);
-    builder.unindent();
+    token(node.leftBracket);
+    builder = builder.startBlock(space: true);
+
+    visitCommaSeparatedNodes(node.cases, between: split);
+
+    var hasTrailingComma = node.cases.last.commaAfter != null;
+    _endBody(node.rightBracket, forceSplit: hasTrailingComma);
   }
 
   @override
-  void visitSwitchDefault(SwitchDefault node) {
-    _visitLabels(node.labels);
-    token(node.keyword);
-    token(node.colon);
+  void visitSwitchExpressionCase(SwitchExpressionCase node) {
+    // Wrap the rule for splitting after "=>" around the pattern so that a
+    // split in the pattern forces the expression to move to the next line too.
+    builder.startLazyRule();
 
-    builder.indent();
-    newline();
+    // Wrap the expression's nesting around the pattern too so that a split in
+    // the pattern is indented farther then the body expression. Used +2 indent
+    // because switch expressions are block-like, similar to how we split the
+    // bodies of if and for elements in collections.
+    builder.nestExpression(indent: Indent.block);
 
-    visitNodes(node.statements, between: oneOrTwoNewlines);
-    builder.unindent();
+    var whenClause = node.guardedPattern.whenClause;
+    if (whenClause == null) {
+      visit(node.guardedPattern.pattern);
+    } else {
+      // Wrap the when clause rule around the pattern so that if the pattern
+      // splits then we split before "when" too.
+      builder.startRule();
+      builder.nestExpression(indent: Indent.block);
+      visit(node.guardedPattern.pattern);
+      split();
+      builder.startBlockArgumentNesting();
+      _visitWhenClause(whenClause);
+      builder.endBlockArgumentNesting();
+      builder.unnest();
+      builder.endRule();
+    }
+
+    space();
+    token(node.arrow);
+    split();
+
+    builder.endRule();
+
+    visit(node.expression);
+    builder.unnest();
   }
 
   @override
-  void visitSwitchPatternCase(SwitchPatternCase node) {
-    _visitLabels(node.labels);
+  void visitSwitchStatement(SwitchStatement node) {
+    _visitSwitchValue(node.switchKeyword, node.leftParenthesis, node.expression,
+        node.rightParenthesis);
+    _beginBody(node.leftBracket);
 
-    token(node.keyword);
-    space();
+    for (var member in node.members) {
+      // If the case pattern and body don't contain any splits, then we allow
+      // the entire case on one line:
+      //
+      //     switch (obj) {
+      //       case 1:
+      //       case 2: print('one or two');
+      //       default: print('other');
+      //     }
+      //
+      // We wrap the rule for this around the entire case so that a split in
+      // the pattern or the case statement forces splitting after the ":" too.
+      builder.startLazyRule();
 
-    builder.indent();
-    builder.startBlockArgumentNesting();
-    builder.nestExpression();
-    visit(node.guardedPattern.pattern);
-    builder.unnest();
-    builder.endBlockArgumentNesting();
-    builder.unindent();
+      _visitLabels(member.labels);
+      token(member.keyword);
 
-    visit(node.guardedPattern.whenClause);
-    token(node.colon);
+      if (member is SwitchCase) {
+        space();
+        visit(member.expression);
+      } else if (member is SwitchPatternCase) {
+        space();
 
-    builder.indent();
-    newline();
+        var whenClause = member.guardedPattern.whenClause;
+        if (whenClause == null) {
+          builder.indent();
+          visit(member.guardedPattern.pattern);
+          builder.unindent();
+        } else {
+          // Wrap the when clause rule around the pattern so that if the pattern
+          // splits then we split before "when" too.
+          builder.startRule();
+          builder.nestExpression();
+          builder.startBlockArgumentNesting();
+          visit(member.guardedPattern.pattern);
+          split();
+          _visitWhenClause(whenClause);
+          builder.endBlockArgumentNesting();
+          builder.unnest();
+          builder.endRule();
+        }
+      }
 
-    visitNodes(node.statements, between: oneOrTwoNewlines);
-    builder.unindent();
+      token(member.colon);
+
+      if (member.statements.isNotEmpty) {
+        builder.indent();
+        split();
+        visitNodes(member.statements, between: oneOrTwoNewlines);
+        builder.unindent();
+        oneOrTwoNewlines();
+      } else {
+        // Don't preserve blank lines between empty cases.
+        newline();
+      }
+
+      builder.endRule();
+    }
+
+    newline();
+    _endBody(node.rightBracket, forceSplit: true);
   }
 
-  @override
-  void visitSwitchStatement(SwitchStatement node) {
+  /// Visits the `switch (expr)` part of a switch statement or expression.
+  void _visitSwitchValue(Token switchKeyword, Token leftParenthesis,
+      Expression value, Token rightParenthesis) {
     builder.nestExpression();
-    token(node.switchKeyword);
+    token(switchKeyword);
     space();
-    token(node.leftParenthesis);
+    token(leftParenthesis);
     soloZeroSplit();
-    visit(node.expression);
-    token(node.rightParenthesis);
+    visit(value);
+    token(rightParenthesis);
     space();
     builder.unnest();
-
-    _beginBody(node.leftBracket);
-    visitNodes(node.members, between: oneOrTwoNewlines, after: newline);
-    _endBody(node.rightBracket, forceSplit: true);
   }
 
   @override
@@ -2951,20 +3025,6 @@ class SourceVisitor extends ThrowingAstVisitor {
     });
   }
 
-  @override
-  void visitWhenClause(WhenClause node) {
-    builder.startRule();
-    split();
-    token(node.whenKeyword);
-    space();
-    builder.startBlockArgumentNesting();
-    builder.nestExpression();
-    visit(node.expression);
-    builder.unnest();
-    builder.endBlockArgumentNesting();
-    builder.endRule();
-  }
-
   @override
   void visitWhileStatement(WhileStatement node) {
     builder.nestExpression();
@@ -3644,19 +3704,20 @@ class SourceVisitor extends ThrowingAstVisitor {
     space();
     token(leftParenthesis);
 
-    if (caseClause != null) {
+    if (caseClause == null) {
+      // Simple if with no "case".
+      visit(condition);
+    } else {
+      // If-case.
+
       // Wrap the rule for splitting before "case" around the value expression
       // so that if the value splits, we split before "case" too.
-      builder.startRule();
+      var caseRule = Rule();
+      builder.startRule(caseRule);
 
-      // Nest the condition so that it indents deeper than the case clause.
-      builder.nestExpression();
-    }
-
-    visit(condition);
+      visit(condition);
 
-    // If-case clause.
-    if (caseClause != null) {
+      // "case" and pattern.
       split();
       token(caseClause.caseKeyword);
       space();
@@ -3665,15 +3726,34 @@ class SourceVisitor extends ThrowingAstVisitor {
       visit(caseClause.guardedPattern.pattern);
       builder.unnest();
       builder.endBlockArgumentNesting();
-      builder.endRule();
-      visit(caseClause.guardedPattern.whenClause);
+
+      builder.endRule(); // Case rule.
+
+      var whenClause = caseClause.guardedPattern.whenClause;
+      if (whenClause != null) {
+        // Wrap the rule for "when" around the guard so that a split in the
+        // guard splits at "when" too.
+        builder.startRule();
+        split();
+        builder.startBlockArgumentNesting();
+        builder.nestExpression();
+        _visitWhenClause(whenClause);
+        builder.unnest();
+        builder.endBlockArgumentNesting();
+        builder.endRule(); // Guard rule.
+      }
     }
 
     token(rightParenthesis);
-    if (caseClause != null) builder.unnest();
     builder.unnest();
   }
 
+  void _visitWhenClause(WhenClause whenClause) {
+    token(whenClause.whenKeyword);
+    space();
+    visit(whenClause.expression);
+  }
+
   /// Writes the separator between a type annotation and a variable or
   /// parameter. If the preceding type annotation ends in a delimited list of
   /// elements that have block formatting, then we don't split between the

test/comments/statements.stmt

@@ -75,41 +75,4 @@ main() {
 <<<
 main() {
   while (b) /*unreachable*/ {}
-}
->>> blank lines before comments in switch
-main() {
-  switch (n) {
-
-
-    // comment
-    case 0:
-
-
-
-    // comment
-
-
-
-    case 1:
-      ;
-
-
-    // comment
-
-
-  }
-}
-<<<
-main() {
-  switch (n) {
-    // comment
-    case 0:
-
-    // comment
-
-    case 1:
-      ;
-
-    // comment
-  }
 }