Flow analysis: introduce TypeOperations.tryPromoteToType method.

Previously, any attempt to promote type A to type B produced type B if
B was a subtype of A, and failed otherwise.  But in order to support
promotion of type parameters, we need the ability to produce a fresh
"intersection type" (e.g. `T & int`).  The new
`TypeOperations.tryPromoteToType method` makes this possible by giving
the client the opportunity to synthesize the new type when necessary.

Change-Id: If671d5d865f38469a878329180c3a1c94e25a42c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/122582
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Paul Berry <paulberry@google.com>

Author: stereotype441

pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart

@@ -277,6 +277,16 @@ class TypeSystemTypeOperations
     return typeSystem.promoteToNonNull(type);
   }
 
+  @override
+  DartType tryPromoteToType(DartType to, DartType from) {
+    // TODO(paulberry): implement appropriate logic for type variable promotion.
+    if (isSubtypeOf(to, from)) {
+      return to;
+    } else {
+      return null;
+    }
+  }
+
   @override
   DartType variableType(PromotableElement variable) {
     return variable.type;

pkg/front_end/lib/src/fasta/flow_analysis/flow_analysis.dart

@@ -1054,11 +1054,11 @@ class FlowModel<Variable, Type> {
     Type previousType = info.promotedType;
     previousType ??= typeOperations.variableType(variable);
 
-    if (!typeOperations.isSubtypeOf(type, previousType) ||
-        typeOperations.isSameType(type, previousType)) {
+    Type newType = typeOperations.tryPromoteToType(type, previousType);
+    if (newType == null || typeOperations.isSameType(newType, previousType)) {
       return this;
     }
-    return _updateVariableInfo(variable, info.withPromotedType(type));
+    return _updateVariableInfo(variable, info.withPromotedType(newType));
   }
 
   /// Updates the state to indicate that the given [writtenVariables] are no
@@ -1325,6 +1325,10 @@ abstract class TypeOperations<Variable, Type> {
   /// `FutureOr<int?>`), so [type] may be returned even if it is nullable.
   Type /*!*/ promoteToNonNull(Type type);
 
+  /// Tries to promote to the first type from the second type, and returns the
+  /// promoted type if it succeeds, otherwise null.
+  Type tryPromoteToType(Type to, Type from);
+
   /// Return the static type of the given [variable].
   Type variableType(Variable variable);
 }

pkg/front_end/test/fasta/flow_analysis/flow_analysis_test.dart

@@ -2092,6 +2092,15 @@ class _Harness implements TypeOperations<_Var, _Type> {
     _flow.finish();
   }
 
+  @override
+  _Type tryPromoteToType(_Type to, _Type from) {
+    if (isSubtypeOf(to, from)) {
+      return to;
+    } else {
+      return null;
+    }
+  }
+
   LazyExpression variableRead(_Var variable) {
     return () {
       var expr = _Expression();

pkg/nnbd_migration/lib/src/decorated_type_operations.dart

@@ -34,6 +34,16 @@ class DecoratedTypeOperations
     return type.withNode(_graph.never);
   }
 
+  @override
+  DecoratedType tryPromoteToType(DecoratedType to, DecoratedType from) {
+    // TODO(paulberry): implement appropriate logic for type variable promotion.
+    if (isSubtypeOf(to, from)) {
+      return to;
+    } else {
+      return null;
+    }
+  }
+
   @override
   DecoratedType variableType(PromotableElement variable) {
     return _variableRepository.decoratedElementType(variable);