Elements. Migrate detachElementsFromNodes.

Change-Id: Icb199b4d2c860569cfce739b4f7b26e0931e38bf
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/412186
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -10552,8 +10552,8 @@ abstract class PropertyInducingElementImpl
       thisOrAncestorOfType<CompilationUnitElementImpl>()!;
 
   @override
-  PropertyInducingFragment? get nextFragment =>
-      augmentation as PropertyInducingFragment?;
+  PropertyInducingElementImpl? get nextFragment =>
+      augmentation as PropertyInducingElementImpl?;
 
   @override
   Element get nonSynthetic {
@@ -10661,6 +10661,19 @@ abstract class PropertyInducingElementImpl
 
 abstract class PropertyInducingElementImpl2 extends VariableElementImpl2
     implements PropertyInducingElement2OrMember {
+  @override
+  PropertyInducingElementImpl get firstFragment;
+
+  @override
+  List<PropertyInducingElementImpl> get fragments {
+    return [
+      for (PropertyInducingElementImpl? fragment = firstFragment;
+          fragment != null;
+          fragment = fragment.nextFragment)
+        fragment,
+    ];
+  }
+
   @override
   bool get hasInitializer {
     return _fragments.any((f) => f.hasInitializer);
@@ -10682,8 +10695,7 @@ abstract class PropertyInducingElementImpl2 extends VariableElementImpl2
   }
 
   bool get shouldUseTypeForInitializerInference {
-    return (firstFragment as PropertyInducingElementImpl)
-        .shouldUseTypeForInitializerInference;
+    return firstFragment.shouldUseTypeForInitializerInference;
   }
 
   List<PropertyInducingElementImpl> get _fragments;
@@ -11984,6 +11996,10 @@ abstract class VariableElementImpl2 extends ElementImpl2
     return null;
   }
 
+  void resetConstantInitializer() {
+    _constantInitializer = null;
+  }
+
   @override
   void visitChildren2<T>(ElementVisitor2<T> visitor) {
     for (var child in children2) {

pkg/analyzer/lib/src/summary2/detach_nodes.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/element/element.dart';
-import 'package:analyzer/dart/element/visitor.dart';
+import 'package:analyzer/dart/element/element2.dart';
+import 'package:analyzer/dart/element/visitor2.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/summary2/not_serializable_nodes.dart';
@@ -16,23 +14,23 @@ import 'package:analyzer/src/utilities/extensions/collection.dart';
 /// the whole token stream for the file. We don't want all this data after
 /// linking. So, we need to detach these nodes.
 void detachElementsFromNodes(LibraryElementImpl element) {
-  element.accept(_Visitor());
+  element.accept2(_Visitor());
 }
 
-class _Visitor extends GeneralizingElementVisitor<void> {
+class _Visitor extends GeneralizingElementVisitor2<void> {
   @override
-  void visitClassElement(ClassElement element) {
-    if (element is ClassElementImpl) {
-      element.mixinInferenceCallback = null;
+  void visitClassElement(covariant ClassElementImpl2 element) {
+    for (var fragment in element.fragments) {
+      fragment.mixinInferenceCallback = null;
     }
     super.visitClassElement(element);
   }
 
   @override
-  void visitConstructorElement(ConstructorElement element) {
-    if (element is ConstructorElementImpl) {
+  void visitConstructorElement(covariant ConstructorElementImpl2 element) {
+    for (var fragment in element.fragments) {
       // Make a copy, so that it is not a NodeList.
-      var initializers = element.constantInitializers.toFixedList();
+      var initializers = fragment.constantInitializers.toFixedList();
       initializers.forEach(_detachNode);
 
       for (var initializer in initializers) {
@@ -56,63 +54,76 @@ class _Visitor extends GeneralizingElementVisitor<void> {
         }
       }
 
-      element.constantInitializers = initializers;
+      fragment.constantInitializers = initializers;
     }
     super.visitConstructorElement(element);
   }
 
   @override
-  void visitElement(Element element) {
-    for (var annotation in element.metadata) {
-      var ast = (annotation as ElementAnnotationImpl).annotationAst;
-      _detachNode(ast);
-      _sanitizeArguments(ast.arguments?.arguments);
+  void visitElement(Element2 element) {
+    if (element case Annotatable annotatable) {
+      for (var annotation in annotatable.metadata2.annotations) {
+        var ast = (annotation as ElementAnnotationImpl).annotationAst;
+        _detachNode(ast);
+        _sanitizeArguments(ast.arguments?.arguments);
+      }
     }
     super.visitElement(element);
   }
 
   @override
-  void visitEnumElement(EnumElement element) {
-    if (element is EnumElementImpl) {
-      element.mixinInferenceCallback = null;
+  void visitEnumElement(covariant EnumElementImpl2 element) {
+    for (var fragment in element.fragments) {
+      fragment.mixinInferenceCallback = null;
     }
     super.visitEnumElement(element);
   }
 
   @override
-  void visitMixinElement(MixinElement element) {
-    if (element is MixinElementImpl) {
-      element.mixinInferenceCallback = null;
-    }
-    super.visitMixinElement(element);
+  void visitFormalParameterElement(
+    FormalParameterElement element,
+  ) {
+    _detachConstVariable(element);
+    super.visitFormalParameterElement(element);
   }
 
   @override
-  void visitParameterElement(ParameterElement element) {
-    _detachConstVariable(element);
-    super.visitParameterElement(element);
+  void visitMixinElement(covariant MixinElementImpl2 element) {
+    for (var fragment in element.fragments) {
+      fragment.mixinInferenceCallback = null;
+    }
+    super.visitMixinElement(element);
   }
 
   @override
-  void visitPropertyInducingElement(PropertyInducingElement element) {
-    if (element is PropertyInducingElementImpl) {
-      element.typeInference = null;
+  void visitPropertyInducingElement(PropertyInducingElement2 element) {
+    for (var fragment in element.fragments) {
+      if (fragment is PropertyInducingElementImpl) {
+        fragment.typeInference = null;
+      }
     }
+    element.constantInitializer2;
     _detachConstVariable(element);
     super.visitPropertyInducingElement(element);
   }
 
-  void _detachConstVariable(Element element) {
-    if (element is ConstVariableElement) {
-      var initializer = element.constantInitializer;
-      if (initializer is ExpressionImpl) {
-        _detachNode(initializer);
+  void _detachConstVariable(Object element) {
+    if (element is VariableElementImpl2) {
+      for (var fragment in element.fragments) {
+        if (fragment case ConstVariableElement fragment) {
+          fragment as VariableElementImpl;
+          var initializer = fragment.constantInitializer;
+          if (initializer is ExpressionImpl) {
+            _detachNode(initializer);
 
-        initializer = replaceNotSerializableNode(initializer);
-        element.constantInitializer = initializer;
+            initializer = replaceNotSerializableNode(initializer);
+            fragment.constantInitializer = initializer;
 
-        ConstantContextForExpressionImpl(element, initializer);
+            ConstantContextForExpressionImpl(fragment, initializer);
+          }
+        }
       }
+      element.resetConstantInitializer();
     }
   }