[flow analysis] Rework tests of try/finally ordering.

This change adds test-only methods `propertyPromotionChainForTesting`
and `variablePromotionChainForTesting` to flow analysis; these are
used by the flow analysis unit tests to query the full promotion chain
of a porperty (or variable, respectively). This allows tests to
observe the effect of try/finally ordering on promotion chains without
having to resort to clever control flow joins.

Thanks to Lasse for the suggestion.

Change-Id: Ida5349ecc93dbd4b3392becd20882be3eb101024
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/432800
Reviewed-by: Lasse Nielsen <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

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

@@ -970,6 +970,34 @@ abstract class FlowAnalysis<
     Type unpromotedType,
   );
 
+  /// The promotion chain associated with the property named [propertyName].
+  ///
+  /// **For testing only!**
+  ///
+  /// The promotion chain only contains the promoted-to types, not the original
+  /// declared type at the top of the chain. Thus, the list is empty if the
+  /// property is not currently promoted.
+  ///
+  /// The type of [target] determines how the property is looked up:
+  /// - If [target] is an [ExpressionPropertyTarget], a property of an
+  ///   expression is queried, and this method should be called just after
+  ///   calling the method(s) that would normally be called when performing flow
+  ///   analysis on the target expression (e.g., [propertyGet] or
+  ///   [variableRead]).
+  /// - If [target] is [ThisPropertyTarget], a property of `this` is queried.
+  /// - If [target] is [SuperPropertyTarget], a property of `super` is queried.
+  ///
+  /// [propertyMember] should be whatever data structure the client uses to keep
+  /// track of the field or property being accessed. If not `null`, and field
+  /// promotion is enabled for the current library,
+  /// [FlowAnalysisOperations.isPropertyPromotable] will be consulted to find
+  /// out whether the property is promotable.
+  List<Type> propertyPromotionChainForTesting(
+    PropertyTarget<Expression> target,
+    String propertyName,
+    Object? propertyMember,
+  );
+
   /// Call this method just before analyzing a subpattern of an object pattern.
   ///
   /// [propertyName] is the name of the property being accessed by this
@@ -1181,6 +1209,15 @@ abstract class FlowAnalysis<
   /// statement.
   void tryFinallyStatement_finallyBegin(Node body);
 
+  /// The promotion chain associated with [variable].
+  ///
+  /// **For testing only!**
+  ///
+  /// The promotion chain only contains the promoted-to types, not the original
+  /// declared type at the top of the chain. Thus, the list is empty if the
+  /// variable is not currently promoted.
+  List<Type> variablePromotionChainForTesting(Variable variable);
+
   /// Call this method when encountering an expression that reads the value of
   /// a variable.
   ///
@@ -2179,6 +2216,24 @@ class FlowAnalysisDebug<
     );
   }
 
+  @override
+  List<Type> propertyPromotionChainForTesting(
+    PropertyTarget<Expression> target,
+    String propertyName,
+    Object? propertyMember,
+  ) {
+    return _wrap(
+      'propertyPromotionChainForTesting($target, $propertyName, '
+      '$propertyMember)',
+      () => _wrapped.propertyPromotionChainForTesting(
+        target,
+        propertyName,
+        propertyMember,
+      ),
+      isQuery: true,
+    );
+  }
+
   @override
   Type? pushPropertySubpattern(
     String propertyName,
@@ -2375,6 +2430,15 @@ class FlowAnalysisDebug<
     );
   }
 
+  @override
+  List<Type> variablePromotionChainForTesting(Variable variable) {
+    return _wrap(
+      'variablePromotionChainForTesting($variable)',
+      () => _wrapped.variablePromotionChainForTesting(variable),
+      isQuery: true,
+    );
+  }
+
   @override
   Type? variableRead(Expression expression, Variable variable) {
     return _wrap(
@@ -6382,6 +6446,36 @@ class _FlowAnalysisImpl<
     return promotedType;
   }
 
+  @override
+  List<Type> propertyPromotionChainForTesting(
+    PropertyTarget<Expression> target,
+    String propertyName,
+    Object? propertyMember,
+  ) {
+    SsaNode<Type>? targetSsaNode = target._getSsaNode(this);
+    if (targetSsaNode == null) return const [];
+    // Find the SSA node for the target of the property access, and figure out
+    // whether the property in question is promotable.
+    bool isPromotable =
+        propertyMember != null &&
+        typeAnalyzerOptions.fieldPromotionEnabled &&
+        operations.isPropertyPromotable(propertyMember);
+    if (!isPromotable) return const [];
+    _PropertySsaNode<Type> propertySsaNode = targetSsaNode
+        .getOrCreatePropertyNode(
+          propertyName,
+          promotionKeyStore,
+          isPromotable: isPromotable,
+        );
+    PromotionModel<Type>? promotionInfo = _current.promotionInfo?.get(
+      this,
+      propertySsaNode.promotionKey,
+    );
+    if (promotionInfo == null) return const [];
+    assert(promotionInfo.ssaNode == propertySsaNode);
+    return promotionInfo.promotedTypes ?? const [];
+  }
+
   @override
   Type? pushPropertySubpattern(
     String propertyName,
@@ -6687,6 +6781,13 @@ class _FlowAnalysisImpl<
     context._beforeFinally = _current;
   }
 
+  @override
+  List<Type> variablePromotionChainForTesting(Variable variable) =>
+      _current.promotionInfo
+          ?.get(this, promotionKeyStore.keyForVariable(variable))
+          ?.promotedTypes ??
+      const [];
+
   @override
   Type? variableRead(Expression expression, Variable variable) {
     Type unpromotedType = operations.variableType(variable);