Elements. Migrate ExtensionMemberResolver.

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

Author: scheglov

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

@@ -445,8 +445,8 @@ class LibraryFragmentScope implements Scope {
     );
   }
 
-  void notifyExtensionUsed(ExtensionElement element) {
-    _importsTracking?.notifyExtensionUsed(element);
+  void notifyExtensionUsed(ExtensionElement2 element) {
+    _importsTracking?.notifyExtensionUsed(element.asElement);
   }
 
   PrefixScope? _getParentPrefixScope(PrefixElementImpl prefix) {

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

@@ -607,6 +607,54 @@ class TypeSystemImpl implements TypeSystem {
     return parameters;
   }
 
+  /// Computes the set of free type parameters appearing in [rootType].
+  ///
+  /// If a non-null [candidates] set is given, then only type parameters
+  /// appearing in it are considered; otherwise all type parameters are
+  /// considered.
+  List<TypeParameterElement2>? getFreeParameters2(DartType rootType,
+      {Set<TypeParameterElement2>? candidates}) {
+    List<TypeParameterElement2>? parameters;
+    Set<DartType> visitedTypes = HashSet<DartType>();
+    Set<TypeParameterElement2> boundTypeParameters =
+        HashSet<TypeParameterElement2>();
+
+    void appendParameters(DartType? type) {
+      if (type == null) {
+        return;
+      }
+      if (visitedTypes.contains(type)) {
+        return;
+      }
+      visitedTypes.add(type);
+      if (type is TypeParameterType) {
+        var element = type.element3;
+        if ((candidates == null || candidates.contains(element)) &&
+            !boundTypeParameters.contains(element)) {
+          parameters ??= <TypeParameterElement2>[];
+          parameters!.add(element);
+        }
+      } else if (type is FunctionType) {
+        assert(
+            !type.typeParameters.any((t) => boundTypeParameters.contains(t)));
+        boundTypeParameters.addAll(type.typeParameters);
+        appendParameters(type.returnType);
+        type.parameters.map((p) => p.type).forEach(appendParameters);
+        // TODO(scheglov): https://github.com/dart-lang/sdk/issues/44218
+        type.alias?.typeArguments.forEach(appendParameters);
+        boundTypeParameters.removeAll(type.typeParameters);
+      } else if (type is InterfaceType) {
+        type.typeArguments.forEach(appendParameters);
+      } else if (type is RecordType) {
+        type.positionalFields.map((f) => f.type).forEach(appendParameters);
+        type.namedFields.map((f) => f.type).forEach(appendParameters);
+      }
+    }
+
+    appendParameters(rootType);
+    return parameters;
+  }
+
   /// Returns the greatest closure of [type] with respect to [typeParameters].
   ///
   /// https://github.com/dart-lang/language
@@ -837,6 +885,83 @@ class TypeSystemImpl implements TypeSystem {
     return orderedArguments;
   }
 
+  /// Given uninstantiated [typeFormals], instantiate them to their bounds.
+  /// See the issue for the algorithm description.
+  ///
+  /// https://github.com/dart-lang/sdk/issues/27526#issuecomment-260021397
+  List<TypeImpl> instantiateTypeFormalsToBounds2(
+      List<TypeParameterElementImpl2> typeFormals,
+      {List<bool>? hasError,
+      Map<TypeParameterElement2, TypeImpl>? knownTypes}) {
+    int count = typeFormals.length;
+    if (count == 0) {
+      return const <TypeImpl>[];
+    }
+
+    Set<TypeParameterElement2> all = <TypeParameterElement2>{};
+    // all ground
+    Map<TypeParameterElement2, TypeImpl> defaults = knownTypes ?? {};
+    // not ground
+    Map<TypeParameterElement2, TypeImpl> partials = {};
+
+    for (var typeParameter in typeFormals) {
+      all.add(typeParameter);
+      if (!defaults.containsKey(typeParameter)) {
+        var bound = typeParameter.bound ?? DynamicTypeImpl.instance;
+        partials[typeParameter] = bound;
+      }
+    }
+
+    bool hasProgress = true;
+    while (hasProgress) {
+      hasProgress = false;
+      for (TypeParameterElement2 parameter in partials.keys) {
+        var value = partials[parameter]!;
+        var freeParameters = getFreeParameters2(value, candidates: all);
+        if (freeParameters == null) {
+          defaults[parameter] = value;
+          partials.remove(parameter);
+          hasProgress = true;
+          break;
+        } else if (freeParameters.every(defaults.containsKey)) {
+          defaults[parameter] =
+              Substitution.fromMap2(defaults).substituteType(value);
+          partials.remove(parameter);
+          hasProgress = true;
+          break;
+        }
+      }
+    }
+
+    // If we stopped making progress, and not all types are ground,
+    // then the whole type is malbounded and an error should be reported
+    // if errors are requested, and a partially completed type should
+    // be returned.
+    if (partials.isNotEmpty) {
+      if (hasError != null) {
+        hasError[0] = true;
+      }
+      var domain = defaults.keys.toList();
+      var range = defaults.values.toList();
+      // Build a substitution Phi mapping each uncompleted type variable to
+      // dynamic, and each completed type variable to its default.
+      for (TypeParameterElement2 parameter in partials.keys) {
+        domain.add(parameter);
+        range.add(DynamicTypeImpl.instance);
+      }
+      // Set the default for an uncompleted type variable (T extends B)
+      // to be Phi(B)
+      for (TypeParameterElement2 parameter in partials.keys) {
+        defaults[parameter] = Substitution.fromPairs2(domain, range)
+            .substituteType(partials[parameter]!);
+      }
+    }
+
+    List<TypeImpl> orderedArguments =
+        typeFormals.map((p) => defaults[p]!).toFixedList();
+    return orderedArguments;
+  }
+
   /// https://github.com/dart-lang/language
   /// accepted/future-releases/0546-patterns/feature-specification.md#exhaustiveness-and-reachability
   bool isAlwaysExhaustive(DartType type) {

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

@@ -2,11 +2,8 @@
 // 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/analysis/features.dart';
 import 'package:analyzer/dart/ast/syntactic_entity.dart';
-import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/type_provider.dart';
@@ -27,7 +24,6 @@ import 'package:analyzer/src/dart/resolver/resolution_result.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/inference_log.dart';
 import 'package:analyzer/src/generated/resolver.dart';
-import 'package:analyzer/src/utilities/extensions/element.dart';
 import 'package:analyzer/src/utilities/extensions/string.dart';
 
 class ExtensionMemberResolver {
@@ -106,7 +102,7 @@ class ExtensionMemberResolver {
     if (extensions.length == 1) {
       var instantiated = extensions[0];
       _resolver.libraryFragment.scope.notifyExtensionUsed(
-        instantiated.extension.asElement,
+        instantiated.extension,
       );
       return instantiated.asResolutionResult;
     }
@@ -115,7 +111,7 @@ class ExtensionMemberResolver {
     if (mostSpecific.length == 1) {
       var instantiated = mostSpecific.first;
       _resolver.libraryFragment.scope.notifyExtensionUsed(
-        instantiated.extension.asElement,
+        instantiated.extension,
       );
       return instantiated.asResolutionResult;
     }
@@ -157,35 +153,35 @@ class ExtensionMemberResolver {
   /// The [node] is fully resolved, and its type arguments are set.
   ExtensionResolutionResult getOverrideMember(
       ExtensionOverride node, String name) {
-    var element = node.element;
+    var element = node.element2;
 
-    ExecutableElement? getter;
-    ExecutableElement? setter;
+    ExecutableElement2? getter;
+    ExecutableElement2? setter;
     if (name == '[]') {
-      getter = element.getMethod('[]');
-      setter = element.getMethod('[]=');
+      getter = element.getMethod2('[]');
+      setter = element.getMethod2('[]=');
     } else {
-      getter = element.getGetter(name) ?? element.getMethod(name);
-      setter = element.getSetter(name);
+      getter = element.getGetter2(name) ?? element.getMethod2(name);
+      setter = element.getSetter2(name);
     }
 
     if (getter == null && setter == null) {
       return ExtensionResolutionError.none;
     }
 
-    var substitution = Substitution.fromPairs(
-      element.typeParameters,
+    var substitution = Substitution.fromPairs2(
+      element.typeParameters2,
       node.typeArgumentTypes!,
     );
 
     var getterMember =
-        getter != null ? ExecutableMember.from2(getter, substitution) : null;
+        getter != null ? ExecutableMember.from(getter, substitution) : null;
     var setterMember =
-        setter != null ? ExecutableMember.from2(setter, substitution) : null;
+        setter != null ? ExecutableMember.from(setter, substitution) : null;
 
     return SingleExtensionResolutionResult(
-      getter2: getterMember?.asElement2,
-      setter2: setterMember?.asElement2,
+      getter2: getterMember,
+      setter2: setterMember,
     );
   }
 
@@ -394,12 +390,12 @@ class ExtensionMemberResolver {
 
   /// Instantiate the extended type of the [extension] to the bounds of the
   /// type formals of the extension.
-  DartType _instantiateToBounds(ExtensionElement extension) {
-    extension as ExtensionElementImpl;
-    var typeParameters = extension.typeParameters;
-    return Substitution.fromPairs(
+  DartType _instantiateToBounds(ExtensionElement2 extension) {
+    extension as ExtensionElementImpl2;
+    var typeParameters = extension.typeParameters2;
+    return Substitution.fromPairs2(
       typeParameters,
-      _typeSystem.instantiateTypeFormalsToBounds(typeParameters),
+      _typeSystem.instantiateTypeFormalsToBounds2(typeParameters),
     ).substituteType(extension.extendedType);
   }
 
@@ -438,8 +434,8 @@ class ExtensionMemberResolver {
     // 5. ...the instantiate-to-bounds type of T1 is a subtype of the
     //    instantiate-to-bounds type of T2 and not vice versa.
     // TODO(scheglov): store instantiated types
-    var extendedTypeBound1 = _instantiateToBounds(e1.extension.asElement);
-    var extendedTypeBound2 = _instantiateToBounds(e2.extension.asElement);
+    var extendedTypeBound1 = _instantiateToBounds(e1.extension);
+    var extendedTypeBound2 = _instantiateToBounds(e2.extension);
     return _isSubtypeOf(extendedTypeBound1, extendedTypeBound2) &&
         !_isSubtypeOf(extendedTypeBound2, extendedTypeBound1);
   }