fix #25486, promote from dynamic in strong mode

[email protected]

Review URL: https://codereview.chromium.org/1585323003 .

Author: John Messerly

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

@@ -9723,24 +9723,17 @@ class ResolverVisitor extends ScopedVisitor {
         return;
       }
       // prepare current variable type
-      DartType type = _promoteManager.getType(element);
-      if (type == null) {
-        type = expression.staticType;
-      }
-      // Declared type should not be "dynamic".
-      if (type == null || type.isDynamic) {
-        return;
-      }
-      // Promoted type should not be "dynamic".
-      if (potentialType == null || potentialType.isDynamic) {
-        return;
-      }
-      // Promoted type should be more specific than declared.
-      if (!potentialType.isMoreSpecificThan(type)) {
-        return;
+      DartType type = _promoteManager.getType(element) ??
+          expression.staticType ??
+          DynamicTypeImpl.instance;
+
+      potentialType ??= DynamicTypeImpl.instance;
+
+      // Check if we can promote to potentialType from type.
+      if (typeSystem.canPromoteToType(potentialType, type)) {
+        // Do promote type of variable.
+        _promoteManager.setType(element, potentialType);
       }
-      // Do promote type of variable.
-      _promoteManager.setType(element, potentialType);
     }
   }
 

pkg/analyzer/lib/src/generated/type_system.dart

@@ -29,6 +29,9 @@ class StrongTypeSystemImpl implements TypeSystem {
     return ft.parameters.any((p) => predicate(p.type));
   }
 
+  @override
+  bool canPromoteToType(DartType to, DartType from) => isSubtypeOf(to, from);
+
   /**
    * Given a type t, if t is an interface type with a call method
    * defined, return the function type for the call method, otherwise
@@ -562,6 +565,16 @@ class StrongTypeSystemImpl implements TypeSystem {
  * pluggable.
  */
 abstract class TypeSystem {
+  /**
+   * Returns `true` if we can promote to the first type from the second type.
+   *
+   * In the standard Dart type system, it is not possible to promote from or to
+   * `dynamic`, and we must be promoting to a more specific type.
+   *
+   * In strong mode, this is equivalent to [isSubtypeOf].
+   */
+  bool canPromoteToType(DartType to, DartType from);
+
   /**
    * Compute the least upper bound of two types.
    */
@@ -605,6 +618,14 @@ abstract class TypeSystem {
 class TypeSystemImpl implements TypeSystem {
   TypeSystemImpl();
 
+  @override
+  bool canPromoteToType(DartType to, DartType from) {
+    // Declared type should not be "dynamic".
+    // Promoted type should not be "dynamic".
+    // Promoted type should be more specific than declared.
+    return !from.isDynamic && !to.isDynamic && to.isMoreSpecificThan(from);
+  }
+
   @override
   DartType getLeastUpperBound(
       TypeProvider typeProvider, DartType type1, DartType type2) {

pkg/analyzer/test/generated/resolver_test.dart

@@ -2276,6 +2276,44 @@ class C {
   }
 }
 
+/**
+ * Tests for generic method and function resolution that do not use strong mode.
+ */
+@reflectiveTest
+class GenericMethodResolverTest extends _StaticTypeAnalyzer2TestShared {
+  void setUp() {
+    super.setUp();
+    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
+    options.enableGenericMethods = true;
+    resetWithOptions(options);
+  }
+
+  void test_genericMethod_propagatedType_promotion() {
+    // Regression test for:
+    // https://github.com/dart-lang/sdk/issues/25340
+    //
+    // Note, after https://github.com/dart-lang/sdk/issues/25486 the original
+    // strong mode example won't work, as we now compute a static type and
+    // therefore discard the propagated type.
+    //
+    // So this test does not use strong mode.
+    _resolveTestUnit(r'''
+abstract class Iter {
+  List<S> map<S>(S f(x));
+}
+class C {}
+C toSpan(dynamic element) {
+  if (element is Iter) {
+    var y = element.map(toSpan);
+  }
+  return null;
+}''');
+    SimpleIdentifier y = _findIdentifier('y = ');
+    expect(y.staticType.toString(), 'dynamic');
+    expect(y.propagatedType.toString(), 'List<dynamic>');
+  }
+}
+
 @reflectiveTest
 class HintCodeTest extends ResolverTestCase {
   void fail_deadCode_statementAfterRehrow() {
@@ -13596,6 +13634,11 @@ class D extends C {
   void test_genericMethod_propagatedType_promotion() {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25340
+
+    // Note, after https://github.com/dart-lang/sdk/issues/25486 the original
+    // example won't work, as we now compute a static type and therefore discard
+    // the propagated type. So a new test was created that doesn't run under
+    // strong mode.
     _resolveTestUnit(r'''
 abstract class Iter {
   List/*<S>*/ map/*<S>*/(/*=S*/ f(x));
@@ -13608,8 +13651,8 @@ C toSpan(dynamic element) {
   return null;
 }''');
     SimpleIdentifier y = _findIdentifier('y = ');
-    expect(y.staticType.toString(), 'dynamic');
-    expect(y.propagatedType.toString(), 'List<dynamic>');
+    expect(y.staticType.toString(), 'List<C>');
+    expect(y.propagatedType, isNull);
   }
 
   void test_genericMethod_tearoff() {

pkg/analyzer/test/src/task/strong/checker_test.dart

@@ -1432,6 +1432,25 @@ void main() {
       '''
   });
 
+  testChecker('type promotion from dynamic', {
+    '/main.dart': r'''
+          f() {
+            dynamic x;
+            if (x is int) {
+              int y = x;
+              String z = /*severe:STATIC_TYPE_ERROR*/x;
+            }
+          }
+          g() {
+            Object x;
+            if (x is int) {
+              int y = x;
+              String z = /*severe:STATIC_TYPE_ERROR*/x;
+            }
+          }
+    '''
+  });
+
   testChecker('unary operators', {
     '/main.dart': '''
       class A {