[flow] Part 1 Issue 3658 - Store variable information after a write.

Assignments in the condition of an if statements don't store the promoted information (for the write of that variable). This fix stores the promotion of that expression for when we use it to null check or otherwise.

Part 1 because there's still some holes with postfix operators and null asserts that need to be fixed, but this behaviour stands on its own at the moment.

Everything is behind the flag so we'll iterate.

Bug: dart-lang/language#3658
Change-Id: I8663f089a451468651efccadeb3991b34a37d899
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/388903
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Kallen Tu <[email protected]>

Author: kallentu

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

@@ -6268,6 +6268,16 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
         newSsaNode,
         operations,
         unpromotedType: unpromotedType);
+
+    // Update the type of the variable for looking up the write expression.
+    if (inferenceUpdate4Enabled && node is Expression) {
+      _Reference<Type> reference = _variableReference(
+        variableKey,
+        unpromotedType,
+      );
+      _storeExpressionInfo(node, reference);
+      _storeExpressionReference(node, reference);
+    }
   }
 }
 

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -293,6 +293,37 @@ main() {
       ]);
     });
 
+    test('equalityOp(x == null) when x is an assignment expression', () {
+      // int? x;
+      // if ((x = <int?>) == null) {
+      //   return;
+      // }
+      // x is promoted to `int`.
+
+      var x = Var('x');
+      h.run([
+        declare(x, type: 'int?'),
+        if_(x.write(expr('int?')).eq(nullLiteral), [
+          return_(),
+        ]),
+        checkPromoted(x, 'int'),
+      ]);
+    });
+
+    test(
+        'equalityOp(x == null) when x is an assignment expression'
+        'and inference-update-4 is disabled', () {
+      var x = Var('x');
+      h.disableInferenceUpdate4();
+      h.run([
+        declare(x, type: 'int?'),
+        if_(x.write(expr('int?')).eq(nullLiteral), [
+          return_(),
+        ]),
+        checkNotPromoted(x),
+      ]);
+    });
+
     test('equalityOp(x == null) when x is non-nullable', () {
       var x = Var('x');
       h.run([
@@ -1634,6 +1665,39 @@ main() {
         ]);
       });
 
+      test(
+          'isExpression_end() variables in assignment expressions are promoted',
+          () {
+        // num x;
+        // if ((x = <int>) is int) {
+        //   x is promoted to `int`.
+        // }
+        // x is not promoted
+
+        var x = Var('x');
+        h.run([
+          declare(x, type: 'num'),
+          if_(x.write(expr('int')).is_('int'), [
+            checkPromoted(x, 'int'),
+          ]),
+          checkNotPromoted(x),
+        ]);
+      });
+
+      test(
+          'isExpression_end() variables in assignment expressions are not'
+          ' promoted when inference-update-4 is disabled', () {
+        var x = Var('x');
+        h.disableInferenceUpdate4();
+        h.run([
+          declare(x, type: 'num'),
+          if_(x.write(expr('int')).is_('int'), [
+            checkNotPromoted(x),
+          ]),
+          checkNotPromoted(x),
+        ]);
+      });
+
       test('on an arbitrary expression', () {
         h.addMember('C', 'f', 'Object?');
         h.run([