Shared type analysis: add support for when clauses and fix label support.

Support for `when` clauses requires flow analysis integration, so that
`when` clauses can promote variables, e.g.:

    f(int x, String? y) {
      switch (x) {
        case 0 when y != null:
          // y is known to be non-null here
      }
    }

Support for labels in switch statements had a small flaw: we weren't
reporting an error in the case where a label shared a case body with a
pattern that tried to bind a variable, e.g.:

    f(int x) {
      switch (x) {

        L: // Error: does not mind the variable `y`
        case var y:
          ...
      }
    }
Change-Id: I0b2bb4721a6b3a8f7898df682b24b75ddb6e44ae
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/256605
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart

@@ -530,6 +530,17 @@ abstract class FlowAnalysis<Node extends Object, Statement extends Node,
   @visibleForTesting
   SsaNode<Type>? ssaNodeForTesting(Variable variable);
 
+  /// Call this method just after visiting a `when` part of a case clause.  See
+  /// [switchStatement_expressionEnd] for details.
+  ///
+  /// [when] should be the expression following the `when` keyword.
+  void switchStatement_afterWhen(Expression when);
+
+  /// Call this method just before visiting a sequence of two or more `case` or
+  /// `default` clauses that share a body.  See [switchStatement_expressionEnd]
+  /// for details.`
+  void switchStatement_beginAlternatives();
+
   /// Call this method just before visiting one of the cases in the body of a
   /// switch statement.  See [switchStatement_expressionEnd] for details.
   ///
@@ -547,16 +558,35 @@ abstract class FlowAnalysis<Node extends Object, Statement extends Node,
   /// were listed in cases.
   void switchStatement_end(bool isExhaustive);
 
+  /// Call this method just after visiting a `case` or `default` clause, if it
+  /// shares a body with at least one other `case` or `default` clause.  See
+  /// [switchStatement_expressionEnd] for details.`
+  void switchStatement_endAlternative();
+
+  /// Call this method just after visiting a sequence of two or more `case` or
+  /// `default` clauses that share a body.  See [switchStatement_expressionEnd]
+  /// for details.`
+  void switchStatement_endAlternatives();
+
   /// Call this method just after visiting the expression part of a switch
   /// statement or expression.  [switchStatement] should be the switch statement
   /// itself (or `null` if this is a switch expression).
   ///
   /// The order of visiting a switch statement should be:
   /// - Visit the switch expression.
   /// - Call [switchStatement_expressionEnd].
-  /// - For each switch case (including the default case, if any):
+  /// - For each case body:
   ///   - Call [switchStatement_beginCase].
-  ///   - Visit the case.
+  ///   - If there is more than one `case` or `default` clause associated with
+  ///     this case body, call [switchStatement_beginAlternatives].
+  ///   - For each `case` or `default` clause associated with this case body:
+  ///     - If a `when` clause is present, visit it and then call
+  ///       [switchStatement_afterWhen].
+  ///     - If there is more than one `case` or `default` clause associated with
+  ///       this case body, call [switchStatement_endAlternative].
+  ///   - If there is more than one `case` or `default` clause associated with
+  ///     this case body, call [switchStatement_endAlternatives].
+  ///   - Visit the case body.
   /// - Call [switchStatement_end].
   void switchStatement_expressionEnd(Statement? switchStatement);
 
@@ -1172,6 +1202,18 @@ class FlowAnalysisDebug<Node extends Object, Statement extends Node,
         isQuery: true);
   }
 
+  @override
+  void switchStatement_afterWhen(Expression when) {
+    _wrap('switchStatement_afterWhen($when)',
+        () => _wrapped.switchStatement_afterWhen(when));
+  }
+
+  @override
+  void switchStatement_beginAlternatives() {
+    _wrap('switchStatement_beginAlternatives()',
+        () => _wrapped.switchStatement_beginAlternatives());
+  }
+
   @override
   void switchStatement_beginCase(bool hasLabel, Statement? node) {
     _wrap('switchStatement_beginCase($hasLabel, $node)',
@@ -1184,6 +1226,18 @@ class FlowAnalysisDebug<Node extends Object, Statement extends Node,
         () => _wrapped.switchStatement_end(isExhaustive));
   }
 
+  @override
+  void switchStatement_endAlternative() {
+    _wrap('switchStatement_endAlternative()',
+        () => _wrapped.switchStatement_endAlternative());
+  }
+
+  @override
+  void switchStatement_endAlternatives() {
+    _wrap('switchStatement_endAlternatives()',
+        () => _wrapped.switchStatement_endAlternatives());
+  }
+
   @override
   void switchStatement_expressionEnd(Statement? switchStatement) {
     _wrap('switchStatement_expressionEnd($switchStatement)',
@@ -3685,6 +3739,22 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
   SsaNode<Type>? ssaNodeForTesting(Variable variable) => _current
       .variableInfo[promotionKeyStore.keyForVariable(variable)]?.ssaNode;
 
+  @override
+  void switchStatement_afterWhen(Expression when) {
+    ExpressionInfo<Type>? expressionInfo = _getExpressionInfo(when);
+    if (expressionInfo != null) {
+      _current = expressionInfo.ifTrue;
+    }
+  }
+
+  @override
+  void switchStatement_beginAlternatives() {
+    _current = _current.split();
+    _SwitchAlternativesContext<Type> context =
+        new _SwitchAlternativesContext<Type>(_current);
+    _stack.add(context);
+  }
+
   @override
   void switchStatement_beginCase(bool hasLabel, Statement? node) {
     _SimpleStatementContext<Type> context =
@@ -3714,6 +3784,21 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
     _current = breakState.unsplit();
   }
 
+  @override
+  void switchStatement_endAlternative() {
+    _SwitchAlternativesContext<Type> context =
+        _stack.last as _SwitchAlternativesContext<Type>;
+    context._combinedModel = _join(context._combinedModel, _current);
+    _current = context._previous;
+  }
+
+  @override
+  void switchStatement_endAlternatives() {
+    _SwitchAlternativesContext<Type> context =
+        _stack.removeLast() as _SwitchAlternativesContext<Type>;
+    _current = context._combinedModel!.unsplit();
+  }
+
   @override
   void switchStatement_expressionEnd(Statement? switchStatement) {
     _current = _current.split();
@@ -4514,12 +4599,24 @@ class _LegacyTypePromotion<Node extends Object, Statement extends Node,
     throw new StateError('ssaNodeForTesting requires null-aware flow analysis');
   }
 
+  @override
+  void switchStatement_afterWhen(Expression when) {}
+
+  @override
+  void switchStatement_beginAlternatives() {}
+
   @override
   void switchStatement_beginCase(bool hasLabel, Statement? node) {}
 
   @override
   void switchStatement_end(bool isExhaustive) {}
 
+  @override
+  void switchStatement_endAlternative() {}
+
+  @override
+  void switchStatement_endAlternatives() {}
+
   @override
   void switchStatement_expressionEnd(Statement? switchStatement) {}
 
@@ -4767,6 +4864,14 @@ class _SimpleStatementContext<Type extends Object>
       'checkpoint: $_checkpoint)';
 }
 
+class _SwitchAlternativesContext<Type extends Object> extends _FlowContext {
+  final FlowModel<Type> _previous;
+
+  FlowModel<Type>? _combinedModel;
+
+  _SwitchAlternativesContext(this._previous);
+}
+
 /// Specialization of [ExpressionInfo] for the case where the information we
 /// have about the expression is trivial (meaning we know by construction that
 /// the expression's [after], [ifTrue], and [ifFalse] models are all the same).

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart

@@ -14,29 +14,36 @@ class ExpressionCaseInfo<Expression, Node> {
   /// For a `case` clause, the case pattern.  For a `default` clause, `null`.
   final Node? pattern;
 
+  /// For a `case` clause that has a `when` part, the expression following
+  /// `when`.  Otherwise `null`.
+  final Expression? when;
+
   /// The body of the `case` or `default` clause.
   final Expression body;
 
-  ExpressionCaseInfo(this.pattern, this.body);
+  ExpressionCaseInfo({required this.pattern, this.when, required this.body});
 }
 
 /// Information supplied by the client to [TypeAnalyzer.analyzeSwitchStatement]
 /// about an individual `case` or `default` clause.
 ///
 /// The client is free to `implement` or `extend` this class.
-class StatementCaseInfo<Statement, Node> {
+class StatementCaseInfo<Statement, Expression, Node> {
   /// The AST node for this `case` or `default` clause.  This is used for error
   /// reporting, in case errors arise from mismatch among the variables bound by
   /// various cases that share a body.
   final Node node;
 
-  /// Indicates whether this `case` or `default` clause is preceded by one or
-  /// more `goto` labels.
-  final bool hasLabel;
+  /// The labels preceding this `case` or `default` clause, if any.
+  final List<Node> labels;
 
   /// For a `case` clause, the case pattern.  For a `default` clause, `null`.
   final Node? pattern;
 
+  /// For a `case` clause that has a `when` part, the expression following
+  /// `when`.  Otherwise `null`.
+  final Expression? when;
+
   /// The statements following this `case` or `default` clause.  If this list is
   /// empty, and this is not the last `case` or `default` clause, this clause
   /// will be considered to share a body with the `case` or `default` clause
@@ -45,8 +52,9 @@ class StatementCaseInfo<Statement, Node> {
 
   StatementCaseInfo(
       {required this.node,
-      required this.hasLabel,
+      this.labels = const [],
       required this.pattern,
+      this.when,
       required this.body});
 }
 
@@ -70,6 +78,9 @@ class StatementCaseInfo<Statement, Node> {
 mixin TypeAnalyzer<Node extends Object, Statement extends Node,
         Expression extends Node, Variable extends Object, Type extends Object>
     implements VariableBindingCallbacks<Node, Variable, Type> {
+  /// Returns the type `bool`.
+  Type get boolType;
+
   /// Returns the type `double`.
   Type get doubleType;
 
@@ -175,6 +186,8 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
   /// - [analyzeExpression]
   /// - For each `case` or `default` clause:
   ///   - [dispatchPattern] if this is a `case` clause
+  ///   - [analyzeExpression] if this is a `case` clause with a `when` part
+  ///   - [handleCaseHead] if this is a `case` clause
   ///   - [handleDefault] if this is a `default` clause
   ///   - [handleCase_afterCaseHeads]
   ///   - [analyzeExpression]
@@ -196,10 +209,17 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
       if (pattern != null) {
         dispatchPattern(pattern)
             .match(expressionType, bindings, isFinal: true, isLate: false);
+        Expression? when = caseInfo.when;
+        bool hasWhen = when != null;
+        if (hasWhen) {
+          analyzeExpression(when, boolType);
+          flow?.switchStatement_afterWhen(when);
+        }
+        handleCaseHead(hasWhen: hasWhen);
       } else {
         handleDefault();
       }
-      handleCase_afterCaseHeads(1);
+      handleCase_afterCaseHeads(const [], 1);
       Type type = analyzeExpression(caseInfo.body, context);
       if (lubType == null) {
         lubType = type;
@@ -217,8 +237,11 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
   /// Invokes the following [TypeAnalyzer] methods (in order):
   /// - [dispatchExpression]
   /// - For each `case` or `default` body:
-  ///   - [dispatchPattern] for each `case` pattern associated with the body
-  ///   - [handleDefault] if a `default` clause is associated with the body
+  ///   - For each `case` or `default` clause associated with the body:
+  ///     - [dispatchPattern] if this is a `case` clause
+  ///     - [analyzeExpression] if this is a `case` clause with a `when` part
+  ///     - [handleCaseHead] if this is a `case` clause
+  ///     - [handleDefault] if this is a `default` clause
   ///   - [handleCase_afterCaseHeads]
   ///   - [dispatchStatement] for each statement in the body
   ///   - [finishStatementCase]
@@ -228,42 +251,65 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
   /// length of [cases] because a case with no statements get merged into the
   /// case that follows).
   int analyzeSwitchStatement(Statement node, Expression scrutinee,
-      List<StatementCaseInfo<Statement, Node>> cases) {
+      List<StatementCaseInfo<Statement, Expression, Node>> cases) {
     Type expressionType = analyzeExpression(scrutinee, unknownType);
     flow?.switchStatement_expressionEnd(node);
-    bool hasLabel = false;
-    List<StatementCaseInfo<Statement, Node>>? casesInThisExecutionPath;
+    List<Node> labels = [];
+    List<StatementCaseInfo<Statement, Expression, Node>>?
+        casesInThisExecutionPath;
     int numExecutionPaths = 0;
     for (int i = 0; i < cases.length; i++) {
-      StatementCaseInfo<Statement, Node> caseInfo = cases[i];
-      hasLabel = hasLabel || caseInfo.hasLabel;
+      StatementCaseInfo<Statement, Expression, Node> caseInfo = cases[i];
+      labels.addAll(caseInfo.labels);
       (casesInThisExecutionPath ??= []).add(caseInfo);
       if (i == cases.length - 1 || caseInfo.body.isNotEmpty) {
         numExecutionPaths++;
-        flow?.switchStatement_beginCase(hasLabel, node);
+        flow?.switchStatement_beginCase(labels.isNotEmpty, node);
         VariableBindings<Node, Variable, Type> bindings =
             new VariableBindings(this);
         bindings.startAlternatives();
-        for (int i = 0; i < casesInThisExecutionPath.length; i++) {
-          StatementCaseInfo<Statement, Node> caseInfo =
+        // Labels count as empty patterns for the purposes of bindings.
+        for (Node label in labels) {
+          bindings.startAlternative(label);
+          bindings.finishAlternative();
+        }
+        int numCasesInThisExecutionPath = casesInThisExecutionPath.length;
+        if (numCasesInThisExecutionPath > 1) {
+          flow?.switchStatement_beginAlternatives();
+        }
+        for (int i = 0; i < numCasesInThisExecutionPath; i++) {
+          StatementCaseInfo<Statement, Expression, Node> caseInfo =
               casesInThisExecutionPath[i];
           bindings.startAlternative(caseInfo.node);
           Node? pattern = caseInfo.pattern;
           if (pattern != null) {
             dispatchPattern(pattern)
                 .match(expressionType, bindings, isFinal: true, isLate: false);
+            Expression? when = caseInfo.when;
+            bool hasWhen = when != null;
+            if (hasWhen) {
+              analyzeExpression(when, boolType);
+              flow?.switchStatement_afterWhen(when);
+            }
+            handleCaseHead(hasWhen: hasWhen);
           } else {
             handleDefault();
           }
           bindings.finishAlternative();
+          if (numCasesInThisExecutionPath > 1) {
+            flow?.switchStatement_endAlternative();
+          }
         }
         bindings.finishAlternatives();
-        handleCase_afterCaseHeads(casesInThisExecutionPath.length);
+        if (numCasesInThisExecutionPath > 1) {
+          flow?.switchStatement_endAlternatives();
+        }
+        handleCase_afterCaseHeads(labels, numCasesInThisExecutionPath);
         for (Statement statement in caseInfo.body) {
           dispatchStatement(statement);
         }
         finishStatementCase(node, i, caseInfo.body.length);
-        hasLabel = false;
+        labels.clear();
         casesInThisExecutionPath = null;
       }
     }
@@ -334,7 +380,10 @@ mixin TypeAnalyzer<Node extends Object, Statement extends Node,
   void finishStatementCase(Statement node, int caseIndex, int numStatements);
 
   /// See [analyzeSwitchStatement] and [analyzeSwitchExpression].
-  void handleCase_afterCaseHeads(int numHeads);
+  void handleCase_afterCaseHeads(List<Node> labels, int numHeads);
+
+  /// See [analyzeSwitchStatement] and [analyzeSwitchExpression].
+  void handleCaseHead({required bool hasWhen});
 
   /// See [analyzeConstOrLiteralPattern].
   void handleConstOrLiteralPattern();