Implement inference via type aliases with aliased InterfaceType.

Change-Id: I1d2bba09f19468bc8e095c5ef4a39c09365eb2a4
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/193450
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -6,17 +6,50 @@ import 'package:_fe_analyzer_shared/src/flow_analysis/flow_analysis.dart';
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
+import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/migration.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
+/// Information about a constructor element to instantiate.
+///
+/// If the target is a [ClassElement], the [element] is a raw
+/// [ConstructorElement] from the class, and [typeParameters] are the
+/// type parameters of the class.
+///
+/// If the target is a [TypeAliasElement] with an [InterfaceType] as the
+/// aliased type, the [element] is a [ConstructorMember] created from the
+/// [ConstructorElement] of the corresponding class, and substituting
+/// the class type parameters with the type arguments specified in the alias,
+/// explicit types or the type parameters of the alias. The [typeParameters]
+/// are the type parameters of the alias.
+class ConstructorElementToInfer {
+  /// The type parameters used in [element].
+  final List<TypeParameterElement> typeParameters;
+
+  /// The element, might be [ConstructorMember].
+  final ConstructorElement element;
+
+  ConstructorElementToInfer(this.typeParameters, this.element);
+
+  FunctionType get asType {
+    return FunctionTypeImpl(
+      typeFormals: typeParameters,
+      parameters: element.parameters,
+      returnType: element.returnType,
+      nullabilitySuffix: NullabilitySuffix.star,
+    );
+  }
+}
+
 class InvocationInferenceHelper {
   final ResolverVisitor _resolver;
   final ErrorReporter _errorReporter;
@@ -49,6 +82,50 @@ class InvocationInferenceHelper {
     }
   }
 
+  /// If the constructor referenced by the [constructorName] is generic,
+  /// and the [constructorName] does not have explicit type arguments,
+  /// return the element and type parameters to infer. Otherwise return `null`.
+  ConstructorElementToInfer? constructorElementToInfer({
+    required ConstructorName constructorName,
+    required LibraryElement definingLibrary,
+  }) {
+    List<TypeParameterElement>? typeParameters;
+    ConstructorElement? rawElement;
+
+    var typeName = constructorName.type;
+    var typeArguments = typeName.typeArguments;
+    var typeElement = typeName.name.staticElement;
+    if (typeElement is ClassElement) {
+      typeParameters = typeElement.typeParameters;
+      if (typeParameters.isNotEmpty && typeArguments == null) {
+        var constructorIdentifier = constructorName.name;
+        if (constructorIdentifier == null) {
+          rawElement = typeElement.unnamedConstructor;
+        } else {
+          var name = constructorIdentifier.name;
+          rawElement = typeElement.getNamedConstructor(name);
+        }
+      }
+    } else if (typeElement is TypeAliasElement) {
+      typeParameters = typeElement.typeParameters;
+      var aliasedType = typeElement.aliasedType;
+      if (aliasedType is InterfaceType) {
+        if (typeParameters.isNotEmpty && typeArguments == null) {
+          var constructorIdentifier = constructorName.name;
+          rawElement = aliasedType.lookUpConstructor(
+            constructorIdentifier?.name,
+            definingLibrary,
+          );
+        }
+      }
+    }
+
+    if (typeParameters != null && rawElement != null) {
+      rawElement = _resolver.toLegacyElement(rawElement);
+      return ConstructorElementToInfer(typeParameters, rawElement);
+    }
+  }
+
   FunctionType? inferArgumentTypesForGeneric(AstNode inferenceNode,
       DartType? uninstantiatedType, TypeArgumentList? typeArguments,
       {AstNode? errorNode, bool isConst = false}) {

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

@@ -2258,22 +2258,24 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
 
   void _inferArgumentTypesForInstanceCreate(
       covariant InstanceCreationExpressionImpl node) {
-    var constructor = node.constructorName;
-    TypeName classTypeName = constructor.type;
-    // if (classTypeName == null) {
-    //   return;
-    // }
+    var constructorName = node.constructorName;
+
+    var typeName = constructorName.type;
+    var typeArguments = typeName.typeArguments;
+
+    var elementToInfer = inferenceHelper.constructorElementToInfer(
+      constructorName: constructorName,
+      definingLibrary: definingLibrary,
+    );
 
-    var originalElement = constructor.staticElement;
     FunctionType? inferred;
     // If the constructor is generic, we'll have a ConstructorMember that
     // substitutes in type arguments (possibly `dynamic`) from earlier in
     // resolution.
     //
     // Otherwise we'll have a ConstructorElement, and we can skip inference
     // because there's nothing to infer in a non-generic type.
-    if (classTypeName.typeArguments == null &&
-        originalElement is ConstructorMember) {
+    if (elementToInfer != null) {
       // TODO(leafp): Currently, we may re-infer types here, since we
       // sometimes resolve multiple times.  We should really check that we
       // have not already inferred something.  However, the obvious ways to
@@ -2284,14 +2286,11 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
       // Get back to the uninstantiated generic constructor.
       // TODO(jmesserly): should we store this earlier in resolution?
       // Or look it up, instead of jumping backwards through the Member?
-      var rawElement = originalElement.declaration;
-      rawElement = toLegacyElement(rawElement);
-
-      FunctionType constructorType =
-          typeAnalyzer.constructorToGenericFunctionType(rawElement);
+      var rawElement = elementToInfer.element;
+      var constructorType = elementToInfer.asType;
 
       inferred = inferenceHelper.inferArgumentTypesForGeneric(
-          node, constructorType, constructor.type.typeArguments,
+          node, constructorType, typeArguments,
           isConst: node.isConst, errorNode: node.constructorName);
 
       if (inferred != null) {
@@ -2301,23 +2300,25 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
         arguments.correspondingStaticParameters =
             resolveArgumentsToParameters(arguments, inferred.parameters, null);
 
-        constructor.type.type = inferred.returnType;
+        constructorName.type.type = inferred.returnType;
 
         // Update the static element as well. This is used in some cases, such
         // as computing constant values. It is stored in two places.
         var constructorElement = ConstructorMember.from(
           rawElement,
           inferred.returnType as InterfaceType,
         );
-        constructorElement = toLegacyElement(constructorElement);
-        constructor.staticElement = constructorElement;
+        constructorName.staticElement = constructorElement;
       }
     }
 
     if (inferred == null) {
-      var type = originalElement?.type;
-      type = type != null ? toLegacyTypeIfOptOut(type) as FunctionType : null;
-      InferenceContext.setType(node.argumentList, type);
+      var constructorElement = constructorName.staticElement;
+      if (constructorElement != null) {
+        var type = constructorElement.type;
+        type = toLegacyTypeIfOptOut(type) as FunctionType;
+        InferenceContext.setType(node.argumentList, type);
+      }
     }
   }
 

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

@@ -362,18 +362,6 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
   /// Given an instance creation of a possibly generic type, infer the type
   /// arguments using the current context type as well as the argument types.
   void _inferInstanceCreationExpression(InstanceCreationExpressionImpl node) {
-    var constructor = node.constructorName;
-    var originalElement = constructor.staticElement;
-    // If the constructor is generic, we'll have a ConstructorMember that
-    // substitutes in type arguments (possibly `dynamic`) from earlier in
-    // resolution.
-    //
-    // Otherwise we'll have a ConstructorElement, and we can skip inference
-    // because there's nothing to infer in a non-generic type.
-    if (originalElement is! ConstructorMember) {
-      return;
-    }
-
     // TODO(leafp): Currently, we may re-infer types here, since we
     // sometimes resolve multiple times.  We should really check that we
     // have not already inferred something.  However, the obvious ways to
@@ -384,35 +372,39 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     // Get back to the uninstantiated generic constructor.
     // TODO(jmesserly): should we store this earlier in resolution?
     // Or look it up, instead of jumping backwards through the Member?
-    var rawElement = originalElement.declaration;
-    rawElement = _resolver.toLegacyElement(rawElement);
+    var constructorName = node.constructorName;
+    var elementToInfer = _resolver.inferenceHelper.constructorElementToInfer(
+      constructorName: constructorName,
+      definingLibrary: _resolver.definingLibrary,
+    );
+
+    // If the constructor is not generic, we are done.
+    if (elementToInfer == null) {
+      return;
+    }
 
-    FunctionType constructorType = constructorToGenericFunctionType(rawElement);
+    var typeName = constructorName.type;
+    var typeArguments = typeName.typeArguments;
 
+    var constructorType = elementToInfer.asType;
     var arguments = node.argumentList;
     var inferred = _resolver.inferenceHelper.inferGenericInvoke(
-        node,
-        constructorType,
-        constructor.type.typeArguments,
-        arguments,
-        node.constructorName,
+        node, constructorType, typeArguments, arguments, constructorName,
         isConst: node.isConst);
 
-    if (inferred != null && inferred != originalElement.type) {
-      inferred = _resolver.toLegacyTypeIfOptOut(inferred) as FunctionType;
+    if (inferred != null) {
       // Fix up the parameter elements based on inferred method.
       arguments.correspondingStaticParameters =
           ResolverVisitor.resolveArgumentsToParameters(
               arguments, inferred.parameters, null);
-      constructor.type.type = inferred.returnType;
+      typeName.type = inferred.returnType;
       // Update the static element as well. This is used in some cases, such as
       // computing constant values. It is stored in two places.
       var constructorElement = ConstructorMember.from(
-        rawElement,
+        elementToInfer.element,
         inferred.returnType as InterfaceType,
       );
-      constructorElement = _resolver.toLegacyElement(constructorElement);
-      constructor.staticElement = constructorElement;
+      constructorName.staticElement = constructorElement;
     }
   }
 }