[sound flow analysis] Implement behaviors for null-aware accesses.

This change updates the flow analysis logic for `??` and `??=`
expressions, so that when the language feature `sound-flow-analysis`
is enabled, the static type of the left hand side is checked for
nullability. If it's non-nullable, then the right hand side of the
expresison is considered unreachable.

These new behaviors break assumptions made by two pre-existing flow
analysis tests. I changed those tests to run with
`sound-flow-analysis` disabled.

There is no behavioral change if the feature `sound-flow-analysis` is
disabled.

Bug: #60438
Change-Id: I33d6d256bd3c41b764245f50ad34eb5c8b33878e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/420740
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: stereotype441

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

@@ -4896,25 +4896,21 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
     } else {
       shortcutState = _current;
     }
-    if (operations.classifyType(leftHandSideType) ==
-        TypeClassification.nullOrEquivalent) {
-      shortcutState = shortcutState.setUnreachable();
+    switch (operations.classifyType(leftHandSideType)) {
+      case TypeClassification.nullOrEquivalent:
+        // The control path that skips the "if null" code is unreachable.
+        shortcutState = shortcutState.setUnreachable();
+      case TypeClassification.nonNullable:
+        // The control path containing the "if null" code is unreachable,
+        // assuming sound null safety.
+        if (typeAnalyzerOptions.soundFlowAnalysisEnabled) {
+          _current = _current.setUnreachable();
+        }
+      case TypeClassification.potentiallyNullable:
+        // Both control flow paths are reachable.
+        break;
     }
     _stack.add(new _IfNullExpressionContext<Type>(shortcutState));
-    // Note: we are now on the RHS of the `??`, and so at this point in the
-    // flow, it is known that the LHS evaluated to `null`.  It's tempting to
-    // update `_current` to reflect this (either promoting the type of the LHS,
-    // if it's a variable reference, or marking the flow as unreachable, if the
-    // LHS had a non-nullable static type).  However:
-    // - In the case where the LHS was a variable reference, we can't promote
-    //   it, because we don't promote to `Null` (see
-    //   https://github.com/dart-lang/language/issues/1505#issuecomment-975706918)
-    // - In the case where the LHS had a non-nullable static type, it still
-    //   might have been `null` due to mixed-mode unsoundness, so we can't mark
-    //   the flow as unreachable without allowing the unsoundness to escalate
-    //   (see https://github.com/dart-lang/language/issues/1143)
-    //
-    // So we just leave `_current` as is.
   }
 
   @override

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -1292,6 +1292,8 @@ main() {
     });
 
     test('ifNullExpression does not detect when RHS is unreachable', () {
+      // Note: sound flow analysis changes this behavior.
+      h.disableSoundFlowAnalysis();
       h.run([
         expr('int')
             .ifNull(second(checkReachable(true), expr('int')))
@@ -1321,6 +1323,8 @@ main() {
     test(
         'ifNullExpression sets shortcut reachability correctly for non-null '
         'type', () {
+      // Note: sound flow analysis changes this behavior.
+      h.disableSoundFlowAnalysis();
       h.run([
         expr('Object')
             .ifNull(second(checkReachable(true), throw_(expr('Object'))))
@@ -10949,6 +10953,21 @@ main() {
         ]);
       });
     });
+
+    group('<nonNullable> ?? <expr>', () {
+      test('When enabled, <expr> is dead', () {
+        h.run([
+          expr('int').ifNull(checkReachable(false)),
+        ]);
+      });
+
+      test('When disabled, <expr> is live', () {
+        h.disableSoundFlowAnalysis();
+        h.run([
+          expr('int').ifNull(checkReachable(true)),
+        ]);
+      });
+    });
   });
 }