Resolve annotations via type aliases.

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

Author: scheglov

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

@@ -14,6 +14,7 @@ import 'package:analyzer/src/dart/constant/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/dart/resolver/invocation_inference_helper.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ -46,6 +47,38 @@ class AnnotationResolver {
     }
   }
 
+  void _classConstructorInvocation(
+    AnnotationImpl node,
+    ClassElement classElement,
+    SimpleIdentifierImpl? constructorName,
+    ArgumentList argumentList,
+    List<Map<DartType, NonPromotionReason> Function()> whyNotPromotedList,
+  ) {
+    ConstructorElement? constructorElement;
+    if (constructorName != null) {
+      constructorElement = classElement.getNamedConstructor(
+        constructorName.name,
+      );
+    } else {
+      constructorElement = classElement.unnamedConstructor;
+    }
+
+    _constructorInvocation(
+      node,
+      constructorName,
+      classElement.typeParameters,
+      constructorElement,
+      argumentList,
+      (typeArguments) {
+        return classElement.instantiate(
+          typeArguments: typeArguments,
+          nullabilitySuffix: _resolver.noneOrStarSuffix,
+        );
+      },
+      whyNotPromotedList,
+    );
+  }
+
   void _classGetter(
     AnnotationImpl node,
     ClassElement classElement,
@@ -80,20 +113,13 @@ class AnnotationResolver {
 
   void _constructorInvocation(
     AnnotationImpl node,
-    ClassElement classElement,
     SimpleIdentifierImpl? constructorName,
+    List<TypeParameterElement> typeParameters,
+    ConstructorElement? constructorElement,
     ArgumentList argumentList,
+    InterfaceType Function(List<DartType> typeArguments) instantiateElement,
     List<Map<DartType, NonPromotionReason> Function()> whyNotPromotedList,
   ) {
-    ConstructorElement? constructorElement;
-    if (constructorName != null) {
-      constructorElement = classElement.getNamedConstructor(
-        constructorName.name,
-      );
-    } else {
-      constructorElement = classElement.unnamedConstructor;
-    }
-
     constructorElement = _resolver.toLegacyElement(constructorElement);
     constructorName?.staticElement = constructorElement;
     node.element = constructorElement;
@@ -108,8 +134,6 @@ class AnnotationResolver {
       return;
     }
 
-    var typeParameters = classElement.typeParameters;
-
     // If no type parameters, the elements are correct.
     if (typeParameters.isEmpty) {
       _resolveConstructorInvocationArguments(node);
@@ -123,10 +147,7 @@ class AnnotationResolver {
       List<DartType> typeArguments,
       ConstructorElement constructorElement,
     ) {
-      var type = classElement.instantiate(
-        typeArguments: typeArguments,
-        nullabilitySuffix: _resolver.noneOrStarSuffix,
-      );
+      var type = instantiateElement(typeArguments);
       constructorElement = ConstructorMember.from(constructorElement, type);
       constructorName?.staticElement = constructorElement;
       node.element = constructorElement;
@@ -166,8 +187,11 @@ class AnnotationResolver {
     _resolver.visitArgumentList(argumentList,
         whyNotPromotedList: whyNotPromotedList);
 
-    var constructorRawType = _resolver.typeAnalyzer
-        .constructorToGenericFunctionType(constructorElement);
+    var elementToInfer = ConstructorElementToInfer(
+      typeParameters,
+      constructorElement,
+    );
+    var constructorRawType = elementToInfer.asType;
 
     var inferred = _resolver.inferenceHelper.inferGenericInvoke(
         node, constructorRawType, typeArgumentList, argumentList, node,
@@ -264,7 +288,7 @@ class AnnotationResolver {
     // Class(args) or Class.CONST
     if (element1 is ClassElement) {
       if (argumentList != null) {
-        _constructorInvocation(
+        _classConstructorInvocation(
             node, element1, name2, argumentList, whyNotPromotedList);
       } else {
         _classGetter(node, element1, name2, whyNotPromotedList);
@@ -286,7 +310,7 @@ class AnnotationResolver {
         // prefix.Class(args) or prefix.Class.CONST
         if (element2 is ClassElement) {
           if (argumentList != null) {
-            _constructorInvocation(
+            _classConstructorInvocation(
                 node, element2, name3, argumentList, whyNotPromotedList);
           } else {
             _classGetter(node, element2, name3, whyNotPromotedList);
@@ -303,6 +327,19 @@ class AnnotationResolver {
           _propertyAccessorElement(node, name2, element2, whyNotPromotedList);
           return;
         }
+
+        // prefix.TypeAlias(args) or prefix.TypeAlias.CONST
+        if (element2 is TypeAliasElement) {
+          var aliasedType = element2.aliasedType;
+          var argumentList = node.arguments;
+          if (aliasedType is InterfaceType && argumentList != null) {
+            _typeAliasConstructorInvocation(node, element2, name3, aliasedType,
+                argumentList, whyNotPromotedList);
+          } else {
+            _typeAliasGetter(node, element2, name3, whyNotPromotedList);
+          }
+          return;
+        }
         // undefined
         if (element2 == null) {
           _errorReporter.reportErrorForNode(
@@ -322,6 +359,19 @@ class AnnotationResolver {
       return;
     }
 
+    // TypeAlias(args) or TypeAlias.CONST
+    if (element1 is TypeAliasElement) {
+      var aliasedType = element1.aliasedType;
+      var argumentList = node.arguments;
+      if (aliasedType is InterfaceType && argumentList != null) {
+        _typeAliasConstructorInvocation(node, element1, name2, aliasedType,
+            argumentList, whyNotPromotedList);
+      } else {
+        _typeAliasGetter(node, element1, name2, whyNotPromotedList);
+      }
+      return;
+    }
+
     // TODO(scheglov) Must be const.
     if (element1 is VariableElement) {
       return;
@@ -393,6 +443,67 @@ class AnnotationResolver {
     }
   }
 
+  void _typeAliasConstructorInvocation(
+    AnnotationImpl node,
+    TypeAliasElement typeAliasElement,
+    SimpleIdentifierImpl? constructorName,
+    InterfaceType aliasedType,
+    ArgumentList argumentList,
+    List<Map<DartType, NonPromotionReason> Function()> whyNotPromotedList,
+  ) {
+    var constructorElement = aliasedType.lookUpConstructor(
+      constructorName?.name,
+      _definingLibrary,
+    );
+
+    _constructorInvocation(
+      node,
+      constructorName,
+      typeAliasElement.typeParameters,
+      constructorElement,
+      argumentList,
+      (typeArguments) {
+        return typeAliasElement.instantiate(
+          typeArguments: typeArguments,
+          nullabilitySuffix: _resolver.noneOrStarSuffix,
+        ) as InterfaceType;
+      },
+      whyNotPromotedList,
+    );
+  }
+
+  void _typeAliasGetter(
+    AnnotationImpl node,
+    TypeAliasElement typeAliasElement,
+    SimpleIdentifierImpl? getterName,
+    List<Map<DartType, NonPromotionReason> Function()> whyNotPromotedList,
+  ) {
+    ExecutableElement? getter;
+    var aliasedType = typeAliasElement.aliasedType;
+    if (aliasedType is InterfaceType) {
+      var classElement = aliasedType.element;
+      if (getterName != null) {
+        getter = classElement.getGetter(getterName.name);
+        getter = _resolver.toLegacyElement(getter);
+      }
+    }
+
+    getterName?.staticElement = getter;
+    node.element = getter;
+
+    if (getterName != null && getter is PropertyAccessorElement) {
+      _propertyAccessorElement(node, getterName, getter, whyNotPromotedList);
+      _resolveAnnotationElementGetter(node, getter);
+    } else if (getter is! ConstructorElement) {
+      _errorReporter.reportErrorForNode(
+        CompileTimeErrorCode.INVALID_ANNOTATION,
+        node,
+      );
+    }
+
+    _visitArguments(node, whyNotPromotedList);
+  }
+
   void _visitArguments(AnnotationImpl node,
       List<Map<DartType, NonPromotionReason> Function()> whyNotPromotedList) {
     var arguments = node.arguments;

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

@@ -40,6 +40,12 @@ class ConstructorElementToInfer {
 
   ConstructorElementToInfer(this.typeParameters, this.element);
 
+  /// Return the equivalent generic function type that we could use to
+  /// forward to the constructor, or for a non-generic type simply returns
+  /// the constructor type.
+  ///
+  /// For example given the type `class C<T> { C(T arg); }`, the generic
+  /// function type is `<T>(T) -> C<T>`.
   FunctionType get asType {
     return FunctionTypeImpl(
       typeFormals: typeParameters,

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

@@ -4,13 +4,10 @@
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.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/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/extensions.dart';
 import 'package:analyzer/src/dart/element/member.dart' show ConstructorMember;
-import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/generated/migration.dart';
@@ -48,28 +45,6 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     _dynamicType = _typeProvider.dynamicType;
   }
 
-  /// Given a constructor for a generic type, returns the equivalent generic
-  /// function type that we could use to forward to the constructor, or for a
-  /// non-generic type simply returns the constructor type.
-  ///
-  /// For example given the type `class C<T> { C(T arg); }`, the generic function
-  /// type is `<T>(T) -> C<T>`.
-  FunctionType constructorToGenericFunctionType(
-      ConstructorElement constructor) {
-    var classElement = constructor.enclosingElement;
-    var typeParameters = classElement.typeParameters;
-    if (typeParameters.isEmpty) {
-      return constructor.type;
-    }
-
-    return FunctionTypeImpl(
-      typeFormals: typeParameters,
-      parameters: constructor.parameters,
-      returnType: constructor.returnType,
-      nullabilitySuffix: NullabilitySuffix.star,
-    );
-  }
-
   /// Record that the static type of the given node is the given type.
   ///
   /// @param expression the node whose type is to be recorded

pkg/analyzer/lib/src/test_utilities/find_element.dart

@@ -149,6 +149,7 @@ class FindElement extends _FindElementBase {
     return result!;
   }
 
+  @override
   ParameterElement parameter(String name) {
     ParameterElement? result;
 
@@ -527,6 +528,28 @@ abstract class _FindElementBase {
     throw StateError('Not found: $name');
   }
 
+  ParameterElement parameter(String name) {
+    ParameterElement? result;
+
+    for (var class_ in unitElement.types) {
+      for (var constructor in class_.constructors) {
+        for (var parameter in constructor.parameters) {
+          if (parameter.name == name) {
+            if (result != null) {
+              throw StateError('Not unique: $name');
+            }
+            result = parameter;
+          }
+        }
+      }
+    }
+
+    if (result != null) {
+      return result;
+    }
+    throw StateError('Not found: $name');
+  }
+
   PropertyAccessorElement setter(String name, {String? of}) {
     PropertyAccessorElement? result;