Elements. Use less VariableFragmentImpl.type

Change-Id: I80e3c41a7acf5bc00d2f36bf3a9ad77c1413f7ea
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/439440
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>

Author: scheglov

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

@@ -510,7 +510,7 @@ class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
                   ),
                 )
                 ..element = formalParameterElement
-                ..setPseudoExpressionStaticType(formalParameterFragment.type),
+                ..setPseudoExpressionStaticType(formalParameterElement.type),
             );
           }
 
@@ -10432,7 +10432,7 @@ abstract class VariableElementImpl extends ElementImpl
   Constant? evaluationResult;
 
   @override
-  ConstantInitializer? get constantInitializer {
+  ConstantInitializerImpl? get constantInitializer {
     if (_constantInitializer case var result?) {
       return result;
     }

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

@@ -1851,7 +1851,7 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
   }
 
   void _verifyExtensionElementImplements(
-    ExtensionTypeFragmentImpl declaredElement,
+    ExtensionTypeFragmentImpl declaredFragment,
     NamedTypeImpl node,
     TypeImpl type,
   ) {
@@ -1866,6 +1866,7 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
       return;
     }
 
+    var declaredElement = declaredFragment.element;
     var declaredRepresentation = declaredElement.representation.type;
     if (typeSystem.isSubtypeOf(declaredRepresentation, type)) {
       return;
@@ -1887,7 +1888,7 @@ class ResolutionVisitor extends RecursiveAstVisitor<void> {
               implementedRepresentation,
               type.element.name ?? '',
               declaredRepresentation,
-              declaredElement.name ?? '',
+              declaredFragment.name ?? '',
             ],
           );
         }

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

@@ -3425,8 +3425,9 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
 
   void _checkForExtensionTypeRepresentationTypeBottom(
     ExtensionTypeDeclarationImpl node,
-    ExtensionTypeFragmentImpl element,
+    ExtensionTypeFragmentImpl fragment,
   ) {
+    var element = fragment.element;
     var representationType = element.representation.type;
     if (representationType.isBottom) {
       diagnosticReporter.atNode(
@@ -4733,7 +4734,8 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
       return;
     }
 
-    var representationType = fragment.representation.type;
+    var element = fragment.element;
+    var representationType = element.representation.type;
 
     for (var typeParameterNode in typeParameters) {
       var typeParameterElement = typeParameterNode.declaredFragment!.element;
@@ -5836,9 +5838,10 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
         if (!typeParameter.isLegacyCovariant) {
           var fields = node.fields;
           var fieldFragment = fields.variables.first.declaredFragment!;
+          var fieldElement = fieldFragment.element;
           var fieldName = fields.variables.first.name;
           Variance fieldVariance = typeParameter.computeVarianceInType(
-            fieldFragment.type,
+            fieldElement.type,
           );
 
           _checkForWrongVariancePosition(
@@ -5894,7 +5897,8 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
       var methodParameters = method.parameters?.parameters;
       if (methodParameters != null) {
         for (var methodParameter in methodParameters) {
-          var methodParameterElement = methodParameter.declaredFragment!;
+          var methodParameterFragment = methodParameter.declaredFragment!;
+          var methodParameterElement = methodParameterFragment.element;
           if (methodParameterElement.isCovariant) {
             continue;
           }

pkg/analyzer/lib/src/summary2/ast_binary_reader.dart

@@ -435,8 +435,8 @@ class AstBinaryReader {
       parameter.declaredFragment = fragment;
     }
     node.declaredFragment = fragment;
-    fragment.element.type = nonDefaultElement.type;
-    fragment.type = nonDefaultElement.type;
+    fragment.element.type = nonDefaultElement.element.type;
+    fragment.type = nonDefaultElement.element.type;
 
     return node;
   }

pkg/analyzer/lib/src/summary2/ast_binary_writer.dart

@@ -898,7 +898,8 @@ class AstBinaryWriter extends ThrowingAstVisitor<void> {
   void _storeForLoopParts(ForLoopParts node) {}
 
   void _storeFormalParameter(FormalParameterImpl node) {
-    var element = node.declaredFragment!;
+    var fragment = node.declaredFragment!;
+    var element = fragment.element;
     _writeActualType(_sink, element.type);
   }
 

pkg/analyzer/lib/src/summary2/default_value_resolver.dart

@@ -2,15 +2,14 @@
 // 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.
 
-import 'package:analyzer/dart/element/scope.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/summary2/ast_resolver.dart';
 import 'package:analyzer/src/summary2/library_builder.dart';
 import 'package:analyzer/src/summary2/link.dart';
 import 'package:analyzer/src/summary2/linking_node_scope.dart';
-import 'package:analyzer/src/utilities/extensions/element.dart';
+import 'package:analyzer/src/utilities/extensions/object.dart';
 
 class DefaultValueResolver {
   final Linker _linker;
@@ -21,26 +20,42 @@ class DefaultValueResolver {
     : _typeSystem = _libraryBuilder.element.typeSystem;
 
   void resolve() {
-    for (var libraryFragment in _libraryBuilder.element.fragments) {
-      _UnitContext(libraryFragment)
-        ..forEach(libraryFragment.classes, _interface)
-        ..forEach(libraryFragment.enums, _interface)
-        ..forEach(libraryFragment.extensions, _extension)
-        ..forEach(libraryFragment.extensionTypes, _interface)
-        ..forEach(libraryFragment.functions, _executable)
-        ..forEach(libraryFragment.mixins, _interface);
+    var libraryElement = _libraryBuilder.element;
+    var instanceElementListList = [
+      libraryElement.classes,
+      libraryElement.enums,
+      libraryElement.extensions,
+      libraryElement.extensionTypes,
+      libraryElement.mixins,
+    ];
+    for (var instanceElementList in instanceElementListList) {
+      for (var instanceElement in instanceElementList) {
+        for (var method in instanceElement.methods) {
+          _executableElement(
+            method,
+            enclosingInterfaceElement: instanceElement.ifTypeOrNull(),
+          );
+        }
+        if (instanceElement case InterfaceElementImpl interfaceElement) {
+          for (var constructor in interfaceElement.constructors) {
+            _executableElement(
+              constructor,
+              enclosingInterfaceElement: interfaceElement,
+            );
+          }
+        }
+      }
     }
-  }
 
-  void _constructor(_ClassContext context, ConstructorFragmentImpl element) {
-    if (element.isSynthetic) return;
-    _executable(context, element);
+    for (var topLevelFunction in libraryElement.topLevelFunctions) {
+      _executableElement(topLevelFunction, enclosingInterfaceElement: null);
+    }
   }
 
-  DefaultFormalParameterImpl? _defaultParameter(
-    FormalParameterFragmentImpl element,
+  DefaultFormalParameterImpl? _defaultParameterNode(
+    FormalParameterFragmentImpl fragment,
   ) {
-    var node = _linker.getLinkingNode(element);
+    var node = _linker.getLinkingNode(fragment);
     if (node?.parent case DefaultFormalParameterImpl defaultParent) {
       if (defaultParent.defaultValue != null) {
         return defaultParent;
@@ -49,110 +64,44 @@ class DefaultValueResolver {
     return null;
   }
 
-  void _executable(_Context context, ExecutableFragmentImpl element) {
-    _ExecutableContext(
-      enclosingContext: context,
-      executableElement: element,
-      scope: _scopeFromElement(element),
-    ).forEach(element.parameters, _parameter);
-  }
-
-  void _extension(_UnitContext context, ExtensionFragmentImpl element) {
-    context.forEach(element.methods, _executable);
-  }
-
-  void _interface(_UnitContext context, InterfaceFragmentImpl element) {
-    _ClassContext(context, element)
-      ..forEach(element.constructors, _constructor)
-      ..forEach(element.methods, _executable);
+  void _executableElement(
+    ExecutableElementImpl element, {
+    required InterfaceElementImpl? enclosingInterfaceElement,
+  }) {
+    for (var formalParameter in element.formalParameters) {
+      _formalParameterElement(
+        formalParameter as FormalParameterElementImpl,
+        enclosingInterfaceElement: enclosingInterfaceElement,
+        enclosingExecutableElement: element,
+      );
+    }
   }
 
-  void _parameter(
-    _ExecutableContext context,
-    FormalParameterFragmentImpl parameter,
-  ) {
-    // If a function typed parameter, process nested parameters.
-    context.forEach(parameter.parameters, _parameter);
-
-    var node = _defaultParameter(parameter);
-    if (node == null) return;
+  void _formalParameterElement(
+    FormalParameterElementImpl formalParameter, {
+    required InterfaceElementImpl? enclosingInterfaceElement,
+    required ExecutableElementImpl enclosingExecutableElement,
+  }) {
+    var firstFragment = formalParameter.firstFragment;
+    var firstNode = _defaultParameterNode(firstFragment);
+    if (firstNode == null) {
+      return;
+    }
 
-    var contextType = _typeSystem.eliminateTypeVariables(parameter.type);
+    var contextType = _typeSystem.eliminateTypeVariables(formalParameter.type);
 
     var analysisOptions = _libraryBuilder.kind.file.analysisOptions;
     var astResolver = AstResolver(
       _linker,
-      context.libraryFragment,
-      context.scope,
+      firstFragment.libraryFragment as LibraryFragmentImpl,
+      LinkingNodeContext.get(firstNode).scope,
       analysisOptions,
-      enclosingClassElement: context.classElement?.asElement2,
-      enclosingExecutableElement: context.executableElement.asElement2,
+      enclosingClassElement: enclosingInterfaceElement,
+      enclosingExecutableElement: enclosingExecutableElement,
     );
     astResolver.resolveExpression(
-      () => node.defaultValue!,
+      () => firstNode.defaultValue!,
       contextType: contextType,
     );
   }
-
-  Scope _scopeFromElement(FragmentImpl element) {
-    var node = _linker.getLinkingNode(element)!;
-    return LinkingNodeContext.get(node).scope;
-  }
-}
-
-class _ClassContext extends _Context {
-  final _UnitContext unitContext;
-
-  @override
-  final InterfaceFragmentImpl classElement;
-
-  _ClassContext(this.unitContext, this.classElement);
-
-  @override
-  LibraryFragmentImpl get libraryFragment {
-    return unitContext.libraryFragment;
-  }
-}
-
-abstract class _Context {
-  InterfaceFragmentImpl? get classElement => null;
-
-  LibraryFragmentImpl get libraryFragment;
-}
-
-class _ExecutableContext extends _Context {
-  final _Context enclosingContext;
-  final ExecutableFragmentImpl executableElement;
-  final Scope scope;
-
-  _ExecutableContext({
-    required this.enclosingContext,
-    required this.executableElement,
-    required this.scope,
-  });
-
-  @override
-  InterfaceFragmentImpl? get classElement {
-    return enclosingContext.classElement;
-  }
-
-  @override
-  LibraryFragmentImpl get libraryFragment {
-    return enclosingContext.libraryFragment;
-  }
-}
-
-class _UnitContext extends _Context {
-  @override
-  final LibraryFragmentImpl libraryFragment;
-
-  _UnitContext(this.libraryFragment);
-}
-
-extension _ContextExtension<C extends _Context> on C {
-  void forEach<T>(List<T> elements, void Function(C context, T element) f) {
-    for (var element in elements) {
-      f(this, element);
-    }
-  }
 }

pkg/analyzer/lib/src/summary2/extension_type.dart

@@ -86,7 +86,7 @@ class _ImplementsNode extends graph.Node<_ImplementsNode> {
     isEvaluated = true;
     element.hasImplementsSelfReference = true;
 
-    var representationType = element.firstFragment.representation.type;
+    var representationType = element.representation.type;
     var typeSystem = element.library.typeSystem;
 
     var superInterface =

pkg/analyzer/lib/src/summary2/instance_member_inferrer.dart

@@ -416,7 +416,10 @@ class InstanceMemberInferrer {
 
     var classElement = constructor.enclosingElement;
     if (classElement is ClassFragmentImpl && classElement.isMixinApplication) {
-      _inferMixinApplicationConstructor(classElement, constructor);
+      _inferMixinApplicationConstructor(
+        classElement.element,
+        constructor.element,
+      );
     }
   }
 
@@ -523,40 +526,38 @@ class InstanceMemberInferrer {
   }
 
   void _inferMixinApplicationConstructor(
-    ClassFragmentImpl classElement,
-    ConstructorFragmentImpl constructor,
+    ClassElementImpl classElement,
+    ConstructorElementImpl constructor,
   ) {
     var superType = classElement.supertype;
     if (superType != null) {
       var index = classElement.constructors.indexOf(constructor);
       var superConstructors =
-          superType.elementImpl.constructors
-              .where(
-                (element) =>
-                    element.asElement2.isAccessibleIn(classElement.library),
-              )
+          superType.element.constructors
+              .where((element) => element.isAccessibleIn(classElement.library))
               .toList();
       if (index < superConstructors.length) {
         var baseConstructor = superConstructors[index];
         var substitution = Substitution.fromInterfaceType(superType);
         forCorrespondingPairs<
-          FormalParameterFragmentImpl,
-          FormalParameterFragmentImpl
-        >(constructor.parameters, baseConstructor.parameters, (
-          parameter,
-          baseParameter,
-        ) {
-          var type = substitution.substituteType(baseParameter.type);
-          parameter.element.type = type;
-          parameter.type = type;
-        });
+          FormalParameterElementImpl,
+          FormalParameterElementImpl
+        >(
+          constructor.formalParameters.cast(),
+          baseConstructor.formalParameters.cast(),
+          (parameter, baseParameter) {
+            var type = substitution.substituteType(baseParameter.type);
+            parameter.type = type;
+            parameter.firstFragment.type = type;
+          },
+        );
         // Update arguments of `SuperConstructorInvocation` to have the types
         // (which we have just set) of the corresponding formal parameters.
         // MixinApp(x, y) : super(x, y);
         var initializers = constructor.constantInitializers;
         var initializer = initializers.single as SuperConstructorInvocation;
-        forCorrespondingPairs<FormalParameterFragmentImpl, Expression>(
-          constructor.parameters,
+        forCorrespondingPairs<FormalParameterElementImpl, Expression>(
+          constructor.formalParameters.cast(),
           initializer.argumentList.arguments,
           (parameter, argument) {
             (argument as SimpleIdentifierImpl).setPseudoExpressionStaticType(