[element model] migrate dart_type_utilities

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

Author: pq

pkg/linter/analyzer_use_new_elements.txt

@@ -2,4 +2,3 @@ lib/src/extensions.dart
 lib/src/rules/invalid_runtime_check_with_js_interop_types.dart
 lib/src/rules/unnecessary_overrides.dart
 lib/src/rules/use_late_for_private_fields_and_variables.dart
-lib/src/util/dart_type_utilities.dart

pkg/linter/lib/src/util/dart_type_utilities.dart

@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/ast/ast.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/src/dart/element/type.dart'; // ignore: implementation_imports
@@ -14,29 +13,30 @@ import '../extensions.dart';
 
 bool argumentsMatchParameters(
     NodeList<Expression> arguments, NodeList<FormalParameter> parameters) {
-  var namedParameters = <String, Element?>{};
-  var namedArguments = <String, Element>{};
-  var positionalParameters = <Element?>[];
-  var positionalArguments = <Element>[];
+  var namedParameters = <String, Element2?>{};
+  var namedArguments = <String, Element2>{};
+  var positionalParameters = <Element2?>[];
+  var positionalArguments = <Element2>[];
   for (var parameter in parameters) {
     var identifier = parameter.name;
+    var parameterElement = parameter.declaredFragment?.element;
     if (identifier != null) {
       if (parameter.isNamed) {
-        namedParameters[identifier.lexeme] = parameter.declaredElement;
+        namedParameters[identifier.lexeme] = parameterElement;
       } else {
-        positionalParameters.add(parameter.declaredElement);
+        positionalParameters.add(parameterElement);
       }
     }
   }
   for (var argument in arguments) {
     if (argument is NamedExpression) {
-      var element = argument.expression.canonicalElement;
+      var element = argument.expression.canonicalElement2;
       if (element == null) {
         return false;
       }
       namedArguments[argument.name.label.name] = element;
     } else {
-      var element = argument.canonicalElement;
+      var element = argument.canonicalElement2;
       if (element == null) {
         return false;
       }
@@ -64,15 +64,12 @@ bool argumentsMatchParameters(
 
 /// Returns whether the canonical elements of [element1] and [element2] are
 /// equal.
-bool canonicalElementsAreEqual(Element? element1, Element? element2) =>
-    element1?.canonicalElement == element2?.canonicalElement;
-
-bool canonicalElementsAreEqual2(Element2? element1, Element2? element2) =>
+bool canonicalElementsAreEqual(Element2? element1, Element2? element2) =>
     element1?.canonicalElement2 == element2?.canonicalElement2;
 
 /// Returns whether the canonical elements from two nodes are equal.
 ///
-/// As in, [AstNodeNullableExtension.canonicalElement], the two nodes must be
+/// As in, [AstNodeNullableExtension.canonicalElement2], the two nodes must be
 /// [Expression]s in order to be compared (otherwise `false` is returned).
 ///
 /// The two nodes must both be a [SimpleIdentifier], [PrefixedIdentifier], or
@@ -104,24 +101,23 @@ bool canonicalElementsFromIdentifiersAreEqual(
 
   if (expression1 is SimpleIdentifier) {
     return expression2 is SimpleIdentifier &&
-        canonicalElementsAreEqual2(getWriteOrReadElement(expression1),
+        canonicalElementsAreEqual(getWriteOrReadElement(expression1),
             getWriteOrReadElement(expression2));
   }
 
   if (expression1 is PrefixedIdentifier) {
     return expression2 is PrefixedIdentifier &&
-        canonicalElementsAreEqual(expression1.prefix.staticElement,
-            expression2.prefix.staticElement) &&
-        canonicalElementsAreEqual2(
-            getWriteOrReadElement(expression1.identifier),
+        canonicalElementsAreEqual(
+            expression1.prefix.element, expression2.prefix.element) &&
+        canonicalElementsAreEqual(getWriteOrReadElement(expression1.identifier),
             getWriteOrReadElement(expression2.identifier));
   }
 
   if (expression1 is PropertyAccess && expression2 is PropertyAccess) {
     var target1 = expression1.target;
     var target2 = expression2.target;
     return canonicalElementsFromIdentifiersAreEqual(target1, target2) &&
-        canonicalElementsAreEqual2(
+        canonicalElementsAreEqual(
             getWriteOrReadElement(expression1.propertyName),
             getWriteOrReadElement(expression2.propertyName));
   }
@@ -179,8 +175,8 @@ bool typesAreUnrelated(
         promotedLeftType, promotedRightType);
   } else if (promotedLeftType is TypeParameterType &&
       promotedRightType is TypeParameterType) {
-    return typesAreUnrelated(typeSystem, promotedLeftType.element.bound,
-        promotedRightType.element.bound);
+    return typesAreUnrelated(typeSystem, promotedLeftType.element3.bound,
+        promotedRightType.element3.bound);
   } else if (promotedLeftType is FunctionType) {
     if (_isFunctionTypeUnrelatedToType(promotedLeftType, promotedRightType)) {
       return true;
@@ -202,9 +198,11 @@ bool _isFunctionTypeUnrelatedToType(FunctionType type1, DartType type2) {
     return false;
   }
   if (type2 is InterfaceType) {
-    var element2 = type2.element;
-    if (element2 is ClassElement &&
-        element2.lookUpConcreteMethod('call', element2.library) != null) {
+    var element2 = type2.element3;
+    if (element2 is ClassElement2 &&
+        element2.thisType
+                .lookUpMethod3('call', element2.library2, concrete: true) !=
+            null) {
       return false;
     }
   }
@@ -236,8 +234,8 @@ class InterfaceTypeDefinition {
 extension on TypeSystem {
   bool interfaceTypesAreUnrelated(
       InterfaceType leftType, InterfaceType rightType) {
-    var leftElement = leftType.element;
-    var rightElement = rightType.element;
+    var leftElement = leftType.element3;
+    var rightElement = rightType.element3;
     if (leftElement == rightElement) {
       // In this case, [leftElement] and [rightElement] represent the same
       // class, modulo generics, e.g. `List<int>` and `List<dynamic>`. Now we
@@ -264,7 +262,7 @@ extension on TypeSystem {
 
       // Unrelated Enums have the same supertype, but they are not the same element, so
       // they are unrelated.
-      if (sameSupertypes && leftElement is EnumElement) {
+      if (sameSupertypes && leftElement is EnumElement2) {
         return true;
       }