Elements. Migrate ConstructorReferenceResolver.

Change-Id: Ib9debc57f199cf33529807350a443b0db94e208d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/406460
Reviewed-by: Phil Quitslund <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -4472,6 +4472,10 @@ final class ConstructorNameImpl extends AstNodeImpl implements ConstructorName {
   @override
   ConstructorElement2? get element => staticElement?.asElement2;
 
+  set element(ConstructorElement2? element) {
+    staticElement = element?.asElement;
+  }
+
   @override
   Token get endToken {
     if (name case var name?) {

pkg/analyzer/lib/src/dart/element/member.dart

@@ -197,6 +197,30 @@ class ConstructorMember extends ExecutableMember
       substitution: Substitution.fromInterfaceType(definingType),
     );
   }
+
+  /// If the given [constructor]'s type is different when any type parameters
+  /// from the defining type's declaration are replaced with the actual type
+  /// arguments from the [definingType], create a constructor member
+  /// representing the given constructor. Return the member that was created, or
+  /// the original constructor if no member was created.
+  static ConstructorElement2 from2(
+      ConstructorElement2 constructor, InterfaceType definingType) {
+    if (definingType.typeArguments.isEmpty) {
+      return constructor;
+    }
+
+    var augmentationSubstitution = Substitution.empty;
+    if (constructor is ConstructorMember) {
+      augmentationSubstitution = constructor.augmentationSubstitution;
+      constructor = constructor.baseElement;
+    }
+
+    return ConstructorMember(
+      declaration: constructor.asElement,
+      augmentationSubstitution: augmentationSubstitution,
+      substitution: Substitution.fromInterfaceType(definingType),
+    );
+  }
 }
 
 /// An executable element defined in a parameterized type where the values of

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

@@ -2,9 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// ignore_for_file: analyzer_use_new_elements
-
-import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/member.dart';
@@ -30,10 +28,10 @@ class ConstructorReferenceResolver {
       );
     }
     node.constructorName.accept(_resolver);
-    var element = node.constructorName.staticElement;
+    var element = node.constructorName.element;
     if (element != null && !element.isFactory) {
-      var enclosingElement = element.enclosingElement3;
-      if (enclosingElement is ClassElement && enclosingElement.isAbstract) {
+      var enclosingElement = element.enclosingElement2;
+      if (enclosingElement is ClassElement2 && enclosingElement.isAbstract) {
         _resolver.errorReporter.atNode(
           node,
           CompileTimeErrorCode
@@ -52,19 +50,19 @@ class ConstructorReferenceResolver {
       //
       // Only report errors when the constructor tearoff feature is enabled,
       // to avoid reporting redundant errors.
-      var enclosingElement = node.constructorName.type.element;
-      if (enclosingElement is TypeAliasElement) {
+      var enclosingElement = node.constructorName.type.element2;
+      if (enclosingElement is TypeAliasElement2) {
         var aliasedType = enclosingElement.aliasedType;
         enclosingElement =
-            aliasedType is InterfaceType ? aliasedType.element : null;
+            aliasedType is InterfaceType ? aliasedType.element3 : null;
       }
       // TODO(srawlins): Handle `enclosingElement` being a function typedef:
       // typedef F<T> = void Function(); var a = F<int>.extensionOnType;`.
       // This is illegal.
-      if (enclosingElement is InterfaceElement) {
-        var method = enclosingElement.getMethod(name.name) ??
-            enclosingElement.getGetter(name.name) ??
-            enclosingElement.getSetter(name.name);
+      if (enclosingElement is InterfaceElement2) {
+        var method = enclosingElement.getMethod2(name.name) ??
+            enclosingElement.getGetter2(name.name) ??
+            enclosingElement.getSetter2(name.name);
         if (method != null) {
           var error = method.isStatic
               ? CompileTimeErrorCode.CLASS_INSTANTIATION_ACCESS_TO_STATIC_MEMBER
@@ -79,7 +77,7 @@ class ConstructorReferenceResolver {
           _resolver.errorReporter.atNode(
             node,
             CompileTimeErrorCode.CLASS_INSTANTIATION_ACCESS_TO_UNKNOWN_MEMBER,
-            arguments: [enclosingElement.name, name.name],
+            arguments: [enclosingElement.name3!, name.name],
           );
         }
       }
@@ -102,7 +100,7 @@ class ConstructorReferenceResolver {
     // Otherwise we'll have a ConstructorElement, and we can skip inference
     // because there's nothing to infer in a non-generic type.
     if (elementToInfer != null &&
-        elementToInfer.typeParameters.isNotEmpty &&
+        elementToInfer.typeParameters2.isNotEmpty &&
         constructorName.type.typeArguments == null) {
       // TODO(leafp): Currently, we may re-infer types here, since we
       // sometimes resolve multiple times.  We should really check that we
@@ -114,7 +112,7 @@ class ConstructorReferenceResolver {
       // 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 = elementToInfer.element;
+      var rawElement = elementToInfer.element2;
       var constructorType = elementToInfer.asType;
 
       var inferred = _resolver.inferenceHelper.inferTearOff(
@@ -127,16 +125,16 @@ class ConstructorReferenceResolver {
         // 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, inferredReturnType);
+            ConstructorMember.from2(rawElement, inferredReturnType);
 
-        constructorName.staticElement = constructorElement.declaration;
-        constructorName.name?.staticElement = constructorElement.declaration;
+        constructorName.element = constructorElement.baseElement;
+        constructorName.name?.element = constructorElement.baseElement;
         node.recordStaticType(inferred, resolver: _resolver);
         // The NamedType child of `constructorName` doesn't have a static type.
         constructorName.type.type = null;
       }
     } else {
-      var constructorElement = constructorName.staticElement;
+      var constructorElement = constructorName.element;
       node.recordStaticType(
           constructorElement == null
               ? InvalidTypeImpl.instance

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

@@ -6,6 +6,7 @@
 
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/error/listener.dart';
@@ -16,6 +17,7 @@ import 'package:analyzer/src/dart/element/type_constraint_gatherer.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/invocation_inferrer.dart';
 import 'package:analyzer/src/generated/resolver.dart';
+import 'package:analyzer/src/utilities/extensions/element.dart';
 
 /// Information about a constructor element to instantiate.
 ///
@@ -54,6 +56,12 @@ class ConstructorElementToInfer {
             nullabilitySuffix: NullabilitySuffix.none,
           );
   }
+
+  ConstructorElement2 get element2 => element.asElement2;
+
+  List<TypeParameterElement2> get typeParameters2 {
+    return typeParameters.map((e) => e.asElement2).toList();
+  }
 }
 
 class InvocationInferenceHelper {