Infer type arguments in constructor redirections.

[email protected]

Bug: #30855
Change-Id: I05e9102fe7b7a304be6ac6dd4d59e11bdafee59c
Reviewed-on: https://dart-review.googlesource.com/46575
Reviewed-by: Brian Wilkerson <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -94,7 +94,7 @@ class AnalysisDriver implements AnalysisDriverGeneric {
   /**
    * The version of data format, should be incremented on every format change.
    */
-  static const int DATA_VERSION = 51;
+  static const int DATA_VERSION = 52;
 
   /**
    * The number of exception contexts allowed to write. Once this field is

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

@@ -8401,7 +8401,13 @@ class TypeNameResolver {
             typeSystem.instantiateTypeFormalsToBounds(element.typeParameters);
         type = element.typeAfterSubstitution(typeArguments) ?? dynamicType;
       } else {
-        type = typeSystem.instantiateToBounds(type);
+        DartType redirectedType =
+            _inferTypeArgumentsForRedirectedConstructor(node, type);
+        if (redirectedType != null) {
+          type = redirectedType;
+        } else {
+          type = typeSystem.instantiateToBounds(type);
+        }
       }
     }
     typeName.staticType = type;
@@ -8509,6 +8515,34 @@ class TypeNameResolver {
     return type;
   }
 
+  /**
+   * If the [node] is the type name in a redirected factory constructor,
+   * infer type arguments using the enclosing class declaration. Return `null`
+   * otherwise.
+   */
+  DartType _inferTypeArgumentsForRedirectedConstructor(
+      TypeName node, DartType type) {
+    AstNode constructorName = node.parent;
+    AstNode enclosingConstructor = constructorName?.parent;
+    TypeSystem ts = typeSystem;
+    if (constructorName is ConstructorName &&
+        enclosingConstructor is ConstructorDeclaration &&
+        enclosingConstructor.redirectedConstructor == constructorName &&
+        type is InterfaceType &&
+        ts is StrongTypeSystemImpl) {
+      ClassDeclaration enclosingClassNode = enclosingConstructor.parent;
+      ClassElement enclosingClassElement = enclosingClassNode.element;
+      if (enclosingClassElement == type.element) {
+        return type;
+      } else {
+        InterfaceType contextType = enclosingClassElement.type;
+        return ts.inferGenericFunctionOrType(
+            type, const <ParameterElement>[], const <DartType>[], contextType);
+      }
+    }
+    return null;
+  }
+
   /**
    * Checks if the given [typeName] is used as the type in an as expression.
    */

pkg/analyzer/test/generated/strong_mode_test.dart

@@ -2476,6 +2476,68 @@ num test(Iterable values) => values.fold(values.first as num, max);
     _isInstantiationOf(_hasElement(elementA))([_isNum, _isNum])(type);
   }
 
+  test_redirectedConstructor_named() async {
+    Source source = addSource(r'''
+class A<T, U> implements B<T, U> {
+  A.named();
+}
+
+class B<T2, U2> {
+  factory B() = A.named;
+}
+   ''');
+    TestAnalysisResult result = await computeAnalysisResult(source);
+    assertNoErrors(source);
+
+    ClassDeclaration b = result.unit.declarations[1];
+    ConstructorDeclaration bConstructor = b.members[0];
+    ConstructorName redirected = bConstructor.redirectedConstructor;
+
+    TypeName typeName = redirected.type;
+    expect(typeName.type.toString(), 'A<T2, U2>');
+    expect(typeName.type.toString(), 'A<T2, U2>');
+
+    var constructorMember = redirected.staticElement;
+    expect(constructorMember.toString(), 'A.named() → A<T2, U2>');
+    expect(redirected.name.staticElement, constructorMember);
+  }
+
+  test_redirectedConstructor_self() async {
+    Source source = addSource(r'''
+class A<T> {
+  A();
+  factory A.redirected() = A;
+}
+   ''');
+    await computeAnalysisResult(source);
+    assertNoErrors(source);
+  }
+
+  test_redirectedConstructor_unnamed() async {
+    Source source = addSource(r'''
+class A<T, U> implements B<T, U> {
+  A();
+}
+
+class B<T2, U2> {
+  factory B() = A;
+}
+   ''');
+    TestAnalysisResult result = await computeAnalysisResult(source);
+    assertNoErrors(source);
+
+    ClassDeclaration b = result.unit.declarations[1];
+    ConstructorDeclaration bConstructor = b.members[0];
+    ConstructorName redirected = bConstructor.redirectedConstructor;
+
+    TypeName typeName = redirected.type;
+    expect(typeName.type.toString(), 'A<T2, U2>');
+    expect(typeName.type.toString(), 'A<T2, U2>');
+
+    expect(redirected.name, isNull);
+    expect(redirected.staticElement.toString(), 'A() → A<T2, U2>');
+  }
+
   test_redirectingConstructor_propagation() async {
     String code = r'''
       class A {