Patterns: initial parser support.

The parser now supports the following subset of the parser grammar:

- logical-or and logical-and patterns (called "binary patterns" to
  reflect analyzer nomenclature)

- extractor patterns

- cast patterns

- list patterns

- map patterns

- null-assert patterns

- null-check patterns

- variable patterns where the variable is preceded by `var`, `final`,
  <type>, or `final <type>`

- if-case statements (and if-case within collections); without guards

- record patterns

- parenthesized patterns

- constant patterns where the constant is a plain expression not
  beginning with `const` (booleanLiteral, nullLiteral, numericLiteral,
  stringLiteral, identifier, or qualifiedName).

- relational patterns

- patterns in switch statements

- integration with the analyzer's AstBuilder class

Not implemented yet:

- constant patterns beginning with `const`

- variable patterns where the variable is a single identifier (note:
  this means that `_` is currently interpreted as a constant pattern
  rather than a "wildcard" variable pattern)

- guards (a.k.a. "when clauses")

- switch expressions

- pattern variable declarations

- patterns appearing in "for loop parts"

- pattern assignment

- several error checking and error recovery scenarios (see TODO
  comments)

- integration with the front_end's BodyBuilder class

- front_end style parser tests (currently the feature is tested using
  analyzer unit tests only)

Note that in patterns, `as` binds has higher precedence than `&` and
`|`, whereas in expressions, `&` and `|` have higher precedence than
`as`.  To reflect this, a new precedence has been added,
CAST_PATTERN_PRECEDENCE.

To reduce the risk to users during parser development, the parser
currently only attempts to parse patterns when instructed to do so
(i.e. when the language feature is enabled).  In the long term, I
intend to change the parser so that it always attempts to parse
patterns, and it is the responsibility of its listener to report
errors if patterns are used without enabling the language feature.

Change-Id: I360b535d2a6ebd35a0ee4d066b06e3ae8e3121ef
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/261020
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Jens Johansen <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/parser/class_member_parser.dart

@@ -45,7 +45,8 @@ class ClassMemberParser extends Parser {
   // This method is overridden for two reasons:
   // 1. Avoid generating events for arguments.
   // 2. Avoid calling skip expression for each argument (which doesn't work).
-  Token parseArgumentsOpt(Token token) => skipArgumentsOpt(token);
+  Token parseArgumentsOpt(Token token, {bool forPattern = false}) =>
+      skipArgumentsOpt(token);
 
   Token parseFunctionBody(Token token, bool isExpression, bool allowAbstract) {
     return skipFunctionBody(token, isExpression, allowAbstract);

pkg/_fe_analyzer_shared/lib/src/parser/forwarding_listener.dart

@@ -35,6 +35,11 @@ class ForwardingListener implements Listener {
     listener?.beginBinaryExpression(token);
   }
 
+  @override
+  void beginBinaryPattern(Token token) {
+    listener?.beginBinaryPattern(token);
+  }
+
   @override
   void beginBlock(Token token, BlockKind blockKind) {
     listener?.beginBlock(token, blockKind);
@@ -522,6 +527,12 @@ class ForwardingListener implements Listener {
     listener?.endArguments(count, beginToken, endToken);
   }
 
+  @override
+  void handleExtractorPatternFields(
+      int count, Token beginToken, Token endToken) {
+    listener?.handleExtractorPatternFields(count, beginToken, endToken);
+  }
+
   @override
   void endAssert(Token assertKeyword, Assert kind, Token leftParenthesis,
       Token? commaToken, Token semicolonToken) {
@@ -539,6 +550,11 @@ class ForwardingListener implements Listener {
     listener?.endBinaryExpression(token);
   }
 
+  @override
+  void endBinaryPattern(Token token) {
+    listener?.endBinaryPattern(token);
+  }
+
   @override
   void handleEndingBinaryExpression(Token token) {
     listener?.handleEndingBinaryExpression(token);
@@ -1254,6 +1270,11 @@ class ForwardingListener implements Listener {
     listener?.handleAsOperator(operator);
   }
 
+  @override
+  void handleCastPattern(Token operator) {
+    listener?.handleCastPattern(operator);
+  }
+
   @override
   void handleAssignmentExpression(Token token) {
     listener?.handleAssignmentExpression(token);
@@ -1561,11 +1582,21 @@ class ForwardingListener implements Listener {
     listener?.handleLiteralList(count, beginToken, constKeyword, endToken);
   }
 
+  @override
+  void handleListPattern(int count, Token beginToken, Token endToken) {
+    listener?.handleListPattern(count, beginToken, endToken);
+  }
+
   @override
   void handleLiteralMapEntry(Token colon, Token endToken) {
     listener?.handleLiteralMapEntry(colon, endToken);
   }
 
+  @override
+  void handleMapPatternEntry(Token colon, Token endToken) {
+    listener?.handleMapPatternEntry(colon, endToken);
+  }
+
   @override
   void handleLiteralNull(Token token) {
     listener?.handleLiteralNull(token);
@@ -1585,6 +1616,11 @@ class ForwardingListener implements Listener {
         count, leftBrace, constKeyword, rightBrace, hasSetEntry);
   }
 
+  @override
+  void handleMapPattern(int count, Token leftBrace, Token rightBrace) {
+    listener?.handleMapPattern(count, leftBrace, rightBrace);
+  }
+
   @override
   void handleMixinHeader(Token mixinKeyword) {
     listener?.handleMixinHeader(mixinKeyword);
@@ -1600,6 +1636,11 @@ class ForwardingListener implements Listener {
     listener?.handleNamedArgument(colon);
   }
 
+  @override
+  void handlePatternField(Token? colon) {
+    listener?.handlePatternField(colon);
+  }
+
   @override
   void handleNamedRecordField(Token colon) {
     listener?.handleNamedRecordField(colon);
@@ -1680,6 +1721,21 @@ class ForwardingListener implements Listener {
     listener?.handleNonNullAssertExpression(bang);
   }
 
+  @override
+  void handleNullAssertPattern(Token bang) {
+    listener?.handleNullAssertPattern(bang);
+  }
+
+  @override
+  void handleNullCheckPattern(Token question) {
+    listener?.handleNullCheckPattern(question);
+  }
+
+  @override
+  void handleVariablePattern(Token? keyword, Token variable) {
+    listener?.handleVariablePattern(keyword, variable);
+  }
+
   @override
   void handleNoType(Token lastConsumed) {
     listener?.handleNoType(lastConsumed);
@@ -1716,8 +1772,8 @@ class ForwardingListener implements Listener {
   }
 
   @override
-  void handleParenthesizedCondition(Token token, [Token? case_]) {
-    listener?.handleParenthesizedCondition(token);
+  void handleParenthesizedCondition(Token token, Token? case_) {
+    listener?.handleParenthesizedCondition(token, case_);
   }
 
   @override
@@ -1730,11 +1786,32 @@ class ForwardingListener implements Listener {
     listener?.endRecordLiteral(token, count, constKeyword);
   }
 
+  @override
+  void handleRecordPattern(Token token, int count) {
+    listener?.handleRecordPattern(token, count);
+  }
+
   @override
   void endParenthesizedExpression(Token token) {
     listener?.endParenthesizedExpression(token);
   }
 
+  @override
+  void handleParenthesizedPattern(Token token) {
+    listener?.handleParenthesizedPattern(token);
+  }
+
+  @override
+  void handleConstantPattern(Token? constKeyword) {
+    listener?.handleConstantPattern(constKeyword);
+  }
+
+  @override
+  void handleExtractorPattern(
+      Token firstIdentifier, Token? dot, Token? secondIdentifier) {
+    listener?.handleExtractorPattern(firstIdentifier, dot, secondIdentifier);
+  }
+
   @override
   void handleQualified(Token period) {
     listener?.handleQualified(period);
@@ -1839,6 +1916,11 @@ class ForwardingListener implements Listener {
     listener?.handleUnaryPrefixExpression(token);
   }
 
+  @override
+  void handleRelationalPattern(Token token) {
+    listener?.handleRelationalPattern(token);
+  }
+
   @override
   void handleUnescapeError(
       Message message, Token location, int offset, int length) {

pkg/_fe_analyzer_shared/lib/src/parser/listener.dart

@@ -52,6 +52,13 @@ class Listener implements UnescapeErrorListener {
     logEvent("Arguments");
   }
 
+  /// Called after the parser has consumed a sequence of patternFields that
+  /// forms the arguments to an extractorPattern
+  void handleExtractorPatternFields(
+      int count, Token beginToken, Token endToken) {
+    logEvent("ExtractorPatternFields");
+  }
+
   /// Handle async modifiers `async`, `async*`, `sync`.
   void handleAsyncModifier(Token? asyncToken, Token? starToken) {
     logEvent("AsyncModifier");
@@ -976,6 +983,12 @@ class Listener implements UnescapeErrorListener {
     logEvent("LiteralMapEntry");
   }
 
+  /// Called after the parser has consumed a mapPatternEntry, consisting of an
+  /// expression, a colon, and a pattern.
+  void handleMapPatternEntry(Token colon, Token endToken) {
+    logEvent("MapPatternEntry");
+  }
+
   void beginLiteralString(Token token) {}
 
   void handleInterpolationExpression(Token leftBracket, Token? rightBracket) {}
@@ -1371,6 +1384,25 @@ class Listener implements UnescapeErrorListener {
     logEvent("NonNullAssertExpression");
   }
 
+  /// Called after the parser has consumed a null-assert pattern, consisting of
+  /// a pattern followed by a `!` operator.
+  void handleNullAssertPattern(Token bang) {
+    logEvent("NullAssertPattern");
+  }
+
+  /// Called after the parser has consumed a null-check pattern, consisting of a
+  /// pattern followed by a `?` operator.
+  void handleNullCheckPattern(Token question) {
+    logEvent('NullCheckPattern');
+  }
+
+  /// Called after the parser has consumed a variable pattern, consisting of an
+  /// optional `var` or `final` keyword, an optional type annotation, and a
+  /// variable name identifier.
+  void handleVariablePattern(Token? keyword, Token variable) {
+    logEvent('VariablePattern');
+  }
+
   void handleNoName(Token token) {
     logEvent("NoName");
   }
@@ -1518,6 +1550,12 @@ class Listener implements UnescapeErrorListener {
     logEvent("AsOperator");
   }
 
+  /// Called after the parser has consumed a cast pattern, consisting of a
+  /// pattern, `as` operator, and type annotation.
+  void handleCastPattern(Token operator) {
+    logEvent('CastPattern');
+  }
+
   void handleAssignmentExpression(Token token) {
     logEvent("AssignmentExpression");
   }
@@ -1532,6 +1570,15 @@ class Listener implements UnescapeErrorListener {
     logEvent("BinaryExpression");
   }
 
+  /// Called when the parser has consumed the operator of a binary pattern.
+  void beginBinaryPattern(Token token) {}
+
+  /// Called when the parser has consumed a binary pattern, consisting of a LHS
+  /// pattern, `&` or `|` operator, and a RHS pattern.
+  void endBinaryPattern(Token token) {
+    logEvent("BinaryPattern");
+  }
+
   /// Called for `.`, `?.` and `..`.
   void handleEndingBinaryExpression(Token token) {
     // TODO(jensj): push implementation into subclasses
@@ -1706,6 +1753,12 @@ class Listener implements UnescapeErrorListener {
     logEvent("LiteralList");
   }
 
+  /// Called after the parser has consumed a list pattern, consisting of a `[`,
+  /// a comma-separated sequence of patterns, and a `]`.
+  void handleListPattern(int count, Token leftBracket, Token rightBracket) {
+    logEvent("ListPattern");
+  }
+
   void handleLiteralSetOrMap(
     int count,
     Token leftBrace,
@@ -1718,6 +1771,12 @@ class Listener implements UnescapeErrorListener {
     logEvent('LiteralSetOrMap');
   }
 
+  /// Called after the parser has consumed a map pattern, consisting of a `{`,
+  /// a comma-separated sequence of mapPatternEntry, and a `}`.
+  void handleMapPattern(int count, Token leftBrace, Token rightBrace) {
+    logEvent('MapPattern');
+  }
+
   void handleLiteralNull(Token token) {
     logEvent("LiteralNull");
   }
@@ -1730,6 +1789,12 @@ class Listener implements UnescapeErrorListener {
     logEvent("NamedArgument");
   }
 
+  /// Called after the parser has consumed a patternField, consisting of an
+  /// optional identifier, optional `:`, and a pattern.
+  void handlePatternField(Token? colon) {
+    logEvent("PatternField");
+  }
+
   void handleNamedRecordField(Token colon) {
     logEvent("NamedRecordField");
   }
@@ -1784,7 +1849,7 @@ class Listener implements UnescapeErrorListener {
   /// - do while loop
   /// - switch statement
   /// - while loop
-  void handleParenthesizedCondition(Token token, [Token? case_]) {
+  void handleParenthesizedCondition(Token token, Token? case_) {
     logEvent("ParenthesizedCondition");
   }
 
@@ -1797,13 +1862,40 @@ class Listener implements UnescapeErrorListener {
     logEvent("RecordLiteral");
   }
 
+  /// Called after the parser has consumed a record pattern, consisting of a
+  /// `(`, a comma-separated sequence of patternFields, and a `)`.
+  void handleRecordPattern(Token token, int count) {
+    logEvent("RecordPattern");
+  }
+
   /// End a parenthesized expression.
   /// These may be within the condition expression of a control structure
   /// but will not be the condition of a control structure.
   void endParenthesizedExpression(Token token) {
     logEvent("ParenthesizedExpression");
   }
 
+  /// Called after the parser has consumed a parenthesized pattern, consisting
+  /// of a `(`, a pattern, and a `)`.
+  void handleParenthesizedPattern(Token token) {
+    logEvent("ParenthesizedPattern");
+  }
+
+  /// Called after the parser has consumed a constant pattern, consisting of an
+  /// optional `const` and an expression.
+  void handleConstantPattern(Token? constKeyword) {
+    logEvent("ConstantPattern");
+  }
+
+  /// Called after the parser has consumed an extractor pattern, consisting of
+  /// an identifier, optional dot and second identifier, optional type
+  /// arguments, and a parenthesized list of extractor pattern fields (see
+  /// [handleExtractorPatternFields]).
+  void handleExtractorPattern(
+      Token firstIdentifier, Token? dot, Token? secondIdentifier) {
+    logEvent("ExtractorPattern");
+  }
+
   /// Handle a construct of the form "identifier.identifier" occurring in a part
   /// of the grammar where expressions in general are not allowed.
   /// Substructures:
@@ -1851,6 +1943,12 @@ class Listener implements UnescapeErrorListener {
     logEvent("UnaryPrefixExpression");
   }
 
+  /// Called after the parser has consumed a relational pattern, consisting of
+  /// an equality operator or relational operator, followed by an expression.
+  void handleRelationalPattern(Token token) {
+    logEvent("RelationalPattern");
+  }
+
   void handleUnaryPrefixAssignmentExpression(Token token) {
     logEvent("UnaryPrefixAssignmentExpression");
   }

pkg/_fe_analyzer_shared/lib/src/parser/literal_entry_info_impl.dart

@@ -144,7 +144,8 @@ class IfCondition extends LiteralEntryInfo {
     final Token ifToken = token.next!;
     assert(optional('if', ifToken));
     parser.listener.beginIfControlFlow(ifToken);
-    Token result = parser.ensureParenthesizedCondition(ifToken);
+    Token result = parser.ensureParenthesizedCondition(ifToken,
+        allowCase: parser.allowPatterns);
     parser.listener.handleThenControlFlow(result);
     return result;
   }