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

It turns out that the flow analysis logic for null-aware map entries
has always presumed sound null safety. That is, given a map entry with
a null-aware key (`{?x: y}`), flow analysis assumed that if the key
was non-nullable, then the value was guaranteed to execute.

However, another piece of logic that could have been implemented, and
wasn't, was that if the key had static type `Null`, then the value was
guaranteed _not_ to execute. This logic would have been sound even
without assuming sound null safety (because even in unsound null
safety mode, the type `Null` was only inhabited by the value `null`).

This change implements the missing logic. Even though it doesn't
strictly depend on the assumption sound null safety, it still makes
sense to guard it by the `sound-flow-analysis` flag, because (a) it's
a potentially breaking change, and (b) it brings the flow analysis
behavior of null-aware map entries into alignment with the other
behaviors that are being implemented as part of the
`sound-flow-analysis` feature.

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

Bug: #60438
Change-Id: Ie711f582660a31a411be0dc339995df140feb04f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/420800
Reviewed-by: Chloe Stefantsova <cstefantsova@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>
Commit-Queue: Paul Berry <paulberry@google.com>

Author: stereotype441

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

@@ -5196,8 +5196,21 @@ class _FlowAnalysisImpl<Node extends Object, Statement extends Node,
     } else {
       shortcutState = _current;
     }
-    if (operations.classifyType(keyType) == TypeClassification.nonNullable) {
-      shortcutState = shortcutState.setUnreachable();
+    switch (operations.classifyType(keyType)) {
+      case TypeClassification.nonNullable:
+        // The control flow path that skips the value expression is unreachable.
+        shortcutState = shortcutState.setUnreachable();
+      case TypeClassification.nullOrEquivalent:
+        // The control flow path containing the value expression is unreachable.
+        // This functionality was added as part of the `sound-flow-analysis`
+        // language feature, even though it would have been a sound reasoning
+        // step before then.
+        if (typeAnalyzerOptions.soundFlowAnalysisEnabled) {
+          _current = _current.setUnreachable();
+        }
+      case TypeClassification.potentiallyNullable:
+        // Both control flow paths are reachable.
+        break;
     }
     _stack.add(new _NullAwareMapEntryContext<Type>(shortcutState));
   }

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -10968,6 +10968,60 @@ main() {
         ]);
       });
     });
+
+    group('{ ?<nonNullable>: <expr> }', () {
+      test('When enabled, guaranteed to execute <expr>', () {
+        var x = Var('x');
+        h.run([
+          declare(x, type: 'int'),
+          mapLiteral(keyType: 'dynamic', valueType: 'dynamic', [
+            mapEntry(expr('int'), x.write(expr('int')), isKeyNullAware: true),
+          ]),
+          checkAssigned(x, true),
+        ]);
+      });
+
+      test('When disabled, guaranteed to execute <expr>', () {
+        // Flow analysis has considered `{ ?<nonNullable>: <expr> }` as
+        // guaranteed to execute <expr> since null-aware map entries were added
+        // to the language.
+        h.disableSoundFlowAnalysis();
+        var x = Var('x');
+        h.run([
+          declare(x, type: 'int'),
+          mapLiteral(keyType: 'dynamic', valueType: 'dynamic', [
+            mapEntry(expr('int'), x.write(expr('int')), isKeyNullAware: true),
+          ]),
+          checkAssigned(x, true),
+        ]);
+      });
+    });
+
+    group('{ ?<Null>: <expr> }', () {
+      test('When enabled, guaranteed to skip execution of <expr>', () {
+        h.run([
+          mapLiteral(keyType: 'dynamic', valueType: 'dynamic', [
+            mapEntry(expr('Null'), checkReachable(false), isKeyNullAware: true),
+          ]),
+        ]);
+      });
+
+      test('When disabled, not guaranteed to skip execution of <expr>', () {
+        // Note: it would always have been sound for flow analysis to reason
+        // that `{ ?<Null>: <expr> }` was guaranteed to skip execution of
+        // `<expr>` (even when flow analysis had to assume that code might be
+        // running in unsound null safety mode). But this functionality wasn't
+        // implemented. It's been added as part of `sound-flow-analysis`; this
+        // test verifies that the old behavior is preserved when
+        // `sound-flow-analysis` is disabled.
+        h.disableSoundFlowAnalysis();
+        h.run([
+          mapLiteral(keyType: 'dynamic', valueType: 'dynamic', [
+            mapEntry(expr('Null'), checkReachable(true), isKeyNullAware: true),
+          ]),
+        ]);
+      });
+    });
   });
 }