Start formatting patterns and other related syntax. (#1165)

* Start formatting patterns and other related syntax.

I'm breaking this up into a series of PRs so it's not overwhelming.
Also, I'm going to merge these PRs into a separate "patterns" branch
until #1164 is resolved. That way, master isn't broken.

This first PR:

- Enables parsing patterns.
- Does some rudimentary formatting of constant patterns so that the
  existing switch tests don't break. I'll add more tests for constant
  patterns in a later PR.
- Formats if-case statements and elements.
- Formats logic, relational, and parenthesized patterns.

* Add missing override annotations.

* Update comments.

Author: munificent

lib/src/dart_formatter.dart

@@ -90,6 +90,10 @@ class DartFormatter {
     var featureSet = FeatureSet.fromEnableFlags2(
       sdkLanguageVersion: Version(2, 19, 0),
       flags: [
+        // TODO(rnystrom): This breaks existing switch cases containing constant
+        // expressions that aren't valid patterns. See:
+        // https://github.com/dart-lang/dart_style/issues/1164
+        'patterns',
         'records',
         'unnamed-libraries',
       ],

lib/src/source_visitor.dart

@@ -359,11 +359,10 @@ class SourceVisitor extends ThrowingAstVisitor {
     // appears before the first operand.
     builder.startLazyRule();
 
-    // Flatten out a tree/chain of the same precedence. If we split on this
-    // precedence level, we will break all of them.
+    // Flatten out a tree/chain of the same precedence. If we need to split on
+    // any of them, we split on all of them.
     var precedence = node.operator.type.precedence;
 
-    @override
     void traverse(Expression e) {
       if (e is BinaryExpression && e.operator.type.precedence == precedence) {
         traverse(e.leftOperand);
@@ -391,6 +390,46 @@ class SourceVisitor extends ThrowingAstVisitor {
     builder.endRule();
   }
 
+  @override
+  void visitBinaryPattern(BinaryPattern node) {
+    builder.startSpan();
+    builder.nestExpression(now: true);
+
+    // Start lazily so we don't force the operator to split if a line comment
+    // appears before the first operand.
+    builder.startLazyRule();
+
+    // Flatten out a tree/chain of the same precedence. If we need to split on
+    // any of them, we split on all of them.
+    var precedence = node.operator.type.precedence;
+
+    void traverse(DartPattern p) {
+      if (p is BinaryPattern && p.operator.type.precedence == precedence) {
+        traverse(p.leftOperand);
+
+        space();
+        token(p.operator);
+
+        split();
+        traverse(p.rightOperand);
+      } else {
+        visit(p);
+      }
+    }
+
+    // Blocks as operands to infix patterns should always nest like regular
+    // operands.
+    builder.startBlockArgumentNesting();
+
+    traverse(node);
+
+    builder.endBlockArgumentNesting();
+
+    builder.unnest();
+    builder.endSpan();
+    builder.endRule();
+  }
+
   @override
   void visitBlock(Block node) {
     // Treat empty blocks specially. In most cases, they are not allowed to
@@ -755,6 +794,12 @@ class SourceVisitor extends ThrowingAstVisitor {
     visit(node.uri);
   }
 
+  @override
+  void visitConstantPattern(ConstantPattern node) {
+    token(node.constKeyword, after: space);
+    visit(node.expression);
+  }
+
   @override
   void visitConstructorDeclaration(ConstructorDeclaration node) {
     visitMetadata(node.metadata);
@@ -1774,12 +1819,8 @@ class SourceVisitor extends ThrowingAstVisitor {
 
     var hasInnerControlFlow = false;
     for (var element in ifElements) {
-      // The condition.
-      token(element.ifKeyword);
-      space();
-      token(element.leftParenthesis);
-      visit(element.condition);
-      token(element.rightParenthesis);
+      _visitIfCondition(element.ifKeyword, element.leftParenthesis,
+          element.condition, element.caseClause, element.rightParenthesis);
 
       visitChild(element, element.thenElement);
       if (element.thenElement.isControlFlowElement) {
@@ -1822,13 +1863,8 @@ class SourceVisitor extends ThrowingAstVisitor {
 
   @override
   void visitIfStatement(IfStatement node) {
-    builder.nestExpression();
-    token(node.ifKeyword);
-    space();
-    token(node.leftParenthesis);
-    visit(node.condition);
-    token(node.rightParenthesis);
-    builder.unnest();
+    _visitIfCondition(node.ifKeyword, node.leftParenthesis, node.condition,
+        node.caseClause, node.rightParenthesis);
 
     void visitClause(Statement clause) {
       if (clause is Block || clause is IfStatement) {
@@ -2222,6 +2258,15 @@ class SourceVisitor extends ThrowingAstVisitor {
     token(node.rightParenthesis);
   }
 
+  @override
+  void visitParenthesizedPattern(ParenthesizedPattern node) {
+    builder.nestExpression();
+    token(node.leftParenthesis);
+    visit(node.pattern);
+    builder.unnest();
+    token(node.rightParenthesis);
+  }
+
   @override
   void visitPartDirective(PartDirective node) {
     _visitDirectiveMetadata(node);
@@ -2402,6 +2447,13 @@ class SourceVisitor extends ThrowingAstVisitor {
     });
   }
 
+  @override
+  void visitRelationalPattern(RelationalPattern node) {
+    token(node.operator);
+    space();
+    visit(node.operand);
+  }
+
   @override
   void visitRethrowExpression(RethrowExpression node) {
     token(node.rethrowKeyword);
@@ -2538,7 +2590,6 @@ class SourceVisitor extends ThrowingAstVisitor {
     token(node.colon);
 
     builder.indent();
-    // TODO(rnystrom): Allow inline cases?
     newline();
 
     visitNodes(node.statements, between: oneOrTwoNewlines);
@@ -2552,7 +2603,29 @@ class SourceVisitor extends ThrowingAstVisitor {
     token(node.colon);
 
     builder.indent();
-    // TODO(rnystrom): Allow inline cases?
+    newline();
+
+    visitNodes(node.statements, between: oneOrTwoNewlines);
+    builder.unindent();
+  }
+
+  @override
+  void visitSwitchPatternCase(SwitchPatternCase node) {
+    _visitLabels(node.labels);
+
+    token(node.keyword);
+    space();
+
+    builder.startBlockArgumentNesting();
+    builder.nestExpression();
+    visit(node.guardedPattern.pattern);
+    builder.unnest();
+    builder.endBlockArgumentNesting();
+
+    visit(node.guardedPattern.whenClause);
+    token(node.colon);
+
+    builder.indent();
     newline();
 
     visitNodes(node.statements, between: oneOrTwoNewlines);
@@ -2711,6 +2784,20 @@ 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();
@@ -3330,6 +3417,45 @@ class SourceVisitor extends ThrowingAstVisitor {
     builder.endRule();
   }
 
+  /// Visits the `if (<expr> [case <pattern> [when <expr>]])` header of an if
+  /// statement or element.
+  void _visitIfCondition(Token ifKeyword, Token leftParenthesis,
+      AstNode condition, CaseClause? caseClause, Token rightParenthesis) {
+    builder.nestExpression();
+    token(ifKeyword);
+    space();
+    token(leftParenthesis);
+
+    if (caseClause != null) {
+      // Wrap the rule for splitting before "case" around the value expression
+      // so that if the value splits, we split before "case" too.
+      builder.startRule();
+
+      // Nest the condition so that it indents deeper than the case clause.
+      builder.nestExpression();
+    }
+
+    visit(condition);
+
+    // If-case clause.
+    if (caseClause != null) {
+      split();
+      token(caseClause.caseKeyword);
+      space();
+      builder.startBlockArgumentNesting();
+      builder.nestExpression();
+      visit(caseClause.guardedPattern.pattern);
+      builder.unnest();
+      builder.endBlockArgumentNesting();
+      builder.endRule();
+      visit(caseClause.guardedPattern.whenClause);
+    }
+
+    token(rightParenthesis);
+    if (caseClause != null) builder.unnest();
+    builder.unnest();
+  }
+
   /// 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/patterns.stmt

@@ -0,0 +1,78 @@
+40 columns                              |
+>>> before first operand of logic
+if (obj case // c
+pattern || otherPattern) {;}
+<<<
+if (obj
+    case // c
+        pattern || otherPattern) {
+  ;
+}
+>>> before first operand of nested logic
+if (obj case pattern || // c
+otherPattern && thirdLongPattern) {;}
+<<<
+if (obj
+    case pattern || // c
+        otherPattern &&
+            thirdLongPattern) {
+  ;
+}
+>>> after left logic operand (looks weird, but user should move comment)
+if (obj case pattern // c
+|| otherPattern) {;}
+<<<
+if (obj
+    case pattern // c
+        ||
+        otherPattern) {
+  ;
+}
+>>> after logic operator
+if (obj case pattern || // c
+otherPattern) {;}
+<<<
+if (obj
+    case pattern || // c
+        otherPattern) {
+  ;
+}
+>>> after right logic operand
+if (obj case somePattern || otherPattern // c
+) {;}
+<<<
+if (obj
+    case somePattern ||
+        otherPattern // c
+    ) {
+  ;
+}
+>>> after relational operator
+if (obj case <= // c
+someConstant + anotherLongConstant) {;}
+<<<
+if (obj
+    case <= // c
+        someConstant +
+            anotherLongConstant) {
+  ;
+}
+>>> after relational operand
+if (obj case <= someConstant + anotherLongConstant // c
+) {;}
+<<<
+if (obj
+    case <= someConstant +
+        anotherLongConstant // c
+    ) {
+  ;
+}
+>>> inside parenthesized
+if (obj case ( // c
+pattern)) {;}
+<<<
+if (obj
+    case ( // c
+        pattern)) {
+  ;
+}