Flow analysis: Move join into State and document it.

Change-Id: I8cec06c0d19107b4973e192534d63f05a5b3d902
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/112036
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>

Author: stereotype441

pkg/front_end/lib/src/fasta/flow_analysis/flow_analysis.dart

@@ -400,44 +400,6 @@ class FlowAnalysis<Statement, Expression, Variable, Type> {
     }
   }
 
-  @visibleForTesting
-  Map<Variable, Type> joinPromoted(
-    Map<Variable, Type> first,
-    Map<Variable, Type> second,
-  ) {
-    if (identical(first, second)) return first;
-    if (first.isEmpty || second.isEmpty) return const {};
-
-    var result = <Variable, Type>{};
-    var alwaysFirst = true;
-    var alwaysSecond = true;
-    for (var variable in first.keys) {
-      var firstType = first[variable];
-      var secondType = second[variable];
-      if (secondType != null) {
-        if (identical(firstType, secondType)) {
-          result[variable] = firstType;
-        } else if (typeOperations.isSubtypeOf(firstType, secondType)) {
-          result[variable] = secondType;
-          alwaysFirst = false;
-        } else if (typeOperations.isSubtypeOf(secondType, firstType)) {
-          result[variable] = firstType;
-          alwaysSecond = false;
-        } else {
-          alwaysFirst = false;
-          alwaysSecond = false;
-        }
-      } else {
-        alwaysFirst = false;
-      }
-    }
-
-    if (alwaysFirst) return first;
-    if (alwaysSecond && result.length == second.length) return second;
-    if (result.isEmpty) return const {};
-    return result;
-  }
-
   void logicalAnd_end(Expression andExpression, Expression rightOperand) {
     _conditionalEnd(rightOperand);
     // Tail of the stack: falseLeft, trueLeft, falseRight, trueRight
@@ -643,27 +605,8 @@ class FlowAnalysis<Statement, Expression, Variable, Type> {
   }
 
   State<Variable, Type> _join(
-    State<Variable, Type> first,
-    State<Variable, Type> second,
-  ) {
-    if (first == null) return second;
-    if (second == null) return first;
-
-    if (first.reachable && !second.reachable) return first;
-    if (!first.reachable && second.reachable) return second;
-
-    var newReachable = first.reachable || second.reachable;
-    var newNotAssigned = first.notAssigned.union(second.notAssigned);
-    var newPromoted = joinPromoted(first.promoted, second.promoted);
-
-    return State._identicalOrNew(
-      first,
-      second,
-      newReachable,
-      newNotAssigned,
-      newPromoted,
-    );
-  }
+          State<Variable, Type> first, State<Variable, Type> second) =>
+      State.join(typeOperations, first, second);
 
   /// If assertions are enabled, records that the given variable has been
   /// referenced.  The [finish] method will verify that all referenced variables
@@ -1019,6 +962,80 @@ class State<Variable, Type> {
     return result;
   }
 
+  /// Forms a new state to reflect a control flow path that might have come from
+  /// either `this` or the [other] state.
+  ///
+  /// The control flow path is considered reachable if either of the input
+  /// states is reachable.  Variables are considered definitely assigned if they
+  /// were definitely assigned in both of the input states.  Variable promotions
+  /// are kept only if they are common to both input states; if a variable is
+  /// promoted to one type in one state and a subtype in the other state, the
+  /// less specific type promotion is kept.
+  static State<Variable, Type> join<Variable, Type>(
+    TypeOperations<Variable, Type> typeOperations,
+    State<Variable, Type> first,
+    State<Variable, Type> second,
+  ) {
+    if (first == null) return second;
+    if (second == null) return first;
+
+    if (first.reachable && !second.reachable) return first;
+    if (!first.reachable && second.reachable) return second;
+
+    var newReachable = first.reachable || second.reachable;
+    var newNotAssigned = first.notAssigned.union(second.notAssigned);
+    var newPromoted =
+        State.joinPromoted(typeOperations, first.promoted, second.promoted);
+
+    return State._identicalOrNew(
+      first,
+      second,
+      newReachable,
+      newNotAssigned,
+      newPromoted,
+    );
+  }
+
+  /// Joins two "promoted" maps.  See [join] for details.
+  @visibleForTesting
+  static Map<Variable, Type> joinPromoted<Variable, Type>(
+    TypeOperations<Variable, Type> typeOperations,
+    Map<Variable, Type> first,
+    Map<Variable, Type> second,
+  ) {
+    if (identical(first, second)) return first;
+    if (first.isEmpty || second.isEmpty) return const {};
+
+    var result = <Variable, Type>{};
+    var alwaysFirst = true;
+    var alwaysSecond = true;
+    for (var variable in first.keys) {
+      var firstType = first[variable];
+      var secondType = second[variable];
+      if (secondType != null) {
+        if (identical(firstType, secondType)) {
+          result[variable] = firstType;
+        } else if (typeOperations.isSubtypeOf(firstType, secondType)) {
+          result[variable] = secondType;
+          alwaysFirst = false;
+        } else if (typeOperations.isSubtypeOf(secondType, firstType)) {
+          result[variable] = firstType;
+          alwaysSecond = false;
+        } else {
+          alwaysFirst = false;
+          alwaysSecond = false;
+        }
+      } else {
+        alwaysFirst = false;
+      }
+    }
+
+    if (alwaysFirst) return first;
+    if (alwaysSecond && result.length == second.length) return second;
+    if (result.isEmpty) return const {};
+    return result;
+  }
+
   /// Creates a new [State] object, unless it is equivalent to either [first] or
   /// [second], in which case one of those objects is re-used.
   static State<Variable, Type> _identicalOrNew<Variable, Type>(

pkg/front_end/test/fasta/flow_analysis/flow_analysis_test.dart

@@ -424,58 +424,58 @@ main() {
       const emptyMap = <Null, Null>{};
 
       test('identical inputs', () {
-        var flow = _Harness().flow;
+        var h = _Harness();
         var p = {x: intType, y: stringType};
-        expect(flow.joinPromoted(p, p), same(p));
+        expect(State.joinPromoted(h, p, p), same(p));
       });
 
       test('one input empty', () {
-        var flow = _Harness().flow;
+        var h = _Harness();
         var p1 = {x: intType, y: stringType};
         var p2 = <_Var, _Type>{};
-        expect(flow.joinPromoted(p1, p2), same(emptyMap));
-        expect(flow.joinPromoted(p2, p1), same(emptyMap));
+        expect(State.joinPromoted(h, p1, p2), same(emptyMap));
+        expect(State.joinPromoted(h, p2, p1), same(emptyMap));
       });
 
       test('related types', () {
-        var flow = _Harness().flow;
+        var h = _Harness();
         var p1 = {x: intType};
         var p2 = {x: intQType};
-        expect(flow.joinPromoted(p1, p2), same(p2));
-        expect(flow.joinPromoted(p2, p1), same(p2));
+        expect(State.joinPromoted(h, p1, p2), same(p2));
+        expect(State.joinPromoted(h, p2, p1), same(p2));
       });
 
       test('unrelated types', () {
-        var flow = _Harness().flow;
+        var h = _Harness();
         var p1 = {x: intType};
         var p2 = {x: stringType};
-        expect(flow.joinPromoted(p1, p2), same(emptyMap));
-        expect(flow.joinPromoted(p2, p1), same(emptyMap));
+        expect(State.joinPromoted(h, p1, p2), same(emptyMap));
+        expect(State.joinPromoted(h, p2, p1), same(emptyMap));
       });
 
       test('sub-map', () {
-        var flow = _Harness().flow;
+        var h = _Harness();
         var p1 = {x: intType, y: stringType};
         var p2 = {x: intType};
-        expect(flow.joinPromoted(p1, p2), same(p2));
-        expect(flow.joinPromoted(p2, p1), same(p2));
+        expect(State.joinPromoted(h, p1, p2), same(p2));
+        expect(State.joinPromoted(h, p2, p1), same(p2));
       });
 
       test('sub-map with matched subtype', () {
-        var flow = _Harness().flow;
+        var h = _Harness();
         var p1 = {x: intType, y: stringType};
         var p2 = {x: intQType};
-        expect(flow.joinPromoted(p1, p2), same(p2));
-        expect(flow.joinPromoted(p2, p1), same(p2));
+        expect(State.joinPromoted(h, p1, p2), same(p2));
+        expect(State.joinPromoted(h, p2, p1), same(p2));
       });
 
       test('sub-map with mismatched subtype', () {
-        var flow = _Harness().flow;
+        var h = _Harness();
         var p1 = {x: intQType, y: stringType};
         var p2 = {x: intType};
-        var join12 = flow.joinPromoted(p1, p2);
+        var join12 = State.joinPromoted(h, p1, p2);
         _Type.allowComparisons(() => expect(join12, {x: intQType}));
-        var join21 = flow.joinPromoted(p2, p1);
+        var join21 = State.joinPromoted(h, p2, p1);
         _Type.allowComparisons(() => expect(join21, {x: intQType}));
       });
     });