Version 2.19.0-427.0.dev

Merge 67015b7 into dev

Author: Dart CI

pkg/_fe_analyzer_shared/lib/src/messages/codes_generated.dart

@@ -10659,6 +10659,60 @@ Message _withArgumentsSdkSummaryNotFound(Uri uri_) {
       arguments: {'uri': uri_});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String
+            name)> templateSealedClassSubtypeOutsideOfLibrary = const Template<
+        Message Function(String name)>(
+    problemMessageTemplate:
+        r"""Sealed class '#name' can't be extended, implemented, or mixed in outside of its library.""",
+    withArguments: _withArgumentsSealedClassSubtypeOutsideOfLibrary);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)>
+    codeSealedClassSubtypeOutsideOfLibrary =
+    const Code<Message Function(String name)>(
+  "SealedClassSubtypeOutsideOfLibrary",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsSealedClassSubtypeOutsideOfLibrary(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeSealedClassSubtypeOutsideOfLibrary,
+      problemMessage:
+          """Sealed class '${name}' can't be extended, implemented, or mixed in outside of its library.""",
+      arguments: {'name': name});
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+    Message Function(
+        String
+            name)> templateSealedMixinSubtypeOutsideOfLibrary = const Template<
+        Message Function(String name)>(
+    problemMessageTemplate:
+        r"""Sealed mixin '#name' can't be mixed in outside of its library.""",
+    withArguments: _withArgumentsSealedMixinSubtypeOutsideOfLibrary);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(String name)>
+    codeSealedMixinSubtypeOutsideOfLibrary =
+    const Code<Message Function(String name)>(
+  "SealedMixinSubtypeOutsideOfLibrary",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsSealedMixinSubtypeOutsideOfLibrary(String name) {
+  if (name.isEmpty) throw 'No name provided';
+  name = demangleMixinApplicationName(name);
+  return new Message(codeSealedMixinSubtypeOutsideOfLibrary,
+      problemMessage:
+          """Sealed mixin '${name}' can't be mixed in outside of its library.""",
+      arguments: {'name': name});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Code<Null> codeSetLiteralTooManyTypeArguments =
     messageSetLiteralTooManyTypeArguments;

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

@@ -454,16 +454,31 @@ class ForwardingListener implements Listener {
     listener?.beginSwitchBlock(token);
   }
 
+  @override
+  void beginSwitchExpressionBlock(Token token) {
+    listener?.beginSwitchExpressionBlock(token);
+  }
+
   @override
   void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
     listener?.beginSwitchCase(labelCount, expressionCount, firstToken);
   }
 
+  @override
+  void beginSwitchExpressionCase() {
+    listener?.beginSwitchExpressionCase();
+  }
+
   @override
   void beginSwitchStatement(Token token) {
     listener?.beginSwitchStatement(token);
   }
 
+  @override
+  void beginSwitchExpression(Token token) {
+    listener?.beginSwitchExpression(token);
+  }
+
   @override
   void handleThenControlFlow(Token token) {
     listener?.handleThenControlFlow(token);
@@ -1146,6 +1161,12 @@ class ForwardingListener implements Listener {
     listener?.endSwitchBlock(caseCount, beginToken, endToken);
   }
 
+  @override
+  void endSwitchExpressionBlock(
+      int caseCount, Token beginToken, Token endToken) {
+    listener?.endSwitchExpressionBlock(caseCount, beginToken, endToken);
+  }
+
   @override
   void endSwitchCase(
       int labelCount,
@@ -1159,11 +1180,21 @@ class ForwardingListener implements Listener {
         colonAfterDefault, statementCount, firstToken, endToken);
   }
 
+  @override
+  void endSwitchExpressionCase(Token? when, Token arrow, Token endToken) {
+    listener?.endSwitchExpressionCase(when, arrow, endToken);
+  }
+
   @override
   void endSwitchStatement(Token switchKeyword, Token endToken) {
     listener?.endSwitchStatement(switchKeyword, endToken);
   }
 
+  @override
+  void endSwitchExpression(Token switchKeyword, Token endToken) {
+    listener?.endSwitchExpression(switchKeyword, endToken);
+  }
+
   @override
   void endThenStatement(Token token) {
     listener?.endThenStatement(token);

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

@@ -1254,12 +1254,25 @@ class Listener implements UnescapeErrorListener {
     logEvent("SwitchStatement");
   }
 
+  void beginSwitchExpression(Token token) {}
+
+  void endSwitchExpression(Token switchKeyword, Token endToken) {
+    logEvent("SwitchExpression");
+  }
+
   void beginSwitchBlock(Token token) {}
 
   void endSwitchBlock(int caseCount, Token beginToken, Token endToken) {
     logEvent("SwitchBlock");
   }
 
+  void beginSwitchExpressionBlock(Token token) {}
+
+  void endSwitchExpressionBlock(
+      int caseCount, Token beginToken, Token endToken) {
+    logEvent("SwitchExpressionBlock");
+  }
+
   void beginLiteralSymbol(Token token) {}
 
   void endLiteralSymbol(Token hashToken, int identifierCount) {
@@ -1950,6 +1963,12 @@ class Listener implements UnescapeErrorListener {
     logEvent("SwitchCase");
   }
 
+  void beginSwitchExpressionCase() {}
+
+  void endSwitchExpressionCase(Token? when, Token arrow, Token endToken) {
+    logEvent("SwitchExpressionCase");
+  }
+
   void handleThisExpression(Token token, IdentifierContext context) {
     logEvent("ThisExpression");
   }

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

@@ -3958,6 +3958,17 @@ class Parser {
     return rewriteAndRecover(token, message, newToken);
   }
 
+  /// If the next token is a function arrow (`=>`), return it.  Otherwise report
+  /// an error, insert a synthetic function arrow, and return the inserted
+  /// function arrow.
+  Token ensureFunctionArrow(Token token) {
+    Token next = token.next!;
+    if (optional('=>', next)) return next;
+    codes.Message message = codes.templateExpectedButGot.withArguments('=>');
+    Token newToken = new SyntheticToken(TokenType.FUNCTION, next.charOffset);
+    return rewriteAndRecover(token, message, newToken);
+  }
+
   /// If the token after [token] is a not literal string,
   /// then insert a synthetic literal string.
   /// Call `parseLiteralString` and return the result.
@@ -6106,6 +6117,8 @@ class Parser {
         // Fall through to the recovery code.
       } else if (identical(value, "assert")) {
         return parseAssert(token, Assert.Expression);
+      } else if (allowPatterns && identical(value, "switch")) {
+        return parseSwitchExpression(token);
       } else if (token.next!.isIdentifier) {
         return parseSendOrFunctionLiteral(token, context);
       } else if (identical(value, "return")) {
@@ -9821,6 +9834,73 @@ class Parser {
         keyword, equals, semicolon);
     return semicolon;
   }
+
+  /// switchExpression    ::= 'switch' '(' expression ')' '{'
+  ///                         switchExpressionCase ( ',' switchExpressionCase )*
+  ///                             ','? '}'
+  /// switchExpressionCase    ::= guardedPattern '=>' expression
+  Token parseSwitchExpression(Token token) {
+    Token switchKeyword = token.next!;
+    assert(optional('switch', switchKeyword));
+    listener.beginSwitchExpression(switchKeyword);
+    token = ensureParenthesizedCondition(switchKeyword, allowCase: false);
+    Token beginSwitch =
+        token = ensureBlock(token, /* template = */ null, 'switch expression');
+    listener.beginSwitchExpressionBlock(beginSwitch);
+    Token next = token.next!;
+    int caseCount = 0;
+    if (!optional('}', next)) {
+      while (true) {
+        listener.beginSwitchExpressionCase();
+        token = parsePattern(token, isRefutableContext: true);
+        Token? when;
+        next = token.next!;
+        if (optional('when', next)) {
+          when = token = next;
+          token = parseExpression(token);
+        }
+        Token arrow = token = ensureFunctionArrow(token);
+        token = parseExpression(token);
+        listener.endSwitchExpressionCase(when, arrow, token);
+        ++caseCount;
+        next = token.next!;
+
+        Token? comma;
+        if (optional(',', next)) {
+          comma = token = next;
+          next = token.next!;
+        }
+        if (optional('}', next)) {
+          break;
+        }
+
+        if (comma == null) {
+          // TODO(paulberry): test this error recovery logic
+          // Recovery
+          if (looksLikePatternStart(next)) {
+            // If this looks like the start of a pattern, then report an error,
+            // insert the comma, and continue parsing.
+            SyntheticToken comma =
+                new SyntheticToken(TokenType.COMMA, next.offset);
+            codes.Message message =
+                codes.templateExpectedButGot.withArguments(',');
+            token = rewriteAndRecover(token, message, comma);
+          } else {
+            reportRecoverableError(
+                next, codes.templateExpectedButGot.withArguments('}'));
+            // Scanner guarantees a closing curly bracket
+            next = beginSwitch.endGroup!;
+            break;
+          }
+        }
+      }
+    }
+    listener.endSwitchExpressionBlock(caseCount, beginSwitch, next);
+    token = next;
+    assert(token.isEof || optional('}', token));
+    listener.endSwitchExpression(switchKeyword, token);
+    return token;
+  }
 }
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -3040,6 +3040,61 @@ class AstBuilder extends StackListener {
     push(members2);
   }
 
+  @override
+  void endSwitchExpression(Token switchKeyword, Token endToken) {
+    assert(optional('switch', switchKeyword));
+    debugEvent("SwitchExpression");
+
+    var rightBracket = pop() as Token;
+    var cases = pop() as List<SwitchExpressionCaseImpl>;
+    var leftBracket = pop() as Token;
+    var condition = pop() as _ParenthesizedCondition;
+    push(
+      SwitchExpressionImpl(
+        switchKeyword: switchKeyword,
+        leftParenthesis: condition.leftParenthesis,
+        expression: condition.expression,
+        rightParenthesis: condition.rightParenthesis,
+        leftBracket: leftBracket,
+        cases: cases,
+        rightBracket: rightBracket,
+      ),
+    );
+  }
+
+  @override
+  void endSwitchExpressionBlock(
+      int caseCount, Token leftBracket, Token rightBracket) {
+    assert(optional('{', leftBracket));
+    assert(optional('}', rightBracket));
+    debugEvent("SwitchExpressionBlock");
+
+    var cases = popTypedList2<SwitchExpressionCaseImpl>(caseCount);
+
+    push(leftBracket);
+    push(cases);
+    push(rightBracket);
+  }
+
+  @override
+  void endSwitchExpressionCase(Token? when, Token arrow, Token endToken) {
+    debugEvent("SwitchExpressionCase");
+    var expression = pop() as ExpressionImpl;
+    WhenClauseImpl? whenClause;
+    if (when != null) {
+      var expression = pop() as ExpressionImpl;
+      whenClause = WhenClauseImpl(whenKeyword: when, expression: expression);
+    }
+    var pattern = pop() as DartPatternImpl;
+    push(SwitchExpressionCaseImpl(
+        guardedPattern: GuardedPatternImpl(
+          pattern: pattern,
+          whenClause: whenClause,
+        ),
+        arrow: arrow,
+        expression: expression));
+  }
+
   @override
   void endSwitchStatement(Token switchKeyword, Token endToken) {
     assert(optional('switch', switchKeyword));

pkg/analyzer/lib/src/test_utilities/find_node.dart

@@ -39,6 +39,7 @@ class FindNode {
           }
         },
         switchPatternCase: (node) => nodes.add(node.guardedPattern),
+        switchExpressionCase: (node) => nodes.add(node.guardedPattern),
       ),
     );
     return nodes.single;

pkg/analyzer/lib/src/test_utilities/function_ast_visitor.dart

@@ -16,6 +16,7 @@ class FunctionAstVisitor extends RecursiveAstVisitor<void> {
   final void Function(Label)? label;
   final void Function(MethodInvocation)? methodInvocation;
   final void Function(SimpleIdentifier)? simpleIdentifier;
+  final void Function(SwitchExpressionCase)? switchExpressionCase;
   final void Function(SwitchPatternCase)? switchPatternCase;
   final void Function(VariableDeclaration)? variableDeclaration;
 
@@ -28,6 +29,7 @@ class FunctionAstVisitor extends RecursiveAstVisitor<void> {
     this.label,
     this.methodInvocation,
     this.simpleIdentifier,
+    this.switchExpressionCase,
     this.switchPatternCase,
     this.variableDeclaration,
   });
@@ -94,6 +96,12 @@ class FunctionAstVisitor extends RecursiveAstVisitor<void> {
     super.visitSimpleIdentifier(node);
   }
 
+  @override
+  void visitSwitchExpressionCase(SwitchExpressionCase node) {
+    switchExpressionCase?.call(node);
+    super.visitSwitchExpressionCase(node);
+  }
+
   @override
   void visitSwitchPatternCase(SwitchPatternCase node) {
     switchPatternCase?.call(node);