[element model] migrate correct_override

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

Author: pq

pkg/analyzer/lib/src/diagnostic/diagnostic_factory.dart

@@ -295,8 +295,8 @@ class DiagnosticFactory {
       Source source,
       ErrorCode errorCode,
       SyntacticEntity errorNode,
-      ExecutableElement member,
-      ExecutableElement superMember,
+      ExecutableElement2 member,
+      ExecutableElement2 superMember,
       String memberName) {
     // Elements enclosing members that can participate in overrides are always
     // named, so we can safely assume `_thisMember.enclosingElement3.name` and
@@ -308,9 +308,9 @@ class DiagnosticFactory {
       errorCode: errorCode,
       arguments: [
         memberName,
-        member.enclosingElement3.name!,
+        member.enclosingElement2!.name3,
         member.type,
-        superMember.enclosingElement3.name!,
+        superMember.enclosingElement2!.name3,
         superMember.type,
       ],
       contextMessages: [
@@ -321,18 +321,18 @@ class DiagnosticFactory {
         // concrete).
         if (errorCode == CompileTimeErrorCode.INVALID_OVERRIDE)
           DiagnosticMessageImpl(
-            filePath: superMember.source.fullName,
+            filePath: superMember.asElement.source.fullName,
             message: "The member being overridden.",
-            offset: superMember.nonSynthetic.nameOffset,
-            length: superMember.nonSynthetic.nameLength,
+            offset: superMember.asElement.nonSynthetic.nameOffset,
+            length: superMember.asElement.nonSynthetic.nameLength,
             url: null,
           ),
         if (errorCode == CompileTimeErrorCode.INVALID_OVERRIDE_SETTER)
           DiagnosticMessageImpl(
-            filePath: superMember.source.fullName,
+            filePath: superMember.asElement.source.fullName,
             message: "The setter being overridden.",
-            offset: superMember.nonSynthetic.nameOffset,
-            length: superMember.nonSynthetic.nameLength,
+            offset: superMember.asElement.nonSynthetic.nameOffset,
+            length: superMember.asElement.nonSynthetic.nameLength,
             url: null,
           )
       ],

pkg/analyzer/lib/src/error/correct_override.dart

@@ -2,10 +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/ast/syntactic_entity.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/error.dart';
@@ -18,27 +16,26 @@ import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/diagnostic/diagnostic_factory.dart';
 import 'package:analyzer/src/error/codes.dart';
-import 'package:analyzer/src/utilities/extensions/element.dart';
 
 class CorrectOverrideHelper {
   final TypeSystemImpl _typeSystem;
 
-  final ExecutableElement _thisMember;
+  final ExecutableElement2 _thisMember;
   FunctionType? _thisTypeForSubtype;
 
   final DiagnosticFactory _diagnosticFactory = DiagnosticFactory();
 
   CorrectOverrideHelper({
     required TypeSystemImpl typeSystem,
-    required ExecutableElement thisMember,
+    required ExecutableElement2 thisMember,
   })  : _typeSystem = typeSystem,
         _thisMember = thisMember {
     _computeThisTypeForSubtype();
   }
 
   /// Return `true` if [_thisMember] is a correct override of [superMember].
   bool isCorrectOverrideOf({
-    required ExecutableElement superMember,
+    required ExecutableElement2 superMember,
   }) {
     var superType = superMember.type;
     return _typeSystem.isSubtypeOf(_thisTypeForSubtype!, superType);
@@ -47,36 +44,35 @@ class CorrectOverrideHelper {
   /// If [_thisMember] is not a correct override of [superMember], report the
   /// error.
   void verify({
-    required ExecutableElement superMember,
+    required ExecutableElement2 superMember,
     required ErrorReporter errorReporter,
     required SyntacticEntity errorNode,
     required ErrorCode errorCode,
   }) {
     var isCorrect = isCorrectOverrideOf(superMember: superMember);
     if (!isCorrect) {
       var member = _thisMember;
-      var memberName = member.name;
-      if (member is PropertyAccessorElement && member.isSetter) {
-        memberName = memberName.substring(0, memberName.length - 1);
+      var memberName = member.name3;
+      if (memberName != null) {
+        errorReporter.reportError(_diagnosticFactory.invalidOverride(
+          errorReporter.source,
+          errorCode,
+          errorNode,
+          _thisMember,
+          superMember,
+          memberName,
+        ));
       }
-      errorReporter.reportError(_diagnosticFactory.invalidOverride(
-        errorReporter.source,
-        errorCode,
-        errorNode,
-        _thisMember,
-        superMember,
-        memberName,
-      ));
     }
   }
 
   /// Fill [_thisTypeForSubtype]. If [_thisMember] has covariant formal
   /// parameters, replace their types with `Object?` or `Object`.
   void _computeThisTypeForSubtype() {
     var type = _thisMember.type;
-    var parameters = type.parameters;
+    var parameters = type.formalParameters;
 
-    List<ParameterElement>? newParameters;
+    List<FormalParameterElement>? newParameters;
     for (var i = 0; i < parameters.length; i++) {
       var parameter = parameters[i];
       if (parameter.isCovariant) {
@@ -88,9 +84,9 @@ class CorrectOverrideHelper {
     }
 
     if (newParameters != null) {
-      _thisTypeForSubtype = FunctionTypeImpl(
-        typeFormals: type.typeFormals,
-        parameters: newParameters,
+      _thisTypeForSubtype = FunctionTypeImpl.v2(
+        typeParameters: type.typeParameters,
+        formalParameters: newParameters,
         returnType: type.returnType,
         nullabilitySuffix: type.nullabilitySuffix,
       );
@@ -104,12 +100,12 @@ class CovariantParametersVerifier {
   final AnalysisSessionImpl _session;
   final TypeSystemImpl _typeSystem;
 
-  final ExecutableElement _thisMember;
+  final ExecutableElement2 _thisMember;
 
   CovariantParametersVerifier({
-    required ExecutableElement thisMember,
-  })  : _session = thisMember.library.session as AnalysisSessionImpl,
-        _typeSystem = thisMember.library.typeSystem as TypeSystemImpl,
+    required ExecutableElement2 thisMember,
+  })  : _session = thisMember.library2.session as AnalysisSessionImpl,
+        _typeSystem = thisMember.library2.typeSystem as TypeSystemImpl,
         _thisMember = thisMember;
 
   void verify({
@@ -133,10 +129,10 @@ class CovariantParametersVerifier {
             errorEntity,
             CompileTimeErrorCode.INVALID_OVERRIDE,
             arguments: [
-              _thisMember.name,
-              _thisMember.enclosingElement3.name!,
+              _thisMember.name3!,
+              _thisMember.enclosingElement2!.name3!,
               _thisMember.type,
-              superMember.enclosingElement3.name!,
+              superMember.enclosingElement2!.name3!,
               superMember.type,
             ],
           );
@@ -147,13 +143,12 @@ class CovariantParametersVerifier {
 
   List<_SuperMember> _superMembers() {
     var classHierarchy = _session.classHierarchy;
-    var classElement = _thisMember.enclosingElement3 as InterfaceElementImpl;
-    var interfaces =
-        classHierarchy.implementedInterfaces(classElement.asElement2);
+    var classElement = _thisMember.enclosingElement2 as InterfaceElementImpl2;
+    var interfaces = classHierarchy.implementedInterfaces(classElement);
 
     var superMembers = <_SuperMember>[];
     for (var interface in interfaces) {
-      var superMember = _correspondingMember(interface.element, _thisMember);
+      var superMember = _correspondingMember(interface.element3, _thisMember);
       if (superMember != null) {
         superMembers.add(
           _SuperMember(interface, superMember),
@@ -164,18 +159,18 @@ class CovariantParametersVerifier {
     return superMembers;
   }
 
-  Map<ParameterElement, List<_SuperParameter>> _superParameters() {
-    var result = <ParameterElement, List<_SuperParameter>>{};
+  Map<FormalParameterElement, List<_SuperParameter>> _superParameters() {
+    var result = <FormalParameterElement, List<_SuperParameter>>{};
 
     List<_SuperMember>? superMembers;
-    var parameters = _thisMember.parameters;
+    var parameters = _thisMember.formalParameters;
     for (var i = 0; i < parameters.length; i++) {
       var parameter = parameters[i];
       if (parameter.isCovariant) {
         superMembers ??= _superMembers();
         for (var superMember in superMembers) {
           var superParameter = _correspondingParameter(
-            superMember.rawElement.parameters,
+            superMember.rawElement.formalParameters,
             parameter,
             i,
           );
@@ -200,11 +195,11 @@ class CovariantParametersVerifier {
     Substitution result = Substitution.fromInterfaceType(superMember.interface);
 
     // If the executable has type parameters, ensure that super uses the same.
-    var thisTypeParameters = _thisMember.typeParameters;
+    var thisTypeParameters = _thisMember.typeParameters2;
     if (thisTypeParameters.isNotEmpty) {
-      var superTypeParameters = superMember.rawElement.typeParameters;
+      var superTypeParameters = superMember.rawElement.typeParameters2;
       if (thisTypeParameters.length == superTypeParameters.length) {
-        var typeParametersSubstitution = Substitution.fromPairs(
+        var typeParametersSubstitution = Substitution.fromPairs2(
           superTypeParameters,
           thisTypeParameters.map((e) {
             return e.instantiate(
@@ -221,27 +216,27 @@ class CovariantParametersVerifier {
 
   /// Return a member from [classElement] that corresponds to the [proto],
   /// or `null` if no such member exist.
-  static ExecutableElement? _correspondingMember(
-    InterfaceElement classElement,
-    ExecutableElement proto,
+  static ExecutableElement2? _correspondingMember(
+    InterfaceElement2 classElement,
+    ExecutableElement2 proto,
   ) {
-    if (proto is MethodElement) {
-      return classElement.getMethod(proto.displayName);
+    if (proto is MethodElement2) {
+      return classElement.getMethod2(proto.displayName);
     }
-    if (proto is PropertyAccessorElement) {
-      if (proto.isGetter) {
-        return classElement.getGetter(proto.displayName);
+    if (proto is PropertyAccessorElement2) {
+      if (proto is GetterElement) {
+        return classElement.getGetter2(proto.displayName);
       }
-      return classElement.getSetter(proto.displayName);
+      return classElement.getSetter2(proto.displayName);
     }
     return null;
   }
 
   /// Return an element of [parameters] that corresponds for the [proto],
   /// or `null` if no such parameter exist.
-  static ParameterElement? _correspondingParameter(
-    List<ParameterElement> parameters,
-    ParameterElement proto,
+  static FormalParameterElement? _correspondingParameter(
+    List<FormalParameterElement> parameters,
+    FormalParameterElement proto,
     int protoIndex,
   ) {
     if (proto.isPositional) {
@@ -254,7 +249,7 @@ class CovariantParametersVerifier {
     } else {
       assert(proto.isNamed);
       for (var parameter in parameters) {
-        if (parameter.isNamed && parameter.name == proto.name) {
+        if (parameter.isNamed && parameter.name3 == proto.name3) {
           return parameter;
         }
       }
@@ -265,17 +260,17 @@ class CovariantParametersVerifier {
 
 class _SuperMember {
   final InterfaceType interface;
-  final ExecutableElement rawElement;
+  final ExecutableElement2 rawElement;
 
   _SuperMember(this.interface, this.rawElement);
 }
 
 class _SuperParameter {
-  final ParameterElement element;
+  final FormalParameterElement element;
   final DartType type;
 
   _SuperParameter(this.element, this.type);
 
-  ExecutableElement get member =>
-      element.enclosingElement3 as ExecutableElement;
+  ExecutableElement2 get member =>
+      element.enclosingElement2 as ExecutableElement2;
 }

pkg/analyzer/lib/src/error/inheritance_override.dart

@@ -351,9 +351,9 @@ class _ClassVerifier {
         //  overriding method. The classNameNode is always wrong.
         CorrectOverrideHelper(
           typeSystem: typeSystem,
-          thisMember: concreteElement,
+          thisMember: concreteElement.asElement2,
         ).verify(
-          superMember: interfaceElement,
+          superMember: interfaceElement.asElement2,
           errorReporter: reporter,
           errorNode: classNameToken,
           errorCode: concreteElement is PropertyAccessorElementOrMember &&
@@ -385,7 +385,7 @@ class _ClassVerifier {
     var name = Name(libraryUri, member.name);
     var correctOverrideHelper = CorrectOverrideHelper(
       typeSystem: typeSystem,
-      thisMember: member,
+      thisMember: member.asElement2,
     );
 
     for (var superType in directSuperInterfaces) {
@@ -405,7 +405,7 @@ class _ClassVerifier {
       }
 
       correctOverrideHelper.verify(
-          superMember: superMember,
+          superMember: superMember.asElement2,
           errorReporter: reporter,
           errorNode: node,
           errorCode: member is PropertyAccessorElement && member.isSetter
@@ -414,7 +414,7 @@ class _ClassVerifier {
     }
 
     if (mixinIndex == -1) {
-      CovariantParametersVerifier(thisMember: member).verify(
+      CovariantParametersVerifier(thisMember: member.asElement2).verify(
         errorReporter: reporter,
         errorEntity: node,
       );

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

@@ -4511,9 +4511,9 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
       if (mixinMember != null) {
         var isCorrect = CorrectOverrideHelper(
           typeSystem: typeSystem,
-          thisMember: superMember,
+          thisMember: superMember.asElement2,
         ).isCorrectOverrideOf(
-          superMember: mixinMember,
+          superMember: mixinMember.asElement2,
         );
         if (!isCorrect) {
           errorReporter.atNode(