[element model] migrate prefer_const_constructors_in_immutables

Bug:https://github.com/dart-lang/linter/issues/5099
Change-Id: I741e7ac8946a44ff800117c3c1f3657c15aaeb3f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/390941
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Phil Quitslund <[email protected]>
Commit-Queue: Brian Wilkerson <[email protected]>
Auto-Submit: Phil Quitslund <[email protected]>

Author: pq

pkg/analyzer/lib/dart/element/element2.dart

@@ -162,6 +162,11 @@ abstract class ClassElement2 implements InterfaceElement2 {
   /// not extended or mixed in.
   bool get isInterface;
 
+  /// Whether the class is a macro class.
+  ///
+  /// A class is a macro class if it has a `macro` modifer.
+  bool get isMacro;
+
   /// Whether the class is a mixin application.
   ///
   /// A class is a mixin application if it was declared using the syntax

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

@@ -6839,6 +6839,9 @@ mixin MaybeAugmentedClassElementMixin on MaybeAugmentedInterfaceElementMixin
   @override
   bool get isInterface => declaration.isInterface;
 
+  @override
+  bool get isMacro => declaration.isMacro;
+
   @override
   bool get isMixinApplication => declaration.isMixinApplication;
 
@@ -6930,8 +6933,7 @@ mixin MaybeAugmentedExtensionTypeElementMixin
   ExtensionTypeElementImpl get firstFragment => declaration;
 
   @override
-  ConstructorElement2 get primaryConstructor2 =>
-      representation as ConstructorElement2;
+  ConstructorElement2 get primaryConstructor2 => primaryConstructor.element;
 
   @override
   FieldElement2 get representation2 => representation as FieldElement2;

pkg/linter/analyzer_use_new_elements.txt

@@ -112,6 +112,7 @@ lib/src/rules/prefer_bool_in_asserts.dart
 lib/src/rules/prefer_collection_literals.dart
 lib/src/rules/prefer_conditional_assignment.dart
 lib/src/rules/prefer_const_constructors.dart
+lib/src/rules/prefer_const_constructors_in_immutables.dart
 lib/src/rules/prefer_const_declarations.dart
 lib/src/rules/prefer_const_literals_to_create_immutables.dart
 lib/src/rules/prefer_constructors_over_static_methods.dart

pkg/linter/lib/src/extensions.dart

@@ -382,6 +382,11 @@ extension ElementExtension2 on Element2? {
         self.name == 'print' &&
         self.firstFragment.libraryFragment.element.isDartCore;
   }
+
+  bool get isMacro => switch (this) {
+        ClassElement2(:var isMacro) => isMacro,
+        _ => false,
+      };
 }
 
 extension ExpressionExtension on Expression? {

pkg/linter/lib/src/rules/prefer_const_constructors_in_immutables.dart

@@ -4,7 +4,7 @@
 
 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/element2.dart';
 import 'package:analyzer/src/lint/linter.dart'; // ignore: implementation_imports
 import 'package:collection/collection.dart' show IterableExtension;
 
@@ -40,17 +40,18 @@ class _Visitor extends SimpleAstVisitor<void> {
 
   @override
   void visitConstructorDeclaration(ConstructorDeclaration node) {
-    var element = node.declaredElement;
+    var element = node.declaredFragment?.element;
     if (element == null) return;
     if (element.isConst) return;
     if (node.body is! EmptyFunctionBody) return;
-    var enclosingElement = element.enclosingElement3;
+    var enclosingElement = element.enclosingElement2;
     if (enclosingElement.isMacro) return;
+
     if (enclosingElement.mixins.isNotEmpty) return;
     if (!_hasImmutableAnnotation(enclosingElement)) return;
     var isRedirected =
-        element.isFactory && element.redirectedConstructor != null;
-    if (isRedirected && (element.redirectedConstructor?.isConst ?? false)) {
+        element.isFactory && element.redirectedConstructor2 != null;
+    if (isRedirected && (element.redirectedConstructor2?.isConst ?? false)) {
       rule.reportLintForToken(node.firstTokenAfterCommentAndMetadata);
     }
     if (!isRedirected &&
@@ -63,56 +64,57 @@ class _Visitor extends SimpleAstVisitor<void> {
   @override
   void visitExtensionTypeDeclaration(ExtensionTypeDeclaration node) {
     if (node.constKeyword != null) return;
-    var element = node.declaredElement;
+    var element = node.declaredFragment?.element;
     if (element == null) return;
-    if (element.hasImmutable) {
+    if (element.metadata2.hasImmutable) {
       rule.reportLintForToken(node.name);
     }
   }
 
-  static List<InterfaceElement> _getSelfAndSuperClasses(InterfaceElement self) {
-    InterfaceElement? current = self;
-    var seenElements = <InterfaceElement>{};
+  static List<InterfaceElement2> _getSelfAndSuperClasses(
+      InterfaceElement2 self) {
+    InterfaceElement2? current = self;
+    var seenElements = <InterfaceElement2>{};
     while (current != null && seenElements.add(current)) {
-      current = current.supertype?.element;
+      current = current.supertype?.element3;
     }
     return seenElements.toList();
   }
 
   static bool _hasConstConstructorInvocation(ConstructorDeclaration node) {
-    var declaredElement = node.declaredElement;
+    var declaredElement = node.declaredFragment?.element;
     if (declaredElement == null) {
       return false;
     }
-    var clazz = declaredElement.enclosingElement3;
+    var clazz = declaredElement.enclosingElement2;
     // Constructor with super-initializer.
     var superInvocation =
         node.initializers.whereType<SuperConstructorInvocation>().firstOrNull;
     if (superInvocation != null) {
-      return superInvocation.staticElement?.isConst ?? false;
+      return superInvocation.element?.isConst ?? false;
     }
     // Constructor with 'this' redirecting initializer.
     var redirectInvocation = node.initializers
         .whereType<RedirectingConstructorInvocation>()
         .firstOrNull;
     if (redirectInvocation != null) {
-      return redirectInvocation.staticElement?.isConst ?? false;
+      return redirectInvocation.element?.isConst ?? false;
     }
 
-    if (clazz is ExtensionTypeElement) {
-      return clazz.primaryConstructor.isConst;
+    if (clazz is ExtensionTypeElement2) {
+      return clazz.primaryConstructor2.isConst;
     }
 
     // Constructor with implicit `super()` call.
     var unnamedSuperConstructor =
-        clazz.supertype?.constructors.firstWhereOrNull((e) => e.name.isEmpty);
+        clazz.supertype?.constructors2.firstWhereOrNull((e) => e.name.isEmpty);
     return unnamedSuperConstructor != null && unnamedSuperConstructor.isConst;
   }
 
   /// Whether [clazz] or any of its super-types are annotated with
   /// `@immutable`.
-  static bool _hasImmutableAnnotation(InterfaceElement clazz) {
+  static bool _hasImmutableAnnotation(InterfaceElement2 clazz) {
     var selfAndInheritedClasses = _getSelfAndSuperClasses(clazz);
-    return selfAndInheritedClasses.any((cls) => cls.hasImmutable);
+    return selfAndInheritedClasses.any((cls) => cls.metadata2.hasImmutable);
   }
 }