[flow analysis] Change representation of promotion chains to match spec.

Previously, flow analysis represented a promotion chain as
`List<Type>?`, with `null` representing an empty promotion chain. This
was an unnecessary optimization, and it was a source of confusion when
comparing the implementation of flow analysis to the spec.

This CL changes the representation of a promotion chain to a
non-nullable `List<Type>`, and represents an empty promotion chain as
an empty list.

To reduce the risk of mistakes, I've tried to minimize the changes to
flow analysis unit tests; for the most part, they still consider an
empty promotion chain to be represented as `null`, and convert to the
new representation at the last minute. In a follow-up CL, I'll modify
the flow analysis unit tests to better follow the new representation.

Change-Id: I72afd18f9d7729f3109e3e3b5c776c5a23860985
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/443540
Reviewed-by: Erik Ernst <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

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

@@ -2772,7 +2772,7 @@ class FlowModel<Type extends Object> {
       // We can just use the "write captured" state from the `finally` block,
       // because any write captures in the `try` block are conservatively
       // considered to take effect in the `finally` block too.
-      List<Type>? newPromotedTypes;
+      List<Type> newPromotedTypes;
       SsaNode<Type>? newSsaNode;
       if (beforeFinallyModel == null ||
           beforeFinallyModel.ssaNode == afterFinallyModel.ssaNode) {
@@ -3067,10 +3067,10 @@ class FlowModel<Type extends Object> {
       // it's captured now.
       bool newWriteCaptured =
           thisModel.writeCaptured || baseModel.writeCaptured;
-      List<Type>? newPromotedTypes;
+      List<Type> newPromotedTypes;
       if (newWriteCaptured) {
         // Write captured variables can't be promoted.
-        newPromotedTypes = null;
+        newPromotedTypes = const [];
       } else if (baseModel.ssaNode != thisModel.ssaNode) {
         // The variable may have been written to since `thisModel`, so we can't
         // use any of the promotions from `thisModel`.
@@ -3389,7 +3389,7 @@ class FlowModel<Type extends Object> {
       newTested = PromotionModel._addTypeToUniqueList(info.tested, testedType);
     }
 
-    List<Type>? newPromotedTypes = info.promotedTypes;
+    List<Type> newPromotedTypes = info.promotedTypes;
     if (promotedType != null) {
       newPromotedTypes = PromotionModel._addToPromotedTypes(
         info.promotedTypes,
@@ -3760,7 +3760,7 @@ class PromotionModel<Type extends Object> {
   /// Sequence of types that the variable or property has been promoted to,
   /// where each element of the sequence is a subtype of the previous.  Null if
   /// the variable or property hasn't been promoted.
-  final List<Type>? promotedTypes;
+  final List<Type> promotedTypes;
 
   /// List of types that the variable has been tested against in all code paths
   /// leading to the given point in the source code. Not relevant for
@@ -3801,9 +3801,8 @@ class PromotionModel<Type extends Object> {
       !(assigned && unassigned),
       "Can't be both definitely assigned and unassigned",
     );
-    assert(promotedTypes == null || promotedTypes!.isNotEmpty);
     assert(
-      !writeCaptured || promotedTypes == null,
+      !writeCaptured || promotedTypes.isEmpty,
       "Write-captured variables can't be promoted",
     );
     assert(
@@ -3817,7 +3816,7 @@ class PromotionModel<Type extends Object> {
   /// Creates a [PromotionModel] representing a variable or property that's
   /// never been seen before.
   PromotionModel.fresh({this.assigned = false, required this.ssaNode})
-    : promotedTypes = null,
+    : promotedTypes = const [],
       tested = const [],
       unassigned = !assigned,
       nonPromotionHistory = null;
@@ -3833,7 +3832,7 @@ class PromotionModel<Type extends Object> {
   /// the top of loops whose bodies write to them.
   PromotionModel<Type> discardPromotionsAndMarkNotUnassigned() {
     return new PromotionModel<Type>(
-      promotedTypes: null,
+      promotedTypes: const [],
       tested: tested,
       assigned: assigned,
       unassigned: false,
@@ -3844,7 +3843,7 @@ class PromotionModel<Type extends Object> {
   @override
   String toString() {
     List<String> parts = [ssaNode.toString()];
-    if (promotedTypes != null) {
+    if (promotedTypes.isNotEmpty) {
       parts.add('promotedTypes: $promotedTypes');
     }
     if (tested.isNotEmpty) {
@@ -3895,7 +3894,7 @@ class PromotionModel<Type extends Object> {
       helper.typeOperations,
       nonPromotionReason,
     );
-    List<Type>? newPromotedTypes = demotionResult.promotedTypes;
+    List<Type> newPromotedTypes = demotionResult.promotedTypes;
 
     if (promoteToTypeOfInterest) {
       newPromotedTypes = _tryPromoteToTypeOfInterest(
@@ -3918,8 +3917,8 @@ class PromotionModel<Type extends Object> {
     }
 
     List<Type> newTested;
-    if (newPromotedTypes == null &&
-        promotedTypes != null &&
+    if (newPromotedTypes.isEmpty &&
+        promotedTypes.isNotEmpty &&
         !helper.typeAnalyzerOptions.soundFlowAnalysisEnabled) {
       // A full demotion used to clear types of interest. This behavior was
       // removed as part of the sound-flow-analysis update (see
@@ -3943,7 +3942,7 @@ class PromotionModel<Type extends Object> {
   /// been write-captured.
   PromotionModel<Type> writeCapture() {
     return new PromotionModel<Type>(
-      promotedTypes: null,
+      promotedTypes: const [],
       tested: const [],
       assigned: assigned,
       unassigned: false,
@@ -3962,14 +3961,14 @@ class PromotionModel<Type extends Object> {
     FlowAnalysisTypeOperations<Type> typeOperations,
     NonPromotionReason? nonPromotionReason,
   ) {
-    List<Type>? promotedTypes = this.promotedTypes;
-    if (promotedTypes == null) {
-      return new _DemotionResult<Type>(null, nonPromotionHistory);
+    List<Type> promotedTypes = this.promotedTypes;
+    if (promotedTypes.isEmpty) {
+      return new _DemotionResult<Type>(const [], nonPromotionHistory);
     }
 
     int numElementsToKeep = promotedTypes.length;
     NonPromotionHistory<Type>? newNonPromotionHistory = nonPromotionHistory;
-    List<Type>? newPromotedTypes;
+    List<Type> newPromotedTypes = const [];
     for (; ; numElementsToKeep--) {
       if (numElementsToKeep == 0) {
         break;
@@ -4017,20 +4016,21 @@ class PromotionModel<Type extends Object> {
   ///
   /// Note that since promotion chains are considered immutable, if promotion
   /// is required, a new promotion chain will be created and returned.
-  List<Type>? _tryPromoteToTypeOfInterest(
+  List<Type> _tryPromoteToTypeOfInterest(
     FlowModelHelper<Type> helper,
     Type declaredType,
-    List<Type>? promotedTypes,
+    List<Type> promotedTypes,
     Type writtenType,
   ) {
     assert(!writeCaptured);
 
     // Figure out if we have any promotion candidates (types that are a
     // supertype of writtenType and a proper subtype of the currently-promoted
     // type).  If at any point we find an exact match, we take it immediately.
-    Type currentlyPromotedType = promotedTypes?.last ?? declaredType;
+    Type currentlyPromotedType =
+        promotedTypes.isNotEmpty ? promotedTypes.last : declaredType;
 
-    List<Type>? result;
+    List<Type>? result = null;
     List<Type>? candidates = null;
 
     void handleTypeOfInterest(Type type) {
@@ -4171,7 +4171,7 @@ class PromotionModel<Type extends Object> {
     _PropertySsaNode<Type>? propertySsaNode,
   }) {
     FlowAnalysisTypeOperations<Type> typeOperations = helper.typeOperations;
-    List<Type>? newPromotedTypes = joinPromotedTypes(
+    List<Type> newPromotedTypes = joinPromotedTypes(
       first.promotedTypes,
       second.promotedTypes,
       typeOperations,
@@ -4208,13 +4208,13 @@ class PromotionModel<Type extends Object> {
   /// chains.  Briefly, we intersect given chains.  The chains are totally
   /// ordered subsets of a global partial order.  Their intersection is a
   /// subset of each, and as such is also totally ordered.
-  static List<Type>? joinPromotedTypes<Type extends Object>(
-    List<Type>? chain1,
-    List<Type>? chain2,
+  static List<Type> joinPromotedTypes<Type extends Object>(
+    List<Type> chain1,
+    List<Type> chain2,
     FlowAnalysisTypeOperations<Type> typeOperations,
   ) {
-    if (chain1 == null) return chain1;
-    if (chain2 == null) return chain2;
+    if (chain1.isEmpty) return chain1;
+    if (chain2.isEmpty) return chain2;
 
     int index1 = 0;
     int index2 = 0;
@@ -4244,7 +4244,7 @@ class PromotionModel<Type extends Object> {
 
     if (index1 == chain1.length && !skipped1) return chain1;
     if (index2 == chain2.length && !skipped2) return chain2;
-    return result;
+    return result ?? const [];
   }
 
   /// Performs the portion of the "join" algorithm that applies to promotion
@@ -4294,16 +4294,16 @@ class PromotionModel<Type extends Object> {
   /// In degenerate cases, the returned chain will be identical to
   /// [newPromotions] or [basePromotions] (to make it easier for the
   /// caller to detect when data structures may be re-used).
-  static List<Type>? rebasePromotedTypes<Type extends Object>({
-    required List<Type>? basePromotions,
-    required List<Type>? newPromotions,
+  static List<Type> rebasePromotedTypes<Type extends Object>({
+    required List<Type> basePromotions,
+    required List<Type> newPromotions,
     required FlowModelHelper<Type> helper,
   }) {
-    if (basePromotions == null) {
+    if (basePromotions.isEmpty) {
       // The base promotion chain contributes nothing so we just use this
       // promotion chain directly.
       return newPromotions;
-    } else if (newPromotions == null) {
+    } else if (newPromotions.isEmpty) {
       // This promotion chain contributes nothing so we just use the base
       // promotion chain directly. Note: this is a performance optimization of
       // the `else` block below; it is not required by the spec.
@@ -4335,10 +4335,10 @@ class PromotionModel<Type extends Object> {
   }
 
   static List<Type> _addToPromotedTypes<Type extends Object>(
-    List<Type>? promotedTypes,
+    List<Type> promotedTypes,
     Type promoted,
   ) =>
-      promotedTypes == null
+      promotedTypes.isEmpty
           ? [promoted]
           : (promotedTypes.toList()..add(promoted));
 
@@ -4355,7 +4355,7 @@ class PromotionModel<Type extends Object> {
   static PromotionModel<Type> _identicalOrNew<Type extends Object>(
     PromotionModel<Type> first,
     PromotionModel<Type> second,
-    List<Type>? newPromotedTypes,
+    List<Type> newPromotedTypes,
     List<Type> newTested,
     bool newAssigned,
     bool newUnassigned,
@@ -4740,7 +4740,7 @@ class SsaNode<Type extends Object> {
         newFlowModel,
       );
       if (afterFinallyModel == null) continue;
-      List<Type>? afterFinallyPromotedTypes = afterFinallyModel.promotedTypes;
+      List<Type> afterFinallyPromotedTypes = afterFinallyModel.promotedTypes;
       // The property was accessed in a promotion-relevant way in the `try`
       // block, so we need to apply the promotions from the `finally` block to
       // the flow model from the `try` block, and see what sticks.
@@ -4756,8 +4756,8 @@ class SsaNode<Type extends Object> {
           newModel,
         );
       }
-      List<Type>? newPromotedTypes = newModel.promotedTypes;
-      List<Type>? rebasedPromotedTypes = PromotionModel.rebasePromotedTypes(
+      List<Type> newPromotedTypes = newModel.promotedTypes;
+      List<Type> rebasedPromotedTypes = PromotionModel.rebasePromotedTypes(
         basePromotions: newPromotedTypes,
         newPromotions: afterFinallyPromotedTypes,
         helper: helper,
@@ -5090,7 +5090,7 @@ class _ConditionalContext<Type extends Object> extends _BranchContext<Type> {
 /// to another.
 class _DemotionResult<Type extends Object> {
   /// The new set of promoted types.
-  final List<Type>? promotedTypes;
+  final List<Type> promotedTypes;
 
   /// The new non-promotion history (including the types that the variable is
   /// no longer promoted to).
@@ -6185,7 +6185,7 @@ class _FlowAnalysisImpl<
         this,
         promotionKey,
         new PromotionModel(
-          promotedTypes: nonNullType == targetType ? null : [nonNullType],
+          promotedTypes: nonNullType == targetType ? const [] : [nonNullType],
           tested: const [],
           assigned: true,
           unassigned: false,
@@ -6377,7 +6377,7 @@ class _FlowAnalysisImpl<
     return _current.promotionInfo
         ?.get(this, promotionKeyStore.keyForVariable(variable))
         ?.promotedTypes
-        ?.last;
+        .lastOrNull;
   }
 
   @override
@@ -6544,7 +6544,7 @@ class _FlowAnalysisImpl<
     );
     if (promotionInfo == null) return const [];
     assert(promotionInfo.ssaNode == propertySsaNode);
-    return promotionInfo.promotedTypes ?? const [];
+    return promotionInfo.promotedTypes;
   }
 
   @override
@@ -6881,7 +6881,7 @@ class _FlowAnalysisImpl<
     ).addPreviousInfo(promotionModel.ssaNode?.expressionInfo, this, _current);
     _storeExpressionReference(expression, expressionInfo);
     _storeExpressionInfo(expression, expressionInfo);
-    return promotionModel.promotedTypes?.last;
+    return promotionModel.promotedTypes.lastOrNull;
   }
 
   @override
@@ -7109,7 +7109,7 @@ class _FlowAnalysisImpl<
     return _current.promotionInfo
             ?.get(this, context._matchedValueInfo.promotionKey)
             ?.promotedTypes
-            ?.last ??
+            .lastOrNull ??
         context._matchedValueInfo._type;
   }
 
@@ -7133,8 +7133,8 @@ class _FlowAnalysisImpl<
             ssaNode.promotionKey,
             ssaNode: ssaNode,
           );
-          List<Type>? promotedTypes = previousPromotionInfo.promotedTypes;
-          if (promotedTypes != null) {
+          List<Type> promotedTypes = previousPromotionInfo.promotedTypes;
+          if (promotedTypes.isNotEmpty) {
             (allPreviouslyPromotedTypes ??= []).add(promotedTypes);
           }
           ssaNode = ssaNode.previousSsaNode;
@@ -7171,8 +7171,8 @@ class _FlowAnalysisImpl<
         reference.promotionKey,
       );
       if (variable == null) {
-        List<Type>? promotedTypes = currentPromotionInfo.promotedTypes;
-        if (promotedTypes != null) {
+        List<Type> promotedTypes = currentPromotionInfo.promotedTypes;
+        if (promotedTypes.isNotEmpty) {
           return () {
             Map<Type, NonPromotionReason> result = <Type, NonPromotionReason>{};
             for (Type type in promotedTypes) {
@@ -7185,7 +7185,7 @@ class _FlowAnalysisImpl<
         return () {
           Map<Type, NonPromotionReason> result = <Type, NonPromotionReason>{};
           Type currentType =
-              currentPromotionInfo.promotedTypes?.last ??
+              currentPromotionInfo.promotedTypes.lastOrNull ??
               operations.variableType(variable);
           NonPromotionHistory<Type>? nonPromotionHistory =
               currentPromotionInfo.nonPromotionHistory;
@@ -7332,7 +7332,7 @@ class _FlowAnalysisImpl<
       if (promotionInfo != null) {
         assert(promotionInfo.ssaNode == propertySsaNode);
       }
-      promotedType = promotionInfo?.promotedTypes?.last;
+      promotedType = promotionInfo?.promotedTypes.lastOrNull;
       if (promotedType != null &&
           !operations.isSubtypeOf(promotedType, unpromotedType)) {
         promotedType = null;
@@ -7449,7 +7449,7 @@ class _FlowAnalysisImpl<
       this,
       promotionKey,
       new PromotionModel(
-        promotedTypes: null,
+        promotedTypes: const [],
         tested: const [],
         assigned: true,
         unassigned: false,
@@ -7625,7 +7625,7 @@ class _FlowAnalysisImpl<
     return new TrivialVariableReference<Type>(
       promotionKey: variableKey,
       model: _current,
-      type: info.promotedTypes?.last ?? unpromotedType,
+      type: info.promotedTypes.lastOrNull ?? unpromotedType,
       isThisOrSuper: false,
       ssaNode: info.ssaNode ?? new SsaNode<Type>(null),
     );