Flow analysis: implement type promotions for or-patterns.

There are three ways type promotion can occur in an or-pattern:

(1) the scrutinee variable (if any) might be promoted, e.g.:

    f(Object x) {
      if (x case int _ && < 0 || int _ && > 10) {
        // `x` is promoted to `int` because both sides of the `||`
        // promote the scrutinee variable to `int`.
      }
    }

(2) the implicit temporary variable that holds the matched value might
    be promoted, e.g.:

    f(Object Function() g) {
      if (g() case (int _ && < 0 || int _ && > 10) && (var x)) {
        // `x` has type `int` because both sides of the `||` promote
        // the matched value to `int`.
      }
    }

    For this sort of promotion to work, we need to

(3) explicitly matched variables might be promoted at the time of the
    match, e.g.:

    f<T>(T t) {
      if (t is int) {
        if (t case var x && < 0 || var x && > 10) {
          // `x` has type `T` but is promoted to `T&int`, because both
          // declarations of `x` are in a context where the matched
          // value has type `T&int`.
        }
      }
    }

The existing flow analysis logic handles cases (1) and (2) without any
extra work, because those promotions are joined as a natural
consequence of the flow control join at the end of matching the
logical-or pattern.

However, flow analysis has to do some extra work for case (3), because
the two copies of variable `x` are associated with different variable
declarations (and hence have different promotion keys).  To ensure
that the promotions are joined in this case, we need to copy the flow
model for the two copies of `x` into a common promotion key prior to
doing the flow control join.

The bookkeeping necessary to figure out a common promotion key is
similar to the bookkeeping necessary to track the association between
the individual declared variable patterns and the joined pattern
variable (and this is bookkeeping that flow analysis is already
doing).  So as part of this change I went ahead and removed the
`getJoinedVariableComponents` method (which was previously used by
flow analysis to query this association).  This reduces the
constraints on the analyzer and CFE implementations by not requiring
them to do this bookkeeping themselves.

In the process I've made two additional small changes:

- I modified the logic for assigning types and finality to joined
  variables so that if there is a finality conflict but no type
  conflict, the common type is used; conversely, if there is a type
  conflict but no finality conflict, the common finality is used.
  This should help reduce follow-on errors.

- I added logic to ensure that if a variable is only declared on one
  side or the other of a logical-or, flow analysis still considers
  that variable to be definitely assigned.  This should help reduce
  follow-on errors.

Change-Id: I62f17adb6a51a583707c216ed48d941d1c621eea
Bug: #50419
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/279756
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: stereotype441

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

@@ -196,6 +196,14 @@ abstract class FlowAnalysis<Node extends Object, Statement extends Node,
 
   void constantPattern_end(Expression expression);
 
+  /// Copy promotion data associated with one promotion key to another.  This
+  /// is used after analyzing a branch of a logical-or pattern, to move the
+  /// promotion data associated with the result of a pattern match on the left
+  /// hand and right hand sides of the logical-or into a common promotion key,
+  /// so that promotions will be properly unified when the control flow paths
+  /// are joined.
+  void copyPromotionData({required int sourceKey, required int destinationKey});
+
   /// Register a declaration of the [variable] in the current state.
   /// Should also be called for function parameters.
   ///
@@ -1092,6 +1100,16 @@ class FlowAnalysisDebug<Node extends Object, Statement extends Node,
         () => _wrapped.constantPattern_end(expression));
   }
 
+  @override
+  void copyPromotionData(
+      {required int sourceKey, required int destinationKey}) {
+    _wrap(
+        'copyPromotionData(sourceKey: $sourceKey, '
+        'destinationKey: $destinationKey)',
+        () => _wrapped.copyPromotionData(
+            sourceKey: sourceKey, destinationKey: destinationKey));
+  }
+
   @override
   void declare(Variable variable, Type staticType,
       {required bool initialized, bool skipDuplicateCheck = false}) {
@@ -3062,6 +3080,18 @@ class VariableModel<Type extends Object> {
     return new _DemotionResult<Type>(newPromotedTypes, newNonPromotionHistory);
   }
 
+  /// Returns a variable model that is the same as this one, but with the
+  /// variable definitely assigned.
+  VariableModel<Type> _setAssigned() => assigned
+      ? this
+      : new VariableModel(
+          promotedTypes: promotedTypes,
+          tested: tested,
+          assigned: true,
+          unassigned: false,
+          ssaNode: ssaNode ?? new SsaNode(null),
+          nonPromotionHistory: nonPromotionHistory);
+
   /// Determines whether a variable with the given [promotedTypes] should be
   /// promoted to [writtenType] based on types of interest.  If it should,
   /// returns an updated promotion chain; otherwise returns [promotedTypes]
@@ -3630,8 +3660,15 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
   @override
   int assignMatchedPatternVariable(Variable variable, int promotionKey) {
     int mergedKey = promotionKeyStore.keyForVariable(variable);
-    _current =
-        _current._updateVariableInfo(mergedKey, _current.infoFor(promotionKey));
+    VariableModel<Type> info = _current.infoFor(promotionKey);
+    // Normally flow analysis is responsible for tracking whether variables are
+    // definitely assigned; however for variables appearing in patterns we
+    // have other logic to make sure that a value is definitely assigned (e.g.
+    // the rule that a variable appearing on one side of an `||` must also
+    // appear on the other side).  So to avoid reporting redundant errors, we
+    // pretend that the variable is definitely assigned, even if it isn't.
+    info = info._setAssigned();
+    _current = _current._updateVariableInfo(mergedKey, info);
     return mergedKey;
   }
 
@@ -3691,6 +3728,13 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
     _unmatched = _join(_unmatched!, _current);
   }
 
+  @override
+  void copyPromotionData(
+      {required int sourceKey, required int destinationKey}) {
+    _current = _current._updateVariableInfo(
+        destinationKey, _current.infoFor(sourceKey));
+  }
+
   @override
   void declare(Variable variable, Type staticType,
       {required bool initialized, bool skipDuplicateCheck = false}) {
@@ -5172,6 +5216,10 @@ class _LegacyTypePromotion<Node extends Object, Statement extends Node,
   @override
   void constantPattern_end(Expression expression) {}
 
+  @override
+  void copyPromotionData(
+      {required int sourceKey, required int destinationKey}) {}
+
   @override
   void declare(Variable variable, Type staticType,
       {required bool initialized, bool skipDuplicateCheck = false}) {}

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

@@ -72,6 +72,10 @@ class MatchContext<Node extends Object, Expression extends Node,
   /// in a logical-or pattern.
   final Map<String, List<Variable>> componentVariables;
 
+  /// For each variable name in the pattern, the promotion key holding the value
+  /// captured by that variable.
+  final Map<String, int> patternVariablePromotionKeys;
+
   MatchContext({
     Expression? initializer,
     this.irrefutableContext,
@@ -81,6 +85,7 @@ class MatchContext<Node extends Object, Expression extends Node,
     required this.topPattern,
     this.assignedVariables,
     required this.componentVariables,
+    required this.patternVariablePromotionKeys,
   })  : _initializer = initializer,
         _switchScrutinee = switchScrutinee;
 
@@ -107,7 +112,23 @@ class MatchContext<Node extends Object, Expression extends Node,
               switchScrutinee: _switchScrutinee,
               topPattern: topPattern,
               componentVariables: componentVariables,
+              patternVariablePromotionKeys: patternVariablePromotionKeys,
             );
+
+  /// Returns a modified version of `this`, with a new value of
+  /// [patternVariablePromotionKeys].
+  MatchContext<Node, Expression, Pattern, Type, Variable> withPromotionKeys(
+          Map<String, int> patternVariablePromotionKeys) =>
+      new MatchContext(
+        initializer: _initializer,
+        irrefutableContext: irrefutableContext,
+        isFinal: isFinal,
+        isLate: isLate,
+        switchScrutinee: _switchScrutinee,
+        topPattern: topPattern,
+        componentVariables: componentVariables,
+        patternVariablePromotionKeys: patternVariablePromotionKeys,
+      );
 }
 
 /// Container for the result of running type analysis on an expression that does