[cfe] Support guard clauses in if-case statements

Part of #49749

Change-Id: I2988ba4dda65b4e54282f892fa377cffed70f25c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/277984
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Commit-Queue: Chloe Stefantsova <[email protected]>

Author: chloestefantsova

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

@@ -1826,6 +1826,11 @@ class ForwardingListener implements Listener {
     listener?.handleParenthesizedCondition(token, case_, when);
   }
 
+  @override
+  void beginPatternGuard(Token when) {
+    listener?.beginPatternGuard(when);
+  }
+
   @override
   void beginParenthesizedExpressionOrRecordLiteral(Token token) {
     listener?.beginParenthesizedExpressionOrRecordLiteral(token);
@@ -1841,6 +1846,11 @@ class ForwardingListener implements Listener {
     listener?.handleRecordPattern(token, count);
   }
 
+  @override
+  void endPatternGuard(Token token) {
+    listener?.endPatternGuard(token);
+  }
+
   @override
   void endParenthesizedExpression(Token token) {
     listener?.endParenthesizedExpression(token);

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

@@ -1898,6 +1898,11 @@ class Listener implements UnescapeErrorListener {
     logEvent("ParenthesizedCondition");
   }
 
+  /// Starts a pattern guard, the expression that follows the 'when' keyword
+  void beginPatternGuard(Token when) {
+    logEvent("PatternGuard");
+  }
+
   /// Starts a parenthesized expression or a record literal. Will be ended with
   /// either [endParenthesizedExpression] or [endRecordLiteral].
   void beginParenthesizedExpressionOrRecordLiteral(Token token) {}
@@ -1913,6 +1918,11 @@ class Listener implements UnescapeErrorListener {
     logEvent("RecordPattern");
   }
 
+  /// End a pattern guard, the expression that follows the 'when' keyword
+  void endPatternGuard(Token token) {
+    logEvent("PatternGuard");
+  }
+
   /// 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.

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

@@ -6324,7 +6324,9 @@ class Parser {
       Token? when;
       if (optional('when', next)) {
         when = token = next;
+        listener.beginPatternGuard(when);
         token = parseExpression(token);
+        listener.endPatternGuard(when);
       }
       token = ensureCloseParen(token, begin);
       listener.handleParenthesizedCondition(begin, case_, when);

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

@@ -471,6 +471,11 @@ class AstBuilder extends StackListener {
     push(mixinToken ?? NullValue.Token);
   }
 
+  @override
+  void beginPatternGuard(Token when) {
+    debugEvent("PatternGuard");
+  }
+
   @override
   void beginTopLevelMethod(
       Token lastConsumed, Token? augmentToken, Token? externalToken) {
@@ -2797,6 +2802,11 @@ class AstBuilder extends StackListener {
     );
   }
 
+  @override
+  void endPatternGuard(Token token) {
+    debugEvent("PatternGuard");
+  }
+
   @override
   void endRecordLiteral(Token token, int count, Token? constKeyword) {
     debugEvent("RecordLiteral");

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

@@ -2252,13 +2252,15 @@ class BodyBuilder extends StackListenerImpl
     if (case_ != null) {
       // ignore: unused_local_variable
       Expression? guard;
+      Scope? scope;
       if (when != null) {
         assert(checkState(token, [
           unionOfKinds([
             ValueKinds.Expression,
             ValueKinds.Generator,
             ValueKinds.ProblemBuilder,
           ]),
+          ValueKinds.Scope,
           unionOfKinds([
             ValueKinds.Expression,
             ValueKinds.Pattern,
@@ -2270,6 +2272,7 @@ class BodyBuilder extends StackListenerImpl
           ]),
         ]));
         guard = popForValue();
+        scope = pop() as Scope;
       }
       assert(checkState(token, [
         unionOfKinds([
@@ -2286,6 +2289,9 @@ class BodyBuilder extends StackListenerImpl
           libraryFeatures.patterns, case_.charOffset, case_.charCount);
       Pattern pattern = toPattern(pop());
       Expression expression = popForValue();
+      if (scope != null) {
+        push(scope);
+      }
       push(new Condition(expression, new PatternGuard(pattern, guard)));
     } else {
       assert(checkState(token, [
@@ -3430,21 +3436,54 @@ class BodyBuilder extends StackListenerImpl
     }
   }
 
+  @override
+  void beginPatternGuard(Token when) {
+    debugEvent("PatternGuard");
+    assert(checkState(when, [
+      unionOfKinds([
+        ValueKinds.Expression,
+        ValueKinds.ProblemBuilder,
+        ValueKinds.Pattern,
+      ])
+    ]));
+
+    Pattern pattern = toPattern(peek());
+    enterLocalScope("then");
+    for (VariableDeclaration variable in pattern.declaredVariables) {
+      declareVariable(variable, scope);
+      typeInferrer.assignedVariables.declare(variable);
+    }
+  }
+
+  @override
+  void endPatternGuard(Token token) {
+    debugEvent("PatternGuard");
+  }
+
   @override
   void beginThenStatement(Token token) {
     debugEvent("beginThenStatement");
     assert(checkState(token, [ValueKinds.Condition]));
     // This is matched by the call to [deferNode] in
     // [endThenStatement].
     typeInferrer.assignedVariables.beginNode();
-    Condition condition = peek() as Condition;
-    enterLocalScope("then");
+    Condition condition = pop() as Condition;
     PatternGuard? patternGuard = condition.patternGuard;
-    if (patternGuard != null) {
-      for (VariableDeclaration variable
-          in patternGuard.pattern.declaredVariables) {
-        declareVariable(variable, scope);
-        typeInferrer.assignedVariables.declare(variable);
+    if (patternGuard != null && patternGuard.guard != null) {
+      assert(checkState(token, [ValueKinds.Scope]));
+      Scope scope = pop() as Scope;
+      push(condition);
+      push(scope);
+    } else {
+      push(condition);
+      // There is no guard, so the scope for "then" isn't entered yet.
+      enterLocalScope("then");
+      if (patternGuard != null) {
+        for (VariableDeclaration variable
+            in patternGuard.pattern.declaredVariables) {
+          declareVariable(variable, scope);
+          typeInferrer.assignedVariables.declare(variable);
+        }
       }
     }
   }

pkg/front_end/lib/src/fasta/kernel/macro/annotation_parser.dart

@@ -2054,6 +2054,11 @@ class _MacroListener implements Listener {
     _unknown();
   }
 
+  @override
+  void beginPatternGuard(Token token) {
+    _unhandled();
+  }
+
   @override
   void beginParenthesizedExpressionOrRecordLiteral(Token token) {
     _unhandled();
@@ -2069,6 +2074,11 @@ class _MacroListener implements Listener {
     _unsupported();
   }
 
+  @override
+  void endPatternGuard(Token token) {
+    _unhandled();
+  }
+
   @override
   void endParenthesizedExpression(Token token) {
     _unhandled();

pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart

@@ -1802,24 +1802,10 @@ class InferenceVisitorImpl extends InferenceVisitorBase
           null);
     }
 
-    List<Statement> replacementStatements;
-    if (node.patternGuard.pattern.declaredVariables.isEmpty) {
-      replacementStatements = [
-        if (otherwise != null) patternMatchedSet,
-        if (then is! Block || then.statements.isNotEmpty) then
-      ];
-    } else {
-      replacementStatements = [
-        if (otherwise != null) patternMatchedSet,
-
-        // The block is created to avoid having variables with the same name in
-        // the same scope.
-        engine.forest.createBlock(node.fileOffset, node.fileOffset, [
-          ...node.patternGuard.pattern.declaredVariables,
-          if (then is! Block || then.statements.isNotEmpty) then
-        ])
-      ];
-    }
+    List<Statement> replacementStatements = [
+      if (otherwise != null) patternMatchedSet,
+      if (then is! Block || then.statements.isNotEmpty) then
+    ];
 
     PatternTransformationResult transformationResult = node.patternGuard.pattern
         .transform(this,
@@ -1828,6 +1814,20 @@ class InferenceVisitorImpl extends InferenceVisitorBase
             matchedType: scrutineeType,
             variableInitializingContext: engine.forest
                 .createVariableGet(node.fileOffset, matchedExpressionVariable));
+    transformationResult = transformationResult.combine(
+        new PatternTransformationResult([
+          new PatternTransformationElement(
+              kind: PatternTransformationElementKind.regular,
+              condition: null,
+              variableInitializers:
+                  node.patternGuard.pattern.declaredVariables),
+          new PatternTransformationElement(
+              kind: PatternTransformationElementKind.regular,
+              condition: node.patternGuard.guard,
+              variableInitializers: [])
+        ]),
+        this);
+
     replacementStatements = _transformationResultToStatements(
         node.fileOffset, transformationResult, replacementStatements);
 

pkg/front_end/lib/src/fasta/util/parser_ast_helper.dart

@@ -2588,6 +2588,13 @@ abstract class AbstractParserAstListener implements Listener {
     seen(data);
   }
 
+  @override
+  void beginPatternGuard(Token when) {
+    PatternGuardBegin data =
+        new PatternGuardBegin(ParserAstType.BEGIN, when: when);
+    seen(data);
+  }
+
   @override
   void beginParenthesizedExpressionOrRecordLiteral(Token token) {
     ParenthesizedExpressionOrRecordLiteralBegin data =
@@ -2610,6 +2617,12 @@ abstract class AbstractParserAstListener implements Listener {
     seen(data);
   }
 
+  @override
+  void endPatternGuard(Token token) {
+    PatternGuardEnd data = new PatternGuardEnd(ParserAstType.END, token: token);
+    seen(data);
+  }
+
   @override
   void endParenthesizedExpression(Token token) {
     ParenthesizedExpressionEnd data =
@@ -7546,6 +7559,18 @@ class ParenthesizedConditionHandle extends ParserAstNode {
       };
 }
 
+class PatternGuardBegin extends ParserAstNode {
+  final Token when;
+
+  PatternGuardBegin(ParserAstType type, {required this.when})
+      : super("PatternGuard", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "when": when,
+      };
+}
+
 class ParenthesizedExpressionOrRecordLiteralBegin extends ParserAstNode {
   final Token token;
 
@@ -7591,6 +7616,18 @@ class RecordPatternHandle extends ParserAstNode {
       };
 }
 
+class PatternGuardEnd extends ParserAstNode {
+  final Token token;
+
+  PatternGuardEnd(ParserAstType type, {required this.token})
+      : super("PatternGuard", type);
+
+  @override
+  Map<String, Object?> get deprecatedArguments => {
+        "token": token,
+      };
+}
+
 class ParenthesizedExpressionEnd extends ParserAstNode {
   final Token token;
 

pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideIfStatement.dart.expect

@@ -24,7 +24,9 @@ beginCompilationUnit(void)
           handleSend(x, case)
           handleLiteralInt(0)
           handleConstantPattern(null)
-          handleLiteralBool(true)
+          beginPatternGuard(when)
+            handleLiteralBool(true)
+          endPatternGuard(when)
           handleParenthesizedCondition((, case, when)
           beginThenStatement({)
             beginBlock({, BlockKind(statement))

pkg/front_end/parser_testcases/patterns/caseHead_withClassicPattern_guarded_insideIfStatement.dart.intertwined.expect

@@ -66,6 +66,7 @@ parseUnit(void)
                               parseLiteralInt(case)
                                 listener: handleLiteralInt(0)
                         listener: handleConstantPattern(null)
+                    listener: beginPatternGuard(when)
                     parseExpression(when)
                       looksLikeOuterPatternEquals(when)
                         skipOuterPattern(when)
@@ -74,6 +75,7 @@ parseUnit(void)
                           parsePrimary(when, expression)
                             parseLiteralBool(when)
                               listener: handleLiteralBool(true)
+                    listener: endPatternGuard(when)
                     ensureCloseParen(true, ()
                     listener: handleParenthesizedCondition((, case, when)
                 listener: beginThenStatement({)

pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideIfStatement.dart.expect

@@ -30,7 +30,9 @@ beginCompilationUnit(void)
             handleType(int, null)
           endAsOperatorType(as)
           handleCastPattern(as)
-          handleLiteralBool(true)
+          beginPatternGuard(when)
+            handleLiteralBool(true)
+          endPatternGuard(when)
           handleParenthesizedCondition((, case, when)
           beginThenStatement({)
             beginBlock({, BlockKind(statement))

pkg/front_end/parser_testcases/patterns/caseHead_withNewPattern_guarded_insideIfStatement.dart.intertwined.expect

@@ -73,6 +73,7 @@ parseUnit(void)
                       listener: handleType(int, null)
                       listener: endAsOperatorType(as)
                       listener: handleCastPattern(as)
+                    listener: beginPatternGuard(when)
                     parseExpression(when)
                       looksLikeOuterPatternEquals(when)
                         skipOuterPattern(when)
@@ -81,6 +82,7 @@ parseUnit(void)
                           parsePrimary(when, expression)
                             parseLiteralBool(when)
                               listener: handleLiteralBool(true)
+                    listener: endPatternGuard(when)
                     ensureCloseParen(true, ()
                     listener: handleParenthesizedCondition((, case, when)
                 listener: beginThenStatement({)