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

// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
// 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:_fe_analyzer_shared/src/type_inference/type_analyzer.dart'
    as shared;
import 'package:_fe_analyzer_shared/src/types/shared_type.dart'
    as shared
    show Variance;
import 'package:_fe_analyzer_shared/src/types/shared_type.dart' hide Variance;
import 'package:analyzer/dart/analysis/declared_variables.dart';
import 'package:analyzer/dart/analysis/features.dart';
import 'package:analyzer/dart/analysis/session.dart';
import 'package:analyzer/dart/ast/token.dart';
import 'package:analyzer/dart/constant/value.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/diagnostic/diagnostic.dart';
import 'package:analyzer/source/line_info.dart';
import 'package:analyzer/source/source.dart';
import 'package:analyzer/source/source_range.dart';
import 'package:analyzer/src/binary/binary_reader.dart';
import 'package:analyzer/src/binary/binary_writer.dart';
import 'package:analyzer/src/dart/analysis/experiments.dart';
import 'package:analyzer/src/dart/analysis/session.dart';
import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:analyzer/src/dart/ast/extensions.dart';
import 'package:analyzer/src/dart/ast/token.dart';
import 'package:analyzer/src/dart/constant/compute.dart';
import 'package:analyzer/src/dart/constant/evaluation.dart';
import 'package:analyzer/src/dart/constant/value.dart';
import 'package:analyzer/src/dart/element/annotation_target.dart';
import 'package:analyzer/src/dart/element/class_hierarchy.dart';
import 'package:analyzer/src/dart/element/display_string_builder.dart';
import 'package:analyzer/src/dart/element/field_name_non_promotability_info.dart';
import 'package:analyzer/src/dart/element/inheritance_manager3.dart';
import 'package:analyzer/src/dart/element/member.dart';
import 'package:analyzer/src/dart/element/name_union.dart';
import 'package:analyzer/src/dart/element/scope.dart';
import 'package:analyzer/src/dart/element/since_sdk_version.dart';
import 'package:analyzer/src/dart/element/type.dart';
import 'package:analyzer/src/dart/element/type_algebra.dart';
import 'package:analyzer/src/dart/element/type_provider.dart';
import 'package:analyzer/src/dart/element/type_system.dart';
import 'package:analyzer/src/dart/resolver/scope.dart'
    show Namespace, NamespaceBuilder, RecordingExportNamespace;
import 'package:analyzer/src/error/inference_error.dart';
import 'package:analyzer/src/fine/annotations.dart';
import 'package:analyzer/src/fine/library_manifest.dart';
import 'package:analyzer/src/fine/requirement_failure.dart';
import 'package:analyzer/src/fine/requirements.dart';
import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
import 'package:analyzer/src/generated/source.dart' show DartUriResolver;
import 'package:analyzer/src/generated/utilities_collection.dart';
import 'package:analyzer/src/generated/utilities_dart.dart';
import 'package:analyzer/src/summary2/ast_binary_tokens.dart';
import 'package:analyzer/src/summary2/export.dart';
import 'package:analyzer/src/summary2/linked_element_factory.dart';
import 'package:analyzer/src/summary2/reference.dart';
import 'package:analyzer/src/util/file_paths.dart' as file_paths;
import 'package:analyzer/src/utilities/extensions/collection.dart';
import 'package:analyzer/src/utilities/extensions/element.dart';
import 'package:analyzer/src/utilities/extensions/object.dart';
import 'package:analyzer/src/utilities/extensions/string.dart';
import 'package:collection/collection.dart';
import 'package:meta/meta.dart';
import 'package:pub_semver/pub_semver.dart';

/// Marker for declarations that are code generated.
const generated = _Generated();

class BindPatternVariableElementImpl extends PatternVariableElementImpl
    implements BindPatternVariableElement {
  BindPatternVariableElementImpl(super.firstFragment);

  @override
  BindPatternVariableFragmentImpl get firstFragment => _firstFragment;

  @override
  List<BindPatternVariableFragmentImpl> get fragments {
    return [
      for (
        BindPatternVariableFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  /// Whether this variable clashes with another pattern variable with the same
  /// name within the same pattern.
  bool get isDuplicate => _firstFragment.isDuplicate;

  /// Set whether this variable clashes with another pattern variable with the
  /// same name within the same pattern.
  set isDuplicate(bool value) => _firstFragment.isDuplicate = value;

  DeclaredVariablePatternImpl get node => _firstFragment.node;

  @override
  BindPatternVariableFragmentImpl get _firstFragment =>
      super._firstFragment as BindPatternVariableFragmentImpl;
}

class BindPatternVariableFragmentImpl extends PatternVariableFragmentImpl
    implements BindPatternVariableFragment {
  final DeclaredVariablePatternImpl node;

  /// This flag is set to `true` if this variable clashes with another
  /// pattern variable with the same name within the same pattern.
  bool isDuplicate = false;

  BindPatternVariableFragmentImpl({
    required this.node,
    required super.name,
    required super.firstTokenOffset,
  }) {
    _element2 = BindPatternVariableElementImpl(this);
  }

  @override
  BindPatternVariableElementImpl get element =>
      super.element as BindPatternVariableElementImpl;

  @override
  BindPatternVariableFragmentImpl? get nextFragment =>
      super.nextFragment as BindPatternVariableFragmentImpl?;

  @override
  BindPatternVariableFragmentImpl? get previousFragment =>
      super.previousFragment as BindPatternVariableFragmentImpl?;
}

@elementClass
@GenerateElementFlags(flags: _ClassElementFlags.values)
class ClassElementImpl extends InterfaceElementImpl implements ClassElement {
  @override
  @trackedIncludedInId
  final MemberContainerReference reference;

  @override
  final ClassFragmentImpl _firstFragment;

  ClassElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    _firstFragment.element = this;

    isAbstract = _firstFragment.isAbstract || _firstFragment.isSealed;
    isBase = _firstFragment.isBase;
    isFinal = _firstFragment.isFinal;
    isInterface = _firstFragment.isInterface;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  /// If we can find all possible subtypes of this class, return them.
  ///
  /// If the class is final, all its subtypes are declared in this library.
  ///
  /// If the class is sealed, and all its subtypes are either final or sealed,
  /// then these subtypes are all subtypes that are possible.
  @trackedDirectly
  List<InterfaceTypeImpl>? get allSubtypes {
    globalResultRequirements?.record_classElement_allSubtypes(element: this);

    return globalResultRequirements.alreadyRecorded(() {
      if (isFinal) {
        var result = <InterfaceTypeImpl>[];
        for (var element in library.children) {
          if (element is InterfaceElementImpl && element != this) {
            var elementThis = element.thisType;
            if (elementThis.asInstanceOf(this) != null) {
              result.add(elementThis);
            }
          }
        }
        return result;
      }

      if (isSealed) {
        var result = <InterfaceTypeImpl>[];
        for (var element in library.children) {
          if (element is! InterfaceElementImpl || identical(element, this)) {
            continue;
          }

          var elementThis = element.thisType;
          if (elementThis.asInstanceOf(this) == null) {
            continue;
          }

          switch (element) {
            case ClassElementImpl _:
              if (element.isFinal || element.isSealed) {
                result.add(elementThis);
              } else {
                return null;
              }
            case EnumElementImpl _:
              result.add(elementThis);
            case MixinElementImpl _:
              return null;
            case ExtensionTypeElementImpl():
              // This should never happen because extension types can't be
              // sealed.
              assert(false);
          }
        }
        return result;
      }

      return null;
    });
  }

  @trackedDirectly
  List<InterfaceElementImpl> get directSubtypesOfSealed {
    assert(isSealed);
    globalResultRequirements?.record_classElement_directSubtypesOfSealed(
      element: this,
    );

    return globalResultRequirements.alreadyRecorded(() {
      List<InterfaceElementImpl> subclasses = [];
      outer:
      for (var declaration in library.children) {
        if (declaration is ExtensionTypeElement) {
          continue;
        }
        if (declaration != this && declaration is InterfaceElementImpl) {
          bool checkType(InterfaceTypeImpl? type) {
            if (type?.element == this) {
              subclasses.add(declaration);
              return true;
            }
            return false;
          }

          if (checkType(declaration.supertype)) {
            continue outer;
          }
          for (var mixin in declaration.mixins) {
            if (checkType(mixin)) {
              continue outer;
            }
          }
          for (var interface in declaration.interfaces) {
            if (checkType(interface)) {
              continue outer;
            }
          }
          if (declaration is MixinElementImpl) {
            for (var type in declaration.superclassConstraints) {
              if (checkType(type)) {
                continue outer;
              }
            }
          }
        }
      }
      return subclasses;
    });
  }

  @override
  @trackedDirectlyOpaque
  ClassFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isAbstract': isAbstract,
      'isBase': isBase,
      'isFinal': isFinal,
      'isInterface': isInterface,
      'isMixinApplication': isMixinApplication,
      'isMixinClass': isMixinClass,
      'isSealed': isSealed,
    };
  }

  @override
  @trackedDirectlyOpaque
  List<ClassFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @trackedIndirectly
  bool get hasGenerativeConstConstructor {
    return constructors.any((c) => !c.isFactory && c.isConst);
  }

  /// Whether the executable element is abstract.
  ///
  /// Executable elements are abstract if they are not external, and have no
  /// body.
  @generated
  @override
  @trackedIncludedInId
  bool get isAbstract {
    return hasFlag(_ElementStorageFlag.classElement_isAbstract);
  }

  @generated
  set isAbstract(bool value) {
    setFlag(_ElementStorageFlag.classElement_isAbstract, value);
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isBase {
    return hasFlag(_ElementStorageFlag.classElement_isBase);
  }

  @generated
  set isBase(bool value) {
    setFlag(_ElementStorageFlag.classElement_isBase, value);
  }

  @override
  @trackedIncludedInId
  bool get isConstructable => !isSealed && !isAbstract;

  @override
  @trackedIncludedInId
  bool get isDartCoreEnum {
    return name == 'Enum' && library.isDartCore;
  }

  /// Whether the class represents the class 'Function' defined in `dart:core`.
  @trackedIncludedInId
  bool get isDartCoreFunction {
    return name == 'Function' && library.isDartCore;
  }

  @override
  @trackedIncludedInId
  bool get isDartCoreObject {
    return name == 'Object' && library.isDartCore;
  }

  @trackedIncludedInId
  bool get isDartCoreRecord {
    return name == 'Record' && library.isDartCore;
  }

  @override
  @trackedIncludedInId
  bool get isExhaustive => isSealed;

  @override
  @trackedIncludedInId
  bool get isExtendableOutside => !isInterface && !isFinal && !isSealed;

  @generated
  @override
  @trackedIncludedInId
  bool get isFinal {
    return hasFlag(_ElementStorageFlag.classElement_isFinal);
  }

  @generated
  set isFinal(bool value) {
    setFlag(_ElementStorageFlag.classElement_isFinal, value);
  }

  @override
  @trackedIncludedInId
  bool get isImplementableOutside => !isBase && !isFinal && !isSealed;

  @generated
  @override
  @trackedIncludedInId
  bool get isInterface {
    return hasFlag(_ElementStorageFlag.classElement_isInterface);
  }

  @generated
  set isInterface(bool value) {
    setFlag(_ElementStorageFlag.classElement_isInterface, value);
  }

  @override
  @trackedIncludedInId
  bool get isMixableOutside {
    if (library.featureSet.isEnabled(Feature.class_modifiers)) {
      return isMixinClass && !isInterface && !isFinal && !isSealed;
    }
    return true;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isMixinApplication {
    return _firstFragment.isMixinApplication;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isMixinClass {
    return _firstFragment.isMixinClass;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isSealed {
    return _firstFragment.isSealed;
  }

  @override
  @trackedIndirectly
  bool get isValidMixin {
    var supertype = this.supertype;
    if (supertype != null && !supertype.isDartCoreObject) {
      return false;
    }
    for (var constructor in constructors) {
      if (constructor.isOriginDeclaration && !constructor.isFactory) {
        return false;
      }
    }
    return true;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.CLASS;

  List<ClassFragmentImpl> get _fragments {
    return [
      for (
        ClassFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitClassElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeClassElement(this);
  }

  @trackedInternal
  void ensureReadMembersForFragments() {
    for (var fragment in _fragments) {
      fragment.ensureReadMembers();
    }
  }

  @trackedInternal
  void linkFragments(List<ClassFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    TypeParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.typeParameters,
    );
  }

  @override
  void _buildMixinAppConstructors() {
    // Do nothing if not a mixin application.
    if (!isMixinApplication) {
      return;
    }

    var superType = supertype;
    if (superType == null) {
      // Shouldn't ever happen, since the only classes with no supertype are
      // Object and mixins, and they aren't a mixin application. But for
      // safety's sake just assume an empty list.
      assert(false);
      _constructors = <ConstructorElementImpl>[];
      return;
    }

    // Assign to break a possible infinite recursion during computing.
    _constructors = const <ConstructorElementImpl>[];

    var superConstructors = superType.constructors
        .where((constructor) => constructor.isAccessibleIn(library))
        .where((constructor) => constructor.isGenerative)
        .toList(growable: false);

    bool typeHasInstanceVariables(InterfaceTypeImpl type) {
      return type.element.fields.any(
        (field) => field.isInstanceField && field.isOriginDeclaration,
      );
    }

    _constructors = superConstructors.map((superConstructor) {
      var constructorFragment = ConstructorFragmentImpl(
        name: superConstructor.name ?? 'new',
      );
      constructorFragment.isOriginMixinApplication = true;
      constructorFragment.typeName = name;
      constructorFragment.isConst =
          superConstructor.isConst && !mixins.any(typeHasInstanceVariables);
      constructorFragment.enclosingFragment = _firstFragment;

      var constructorElement = ConstructorElementImpl(
        name: constructorFragment.name,
        reference: reference.getOrCreateConstructor(constructorFragment.name),
        firstFragment: constructorFragment,
      );
      constructorElement.hasEnclosingTypeParameterReference =
          typeParameters.isNotEmpty;
      constructorElement.superConstructor = superConstructor;
      // TODO(scheglov): make it explicit
      // constructorElement.enclosingElement = this;

      var formalParameterFragments = <FormalParameterFragmentImpl>[];
      var formalParameterElements = <FormalParameterElementImpl>[];
      var superInvocationArguments = <ExpressionImpl>[];
      for (var superFormalParameter in superConstructor.formalParameters) {
        var formalParameterFragment =
            FormalParameterFragmentImpl(
                name: superFormalParameter.name,
                nameOffset: null,
                parameterKind: superFormalParameter.parameterKind,
              )
              ..constantInitializer2 = superFormalParameter
                  .baseElement
                  ._firstFragment
                  .constantInitializer2;

        formalParameterFragment.isConst = superFormalParameter.isConst;
        formalParameterFragment.isFinal = superFormalParameter.isFinal;
        formalParameterFragment.isOriginMixinApplicationClassConstructor = true;
        formalParameterFragments.add(formalParameterFragment);

        var formalParameterElement = FormalParameterElementImpl(
          formalParameterFragment,
        );
        formalParameterElements.add(formalParameterElement);
        formalParameterElement.type = superFormalParameter.type;

        superInvocationArguments.add(
          UnqualifiedNameExpressionImpl(
              name: StringToken(
                TokenType.STRING,
                formalParameterFragment.name ?? '',
                -1,
              ),
            )
            ..resolution = VariableReadResolutionImpl(
              element: formalParameterElement,
              type: formalParameterElement.type,
            )
            ..setPseudoExpressionStaticType(formalParameterElement.type),
        );
      }

      constructorFragment.formalParameters = formalParameterFragments
          .toFixedList();

      var isNamed = superConstructor.name != 'new';
      var constructorSelector = isNamed
          ? ConstructorSelectorImpl.v2(
              period: Tokens.period(),
              name2: StringToken(
                TokenType.STRING,
                superConstructor.name ?? 'new',
                0,
              ),
            )
          : null;
      constructorSelector?.element = superConstructor.baseElement;
      var superInvocation = SuperConstructorInvocationImpl(
        superKeyword: Tokens.super_(),
        constructorSelector: constructorSelector,
        argumentList: ArgumentListImpl(
          leftParenthesis: Tokens.openParenthesis(),
          arguments2: superInvocationArguments,
          rightParenthesis: Tokens.closeParenthesis(),
        ),
      );
      AstNodeImpl.linkNodeTokens(superInvocation);
      superInvocation.element = superConstructor.baseElement;
      constructorFragment.constantInitializers = [superInvocation];

      return constructorElement;
    }).toFixedList();

    _firstFragment.constructors = _constructors
        .map((e) => e._firstFragment)
        .toFixedList();
  }
}

/// An [InterfaceFragmentImpl] which is a class.
@GenerateElementFlags(flags: _ClassElementFlags.values)
class ClassFragmentImpl extends InterfaceFragmentImpl implements ClassFragment {
  @override
  late final ClassElementImpl element;

  /// Initialize a newly created class element to have the given [name] at the
  /// given [offset] in the file that contains the declaration of this element.
  ClassFragmentImpl({required super.name});

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasExtendsClause': hasExtendsClause,
      'isAbstract': isAbstract,
      'isBase': isBase,
      'isFinal': isFinal,
      'isInterface': isInterface,
      'isMixinApplication': isMixinApplication,
      'isMixinClass': isMixinClass,
      'isSealed': isSealed,
    };
  }

  @generated
  bool get hasExtendsClause {
    return hasFlag(_FragmentStorageFlag.classFragment_hasExtendsClause);
  }

  @generated
  set hasExtendsClause(bool value) {
    setFlag(_FragmentStorageFlag.classFragment_hasExtendsClause, value);
  }

  /// Whether the executable element is abstract.
  ///
  /// Executable elements are abstract if they are not external, and have no
  /// body.
  @generated
  bool get isAbstract {
    return hasFlag(_FragmentStorageFlag.classFragment_isAbstract);
  }

  @generated
  set isAbstract(bool value) {
    setFlag(_FragmentStorageFlag.classFragment_isAbstract, value);
  }

  @generated
  bool get isBase {
    return hasFlag(_FragmentStorageFlag.classFragment_isBase);
  }

  @generated
  set isBase(bool value) {
    setFlag(_FragmentStorageFlag.classFragment_isBase, value);
  }

  @generated
  bool get isFinal {
    return hasFlag(_FragmentStorageFlag.classFragment_isFinal);
  }

  @generated
  set isFinal(bool value) {
    setFlag(_FragmentStorageFlag.classFragment_isFinal, value);
  }

  @generated
  bool get isInterface {
    return hasFlag(_FragmentStorageFlag.classFragment_isInterface);
  }

  @generated
  set isInterface(bool value) {
    setFlag(_FragmentStorageFlag.classFragment_isInterface, value);
  }

  @generated
  bool get isMixinApplication {
    return hasFlag(_FragmentStorageFlag.classFragment_isMixinApplication);
  }

  @generated
  set isMixinApplication(bool value) {
    setFlag(_FragmentStorageFlag.classFragment_isMixinApplication, value);
  }

  @generated
  bool get isMixinClass {
    return hasFlag(_FragmentStorageFlag.classFragment_isMixinClass);
  }

  @generated
  set isMixinClass(bool value) {
    setFlag(_FragmentStorageFlag.classFragment_isMixinClass, value);
  }

  @generated
  bool get isSealed {
    return hasFlag(_FragmentStorageFlag.classFragment_isSealed);
  }

  @generated
  set isSealed(bool value) {
    setFlag(_FragmentStorageFlag.classFragment_isSealed, value);
  }

  @override
  ClassFragmentImpl? get nextFragment {
    return super.nextFragment as ClassFragmentImpl?;
  }

  @override
  List<ClassFragmentImpl> get precedingFragments {
    return [
      for (
        var current = previousFragment;
        current != null;
        current = current.previousFragment
      )
        current,
    ];
  }

  @override
  ClassFragmentImpl? get previousFragment {
    return super.previousFragment as ClassFragmentImpl?;
  }

  void addFragment(ClassFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

// TODO(scheglov): remove this
class ConstantInitializerImpl {
  final VariableFragmentImpl fragment;
  final ExpressionImpl expression;

  ConstantInitializerImpl({required this.fragment, required this.expression});
}

@elementClass
@GenerateElementFlags(flags: _ConstructorElementFlags.values)
class ConstructorElementImpl extends ExecutableElementImpl
    with InternalConstructorElement
    implements ConstantEvaluationTarget {
  @override
  @trackedIncludedInId
  final MemberReference reference;

  @override
  @trackedIncludedInId
  final String? name;

  @override
  final ConstructorFragmentImpl _firstFragment;

  /// The constructor to which this constructor is redirecting.
  InternalConstructorElement? _redirectedConstructor;

  /// The super-constructor which this constructor is invoking, or `null` if
  /// this constructor is not generative, or is redirecting, or the
  /// super-constructor is not resolved, or the enclosing class is `Object`.
  ///
  // TODO(scheglov): We cannot have both super and redirecting constructors.
  // So, ideally we should have some kind of "either" or "variant" here.
  InternalConstructorElement? _superConstructor;

  /// For every constructor we initially set this flag to `true`, and then
  /// set it to `false` during computing constant values if we detect that it
  /// is a part of a cycle.
  @trackedInternal
  bool isCycleFree = true;

  @override
  @trackedInternal
  bool isConstantEvaluated = false;

  ConstructorElementImpl({
    required this.name,
    required this.reference,
    required ConstructorFragmentImpl firstFragment,
  }) : _firstFragment = firstFragment {
    reference.element = this;
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  @override
  @trackedIncludedInId
  ConstructorElementImpl get baseElement => this;

  /// The constant initializers for this element, from all fragments.
  @trackedIncludedInId
  List<ConstructorInitializer> get constantInitializers {
    return _fragments
        .expand((fragment) => fragment.constantInitializers)
        .toList(growable: false);
  }

  @override
  @trackedIndirectly
  String get displayName {
    var className = enclosingElement.name ?? '<null>';
    var name = this.name ?? '<null>';
    return '$className.$name';
  }

  @override
  @trackedIndirectly
  InterfaceElementImpl get enclosingElement =>
      _firstFragment.enclosingFragment.element;

  @override
  @trackedDirectlyOpaque
  ConstructorFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isConst': isConst,
      'isFactory': isFactory,
      'isInRedirectingConstructorCycle': isInRedirectingConstructorCycle,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginExtensionTypeRecovery': isOriginExtensionTypeRecovery,
      'isOriginImplicitDefault': isOriginImplicitDefault,
      'isOriginMixinApplication': isOriginMixinApplication,
      'isPrimary': isPrimary,
      'isRedirecting': isRedirecting,
    };
  }

  @override
  @trackedDirectlyOpaque
  List<ConstructorFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isConst {
    return _firstFragment.isConst;
  }

  @override
  @trackedIndirectly
  bool get isDefaultConstructor => _firstFragment.isDefaultConstructor;

  @generated
  @override
  @trackedIncludedInId
  bool get isFactory {
    return _firstFragment.isFactory;
  }

  @override
  @trackedIndirectly
  bool get isGenerative => !isFactory;

  @generated
  @trackedIncludedInId
  bool get isInRedirectingConstructorCycle {
    return hasFlag(
      _ElementStorageFlag.constructorElement_isInRedirectingConstructorCycle,
    );
  }

  @generated
  set isInRedirectingConstructorCycle(bool value) {
    setFlag(
      _ElementStorageFlag.constructorElement_isInRedirectingConstructorCycle,
      value,
    );
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginDeclaration {
    return _firstFragment.isOriginDeclaration;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginExtensionTypeRecovery {
    return _firstFragment.isOriginExtensionTypeRecovery;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginImplicitDefault {
    return _firstFragment.isOriginImplicitDefault;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginMixinApplication {
    return _firstFragment.isOriginMixinApplication;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isPrimary {
    return _firstFragment.isPrimary;
  }

  @trackedIncludedInId
  bool get isRedirecting {
    return _fragments.any((fragment) => fragment.isRedirecting);
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.CONSTRUCTOR;

  @override
  @trackedDirectlyOpaque
  ConstructorFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );
    return super.lastFragment as ConstructorFragmentImpl;
  }

  @override
  @trackedInternal
  LibraryFragmentImpl get libraryFragment => _firstFragment.libraryFragment;

  @override
  @trackedIncludedInId
  Element get nonSynthetic {
    if (isOriginDeclaration) {
      return this;
    } else {
      return enclosingElement;
    }
  }

  @override
  @trackedIncludedInId
  InternalConstructorElement? get redirectedConstructor {
    _ensureReadResolution();
    return _redirectedConstructor;
  }

  set redirectedConstructor(InternalConstructorElement? value) {
    _redirectedConstructor = value;
  }

  @override
  @trackedIncludedInId
  InterfaceTypeImpl get returnType {
    var result = _returnType;
    if (result != null) {
      return result as InterfaceTypeImpl;
    }

    return _returnType = enclosingElement.thisType;
  }

  @override
  @trackedIncludedInId
  InternalConstructorElement? get superConstructor {
    _ensureReadResolution();
    return _superConstructor;
  }

  set superConstructor(InternalConstructorElement? superConstructor) {
    _superConstructor = superConstructor;
  }

  @override
  List<ConstructorFragmentImpl> get _fragments {
    return [
      for (
        ConstructorFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitConstructorElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeConstructorElement(this);
  }

  /// Ensures that dependencies of this constructor, such as default values
  /// of formal parameters, are evaluated.
  @trackedInternal
  void computeConstantDependencies() {
    if (!isConstantEvaluated) {
      computeConstants(
        declaredVariables: library.declaredVariables,
        constants: [this],
        featureSet: library.featureSet,
        configuration: ConstantEvaluationConfiguration(),
      );
    }
  }

  @trackedInternal
  void linkFragments(List<ConstructorFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    TypeParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.typeParameters,
    );

    FormalParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.formalParameters,
    );
  }

  @override
  @trackedIndirectly
  InternalConstructorElement substitute(MapSubstitution substitution) {
    if (substitution.map.isEmpty) {
      return this;
    }
    return SubstitutedConstructorElementImpl(
      baseElement: this,
      substitution: substitution,
    );
  }

  @override
  @trackedDirectlyOpaque
  void visitChildren<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueVisitChildren,
      target: this,
      method: 'visitChildren',
    );
    for (var child in children) {
      child.accept(visitor);
    }
  }
}

/// A concrete implementation of a [ConstructorFragment].
@GenerateElementFlags(flags: _ConstructorElementFlags.values)
class ConstructorFragmentImpl extends ExecutableFragmentImpl
    implements ConstructorFragment {
  late final ConstructorElementImpl element;

  /// The initializers for this constructor (used for evaluating constant
  /// instance creation expressions).
  List<ConstructorInitializer> _constantInitializers = const [];

  @override
  int? newKeywordOffset;

  @override
  int? factoryKeywordOffset;

  @override
  String? typeName;

  @override
  int? typeNameOffset;

  @override
  int? periodOffset;

  @override
  final String name;

  @override
  int? nameOffset;

  @override
  int? nameEnd;

  @override
  int? thisKeywordOffset;

  /// The code range of the part of [PrimaryConstructorDeclaration] that
  /// belongs to this fragment: the constructor name and formal parameters.
  ///
  /// The type name and type parameters belong to the class, so this range is
  /// shorter than [codeOffset] and [codeLength], which cover all of the
  /// [PrimaryConstructorDeclaration].
  SourceRange? primaryHeaderCodeRange;

  /// The code range of the [PrimaryConstructorBody], if this fragment is
  /// based on [PrimaryConstructorDeclaration] and has the body.
  ///
  /// The body is a member of the class body, so it is separate from
  /// [primaryHeaderCodeRange] in the class header.
  SourceRange? primaryBodyCodeRange;

  @override
  ConstructorFragmentImpl? previousFragment;

  @override
  ConstructorFragmentImpl? nextFragment;

  /// Initialize a newly created constructor element to have the given [name]
  /// and [offset].
  ConstructorFragmentImpl({required this.name});

  /// Return the constant initializers for this element, which will be empty if
  /// there are no initializers, or `null` if there was an error in the source.
  List<ConstructorInitializer> get constantInitializers {
    _ensureReadResolution();
    return _constantInitializers;
  }

  set constantInitializers(List<ConstructorInitializer> constantInitializers) {
    _constantInitializers = constantInitializers;
  }

  @override
  String get displayName {
    var className = enclosingFragment.name ?? '<null>';
    var name = this.name;
    return '$className.$name';
  }

  @override
  InterfaceFragmentImpl get enclosingFragment =>
      super.enclosingFragment as InterfaceFragmentImpl;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isConst': isConst,
      'isFactory': isFactory,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginExtensionTypeRecovery': isOriginExtensionTypeRecovery,
      'isOriginImplicitDefault': isOriginImplicitDefault,
      'isOriginMixinApplication': isOriginMixinApplication,
      'isPrimary': isPrimary,
      'isRedirecting': isRedirecting,
    };
  }

  @generated
  bool get isConst {
    return hasFlag(_FragmentStorageFlag.constructorFragment_isConst);
  }

  @generated
  set isConst(bool value) {
    setFlag(_FragmentStorageFlag.constructorFragment_isConst, value);
  }

  /// Whether the constructor can be used as a default constructor - unnamed,
  /// and has no required parameters.
  bool get isDefaultConstructor {
    // unnamed
    if (name != 'new') {
      return false;
    }
    // no required parameters
    for (var formalParameters in formalParameters) {
      if (formalParameters.isRequired) {
        return false;
      }
    }
    // OK, can be used as default constructor
    return true;
  }

  @generated
  bool get isFactory {
    return hasFlag(_FragmentStorageFlag.constructorFragment_isFactory);
  }

  @generated
  set isFactory(bool value) {
    setFlag(_FragmentStorageFlag.constructorFragment_isFactory, value);
  }

  /// Whether the constructor represents a generative constructor.
  bool get isGenerative {
    return !isFactory;
  }

  @generated
  bool get isOriginDeclaration {
    return hasFlag(
      _FragmentStorageFlag.constructorFragment_isOriginDeclaration,
    );
  }

  @generated
  set isOriginDeclaration(bool value) {
    setFlag(
      _FragmentStorageFlag.constructorFragment_isOriginDeclaration,
      value,
    );
  }

  @generated
  @override
  bool get isOriginExtensionTypeRecovery {
    return hasFlag(
      _FragmentStorageFlag.constructorFragment_isOriginExtensionTypeRecovery,
    );
  }

  @generated
  set isOriginExtensionTypeRecovery(bool value) {
    setFlag(
      _FragmentStorageFlag.constructorFragment_isOriginExtensionTypeRecovery,
      value,
    );
  }

  @generated
  bool get isOriginImplicitDefault {
    return hasFlag(
      _FragmentStorageFlag.constructorFragment_isOriginImplicitDefault,
    );
  }

  @generated
  set isOriginImplicitDefault(bool value) {
    setFlag(
      _FragmentStorageFlag.constructorFragment_isOriginImplicitDefault,
      value,
    );
  }

  @generated
  bool get isOriginMixinApplication {
    return hasFlag(
      _FragmentStorageFlag.constructorFragment_isOriginMixinApplication,
    );
  }

  @generated
  set isOriginMixinApplication(bool value) {
    setFlag(
      _FragmentStorageFlag.constructorFragment_isOriginMixinApplication,
      value,
    );
  }

  @generated
  bool get isPrimary {
    return hasFlag(_FragmentStorageFlag.constructorFragment_isPrimary);
  }

  @generated
  set isPrimary(bool value) {
    setFlag(_FragmentStorageFlag.constructorFragment_isPrimary, value);
  }

  @generated
  bool get isRedirecting {
    return hasFlag(_FragmentStorageFlag.constructorFragment_isRedirecting);
  }

  @generated
  set isRedirecting(bool value) {
    setFlag(_FragmentStorageFlag.constructorFragment_isRedirecting, value);
  }

  @override
  int get offset =>
      nameOffset ??
      typeNameOffset ??
      firstTokenOffset ??
      enclosingFragment.offset;

  void addFragment(ConstructorFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

/// This mixin is used to set up loading class members from summaries only when
/// they are requested. The summary reader uses [deferReadMembers], and
/// getters invoke [ensureReadMembers].
///
/// We defer reading of both class elements, and class fragments. However
/// getters on class fragments ensure that the whole class element members are
/// read. The reason is that we want to have `nextFragment`, `previousFragment`,
/// and `element` properties return correct value, and reading the whole
/// element is the simplest way to do this.
mixin DeferredMembersReadingMixin {
  void Function()? _readMembersCallback;
  void Function()? _applyMembersOffsets;

  void deferApplyMembersOffsets(void Function() callback) {
    assert(_applyMembersOffsets == null);
    _applyMembersOffsets = callback;
  }

  void deferReadMembers(void Function()? callback) {
    assert(_readMembersCallback == null);
    _readMembersCallback = callback;
  }

  void ensureReadMembers() {
    if (_readMembersCallback case var callback?) {
      _readMembersCallback = null;
      callback();
    }

    if (_applyMembersOffsets case var callback?) {
      _applyMembersOffsets = null;
      callback();
    }
  }
}

class DeferredResolutionReadingHelper {
  static int _lockResolutionLoading = 0;

  static void withoutLoadingResolution(void Function() operation) {
    _lockResolutionLoading++;
    operation();
    _lockResolutionLoading--;
  }
}

/// This mixin is used to set up loading resolution information from summaries
/// on demand, and after all elements are loaded, so for example types can
/// reference them. The summary reader uses [deferReadResolution], and getters
/// invoke [_ensureReadResolution].
mixin DeferredResolutionReadingMixin {
  // TODO(scheglov): review whether we need this
  void Function()? _readResolutionCallback;
  void Function()? _applyResolutionConstantOffsets;

  void deferReadResolution(void Function()? callback) {
    assert(_readResolutionCallback == null);
    _readResolutionCallback = callback;
  }

  void deferResolutionConstantOffsets(void Function() callback) {
    assert(_applyResolutionConstantOffsets == null);
    _applyResolutionConstantOffsets = callback;
  }

  void _ensureReadResolution() {
    if (DeferredResolutionReadingHelper._lockResolutionLoading > 0) {
      return;
    }

    if (_readResolutionCallback case var callback?) {
      _readResolutionCallback = null;
      callback();

      // The callback read all AST nodes, apply offsets.
      if (_applyResolutionConstantOffsets case var callback?) {
        _applyResolutionConstantOffsets = null;
        callback();
      }
    }
  }
}

class DirectiveUriImpl implements DirectiveUri {}

class DirectiveUriWithLibraryImpl extends DirectiveUriWithSourceImpl
    implements DirectiveUriWithLibrary {
  @override
  late LibraryElementImpl library;

  DirectiveUriWithLibraryImpl({
    required super.relativeUriString,
    required super.relativeUri,
    required super.source,
    required this.library,
  });

  DirectiveUriWithLibraryImpl.read({
    required super.relativeUriString,
    required super.relativeUri,
    required super.source,
  });
}

class DirectiveUriWithRelativeUriImpl
    extends DirectiveUriWithRelativeUriStringImpl
    implements DirectiveUriWithRelativeUri {
  @override
  final Uri relativeUri;

  DirectiveUriWithRelativeUriImpl({
    required super.relativeUriString,
    required this.relativeUri,
  });
}

class DirectiveUriWithRelativeUriStringImpl extends DirectiveUriImpl
    implements DirectiveUriWithRelativeUriString {
  @override
  final String relativeUriString;

  DirectiveUriWithRelativeUriStringImpl({required this.relativeUriString});
}

class DirectiveUriWithSourceImpl extends DirectiveUriWithRelativeUriImpl
    implements DirectiveUriWithSource {
  @override
  final Source source;

  DirectiveUriWithSourceImpl({
    required super.relativeUriString,
    required super.relativeUri,
    required this.source,
  });
}

class DirectiveUriWithUnitImpl extends DirectiveUriWithRelativeUriImpl
    implements DirectiveUriWithUnit {
  @override
  final LibraryFragmentImpl libraryFragment;

  DirectiveUriWithUnitImpl({
    required super.relativeUriString,
    required super.relativeUri,
    required this.libraryFragment,
  });

  @override
  Source get source => libraryFragment.source;
}

/// The prefix declared by `@docImport`s, such as `io` in
/// `/// @docImport 'dart:io' as io;`.
///
/// Doc imports affect only documentation comments, so they are not a part of
/// the element model: this element is created when a library is analyzed, and
/// is not included into [LibraryFragmentImpl.prefixes]. Its [imports] are the
/// doc imports with this prefix, in the file that declares it.
class DocImportPrefixElementImpl extends PrefixElementImpl {
  @override
  final List<LibraryImportImpl> imports = [];

  DocImportPrefixElementImpl({
    required super.localId,
    required super.firstFragment,
  });

  @override
  PrefixScope get scope {
    // SAFETY: We create the [DocImportScope] of the file right after its doc
    // import prefixes, and its constructor sets this field.
    return _scope!;
  }
}

/// The synthetic element representing the declaration of the type `dynamic`.
class DynamicElementImpl extends ElementImpl {
  /// The unique instance of this class.
  static final DynamicElementImpl instance = DynamicElementImpl._();

  DynamicElementImpl._();

  @override
  Null get documentationComment => null;

  @override
  Element? get enclosingElement => null;

  @override
  DynamicFragmentImpl get firstFragment => _firstFragment;

  @override
  List<DynamicFragmentImpl> get fragments {
    return [
      for (
        DynamicFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  ElementKind get kind => ElementKind.DYNAMIC;

  @override
  Null get library => null;

  @override
  MetadataImpl get metadata {
    return MetadataImpl(const []);
  }

  @override
  String get name => 'dynamic';

  @override
  DynamicFragmentImpl get _firstFragment => DynamicFragmentImpl.instance;

  @override
  T? accept<T>(ElementVisitor2<T> visitor) => null;

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeDynamicElement(this);
  }
}

/// The synthetic element representing the declaration of the type `dynamic`.
class DynamicFragmentImpl extends FragmentImpl {
  /// The unique instance of this class.
  static final DynamicFragmentImpl instance = DynamicFragmentImpl._();

  /// Initialize a newly created instance of this class. Instances of this class
  /// should <b>not</b> be created except as part of creating the type
  /// associated with this element. The single instance of this class should be
  /// accessed through the method [instance].
  DynamicFragmentImpl._() : super(firstTokenOffset: null);

  @override
  List<FragmentImpl> get children => const [];

  @override
  DynamicElementImpl get element => DynamicElementImpl.instance;

  @override
  Null get enclosingFragment => null;

  @override
  Null get libraryFragment => null;

  @override
  String get name => 'dynamic';

  @override
  Null get nameOffset => null;

  @override
  Null get nextFragment => null;

  @override
  int get offset => 0;

  @override
  Null get previousFragment => null;
}

/// A concrete implementation of an [ElementAnnotation].
class ElementAnnotationImpl
    implements ElementAnnotation, ConstantEvaluationTarget {
  /// The name of the top-level variable used to mark that a function always
  /// throws, for dead code purposes.
  static const String _alwaysThrowsVariableName = 'alwaysThrows';

  /// The name of the top-level variable used to mark an element as not needing
  /// to be awaited.
  static const String _awaitNotRequiredVariableName = 'awaitNotRequired';

  /// The name of the class used to mark an element as being deprecated.
  static const String _deprecatedClassName = 'Deprecated';

  /// The name of the top-level variable used to mark an element as being
  /// deprecated.
  static const String _deprecatedVariableName = 'deprecated';

  /// The name of the top-level variable used to mark an element as not to be
  /// stored.
  static const String _doNotStoreVariableName = 'doNotStore';

  /// The name of the top-level variable used to mark a declaration as not to be
  /// used (for ephemeral testing and debugging only).
  static const String _doNotSubmitVariableName = 'doNotSubmit';

  /// The name of the top-level variable used to mark a declaration as experimental.
  static const String _experimentalVariableName = 'experimental';

  /// The name of the top-level variable used to mark a method as being a
  /// factory.
  static const String _factoryVariableName = 'factory';

  /// The name of the class used to mark a class and its subclasses as being
  /// immutable.
  static const String _immutableClassName = 'Immutable';

  /// The name of the top-level variable used to mark a class and its subclasses
  /// as being immutable.
  static const String _immutableVariableName = 'immutable';

  /// The name of the top-level variable used to mark an element as being
  /// internal to its package.
  static const String _internalVariableName = 'internal';

  /// The name of the top-level variable used to mark a constructor as being
  /// literal.
  static const String _literalVariableName = 'literal';

  /// The name of the top-level variable used to mark a returned element as
  /// requiring use.
  static const String _mustBeConstVariableName = 'mustBeConst';

  /// The name of the top-level variable used to mark a type as having
  /// "optional" type arguments.
  static const String _optionalTypeArgsVariableName = 'optionalTypeArgs';

  /// The name of the top-level variable used to mark a function as running
  /// a single test.
  static const String _isTestVariableName = 'isTest';

  /// The name of the top-level variable used to mark a function as a Flutter
  /// widget factory.
  static const String _widgetFactoryName = 'widgetFactory';

  /// The URI of the Flutter widget inspector library.
  static final Uri _flutterWidgetInspectorLibraryUri = Uri.parse(
    'package:flutter/src/widgets/widget_inspector.dart',
  );

  /// The name of the top-level variable used to mark a function as running
  /// a test group.
  static const String _isTestGroupVariableName = 'isTestGroup';

  /// The name of the class used to JS annotate an element.
  static const String _jsClassName = 'JS';

  /// The name of `_js_annotations` library, used to define JS annotations.
  static const String _jsLibName = '_js_annotations';

  /// The URI of `dart:js_interop` library.
  static const String _jsInteropLibUri = 'dart:js_interop';

  /// The name of `meta` library, used to define analysis annotations.
  static const String _metaLibName = 'meta';

  /// The name of `meta_meta` library, used to define annotations for other
  /// annotations.
  static const String _metaMetaLibName = 'meta_meta';

  /// The name of the top-level variable used to mark a method as requiring
  /// subclasses to override this method.
  static const String _mustBeOverridden = 'mustBeOverridden';

  /// The name of the top-level variable used to mark a method as requiring
  /// overriders to call super.
  static const String _mustCallSuperVariableName = 'mustCallSuper';

  /// The name of `angular.meta` library, used to define angular analysis
  /// annotations.
  static const String _angularMetaLibName = 'angular.meta';

  /// The name of the top-level variable used to mark a member as being nonVirtual.
  static const String _nonVirtualVariableName = 'nonVirtual';

  /// The name of the top-level variable used to mark a method as being expected
  /// to override an inherited method.
  static const String _overrideVariableName = 'override';

  /// The name of the top-level variable used to mark a method as being
  /// protected.
  static const String _protectedVariableName = 'protected';

  /// The name of the top-level variable used to mark a member as redeclaring.
  static const String _redeclareVariableName = 'redeclare';

  /// The name of the top-level variable used to mark a class or mixin as being
  /// reopened.
  static const String _reopenVariableName = 'reopen';

  /// The name of the class used to mark a parameter as being required.
  static const String _requiredClassName = 'Required';

  /// The name of the top-level variable used to mark a parameter as being
  /// required.
  static const String _requiredVariableName = 'required';

  /// The name of the top-level variable used to mark a class as being sealed.
  static const String _sealedVariableName = 'sealed';

  /// The name of the class used to annotate a class as an annotation with a
  /// specific set of target element kinds.
  static const String _targetClassName = 'Target';

  /// The name of the class used to mark a returned element as requiring use.
  static const String _useResultClassName = 'UseResult';

  /// The name of the top-level variable used to mark a returned element as
  /// requiring use.
  static const String _useResultVariableName = 'useResult';

  /// The name of the top-level variable used to mark a member as being visible
  /// for overriding only.
  static const String _visibleForOverridingName = 'visibleForOverriding';

  /// The name of the top-level variable used to mark a method as being
  /// visible for templates.
  static const String _visibleForTemplateVariableName = 'visibleForTemplate';

  /// The name of the top-level variable used to mark a method as being
  /// visible for testing.
  static const String _visibleForTestingVariableName = 'visibleForTesting';

  /// The name of the top-level variable used to mark a method as being
  /// visible outside of template files.
  static const String _visibleOutsideTemplateVariableName =
      'visibleOutsideTemplate';

  @override
  LibraryFragmentImpl libraryFragment;

  /// The AST of the annotation itself, cloned from the resolved AST for the
  /// source code.
  late AnnotationImpl annotationAst;

  /// The result of evaluating this annotation as a compile-time constant
  /// expression, or `null` if the compilation unit containing the variable has
  /// not been resolved.
  Constant? evaluationResult;

  /// Any additional errors, other than [evaluationResult] being an
  /// [InvalidConstant], that came from evaluating the constant expression,
  /// or `null` if the compilation unit containing the variable has
  /// not been resolved.
  ///
  // TODO(kallentu): Remove this field once we fix up g3's dependency on
  // annotations having a valid result as well as unresolved errors.
  List<Diagnostic>? additionalErrors;

  /// Initialize a newly created annotation. The given [libraryFragment] is the
  /// compilation unit in which the annotation appears.
  ElementAnnotationImpl(this.libraryFragment, this.annotationAst) {
    annotationAst.elementAnnotation = this;
  }

  @override
  List<Diagnostic> get constantEvaluationErrors {
    var evaluationResult = this.evaluationResult;
    var additionalErrors = this.additionalErrors;
    if (evaluationResult is InvalidConstant) {
      // When we have an [InvalidConstant], we don't report the additional
      // errors because this result contains the most relevant error.
      return [
        Diagnostic.tmp(
          source: libraryFragment.source,
          offset: evaluationResult.offset,
          length: evaluationResult.length,
          diagnosticCode: evaluationResult.locatableDiagnostic.code,
          arguments: evaluationResult.locatableDiagnostic.arguments,
          contextMessages: evaluationResult.locatableDiagnostic.contextMessages
              .toList(),
        ),
      ];
    }
    return additionalErrors ?? const <Diagnostic>[];
  }

  @override
  String? get deprecationKind {
    if (!isDeprecated) return null;
    return computeConstantValue()
            ?.getField('_kind')
            ?.getField('_name')
            ?.toStringValue() ??
        // For SDKs where the `Deprecated` class does not have a deprecation kind.
        'use';
  }

  /// The constructor that the annotation invokes, or the getter or variable
  /// that it reads, according to the resolution of its expression.
  ///
  /// An annotation that names a class, such as `@C`, or tears off a
  /// constructor, such as `@C.named`, is taken as an invocation with missing
  /// arguments, and denotes the unnamed constructor of the class, or the
  /// torn-off constructor. Constant verification reports the missing
  /// arguments.
  ///
  /// An invalid annotation that instantiates a generic function, such as
  /// `@g<int>`, denotes the function.
  @override
  Element? get element {
    return switch (annotationAst.expression) {
      ConstructorInvocationImpl(:var constructorReference) =>
        constructorReference.element,
      ConstructorTearOffImpl(:var element) => element,
      // TODO(scheglov): `@C` resolves to the class, not to a constructor.
      // Consider returning the class, or `null`, instead of the unnamed
      // constructor, which was kept for compatibility with V1.
      TypeLiteralImpl(type: NamedTypeImpl(:InterfaceElement element)) =>
        element.unnamedConstructor,
      NameExpressionImpl(:var resolution) => resolution?.elementOrRecovery,
      FunctionInstantiationImpl(operand: NameExpressionImpl(:var resolution)) =>
        resolution?.elementOrRecovery,
      _ => null,
    };
  }

  @override
  bool get isAlwaysThrows => _isPackageMetaGetter(_alwaysThrowsVariableName);

  @override
  bool get isAwaitNotRequired =>
      _isPackageMetaGetter(_awaitNotRequiredVariableName);

  @override
  bool get isConstantEvaluated => evaluationResult != null;

  bool get isDartInternalSince {
    var element = this.element;
    if (element is ConstructorElement) {
      return element.enclosingElement.name == 'Since' &&
          element.library.uri.toString() == 'dart:_internal';
    }
    return false;
  }

  @override
  bool get isDeprecated {
    var element = this.element;
    if (element is ConstructorElement) {
      return element.library.isDartCore &&
          element.enclosingElement.name == _deprecatedClassName;
    } else if (element is PropertyAccessorElement) {
      return element.library.isDartCore &&
          element.name == _deprecatedVariableName;
    }
    return false;
  }

  @override
  bool get isDoNotStore => _isPackageMetaGetter(_doNotStoreVariableName);

  @override
  bool get isDoNotSubmit => _isPackageMetaGetter(_doNotSubmitVariableName);

  @override
  bool get isExperimental => _isPackageMetaGetter(_experimentalVariableName);

  @override
  bool get isFactory => _isPackageMetaGetter(_factoryVariableName);

  @override
  bool get isImmutable =>
      _isPackageMetaGetter(_immutableVariableName) ||
      _isPackageMetaConstructor(_immutableClassName);

  @override
  bool get isInternal => _isPackageMetaGetter(_internalVariableName);

  @override
  bool get isIsTest => _isPackageMetaGetter(_isTestVariableName);

  @override
  bool get isIsTestGroup => _isPackageMetaGetter(_isTestGroupVariableName);

  @override
  bool get isJS =>
      _isConstructor(libraryName: _jsLibName, className: _jsClassName) ||
      _isConstructor(libraryUri: _jsInteropLibUri, className: _jsClassName);

  @override
  bool get isLiteral => _isPackageMetaGetter(_literalVariableName);

  @override
  bool get isMustBeConst => _isPackageMetaGetter(_mustBeConstVariableName);

  @override
  bool get isMustBeOverridden => _isPackageMetaGetter(_mustBeOverridden);

  @override
  bool get isMustCallSuper => _isPackageMetaGetter(_mustCallSuperVariableName);

  @override
  bool get isNonVirtual => _isPackageMetaGetter(_nonVirtualVariableName);

  @override
  bool get isOptionalTypeArgs =>
      _isPackageMetaGetter(_optionalTypeArgsVariableName);

  @override
  bool get isOverride => _isDartCoreGetter(_overrideVariableName);

  /// Return `true` if this is an annotation of the form
  /// `@pragma("vm:entry-point")`.
  bool get isPragmaVmEntryPoint {
    if (_isConstructor(libraryName: 'dart.core', className: 'pragma')) {
      var value = computeConstantValue();
      var nameValue = value?.getField('name');
      return nameValue?.toStringValue() == 'vm:entry-point';
    }
    return false;
  }

  @override
  bool get isProtected => _isPackageMetaGetter(_protectedVariableName);

  @override
  bool get isProxy => false;

  @override
  bool get isRedeclare => _isPackageMetaGetter(_redeclareVariableName);

  @override
  bool get isReopen => _isPackageMetaGetter(_reopenVariableName);

  @override
  bool get isRequired =>
      _isConstructor(
        libraryName: _metaLibName,
        className: _requiredClassName,
      ) ||
      _isPackageMetaGetter(_requiredVariableName);

  @override
  bool get isSealed => _isPackageMetaGetter(_sealedVariableName);

  @override
  bool get isTarget => _isConstructor(
    libraryName: _metaMetaLibName,
    className: _targetClassName,
  );

  @override
  bool get isUseResult =>
      _isConstructor(
        libraryName: _metaLibName,
        className: _useResultClassName,
      ) ||
      _isPackageMetaGetter(_useResultVariableName);

  @override
  bool get isVisibleForOverriding =>
      _isPackageMetaGetter(_visibleForOverridingName);

  @override
  bool get isVisibleForTemplate => _isTopGetter(
    libraryName: _angularMetaLibName,
    name: _visibleForTemplateVariableName,
  );

  @override
  bool get isVisibleForTesting =>
      _isPackageMetaGetter(_visibleForTestingVariableName);

  @override
  bool get isVisibleOutsideTemplate => _isTopGetter(
    libraryName: _angularMetaLibName,
    name: _visibleOutsideTemplateVariableName,
  );

  @override
  bool get isWidgetFactory => _isTopGetter(
    libraryUri: _flutterWidgetInspectorLibraryUri,
    name: _widgetFactoryName,
  );

  @override
  DartObject? computeConstantValue() {
    if (evaluationResult == null) {
      var library = libraryFragment.element;
      computeConstants(
        declaredVariables: library.declaredVariables,
        constants: [this],
        featureSet: library.featureSet,
        configuration: ConstantEvaluationConfiguration(),
      );
    }

    if (evaluationResult case DartObjectImpl result) {
      return result;
    }
    return null;
  }

  @override
  bool? isValidAtElement(Element element) {
    return isAnnotationValidAtElement(this, element);
  }

  @override
  String toSource() => annotationAst.toSource();

  @override
  String toString() => '@$element';

  bool _isConstructor({
    String? libraryName,
    String? libraryUri,
    required String className,
  }) {
    assert(
      (libraryName != null) != (libraryUri != null),
      'Exactly one of libraryName/libraryUri should be provided',
    );
    var element = this.element;
    return element is ConstructorElement &&
        element.enclosingElement.name == className &&
        (libraryName == null || element.library.name == libraryName) &&
        (libraryUri == null || element.library.uri.toString() == libraryUri);
  }

  bool _isDartCoreGetter(String name) {
    return _isTopGetter(libraryName: 'dart.core', name: name);
  }

  bool _isPackageMetaConstructor(String className) {
    return _isConstructor(libraryName: _metaLibName, className: className);
  }

  bool _isPackageMetaGetter(String name) {
    return _isTopGetter(libraryName: _metaLibName, name: name);
  }

  bool _isTopGetter({
    String? libraryName,
    Uri? libraryUri,
    required String name,
  }) {
    assert(
      (libraryName != null) != (libraryUri != null),
      'Exactly one of libraryName/libraryUri should be provided',
    );
    var element = this.element;
    return element is GetterElement &&
        element.name == name &&
        (libraryName == null || element.library.name == libraryName) &&
        (libraryUri == null || element.library.uri == libraryUri);
  }
}

sealed class ElementDirectiveImpl implements ElementDirective {
  @override
  late LibraryFragmentImpl libraryFragment;

  @override
  final DirectiveUri uri;

  @override
  MetadataImpl metadata = MetadataImpl(const []);

  ElementDirectiveImpl({required this.uri});

  /// Append a textual representation to the given [builder].
  void appendTo(ElementDisplayStringBuilder builder);

  String displayString() {
    var builder = ElementDisplayStringBuilder(preferTypeAlias: false);
    appendTo(builder);
    return builder.toString();
  }

  @override
  String toString() {
    return displayString();
  }
}

@elementClass
@GenerateElementFlags(flags: _ElementFlags.values)
abstract class ElementImpl implements Element {
  /// Cached values for [sinceSdkVersion].
  ///
  /// Only very few elements have `@Since()` annotations, so instead of adding
  /// an instance field to [ElementImpl], we attach this information this way.
  /// We ask it only when [_ElementStorageFlag.element_hasSinceSdkVersionValue]
  /// is `true`, so
  /// don't pay for a hash lookup when we know that the result is `null`.
  static final Expando<Version> _sinceSdkVersion = Expando<Version>();

  @override
  @trackedIncludedInId
  final int id = FragmentImpl._NEXT_ID++;

  /// The previous fragment with the same name in the library, but of a
  /// different kind. Used for error reporting when an augmentation does not
  /// match the kind of the declaration it augments.
  @trackedIncludedInId
  FragmentImpl? previousFragmentOfDifferentKind;

  /// The flags associated with this element.
  EnumSet<_ElementStorageFlag> _flags = EnumSet.empty();

  @override
  @trackedIncludedInId
  Element get baseElement => this;

  @override
  @trackedIndirectly
  List<ElementImpl> get children => const [];

  @override
  @trackedIndirectly
  String get displayName => name ?? '<unnamed>';

  @override
  @trackedDirectlyOpaque
  String? get documentationComment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueDocumentationComment,
      target: this,
      method: 'documentationComment',
    );
    var buffer = StringBuffer();
    for (var fragment in fragments) {
      var comment = fragment.documentationComment;
      if (comment != null) {
        if (buffer.isNotEmpty) {
          buffer.writeln();
          buffer.writeln();
        }
        buffer.write(comment);
      }
    }
    if (buffer.isEmpty) {
      return null;
    }
    return buffer.toString();
  }

  @override
  FragmentImpl get firstFragment;

  /// The location of [firstFragment], without recording opaque requirement.
  @trackedIncludedInId
  FirstFragmentLocation get firstFragmentLocation {
    return FirstFragmentLocation(
      libraryFragment: _firstFragment.libraryFragment,
      name: _firstFragment.name,
      nameOffset: _firstFragment.nameOffset,
      firstTokenOffset: _firstFragment.firstTokenOffset,
    );
  }

  @generated
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      'hasSinceSdkVersionComputed': hasSinceSdkVersionComputed,
      'hasSinceSdkVersionValue': hasSinceSdkVersionValue,
    };
  }

  @override
  List<FragmentImpl> get fragments;

  @generated
  @trackedInternal
  bool get hasSinceSdkVersionComputed {
    return hasFlag(_ElementStorageFlag.element_hasSinceSdkVersionComputed);
  }

  @generated
  set hasSinceSdkVersionComputed(bool value) {
    setFlag(_ElementStorageFlag.element_hasSinceSdkVersionComputed, value);
  }

  @generated
  @trackedInternal
  bool get hasSinceSdkVersionValue {
    return hasFlag(_ElementStorageFlag.element_hasSinceSdkVersionValue);
  }

  @generated
  set hasSinceSdkVersionValue(bool value) {
    setFlag(_ElementStorageFlag.element_hasSinceSdkVersionValue, value);
  }

  /// Whether this element was created for an `augment` declaration that did
  /// not have a same-kind declaration to augment.
  @trackedIncludedInId
  bool get isAugmentationWithoutAugmentedDeclaration {
    return _firstFragment.isAugmentation &&
        _firstFragment.previousFragment == null;
  }

  @override
  @trackedIndirectly
  bool get isPrivate {
    var name = this.name;
    if (name == null) {
      return true;
    }
    return name.isPrivateName;
  }

  @override
  @trackedIndirectly
  bool get isPublic => !isPrivate;

  @override
  @trackedIncludedInId
  LibraryElementImpl? get library {
    return _firstFragment.libraryFragment?.element;
  }

  @override
  @trackedIndirectly
  String? get lookupName {
    return name;
  }

  @override
  @trackedIncludedInId
  MetadataImpl get metadata => MetadataImpl.empty;

  @override
  @trackedIncludedInId
  Element get nonSynthetic => this;

  /// The reference of this element, used during reading summaries.
  ///
  /// Can be `null` if this element cannot be referenced from outside,
  /// for example a [LocalFunctionElement], a [TypeParameterElement],
  /// a positional [FormalParameterElement], etc.
  @trackedIncludedInId
  Reference? get reference => null;

  @override
  @trackedDirectlyOpaque
  AnalysisSession? get session {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueSession,
      target: this,
      method: 'session',
    );
    return enclosingElement?.session;
  }

  @override
  @trackedIndirectly
  Version? get sinceSdkVersion {
    if (!hasSinceSdkVersionComputed) {
      hasSinceSdkVersionComputed = true;
      var result = SinceSdkVersionComputer().compute(this);
      if (result != null) {
        _sinceSdkVersion[this] = result;
        hasSinceSdkVersionValue = true;
      }
    }
    if (hasSinceSdkVersionValue) {
      return _sinceSdkVersion[this];
    }
    return null;
  }

  /// See [firstFragment].
  ///
  /// This getter is used internally to access data from the first fragment,
  /// without triggering "opaque" requirements.
  FragmentImpl get _firstFragment;

  @override
  @trackedIncludedInId
  bool operator ==(Object other) {
    return identical(this, other);
  }

  /// Append a textual representation of this element to the given [builder].
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeAbstractElement(this);
  }

  @override
  @trackedIndirectly
  String displayString({
    bool multiline = false,
    bool preferTypeAlias = false,
    bool includePositionalParameterNames = false,
  }) {
    var builder = ElementDisplayStringBuilder(
      multiline: multiline,
      preferTypeAlias: preferTypeAlias,
      includePositionalParameterNames: includePositionalParameterNames,
    );
    appendTo(builder);
    return builder.toString();
  }

  @override
  @trackedIndirectly
  String getExtendedDisplayName({String? shortName}) {
    shortName ??= displayName;
    var source = _firstFragment.libraryFragment?.source;
    return "$shortName (${source?.fullName})";
  }

  /// Whether this element has the [flag].
  @trackedIncludedInId
  bool hasFlag(_ElementStorageFlag flag) => _flags[flag];

  @override
  @trackedIncludedInId
  bool isAccessibleIn(LibraryElement library) {
    var name = this.name;
    if (name == null || name.isPrivateName) {
      return library == this.library;
    }
    return true;
  }

  @override
  @trackedIndirectly
  bool isDeprecatedWithKind(String kind) => metadata.annotations
      .where((e) => e.isDeprecated)
      .any((e) => e.deprecationKind == kind);

  @trackedInternal
  void readFlags(BinaryReader reader) {
    _flags = EnumSet.read(reader);
  }

  /// Update [flag] of this element to [value].
  @trackedInternal
  void setFlag(_ElementStorageFlag flag, bool value) {
    _flags = _flags.updated(flag, value);
  }

  @override
  @trackedIncludedInId
  Element? thisOrAncestorMatching(bool Function(Element p1) predicate) {
    Element? element = this;
    while (element != null && !predicate(element)) {
      element = element.enclosingElement;
    }
    return element;
  }

  @override
  @trackedIncludedInId
  E? thisOrAncestorOfType<E extends Element>() {
    Element element = this;
    while (element is! E) {
      var ancestor = element.enclosingElement;
      if (ancestor == null) return null;
      element = ancestor;
    }
    return element;
  }

  @override
  @trackedIndirectly
  String toString() {
    return displayString();
  }

  /// Use the given [visitor] to visit all of the children of this element.
  /// There is no guarantee of the order in which the children will be visited.
  @override
  @trackedDirectlyOpaque
  void visitChildren<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueVisitChildren,
      target: this,
      method: 'visitChildren',
    );
    for (var child in children) {
      child.accept(visitor);
    }
  }

  @trackedInternal
  void writeFlags(BinaryWriter writer) {
    _flags.write(writer);
  }
}

@elementClass
class EnumElementImpl extends InterfaceElementImpl implements EnumElement {
  @override
  @trackedIncludedInId
  final MemberContainerReference reference;

  @override
  final EnumFragmentImpl _firstFragment;

  EnumElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  @override
  @trackedIndirectly
  List<FieldElementImpl> get constants {
    return fields.where((field) => field.isEnumConstant).toList();
  }

  @override
  @trackedDirectlyOpaque
  EnumFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @override
  @trackedDirectlyOpaque
  List<EnumFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind {
    return ElementKind.ENUM;
  }

  @trackedIndirectly
  FieldElementImpl? get valuesField {
    for (var field in fields) {
      if (field.isOriginEnumValues) {
        return field;
      }
    }
    return null;
  }

  List<EnumFragmentImpl> get _fragments {
    return [
      for (
        EnumFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitEnumElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeEnumElement(this);
  }

  @trackedInternal
  void ensureReadMembersForFragments() {
    for (var fragment in _fragments) {
      fragment.ensureReadMembers();
    }
  }

  @trackedInternal
  void linkFragments(List<EnumFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    TypeParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.typeParameters,
    );
  }
}

/// An [InterfaceFragmentImpl] which is an enum.
class EnumFragmentImpl extends InterfaceFragmentImpl implements EnumFragment {
  @override
  late final EnumElementImpl element;

  /// Initialize a newly created class element to have the given [name] at the
  /// given [offset] in the file that contains the declaration of this element.
  EnumFragmentImpl({required super.name});

  @override
  List<FieldElement> get constants {
    var constants = fields.where((field) => field.isEnumConstant).toList();
    return constants.map((e) => e.element).toList();
  }

  @override
  EnumFragmentImpl? get nextFragment => super.nextFragment as EnumFragmentImpl?;

  @override
  EnumFragmentImpl? get previousFragment =>
      super.previousFragment as EnumFragmentImpl?;

  void addFragment(EnumFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

@elementClass
@GenerateElementFlags(flags: _ExecutableElementFlags.values)
abstract class ExecutableElementImpl extends FunctionTypedElementImpl
    with InternalExecutableElement, DeferredResolutionReadingMixin {
  TypeImpl? _returnType;

  FunctionTypeImpl? _type;

  ExecutableElementImpl() {
    // Conservative until finalized during linking.
    hasEnclosingTypeParameterReference = true;
  }

  @override
  @trackedIncludedInId
  ExecutableElementImpl get baseElement => this;

  @override
  @trackedIndirectly
  List<ElementImpl> get children => [
    ...super.children,
    ...typeParameters,
    ...formalParameters,
  ];

  @override
  ExecutableFragmentImpl get firstFragment;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasEnclosingTypeParameterReference': hasEnclosingTypeParameterReference,
      'hasImplicitReturnType': hasImplicitReturnType,
      'invokesSuperSelf': invokesSuperSelf,
      'isExtensionTypeMember': isExtensionTypeMember,
      'isExternal': isExternal,
      'isStatic': isStatic,
    };
  }

  @override
  @trackedIncludedInId
  List<FormalParameterElementImpl> get formalParameters {
    var formalParameters = _firstFragment.formalParameters;

    var hasRecoveryFragments = false;
    for (var i = 0; i < formalParameters.length; i++) {
      if (formalParameters[i].isOriginOtherFragmentOfEnclosing) {
        hasRecoveryFragments = true;
        break;
      }
    }

    // Don't expose recovery elements as the actual executable signature.
    if (hasRecoveryFragments) {
      var result = <FormalParameterElementImpl>[];
      for (var formalParameter in formalParameters) {
        if (!formalParameter.isOriginOtherFragmentOfEnclosing) {
          result.add(formalParameter.element);
        }
      }
      return result.toFixedList();
    }

    return List.generate(formalParameters.length, (index) {
      return formalParameters[index].element;
    }, growable: false);
  }

  @trackedInternal
  List<FormalParameterElementImpl> get formalParametersIncludingRecovery {
    var fragments = _firstFragment._formalParameters;
    return List.generate(fragments.length, (index) {
      return fragments[index].element;
    }, growable: false);
  }

  @override
  List<ExecutableFragmentImpl> get fragments;

  @generated
  @trackedIncludedInId
  bool get hasEnclosingTypeParameterReference {
    return hasFlag(
      _ElementStorageFlag.executableElement_hasEnclosingTypeParameterReference,
    );
  }

  @generated
  set hasEnclosingTypeParameterReference(bool value) {
    setFlag(
      _ElementStorageFlag.executableElement_hasEnclosingTypeParameterReference,
      value,
    );
  }

  @override
  @trackedIncludedInId
  bool get hasImplicitReturnType => _firstFragment.hasImplicitReturnType;

  @generated
  @trackedIncludedInId
  bool get invokesSuperSelf {
    return _firstFragment.invokesSuperSelf;
  }

  @override
  @trackedIncludedInId
  bool get isAbstract {
    for (var fragment in _fragments) {
      if (!fragment.isAbstract) {
        return false;
      }
    }
    return true;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isExtensionTypeMember {
    return hasFlag(_ElementStorageFlag.executableElement_isExtensionTypeMember);
  }

  @generated
  set isExtensionTypeMember(bool value) {
    setFlag(_ElementStorageFlag.executableElement_isExtensionTypeMember, value);
  }

  @override
  @trackedIncludedInId
  bool get isExternal {
    return _fragments.any((fragment) => fragment.isExternal);
  }

  @override
  @trackedIncludedInId
  bool get isSimplyBounded => true;

  @generated
  @override
  @trackedIncludedInId
  bool get isStatic {
    return _firstFragment.isStatic;
  }

  @trackedDirectlyOpaque
  ExecutableFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );
    var result = _firstFragment;
    while (true) {
      if (result.nextFragment case ExecutableFragmentImpl nextFragment) {
        result = nextFragment;
      } else {
        return result;
      }
    }
  }

  @override
  @trackedIncludedInId
  MetadataImpl get metadata {
    return _firstFragment.elementMetadata;
  }

  @override
  @trackedIncludedInId
  TypeImpl get returnType {
    _ensureReadResolution();

    // If an accessor for a variable, we might need to infer the type.
    if (_returnType == null) {
      if (this case PropertyAccessorElementImpl self) {
        if (self.isOriginVariable) {
          self.variable.type;
        }
      }
    }

    return _returnType!;
  }

  set returnType(TypeImpl value) {
    _returnType = value;
    // We do this because of return type inference. At the moment when we
    // create a local function element we don't know yet its return type,
    // because we have not done static type analysis yet.
    // It somewhere it between we access the type of this element, so it gets
    // cached in the element. When we are done static type analysis, we then
    // should clear this cached type to make it right.
    // TODO(scheglov): Remove when type analysis is done in the single pass.
    _type = null;
  }

  @override
  @trackedIncludedInId
  FunctionTypeImpl get type {
    return _type ??= FunctionTypeImpl(
      typeParameters: typeParameters,
      formalParameters: formalParameters,
      returnType: returnType,
      nullabilitySuffix: NullabilitySuffix.none,
    );
  }

  @override
  @trackedIncludedInId
  List<TypeParameterElementImpl> get typeParameters {
    _ensureReadResolution();

    var typeParameters = _firstFragment.typeParameters;

    var hasRecoveryFragments = false;
    for (var i = 0; i < typeParameters.length; i++) {
      if (typeParameters[i].isOriginOtherFragmentOfEnclosing) {
        hasRecoveryFragments = true;
        break;
      }
    }

    // Don't expose recovery elements as the actual element arity.
    if (hasRecoveryFragments) {
      var result = <TypeParameterElementImpl>[];
      for (var typeParameter in typeParameters) {
        if (!typeParameter.isOriginOtherFragmentOfEnclosing) {
          result.add(typeParameter.element);
        }
      }
      return result.toFixedList();
    }

    return List.generate(
      typeParameters.length,
      (index) => typeParameters[index].element,
      growable: false,
    );
  }

  @override
  ExecutableFragmentImpl get _firstFragment;

  List<ExecutableFragmentImpl> get _fragments;

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeExecutableElement(this, name!);
  }

  @override
  @trackedIndirectly
  InternalExecutableElement substitute(MapSubstitution substitution) {
    throw StateError('substitute not supported for $runtimeType');
  }
}

@GenerateElementFlags(flags: _ExecutableElementFlags.values)
abstract class ExecutableFragmentImpl extends FunctionTypedFragmentImpl
    with DeferredResolutionReadingMixin
    implements ExecutableFragment {
  List<TypeParameterFragmentImpl> _typeParameters = const [];

  /// A list containing all of the parameters defined by this executable
  /// element.
  List<FormalParameterFragmentImpl> _formalParameters = const [];

  /// Initialize a newly created executable element to have the given [name] and
  /// [offset].
  ExecutableFragmentImpl({super.firstTokenOffset});

  @override
  List<FragmentImpl> get children => [...typeParameters, ...formalParameters];

  @override
  ExecutableElementImpl get element;

  @override
  FragmentImpl get enclosingFragment {
    return super.enclosingFragment!;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasImplicitReturnType': hasImplicitReturnType,
      'invokesSuperSelf': invokesSuperSelf,
      'isAbstract': isAbstract,
      'isAsynchronous': isAsynchronous,
      'isExternal': isExternal,
      'isGenerator': isGenerator,
      'isStatic': isStatic,
    };
  }

  @override
  List<ExecutableFragmentImpl> get followingFragments {
    return [
      for (
        var current = nextFragment;
        current != null;
        current = current.nextFragment
      )
        current,
    ];
  }

  @override
  List<FormalParameterFragmentImpl> get formalParameters {
    _ensureReadResolution();
    return _formalParameters;
  }

  set formalParameters(List<FormalParameterFragmentImpl> formalParameters) {
    for (var formalParameter in formalParameters) {
      formalParameter.enclosingFragment = this;
    }
    _formalParameters = formalParameters;
  }

  @generated
  bool get hasImplicitReturnType {
    return hasFlag(
      _FragmentStorageFlag.executableFragment_hasImplicitReturnType,
    );
  }

  @generated
  set hasImplicitReturnType(bool value) {
    setFlag(
      _FragmentStorageFlag.executableFragment_hasImplicitReturnType,
      value,
    );
  }

  @generated
  bool get invokesSuperSelf {
    return hasFlag(_FragmentStorageFlag.executableFragment_invokesSuperSelf);
  }

  @generated
  set invokesSuperSelf(bool value) {
    setFlag(_FragmentStorageFlag.executableFragment_invokesSuperSelf, value);
  }

  /// Whether the executable element is abstract.
  ///
  /// Executable elements are abstract if they are not external, and have no
  /// body.
  @generated
  bool get isAbstract {
    return hasFlag(_FragmentStorageFlag.executableFragment_isAbstract);
  }

  @generated
  set isAbstract(bool value) {
    setFlag(_FragmentStorageFlag.executableFragment_isAbstract, value);
  }

  @generated
  @override
  bool get isAsynchronous {
    return hasFlag(_FragmentStorageFlag.executableFragment_isAsynchronous);
  }

  @generated
  set isAsynchronous(bool value) {
    setFlag(_FragmentStorageFlag.executableFragment_isAsynchronous, value);
  }

  /// Executable elements are external if they are explicitly marked as such
  /// using the 'external' keyword.
  @generated
  bool get isExternal {
    return hasFlag(_FragmentStorageFlag.executableFragment_isExternal);
  }

  @generated
  set isExternal(bool value) {
    setFlag(_FragmentStorageFlag.executableFragment_isExternal, value);
  }

  @generated
  @override
  bool get isGenerator {
    return hasFlag(_FragmentStorageFlag.executableFragment_isGenerator);
  }

  @generated
  set isGenerator(bool value) {
    setFlag(_FragmentStorageFlag.executableFragment_isGenerator, value);
  }

  /// Whether the executable element is an operator.
  ///
  /// The test may be based on the name of the executable element, in which
  /// case the result will be correct when the name is legal.
  bool get isOperator => false;

  @generated
  bool get isStatic {
    return hasFlag(_FragmentStorageFlag.executableFragment_isStatic);
  }

  @generated
  set isStatic(bool value) {
    setFlag(_FragmentStorageFlag.executableFragment_isStatic, value);
  }

  @override
  bool get isSynchronous => !isAsynchronous;

  @override
  LibraryFragmentImpl get libraryFragment => enclosingUnit;

  @override
  MetadataImpl get metadata {
    _ensureReadResolution();
    return super.metadata;
  }

  @override
  ExecutableFragmentImpl? get nextFragment;

  @override
  int get offset => nameOffset ?? firstTokenOffset!;

  @override
  List<ExecutableFragmentImpl> get precedingFragments {
    return [
      for (
        var current = previousFragment;
        current != null;
        current = current.previousFragment
      )
        current,
    ];
  }

  @override
  ExecutableFragmentImpl? get previousFragment;

  @override
  List<TypeParameterFragmentImpl> get typeParameters {
    _ensureReadResolution();
    return _typeParameters;
  }

  set typeParameters(List<TypeParameterFragmentImpl> typeParameters) {
    for (var typeParameter in typeParameters) {
      typeParameter.enclosingFragment = this;
    }
    _typeParameters = typeParameters;
  }
}

@elementClass
class ExtensionElementImpl extends InstanceElementImpl
    implements ExtensionElement {
  @override
  @trackedIncludedInId
  final MemberContainerReference reference;

  @override
  final ExtensionFragmentImpl _firstFragment;

  TypeImpl _extendedType = InvalidTypeImpl.instance;

  ExtensionElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  @override
  @trackedIncludedInId
  TypeImpl get extendedType {
    _ensureReadResolution();
    return _extendedType;
  }

  set extendedType(TypeImpl value) {
    _extendedType = value;
  }

  @override
  @trackedDirectlyOpaque
  ExtensionFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @override
  @trackedDirectlyOpaque
  List<ExtensionFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.EXTENSION;

  /// Computes the on-declaration of the extension.
  ///
  /// The on-declaration is computed a described in
  /// https://github.com/dart-lang/language/blob/main/working/0723-static-extensions/feature-specification.md#syntax
  /// In case the extension declaration doesn't have an on-declaration, `null`
  /// is returned.
  @trackedIndirectly
  InterfaceElementImpl? get onDeclaration {
    if (extendedType.nullabilitySuffix != NullabilitySuffix.question) {
      switch (extendedType.element) {
        // In an extension declaration of the form extension E on C {...} where C
        // is an identifier (or an identifier with an import prefix) that denotes
        // a class, mixin, enum, or extension type declaration, we say that the
        // on-declaration of the extension is C.

        // If C denotes a generic class then E is treated as extension E on C<T1
        // ..  Tk> {...} where T1 .. Tk are obtained by instantiation to bound.

        // In an extension of the form extension E on C<T1 .. Tk> {...} where C is
        // an identifier or prefixed identifier that denotes a class, mixin, enum,
        // or extension type declaration, we say that the on-declaration of E is
        // C.

        // In an extension of the form extension E on F<T1 .. Tk> {...} where F is
        // a type alias whose transitive alias expansion denotes a class, mixin,
        // enum, or extension type C, we say that the on-declaration of E is C,
        // and the declaration is treated as if F<T1 .. Tk> were replaced by its
        // transitive alias expansion.

        // Implementation note: type aliases in [extendedType] are already
        // unaliased at this point, so there's no need to consider them
        // separately.

        // For the purpose of identifying the on-declaration of a given extension,
        // the types void, dynamic, and Never are not considered to be classes,
        // and neither are record types or function types.

        // Also note that none of the following types are classes:
        //   * A type of the form T? or FutureOr<T>, for any type T.
        //   * A type variable.
        //   * An intersection type.
        case ClassElementImpl() when !extendedType.isDartAsyncFutureOr:
        case MixinElementImpl():
        case EnumElementImpl():
        case ExtensionTypeElementImpl():
          return extendedType.element as InterfaceElementImpl;
        default:
          // In all other cases, an extension declaration does not have an
          // on-declaration.
          return null;
      }
    } else {
      // Also note that none of the following types are classes:
      //   * A type of the form T? or FutureOr<T>, for any type T.
      //   * A type variable.
      //   * An intersection type.
      return null;
    }
  }

  @override
  @trackedIndirectly
  TypeImpl get thisType => extendedType;

  List<ExtensionFragmentImpl> get _fragments {
    return [
      for (
        ExtensionFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitExtensionElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeExtensionElement(this);
  }

  @trackedInternal
  void ensureReadMembersForFragments() {
    for (var fragment in _fragments) {
      fragment.ensureReadMembers();
    }
  }

  @trackedInternal
  void linkFragments(List<ExtensionFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    TypeParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.typeParameters,
    );
  }
}

class ExtensionFragmentImpl extends InstanceFragmentImpl
    implements ExtensionFragment {
  @override
  late final ExtensionElementImpl element;

  /// Initialize a newly created extension element to have the given [name] at
  /// the given [nameOffset] in the file that contains the declaration of this
  /// element.
  ExtensionFragmentImpl({required super.name});

  @override
  List<FragmentImpl> get children => [
    ...fields,
    ...getters,
    ...methods,
    ...setters,
    ...typeParameters,
  ];

  @override
  String get displayName => name ?? '';

  TypeImpl get extendedType {
    return element.extendedType;
  }

  @override
  bool get isPrivate {
    var name = this.name;
    return name == null || name.isPrivateName;
  }

  @override
  MetadataImpl get metadata {
    _ensureReadResolution();
    return super.metadata;
  }

  @override
  ExtensionFragmentImpl? get nextFragment =>
      super.nextFragment as ExtensionFragmentImpl?;

  @override
  ExtensionFragmentImpl? get previousFragment =>
      super.previousFragment as ExtensionFragmentImpl?;

  void addFragment(ExtensionFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

@elementClass
class ExtensionTypeElementImpl extends InterfaceElementImpl
    implements ExtensionTypeElement {
  @override
  @trackedIncludedInId
  final MemberContainerReference reference;

  @override
  final ExtensionTypeFragmentImpl _firstFragment;

  /// Whether the element has direct or indirect reference to itself,
  /// in representation.
  @trackedIncludedInId
  bool hasRepresentationSelfReference = false;

  /// Whether the element has direct or indirect reference to itself,
  /// in implemented superinterfaces.
  @trackedIncludedInId
  bool hasImplementsSelfReference = false;

  late TypeImpl _typeErasure;

  ExtensionTypeElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  @override
  @trackedDirectlyOpaque
  ExtensionTypeFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @override
  @trackedDirectlyOpaque
  List<ExtensionTypeFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.EXTENSION_TYPE;

  @override
  @trackedIndirectly
  ConstructorElementImpl get primaryConstructor {
    return constructors.first;
  }

  @override
  @trackedIndirectly
  FieldElementImpl get representation {
    return fields.first;
  }

  @override
  @trackedIncludedInId
  TypeImpl get typeErasure {
    _ensureReadResolution();
    return _typeErasure;
  }

  set typeErasure(TypeImpl value) {
    _typeErasure = value;
  }

  List<ExtensionTypeFragmentImpl> get _fragments {
    return [
      for (
        ExtensionTypeFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitExtensionTypeElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeExtensionTypeElement(this);
  }

  @trackedInternal
  void ensureReadMembersForFragments() {
    for (var fragment in _fragments) {
      fragment.ensureReadMembers();
    }
  }

  @trackedInternal
  void linkFragments(List<ExtensionTypeFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    TypeParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.typeParameters,
    );
  }
}

class ExtensionTypeFragmentImpl extends InterfaceFragmentImpl
    implements ExtensionTypeFragment {
  @override
  late final ExtensionTypeElementImpl element;

  ExtensionTypeFragmentImpl({required super.name});

  @override
  ExtensionTypeFragmentImpl? get nextFragment =>
      super.nextFragment as ExtensionTypeFragmentImpl?;

  @override
  ExtensionTypeFragmentImpl? get previousFragment =>
      super.previousFragment as ExtensionTypeFragmentImpl?;

  void addFragment(ExtensionTypeFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

@elementClass
@GenerateElementFlags(flags: _FieldElementFlags.values)
class FieldElementImpl extends PropertyInducingElementImpl
    with InternalFieldElement {
  @override
  @trackedIncludedInId
  final MemberReference reference;

  @override
  final FieldFragmentImpl _firstFragment;

  FieldElementImpl({
    required this.reference,
    required FieldFragmentImpl firstFragment,
  }) : _firstFragment = firstFragment {
    reference.element = this;
    _firstFragment.element = this;
    // Conservative until finalized during linking.
    hasEnclosingTypeParameterReference = true;
  }

  @override
  @trackedIncludedInId
  FieldElementImpl get baseElement => this;

  @override
  @trackedIndirectly
  FieldFormalParameterElementImpl? get declaringFormalParameter {
    if (enclosingElement case InterfaceElementImpl enclosingElement) {
      var declaringConstructor = enclosingElement.constructors.firstWhereOrNull(
        (constructor) => constructor.isPrimary,
      );
      return declaringConstructor?.formalParametersIncludingRecovery
          .whereType<FieldFormalParameterElementImpl>()
          .firstWhereOrNull((f) {
            return f.isDeclaring && f.field == this;
          });
    }
    return null;
  }

  @override
  @trackedDirectlyOpaque
  String? get documentationComment {
    if (isOriginDeclaringFormalParameter) {
      if (declaringFormalParameter case var declaringFormalParameter?) {
        return declaringFormalParameter.documentationComment;
      }
    }

    return super.documentationComment;
  }

  @override
  @trackedIncludedInId
  InstanceElementImpl get enclosingElement {
    return _firstFragment.enclosingFragment.element;
  }

  @override
  @trackedDirectlyOpaque
  FieldFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasEnclosingTypeParameterReference': hasEnclosingTypeParameterReference,
      'isCovariant': isCovariant,
      'isEnumConstant': isEnumConstant,
      'isOriginDeclaringFormalParameter': isOriginDeclaringFormalParameter,
      'isOriginEnumValues': isOriginEnumValues,
      'isOriginExtensionTypeRecoveryRepresentation':
          isOriginExtensionTypeRecoveryRepresentation,
      'isPromotable': isPromotable,
    };
  }

  @override
  @trackedDirectlyOpaque
  List<FieldFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedDirectly
  GetterElementImpl? get getter {
    globalResultRequirements?.record_fieldElement_getter(
      element: this,
      name: name,
    );

    return super.getter;
  }

  @generated
  @trackedIncludedInId
  bool get hasEnclosingTypeParameterReference {
    return hasFlag(
      _ElementStorageFlag.fieldElement_hasEnclosingTypeParameterReference,
    );
  }

  @generated
  set hasEnclosingTypeParameterReference(bool value) {
    setFlag(
      _ElementStorageFlag.fieldElement_hasEnclosingTypeParameterReference,
      value,
    );
  }

  @override
  @trackedIncludedInId
  bool get isCovariant => _firstFragment.isExplicitlyCovariant;

  @generated
  @override
  @trackedIncludedInId
  bool get isEnumConstant {
    return _firstFragment.isEnumConstant;
  }

  @trackedIndirectly
  bool get isEnumValues {
    return enclosingElement is EnumElementImpl && name == 'values';
  }

  @trackedIndirectly
  bool get isInstanceField => !isStatic;

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginDeclaringFormalParameter {
    return _firstFragment.isOriginDeclaringFormalParameter;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginEnumValues {
    return _firstFragment.isOriginEnumValues;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginExtensionTypeRecoveryRepresentation {
    return _firstFragment.isOriginExtensionTypeRecoveryRepresentation;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isPromotable {
    return _firstFragment.isPromotable;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.FIELD;

  @trackedDirectlyOpaque
  FieldFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );

    var result = _firstFragment;
    while (true) {
      if (result.nextFragment case var nextFragment?) {
        result = nextFragment;
      } else {
        return result;
      }
    }
  }

  @override
  @trackedIncludedInId
  MetadataImpl get metadata {
    if (isOriginDeclaringFormalParameter) {
      if (declaringFormalParameter case var declaringFormalParameter?) {
        return declaringFormalParameter.metadata;
      }
    }

    return _firstFragment.elementMetadata;
  }

  @override
  @trackedIncludedInId
  String? get name => _firstFragment.name;

  @override
  @trackedIndirectly
  Element get nonSynthetic {
    if (isOriginDeclaringFormalParameter) {
      return declaringFormalParameter!;
    }
    return super.nonSynthetic;
  }

  @override
  @trackedDirectly
  SetterElementImpl? get setter {
    globalResultRequirements?.record_fieldElement_setter(
      element: this,
      name: name,
    );

    return super.setter;
  }

  @override
  List<FieldFragmentImpl> get _fragments {
    return [
      for (
        FieldFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitFieldElement(this);
  }

  @trackedInternal
  void linkFragments(List<FieldFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
  }

  @override
  @trackedIndirectly
  InternalFieldElement substitute(MapSubstitution substitution) {
    if (substitution.map.isEmpty) {
      return this;
    }
    if (!hasEnclosingTypeParameterReference) {
      return this;
    }
    return SubstitutedFieldElementImpl(
      baseElement: this,
      substitution: substitution,
    );
  }
}

@GenerateElementFlags(flags: _FieldFormalParameterElementFlags.values)
class FieldFormalParameterElementImpl extends FormalParameterElementImpl
    with InternalFieldFormalParameterElement {
  FieldElementImpl? _field;

  FieldFormalParameterElementImpl(super.firstFragment);

  @override
  FieldFormalParameterElementImpl get baseElement => this;

  @override
  FieldElementImpl? get field {
    _ensureEnclosingExecutableReadResolution();
    return _field;
  }

  set field(FieldElementImpl? value) {
    _field = value;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {...super.flagsForTesting, 'isDeclaring': isDeclaring};
  }

  @override
  bool get isDeclaring {
    return _fieldFormalParameterFragment.isDeclaring;
  }

  @override
  bool get isFinal => true;

  @override
  String? get privateName => _fieldFormalParameterFragment.privateName;

  FieldFormalParameterFragmentImpl get _fieldFormalParameterFragment {
    return fragments.whereType<FieldFormalParameterFragmentImpl>().first;
  }

  @override
  InternalFieldFormalParameterElement substitute(MapSubstitution substitution) {
    if (substitution.map.isEmpty) {
      return this;
    }
    return SubstitutedFieldFormalParameterElementImpl(
      baseElement: this,
      substitution: substitution,
    );
  }
}

@GenerateElementFlags(flags: _FieldFormalParameterElementFlags.values)
class FieldFormalParameterFragmentImpl extends FormalParameterFragmentImpl
    implements FieldFormalParameterFragment {
  @override
  final String? privateName;

  /// Initialize a newly created parameter element to have the given [name] and
  /// [nameOffset].
  FieldFormalParameterFragmentImpl({
    super.firstTokenOffset,
    required super.name,
    required super.nameOffset,
    required super.parameterKind,
    required this.privateName,
  });

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {...super.flagsForTesting, 'isDeclaring': isDeclaring};
  }

  @generated
  bool get isDeclaring {
    return hasFlag(
      _FragmentStorageFlag.fieldFormalParameterFragment_isDeclaring,
    );
  }

  @generated
  set isDeclaring(bool value) {
    setFlag(
      _FragmentStorageFlag.fieldFormalParameterFragment_isDeclaring,
      value,
    );
  }

  /// Initializing formals are visible only in the "formal parameter
  /// initializer scope", which is the current scope of the initializer list
  /// of the constructor, and which is enclosed in the scope where the
  /// constructor is declared. And according to the specification, they
  /// introduce final local variables, always, regardless whether the field
  /// is final.
  @override
  bool get isFinal => true;
}

@GenerateElementFlags(flags: _FieldElementFlags.values)
class FieldFragmentImpl extends PropertyInducingFragmentImpl
    implements FieldFragment {
  /// True if this field inherits from a covariant parameter. This happens
  /// when it overrides a field in a supertype that is covariant.
  bool inheritsCovariant = false;

  @override
  late final FieldElementImpl element;

  /// Initialize a newly created synthetic field element to have the given
  /// [name] at the given [offset].
  FieldFragmentImpl({required super.name});

  @override
  ExpressionImpl? get constantInitializer2 {
    _ensureReadResolution();
    return super.constantInitializer2;
  }

  @override
  InstanceFragmentImpl get enclosingFragment {
    return super.enclosingFragment as InstanceFragmentImpl;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isEnumConstant': isEnumConstant,
      'isExplicitlyCovariant': isExplicitlyCovariant,
      'isOriginDeclaringFormalParameter': isOriginDeclaringFormalParameter,
      'isOriginEnumValues': isOriginEnumValues,
      'isOriginExtensionTypeRecoveryRepresentation':
          isOriginExtensionTypeRecoveryRepresentation,
      'isPromotable': isPromotable,
    };
  }

  @generated
  bool get isEnumConstant {
    return hasFlag(_FragmentStorageFlag.fieldFragment_isEnumConstant);
  }

  @generated
  set isEnumConstant(bool value) {
    setFlag(_FragmentStorageFlag.fieldFragment_isEnumConstant, value);
  }

  /// Whether the field was explicitly marked as being covariant.
  @generated
  bool get isExplicitlyCovariant {
    return hasFlag(_FragmentStorageFlag.fieldFragment_isExplicitlyCovariant);
  }

  @generated
  set isExplicitlyCovariant(bool value) {
    setFlag(_FragmentStorageFlag.fieldFragment_isExplicitlyCovariant, value);
  }

  @generated
  bool get isOriginDeclaringFormalParameter {
    return hasFlag(
      _FragmentStorageFlag.fieldFragment_isOriginDeclaringFormalParameter,
    );
  }

  @generated
  set isOriginDeclaringFormalParameter(bool value) {
    setFlag(
      _FragmentStorageFlag.fieldFragment_isOriginDeclaringFormalParameter,
      value,
    );
  }

  @generated
  bool get isOriginEnumValues {
    return hasFlag(_FragmentStorageFlag.fieldFragment_isOriginEnumValues);
  }

  @generated
  set isOriginEnumValues(bool value) {
    setFlag(_FragmentStorageFlag.fieldFragment_isOriginEnumValues, value);
  }

  @generated
  bool get isOriginExtensionTypeRecoveryRepresentation {
    return hasFlag(
      _FragmentStorageFlag
          .fieldFragment_isOriginExtensionTypeRecoveryRepresentation,
    );
  }

  @generated
  set isOriginExtensionTypeRecoveryRepresentation(bool value) {
    setFlag(
      _FragmentStorageFlag
          .fieldFragment_isOriginExtensionTypeRecoveryRepresentation,
      value,
    );
  }

  @generated
  bool get isPromotable {
    return hasFlag(_FragmentStorageFlag.fieldFragment_isPromotable);
  }

  @generated
  set isPromotable(bool value) {
    setFlag(_FragmentStorageFlag.fieldFragment_isPromotable, value);
  }

  @override
  MetadataImpl get metadata {
    _ensureReadResolution();
    return super.metadata;
  }

  @override
  FieldFragmentImpl? get nextFragment =>
      super.nextFragment as FieldFragmentImpl?;

  @override
  int get offset => nameOffset ?? firstTokenOffset ?? enclosingFragment.offset;

  @override
  FieldFragmentImpl? get previousFragment =>
      super.previousFragment as FieldFragmentImpl?;

  void addFragment(FieldFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

/// Location information extracted from [Element.firstFragment].
class FirstFragmentLocation {
  final LibraryFragmentImpl? libraryFragment;
  final String? name;
  final int? nameOffset;
  final int? firstTokenOffset;

  FirstFragmentLocation({
    required this.libraryFragment,
    required this.name,
    required this.nameOffset,
    required this.firstTokenOffset,
  });
}

enum FormalParameterDeclarationForm { regular, fieldFormal, superFormal }

@GenerateElementFlags(flags: _FormalParameterElementFlags.values)
class FormalParameterElementImpl extends PromotableElementImpl
    with InternalFormalParameterElement {
  @override
  final FormalParameterFragmentImpl _firstFragment;

  TypeImpl _type = InvalidTypeImpl.instance;

  final FormalParameterElementImpl? _baseFormalParameter;

  FormalParameterElementImpl(
    this._firstFragment, {
    FormalParameterElementImpl? baseFormalParameter,
  }) : _baseFormalParameter = baseFormalParameter {
    isCovariant = _firstFragment.isExplicitlyCovariant;
    for (var fragment in _fragments) {
      fragment._element = this;
    }
  }

  /// Creates a synthetic parameter with [name], [type] and [parameterKind].
  factory FormalParameterElementImpl.synthetic(
    String? name,
    TypeImpl type,
    ParameterKind parameterKind, {
    FormalParameterElementImpl? baseFormalParameter,
  }) {
    var fragment = FormalParameterFragmentImpl.synthetic(name, parameterKind);
    return FormalParameterElementImpl(
      fragment,
      baseFormalParameter: baseFormalParameter,
    )..type = type;
  }

  @override
  FormalParameterElementImpl get baseElement => _baseFormalParameter ?? this;

  @override
  // TODO(augmentations): Implement the merge of formal parameters.
  String? get defaultValueCode {
    return constantInitializer2?.toSource();
  }

  @override
  Element? get enclosingElement {
    return _firstFragment.enclosingFragment?.element;
  }

  @override
  FormalParameterFragmentImpl get firstFragment => _firstFragment;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasDefaultValue': hasDefaultValue,
      'isCovariant': isCovariant,
    };
  }

  @override
  List<FormalParameterFragmentImpl> get fragments {
    return _fragments;
  }

  @override
  // TODO(augmentations): Implement the merge of formal parameters.
  bool get hasDefaultValue => defaultValueCode != null;

  @generated
  @override
  bool get isCovariant {
    return hasFlag(_ElementStorageFlag.formalParameterElement_isCovariant);
  }

  @generated
  set isCovariant(bool value) {
    setFlag(_ElementStorageFlag.formalParameterElement_isCovariant, value);
  }

  @override
  bool get isNamed => _firstFragment.isNamed;

  @override
  bool get isOptional => _firstFragment.isOptional;

  @override
  bool get isOptionalNamed => _firstFragment.isOptionalNamed;

  @override
  bool get isOptionalPositional => _firstFragment.isOptionalPositional;

  @override
  bool get isPositional => _firstFragment.isPositional;

  @override
  bool get isRequired => _firstFragment.isRequired;

  @override
  bool get isRequiredNamed => _firstFragment.isRequiredNamed;

  @override
  bool get isRequiredPositional => _firstFragment.isRequiredPositional;

  @override
  ElementKind get kind => ElementKind.PARAMETER;

  @override
  MetadataImpl get metadata {
    return _firstFragment.elementMetadata;
  }

  @override
  String? get name {
    var fragment = _firstWhereInlined((fragment) {
      var name = fragment.name;
      return name != null && name != '_';
    });
    return (fragment ?? _firstFragment).name;
  }

  @override
  String get nameShared => _firstFragment.name ?? '';

  @override
  ParameterKind get parameterKind {
    return _firstFragment.parameterKind;
  }

  @override
  TypeImpl get type {
    _ensureEnclosingExecutableReadResolution();
    return _type;
  }

  @override
  set type(TypeImpl value) {
    _type = value;
  }

  @Deprecated('Use the function type of this parameter instead')
  @override
  TypeImpl get typeShared => type;

  @override
  List<FormalParameterFragmentImpl> get _fragments {
    return [
      for (
        FormalParameterFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return visitor.visitFormalParameterElement(this);
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeFormalParameterElement(this);
  }

  @override
  InternalFormalParameterElement substitute(MapSubstitution substitution) {
    if (substitution.map.isEmpty) {
      return this;
    }
    return SubstitutedFormalParameterElementImpl(
      baseElement: this,
      substitution: substitution,
    );
  }

  @override
  void visitChildren<T>(ElementVisitor2<T> visitor) {
    for (var child in children) {
      child.accept(visitor);
    }
  }

  void _ensureEnclosingExecutableReadResolution() {
    var enclosingElement = this.enclosingElement;
    if (enclosingElement is ExecutableElementImpl) {
      enclosingElement._ensureReadResolution();
    }
  }

  /// The first element in [fragments] that satisfies the given predicate [test]
  /// or `null` if there is no such element.
  ///
  /// Used for avoiding allocating a list via [fragments] when all that is
  /// needed is to find a fragment satisfying some test.
  /// Marked for inlining which should avoid allocating closures and contexts.
  @pragma("vm:prefer-inline")
  FormalParameterFragmentImpl? _firstWhereInlined(
    bool Function(FormalParameterFragmentImpl element) test,
  ) {
    FormalParameterFragmentImpl? fragment = _firstFragment;
    while (fragment != null) {
      if (test(fragment)) return fragment;
      fragment = fragment.nextFragment;
    }
    return null;
  }
}

@GenerateElementFlags(flags: _FormalParameterElementFlags.values)
class FormalParameterFragmentImpl extends VariableFragmentImpl
    implements FormalParameterFragment {
  @override
  final String? name;

  @override
  int? nameOffset;

  /// The kind of a parameter. A parameter can be either positional or named, and
  /// can be either required or optional.
  ///
  /// Prefer using `isXyz` instead, e.g. [isRequiredNamed].
  final ParameterKind parameterKind;

  /// The element corresponding to this fragment.
  late final FormalParameterElementImpl _element;

  @override
  FormalParameterFragmentImpl? nextFragment;

  @override
  FormalParameterFragmentImpl? previousFragment;

  /// Initialize a newly created parameter element to have the given [name] and
  /// [nameOffset].
  FormalParameterFragmentImpl({
    super.firstTokenOffset,
    required this.name,
    required this.nameOffset,
    required this.parameterKind,
  }) : assert(nameOffset == null || nameOffset >= 0),
       assert(name == null || name.isNotEmpty);

  /// Creates a synthetic parameter with [name2] and [parameterKind].
  factory FormalParameterFragmentImpl.synthetic(
    String? name2,
    ParameterKind parameterKind,
  ) {
    // TODO(dantup): This does not keep any reference to the non-synthetic
    //  parameter which prevents navigation/references from working. See
    //  https://github.com/dart-lang/sdk/issues/60200
    var fragment = FormalParameterFragmentImpl(
      name: name2,
      nameOffset: null,
      parameterKind: parameterKind,
    );
    return fragment;
  }

  @override
  List<FragmentImpl> get children => const [];

  @override
  FormalParameterElementImpl get element => _element;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isExplicitlyCovariant': isExplicitlyCovariant,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginMixinApplicationClassConstructor':
          isOriginMixinApplicationClassConstructor,
      'isOriginOtherFragmentOfEnclosing': isOriginOtherFragmentOfEnclosing,
    };
  }

  @override
  List<FormalParameterFragmentImpl> get followingFragments {
    return [
      for (
        var current = nextFragment;
        current != null;
        current = current.nextFragment
      )
        current,
    ];
  }

  /// Whether the field was explicitly marked as being covariant.
  @generated
  bool get isExplicitlyCovariant {
    return hasFlag(
      _FragmentStorageFlag.formalParameterFragment_isExplicitlyCovariant,
    );
  }

  @generated
  set isExplicitlyCovariant(bool value) {
    setFlag(
      _FragmentStorageFlag.formalParameterFragment_isExplicitlyCovariant,
      value,
    );
  }

  /// Whether the parameter is a named parameter.
  ///
  /// Named parameters that are annotated with the `@required` annotation are
  /// considered optional. Named parameters that are annotated with the
  /// `required` syntax are considered required.
  bool get isNamed => parameterKind.isNamed;

  /// Whether the parameter is an optional parameter.
  ///
  /// Optional parameters can either be positional or named. Named parameters
  /// that are annotated with the `@required` annotation are considered
  /// optional. Named parameters that are annotated with the `required` syntax
  /// are considered required.
  bool get isOptional => parameterKind.isOptional;

  /// Whether the parameter is both an optional and named parameter.
  ///
  /// Named parameters that are annotated with the `@required` annotation are
  /// considered optional. Named parameters that are annotated with the
  /// `required` syntax are considered required.
  bool get isOptionalNamed => parameterKind.isOptionalNamed;

  /// Whether the parameter is both an optional and positional parameter.
  bool get isOptionalPositional => parameterKind.isOptionalPositional;

  @generated
  bool get isOriginDeclaration {
    return hasFlag(
      _FragmentStorageFlag.formalParameterFragment_isOriginDeclaration,
    );
  }

  @generated
  set isOriginDeclaration(bool value) {
    setFlag(
      _FragmentStorageFlag.formalParameterFragment_isOriginDeclaration,
      value,
    );
  }

  @generated
  bool get isOriginMixinApplicationClassConstructor {
    return hasFlag(
      _FragmentStorageFlag
          .formalParameterFragment_isOriginMixinApplicationClassConstructor,
    );
  }

  @generated
  set isOriginMixinApplicationClassConstructor(bool value) {
    setFlag(
      _FragmentStorageFlag
          .formalParameterFragment_isOriginMixinApplicationClassConstructor,
      value,
    );
  }

  @generated
  bool get isOriginOtherFragmentOfEnclosing {
    return hasFlag(
      _FragmentStorageFlag
          .formalParameterFragment_isOriginOtherFragmentOfEnclosing,
    );
  }

  @generated
  set isOriginOtherFragmentOfEnclosing(bool value) {
    setFlag(
      _FragmentStorageFlag
          .formalParameterFragment_isOriginOtherFragmentOfEnclosing,
      value,
    );
  }

  /// Whether the parameter is a positional parameter.
  ///
  /// Positional parameters can either be required or optional.
  bool get isPositional => parameterKind.isPositional;

  /// Whether the parameter is either a required positional parameter, or a
  /// named parameter with the `required` keyword.
  ///
  /// Note: the presence or absence of the `@required` annotation does not
  /// change the meaning of this getter. The parameter `{@required int x}`
  /// will return `false` and the parameter `{@required required int x}`
  /// will return `true`.
  bool get isRequired => parameterKind.isRequired;

  /// Whether the parameter is both a required and named parameter.
  ///
  /// Named parameters that are annotated with the `@required` annotation are
  /// considered optional. Named parameters that are annotated with the
  /// `required` syntax are considered required.
  bool get isRequiredNamed => parameterKind.isRequiredNamed;

  /// Whether the parameter is both a required and positional parameter.
  bool get isRequiredPositional => parameterKind.isRequiredPositional;

  @override
  LibraryFragmentImpl? get libraryFragment {
    return enclosingFragment?.libraryFragment;
  }

  @override
  List<FormalParameterFragmentImpl> get precedingFragments {
    return [
      for (
        var current = previousFragment;
        current != null;
        current = current.previousFragment
      )
        current,
    ];
  }

  void addFragment(FormalParameterFragmentImpl fragment) {
    fragment.previousFragment = this;
    nextFragment = fragment;
  }

  void initElement() {
    assert(previousFragment == null);

    FormalParameterFragmentImpl firstFragment = this;
    FormalParameterFragmentImpl? fragment = firstFragment;
    while (fragment != null) {
      switch (fragment) {
        case FieldFormalParameterFragmentImpl():
          FieldFormalParameterElementImpl(firstFragment);
          return;
        case SuperFormalParameterFragmentImpl():
          SuperFormalParameterElementImpl(firstFragment);
          return;
      }
      fragment = fragment.nextFragment;
    }

    FormalParameterElementImpl(firstFragment);
  }

  static void _linkFragments<T extends FragmentImpl>(
    List<T> fragments, {
    required List<FormalParameterFragmentImpl> Function(T) getFragments,
  }) {
    DeferredResolutionReadingHelper.withoutLoadingResolution(() {
      var firstFormalParameters = getFragments(fragments.first);

      var length = firstFormalParameters.length;
      fragments.reduce((previous, current) {
        var previousFragments = getFragments(previous);
        var currentFragments = getFragments(current);

        var index = 0;
        while (index < previousFragments.length) {
          var previousFragment = previousFragments[index];
          if (!previousFragment.isPositional) {
            break;
          }
          previousFragments[index].addFragment(currentFragments[index]);
          index++;
        }

        var namedMap = <String?, List<FormalParameterFragmentImpl>>{};
        for (var i = index; i < length; i++) {
          var f = currentFragments[i];
          (namedMap[f.name] ??= <FormalParameterFragmentImpl>[]).add(f);
        }

        for (var i = index; i < length; i++) {
          var previousParameter = previousFragments[i];
          var currentParameter = namedMap[previousParameter.name]!.removeAt(0);
          previousParameter.addFragment(currentParameter);
        }

        return current;
      });

      for (var formalParameter in firstFormalParameters) {
        formalParameter.initElement();
      }
    });
  }
}

@GenerateElementFlags(flags: _FragmentFlags.values)
abstract class FragmentImpl implements Fragment {
  static int _NEXT_ID = 0;

  /// The unique integer identifier of this fragment.
  final int id = _NEXT_ID++;

  /// The fragment that either physically or logically encloses this fragment.
  ///
  /// For [LibraryFragment] returns `null`, because library fragments are the
  /// top-level fragments in the model.
  @override
  FragmentImpl? enclosingFragment;

  /// The offset of the first token of the declaration of this fragment,
  /// or `null` if this fragment is synthetic.
  int? firstTokenOffset;

  /// The flags associated with this fragment.
  EnumSet<_FragmentStorageFlag> _flags = EnumSet.empty();

  @override
  String? documentationComment;

  @override
  MetadataImpl metadata = MetadataImpl.empty;

  /// The offset of the beginning of the element's code in the file that
  /// contains the element, or `null` if the element is synthetic.
  int? _codeOffset;

  /// The length of the element's code, or `null` if the element is synthetic.
  int? _codeLength;

  /// Initialize a newly created fragment at the given [firstTokenOffset].
  FragmentImpl({this.firstTokenOffset});

  @override
  List<FragmentImpl> get children;

  /// The length of the element's code, or `null` if the element is synthetic.
  int? get codeLength => _codeLength;

  /// The offset of the beginning of the element's code in the file that
  /// contains the element, or `null` if the element is synthetic.
  int? get codeOffset => _codeOffset;

  /// The display name of this element, possibly the empty string if the
  /// element does not have a name.
  ///
  /// In most cases the name and the display name are the same. Differences
  /// though are cases such as setters where the name of some setter `set f(x)`
  /// is `f=`, instead of `f`.
  String get displayName => name ?? '';

  @override
  ElementImpl get element;

  /// Returns the metadata for the element represented by this fragment chain.
  ///
  /// If the element has multiple fragments, annotations from this fragment and
  /// all subsequent fragments are combined in fragment order.
  MetadataImpl get elementMetadata {
    if (nextFragment == null) {
      return metadata;
    }

    List<ElementAnnotationImpl>? annotations;
    MetadataImpl? firstMetadata;
    for (
      FragmentImpl? fragment = this;
      fragment != null;
      fragment = fragment.nextFragment
    ) {
      var fragmentMetadata = fragment.metadata;
      if (fragmentMetadata.annotations.isNotEmpty) {
        if (firstMetadata == null) {
          firstMetadata = fragmentMetadata;
        } else {
          annotations ??= firstMetadata.annotations.toList();
          annotations.addAll(fragmentMetadata.annotations);
        }
      }
    }

    if (annotations != null) {
      return MetadataImpl(annotations);
    }

    if (firstMetadata != null) {
      return firstMetadata;
    }

    return MetadataImpl.empty;
  }

  /// Return the enclosing unit element (which might be the same as `this`), or
  /// `null` if this element is not contained in any compilation unit.
  LibraryFragmentImpl get enclosingUnit {
    return enclosingFragment!.enclosingUnit;
  }

  /// The first fragment in the augmentation chain.
  FragmentImpl get firstFragment {
    var current = this;
    while (current.previousFragment != null) {
      current = current.previousFragment!;
    }
    return current;
  }

  @generated
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {'isAugmentation': isAugmentation, 'isComplete': isComplete};
  }

  /// The fragments in the augmentation chain that follow this fragment,
  /// in order from the immediate next fragment to the last fragment.
  List<FragmentImpl> get followingFragments {
    return [
      for (
        var current = nextFragment;
        current != null;
        current = current.nextFragment
      )
        current,
    ];
  }

  @generated
  bool get isAugmentation {
    return hasFlag(_FragmentStorageFlag.fragment_isAugmentation);
  }

  @generated
  set isAugmentation(bool value) {
    setFlag(_FragmentStorageFlag.fragment_isAugmentation, value);
  }

  @generated
  bool get isComplete {
    return hasFlag(_FragmentStorageFlag.fragment_isComplete);
  }

  @generated
  set isComplete(bool value) {
    setFlag(_FragmentStorageFlag.fragment_isComplete, value);
  }

  /// Whether the element is private.
  ///
  /// Private elements are visible only within the library in which they are
  /// declared.
  bool get isPrivate {
    var name = this.name;
    if (name == null) {
      return false;
    }
    return name.isPrivateName;
  }

  /// Whether the element is public.
  ///
  /// Public elements are visible within any library that imports the library
  /// in which they are declared.
  bool get isPublic => !isPrivate;

  @override
  LibraryFragmentImpl? get libraryFragment;

  String? get lookupName {
    return name;
  }

  /// The offset after the last character of the name, or `null` if there is
  /// no declaration in code for this fragment, or the name is absent.
  int? get nameEnd {
    if (nameOffset case var nameOffset?) {
      if (name case var name?) {
        return nameOffset + name.length;
      }
    }
    return null;
  }

  /// The nearest preceding fragment in the augmentation chain that is complete.
  FragmentImpl? get nearestPrecedingCompleteFragment {
    return precedingFragments.firstWhereOrNull((fragment) {
      return fragment.isComplete;
    });
  }

  @override
  FragmentImpl? get nextFragment;

  /// The fragments in the augmentation chain that precede this fragment,
  /// in order from the immediate previous fragment to the first fragment.
  List<FragmentImpl> get precedingFragments {
    return [
      for (
        var current = previousFragment;
        current != null;
        current = current.previousFragment
      )
        current,
    ];
  }

  @override
  FragmentImpl? get previousFragment;

  /// The version where this SDK API was added.
  ///
  /// A `@Since()` annotation can be applied to a library declaration,
  /// any public declaration in a library, or in a class, or to an optional
  /// parameter, etc.
  ///
  /// The returned version is "effective", so that if a library is annotated
  /// then all elements of the library inherit it; or if a class is annotated
  /// then all members and constructors of the class inherit it.
  ///
  /// If multiple `@Since()` annotations apply to the same element, the latest
  /// version takes precedence.
  ///
  /// Returns `null` if the element is not declared in SDK, or does not have
  /// a `@Since()` annotation applicable to it.
  Version? get sinceSdkVersion {
    return element.sinceSdkVersion;
  }

  @override
  bool operator ==(Object other) {
    return identical(this, other);
  }

  /// Set this element as the enclosing element for given [fragment].
  void encloseElement(FragmentImpl fragment) {
    fragment.enclosingFragment = this;
  }

  /// Set this element as the enclosing element for given [fragments].
  void encloseElements(List<FragmentImpl> fragments) {
    for (var fragment in fragments) {
      fragment.enclosingFragment = this;
    }
  }

  /// Return `true` if this fragment has the given [flag] associated with it.
  bool hasFlag(_FragmentStorageFlag flag) => _flags[flag];

  void readFlags(BinaryReader reader) {
    _flags = EnumSet.read(reader);
  }

  /// Set the code range for this element.
  void setCodeRange(int offset, int length) {
    _codeOffset = offset;
    _codeLength = length;
  }

  /// Set whether the given [flag] is associated with this fragment to
  /// correspond to the given [value].
  void setFlag(_FragmentStorageFlag flag, bool value) {
    _flags = _flags.updated(flag, value);
  }

  @override
  String toString() {
    return "fragmentOf: $element";
  }

  void writeFlags(BinaryWriter writer) {
    _flags.write(writer);
  }
}

sealed class FunctionFragmentImpl extends ExecutableFragmentImpl
    implements FunctionTypedFragmentImpl {
  @override
  final String? name;

  @override
  int? nameOffset;

  /// Initialize a newly created function element to have the given [name] and
  /// [offset].
  FunctionFragmentImpl({required this.name, super.firstTokenOffset});

  @override
  FunctionFragmentImpl? get nextFragment;

  @override
  FunctionFragmentImpl? get previousFragment;
}

@elementClass
abstract class FunctionTypedElementImpl extends ElementImpl
    implements FunctionTypedElement {
  @override
  FunctionTypedFragmentImpl get firstFragment;

  @override
  List<FunctionTypedFragmentImpl> get fragments;

  @override
  @trackedIncludedInId
  LibraryElementImpl get library => super.library!;
}

/// Common internal interface shared by elements whose type is a function type.
///
/// Clients may not extend, implement or mix-in this class.
abstract class FunctionTypedFragmentImpl extends FragmentImpl
    implements FunctionTypedFragment {
  FunctionTypedFragmentImpl({super.firstTokenOffset});

  @override
  FunctionTypedElementImpl get element;

  @override
  List<FormalParameterFragmentImpl> get formalParameters;

  @override
  FunctionTypedFragmentImpl? get nextFragment;

  @override
  FunctionTypedFragmentImpl? get previousFragment;

  @override
  List<TypeParameterFragmentImpl> get typeParameters;
}

class GenerateElementFlags {
  /// Flags to generate in the annotated class.
  ///
  /// Should be a companion enum to reuse Dart syntax, and allow attaching
  /// optional documentation comments. Theoretically it could be a type
  /// literal, but then each enum constant is marked as unused, so we
  /// use `_MyFragmentFlagsEnum.values` instead.
  final List<Enum> flags;

  const GenerateElementFlags({required this.flags});
}

/// The element used for a generic function type.
///
/// Clients may not extend, implement or mix-in this class.
class GenericFunctionTypeElementImpl extends FunctionTypedElementImpl
    implements GenericFunctionTypeElement {
  @override
  final GenericFunctionTypeFragmentImpl _firstFragment;

  @override
  late TypeImpl returnType;

  /// The type defined by this element.
  FunctionTypeImpl? _type;

  GenericFunctionTypeElementImpl(this._firstFragment) {
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
    for (var formalParameter in _firstFragment._formalParameters) {
      formalParameter.initElement();
    }
  }

  @override
  String? get documentationComment => _firstFragment.documentationComment;

  @override
  Element? get enclosingElement => _firstFragment.enclosingFragment?.element;

  @override
  GenericFunctionTypeFragmentImpl get firstFragment => _firstFragment;

  @override
  List<FormalParameterElementImpl> get formalParameters => _firstFragment
      .formalParameters
      .map((fragment) => fragment.element)
      .toList();

  @override
  List<GenericFunctionTypeFragmentImpl> get fragments {
    return [
      for (
        GenericFunctionTypeFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  bool get isSimplyBounded => true;

  @override
  ElementKind get kind => ElementKind.GENERIC_FUNCTION_TYPE;

  @override
  MetadataImpl get metadata => _firstFragment.metadata;

  @override
  String? get name => _firstFragment.name;

  @override
  FunctionTypeImpl get type {
    return _type ??= FunctionTypeImpl(
      typeParameters: typeParameters,
      formalParameters: formalParameters,
      returnType: returnType,
      nullabilitySuffix: _firstFragment.isNullable
          ? NullabilitySuffix.question
          : NullabilitySuffix.none,
    );
  }

  set type(FunctionTypeImpl type) {
    _type = type;
  }

  @override
  List<TypeParameterElementImpl> get typeParameters {
    return _firstFragment.typeParameters
        .map((fragment) => fragment.element)
        .toList();
  }

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return visitor.visitGenericFunctionTypeElement(this);
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeGenericFunctionTypeElement(this);
  }
}

/// The element used for a generic function type.
///
/// Clients may not extend, implement or mix-in this class.
class GenericFunctionTypeFragmentImpl extends FragmentImpl
    with DeferredResolutionReadingMixin
    implements FunctionTypedFragmentImpl, GenericFunctionTypeFragment {
  List<TypeParameterFragmentImpl> _typeParameters = const [];

  /// The elements representing the parameters of the function.
  List<FormalParameterFragmentImpl> _formalParameters = const [];

  /// Is `true` if the type has the question mark, so is nullable.
  bool isNullable = false;

  @override
  late final GenericFunctionTypeElementImpl element;

  /// Initialize a newly created function element to have no name and the given
  /// [nameOffset]. This is used for function expressions, that have no name.
  GenericFunctionTypeFragmentImpl({super.firstTokenOffset});

  @override
  List<FragmentImpl> get children => [...typeParameters, ...formalParameters];

  @override
  List<FormalParameterFragmentImpl> get formalParameters {
    return _formalParameters;
  }

  /// Set the parameters defined by this function type element to the given
  /// [formalParameters].
  set formalParameters(List<FormalParameterFragmentImpl> formalParameters) {
    for (var formalParameter in formalParameters) {
      formalParameter.enclosingFragment = this;
    }
    _formalParameters = formalParameters;
  }

  @override
  LibraryFragmentImpl get libraryFragment => enclosingUnit;

  @override
  String? get name => null;

  @override
  int? get nameOffset => null;

  @override
  GenericFunctionTypeFragmentImpl? get nextFragment => null;

  @override
  int get offset => firstTokenOffset!;

  @override
  GenericFunctionTypeFragmentImpl? get previousFragment => null;

  @override
  List<TypeParameterFragmentImpl> get typeParameters {
    _ensureReadResolution();
    return _typeParameters;
  }

  set typeParameters(List<TypeParameterFragmentImpl> typeParameters) {
    for (var typeParameter in typeParameters) {
      typeParameter.enclosingFragment = this;
    }
    _typeParameters = typeParameters;
  }
}

@elementClass
class GetterElementImpl extends PropertyAccessorElementImpl
    with InternalGetterElement {
  @override
  @trackedIncludedInId
  DeclarationReference reference;

  @override
  final GetterFragmentImpl _firstFragment;

  GetterElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    GetterFragmentImpl? fragment = _firstFragment;
    while (fragment != null) {
      fragment.element = this;
      fragment = fragment.nextFragment;
    }
  }

  @override
  @trackedIncludedInId
  GetterElementImpl get baseElement => this;

  @override
  @trackedIndirectly
  SetterElement? get correspondingSetter {
    return variable.setter;
  }

  @override
  @trackedDirectlyOpaque
  GetterFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @override
  @trackedDirectlyOpaque
  List<GetterFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.GETTER;

  @override
  @trackedDirectlyOpaque
  GetterFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );
    return super.lastFragment as GetterFragmentImpl;
  }

  @override
  @trackedIndirectly
  Element get nonSynthetic {
    if (isOriginVariable) {
      return variable.nonSynthetic;
    } else {
      return this;
    }
  }

  @override
  @trackedIndirectly
  Version? get sinceSdkVersion {
    if (isOriginVariable) {
      return variable.sinceSdkVersion;
    }
    return super.sinceSdkVersion;
  }

  @override
  List<GetterFragmentImpl> get _fragments {
    return [
      for (
        GetterFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitGetterElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeGetterElement(this);
  }

  @trackedInternal
  void linkFragments(List<GetterFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    FormalParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.formalParameters,
    );
  }

  @override
  @trackedIndirectly
  InternalGetterElement substitute(MapSubstitution substitution) {
    if (substitution.map.isEmpty) {
      return this;
    }
    if (enclosingElement is! InstanceElement) {
      throw StateError('Cannot substitute a non-member: $this');
    }
    if (!hasEnclosingTypeParameterReference) {
      return this;
    }
    return SubstitutedGetterElementImpl(
      baseElement: this,
      substitution: substitution,
    );
  }
}

class GetterFragmentImpl extends PropertyAccessorFragmentImpl
    implements GetterFragment {
  @override
  late GetterElementImpl element;

  @override
  GetterFragmentImpl? previousFragment;

  @override
  GetterFragmentImpl? nextFragment;

  GetterFragmentImpl({required super.name});

  void addFragment(GetterFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

/// A concrete implementation of a [HideElementCombinator].
class HideElementCombinatorImpl implements HideElementCombinator {
  @override
  List<String> hiddenNames = const [];

  @override
  int offset = 0;

  @override
  int end = -1;

  @override
  String toString() {
    StringBuffer buffer = StringBuffer();
    buffer.write("hide ");
    int count = hiddenNames.length;
    for (int i = 0; i < count; i++) {
      if (i > 0) {
        buffer.write(", ");
      }
      buffer.write(hiddenNames[i]);
    }
    return buffer.toString();
  }
}

@elementClass
@GenerateElementFlags(flags: _InstanceElementFlags.values)
sealed class InstanceElementImpl extends ElementImpl
    with DeferredMembersReadingMixin, DeferredResolutionReadingMixin
    implements InstanceElement, TypeParameterizedElement {
  List<FieldElementImpl> _fields = [];

  List<GetterElementImpl> _getters = [];

  List<SetterElementImpl> _setters = [];

  List<MethodElementImpl> _methods = [];

  @trackedInternal
  InstanceElementRequirementState requirementState =
      InstanceElementRequirementState();

  @override
  @trackedIncludedInId
  InstanceElement get baseElement => this;

  @override
  @trackedIndirectly
  List<ElementImpl> get children {
    return [...fields, ...getters, ...setters, ...methods];
  }

  @override
  @trackedIncludedInId
  String get displayName {
    return _firstFragment.displayName;
  }

  @override
  @trackedDirectlyOpaque
  String? get documentationComment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueDocumentationComment,
      target: this,
      method: 'documentationComment',
    );
    return _firstFragment.documentationComment;
  }

  @override
  @trackedIncludedInId
  LibraryElementImpl get enclosingElement => library;

  @override
  @trackedDirectlyExpensive
  List<FieldElementImpl> get fields {
    globalResultRequirements?.record_instanceElement_fields(element: this);
    ensureReadMembers();
    return _fields;
  }

  set fields(List<FieldElementImpl> value) {
    _fields = value;
  }

  @override
  InstanceFragmentImpl get firstFragment;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {...super.flagsForTesting, 'isSimplyBounded': isSimplyBounded};
  }

  @override
  List<InstanceFragmentImpl> get fragments;

  @override
  @trackedDirectlyExpensive
  List<GetterElementImpl> get getters {
    globalResultRequirements?.record_instanceElement_getters(element: this);
    ensureReadMembers();
    return _getters;
  }

  set getters(List<GetterElementImpl> value) {
    _getters = value;
  }

  @override
  @trackedIncludedInId
  bool get isPrivate => _firstFragment.isPrivate;

  @override
  @trackedIncludedInId
  bool get isPublic => _firstFragment.isPublic;

  @generated
  @override
  @trackedIncludedInId
  bool get isSimplyBounded {
    return hasFlag(_ElementStorageFlag.instanceElement_isSimplyBounded);
  }

  @generated
  set isSimplyBounded(bool value) {
    setFlag(_ElementStorageFlag.instanceElement_isSimplyBounded, value);
  }

  @override
  @trackedIncludedInId
  LibraryElementImpl get library => super.library!;

  @override
  @trackedIncludedInId
  MetadataImpl get metadata {
    return _firstFragment.metadata;
  }

  @override
  @trackedDirectlyExpensive
  List<MethodElementImpl> get methods {
    globalResultRequirements?.record_instanceElement_methods(element: this);
    ensureReadMembers();
    return _methods;
  }

  set methods(List<MethodElementImpl> value) {
    _methods = value;
  }

  @override
  @trackedIncludedInId
  String? get name {
    return _firstFragment.name;
  }

  @override
  MemberContainerReference get reference;

  @override
  @trackedDirectlyOpaque
  AnalysisSessionImpl get session {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueSession,
      target: this,
      method: 'session',
    );
    return library.session;
  }

  @override
  @trackedDirectlyExpensive
  List<SetterElementImpl> get setters {
    globalResultRequirements?.record_instanceElement_setters(element: this);
    ensureReadMembers();
    return _setters;
  }

  set setters(List<SetterElementImpl> value) {
    _setters = value;
  }

  @override
  TypeImpl get thisType;

  @override
  @trackedIncludedInId
  List<TypeParameterElementImpl> get typeParameters {
    _ensureReadResolution();

    var typeParameters = _firstFragment.typeParameters;

    var hasRecoveryFragments = false;
    for (var i = 0; i < typeParameters.length; i++) {
      if (typeParameters[i].isOriginOtherFragmentOfEnclosing) {
        hasRecoveryFragments = true;
        break;
      }
    }

    // Don't expose recovery elements as the actual element arity.
    if (hasRecoveryFragments) {
      var result = <TypeParameterElementImpl>[];
      for (var typeParameter in typeParameters) {
        if (!typeParameter.isOriginOtherFragmentOfEnclosing) {
          result.add(typeParameter.element);
        }
      }
      return result.toFixedList();
    }

    return List.generate(
      typeParameters.length,
      (index) => typeParameters[index].element,
      growable: false,
    );
  }

  @override
  InstanceFragmentImpl get _firstFragment;

  @trackedInternal
  void addField(FieldElementImpl element) {
    _fields.add(element);
  }

  @trackedInternal
  void addGetter(GetterElementImpl element) {
    _getters.add(element);
  }

  @trackedInternal
  void addMethod(MethodElementImpl element) {
    _methods.add(element);
  }

  @trackedInternal
  void addSetter(SetterElementImpl element) {
    _setters.add(element);
  }

  @override
  @trackedDirectly
  FieldElementImpl? getField(String name) {
    globalResultRequirements?.record_instanceElement_getField(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      for (var e in fields) {
        if (e.name == name) return e;
      }
      return null;
    });
  }

  @override
  @trackedDirectly
  GetterElementImpl? getGetter(String name) {
    globalResultRequirements?.record_instanceElement_getGetter(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      for (var e in getters) {
        if (e.name == name) return e;
      }
      return null;
    });
  }

  /// Returns what this declares instead of [name], for a lookup of [name]
  /// that failed, or `null` if it declares nothing.
  ///
  /// If [name] is public, or this is declared in the library of [name], this
  /// is a getter or method when [name] is a setter, or a setter when it is a
  /// getter. Otherwise this is a private getter, setter, or method spelled
  /// like [name] that this declares in another library.
  @trackedIndirectly
  ExecutableElementImpl? getMemberForFailedLookup(Name name) {
    var getterName = name.forGetter.name;
    if (name.isPublic || library.uri == name.libraryUri) {
      if (name.isSetter) {
        return getGetter(getterName) ?? getMethod(getterName);
      } else {
        return getSetter(getterName);
      }
    } else {
      return getGetter(getterName) ??
          getMethod(getterName) ??
          getSetter(getterName);
    }
  }

  @override
  @trackedDirectly
  MethodElementImpl? getMethod(String name) {
    globalResultRequirements?.record_instanceElement_getMethod(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      for (var e in methods) {
        if (e.lookupName == name) return e;
      }
      return null;
    });
  }

  @override
  @trackedDirectly
  SetterElementImpl? getSetter(String name) {
    globalResultRequirements?.record_instanceElement_getSetter(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return setters.firstWhereOrNull((e) => e.name == name);
    });
  }

  @override
  @trackedIncludedInId
  bool isAccessibleIn(LibraryElement library) {
    var name = this.name;
    if (name != null && name.isPrivateName) {
      return library == this.library;
    }
    return true;
  }

  @override
  @trackedDirectlyOpaque
  GetterElement? lookUpGetter({
    required String name,
    required LibraryElement library,
  }) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLookUpGetter,
      target: this,
      method: 'lookUpGetter',
    );
    return _implementationsOfGetter(
          name,
        ).firstWhereOrNull((getter) => getter.isAccessibleIn(library))
        as GetterElement?;
  }

  @override
  @trackedDirectlyOpaque
  MethodElement? lookUpMethod({
    required String name,
    required LibraryElement library,
  }) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLookUpMethod,
      target: this,
      method: 'lookUpMethod',
    );
    return _implementationsOfMethod(
      name,
    ).firstWhereOrNull((method) => method.isAccessibleIn(library));
  }

  @override
  @trackedDirectlyOpaque
  SetterElement? lookUpSetter({
    required String name,
    required LibraryElement library,
  }) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLookUpSetter,
      target: this,
      method: 'lookUpSetter',
    );
    return _implementationsOfSetter(
          name,
        ).firstWhereOrNull((setter) => setter.isAccessibleIn(library))
        as SetterElement?;
  }

  @override
  @trackedIncludedInId
  Element? thisOrAncestorMatching(bool Function(Element) predicate) {
    if (predicate(this)) {
      return this;
    }
    return library.thisOrAncestorMatching(predicate);
  }

  @override
  @trackedIncludedInId
  E? thisOrAncestorOfType<E extends Element>() {
    if (this case E result) {
      return result;
    }
    return library.thisOrAncestorOfType<E>();
  }

  Iterable<InternalPropertyAccessorElement> _implementationsOfGetter(
    String name,
  ) sync* {
    var visitedElements = <InstanceElement>{};
    InstanceElement? element = this;
    while (element != null && visitedElements.add(element)) {
      var getter = element.getGetter(name);
      if (getter != null) {
        yield getter as InternalPropertyAccessorElement;
      }
      if (element is! InterfaceElement) {
        return;
      }
      for (var mixin in element.mixins.reversed) {
        mixin as InterfaceTypeImpl;
        getter = mixin.element.getGetter(name);
        if (getter != null) {
          yield getter as InternalPropertyAccessorElement;
        }
      }
      var supertype = element.supertype;
      supertype as InterfaceTypeImpl?;
      element = supertype?.element;
    }
  }

  Iterable<InternalMethodElement> _implementationsOfMethod(String name) sync* {
    var visitedElements = <InstanceElement>{};
    InstanceElement? element = this;
    while (element != null && visitedElements.add(element)) {
      var method = element.getMethod(name);
      if (method != null) {
        yield method as InternalMethodElement;
      }
      if (element is! InterfaceElement) {
        return;
      }
      for (var mixin in element.mixins.reversed) {
        mixin as InterfaceTypeImpl;
        method = mixin.element.getMethod(name);
        if (method != null) {
          yield method as InternalMethodElement;
        }
      }
      var supertype = element.supertype;
      supertype as InterfaceTypeImpl?;
      element = supertype?.element;
    }
  }

  Iterable<InternalPropertyAccessorElement> _implementationsOfSetter(
    String name,
  ) sync* {
    var visitedElements = <InstanceElement>{};
    InstanceElement? element = this;
    while (element != null && visitedElements.add(element)) {
      var setter = element.getSetter(name);
      if (setter != null) {
        yield setter as InternalPropertyAccessorElement;
      }
      if (element is! InterfaceElement) {
        return;
      }
      for (var mixin in element.mixins.reversed) {
        mixin as InterfaceTypeImpl;
        setter = mixin.element.getSetter(name);
        if (setter != null) {
          yield setter as InternalPropertyAccessorElement;
        }
      }
      var supertype = element.supertype;
      supertype as InterfaceTypeImpl?;
      element = supertype?.element;
    }
  }
}

abstract class InstanceFragmentImpl extends FragmentImpl
    with DeferredMembersReadingMixin, DeferredResolutionReadingMixin
    implements InstanceFragment {
  @override
  final String? name;

  @override
  int? nameOffset;

  @override
  InstanceFragmentImpl? previousFragment;

  @override
  InstanceFragmentImpl? nextFragment;

  List<TypeParameterFragmentImpl> _typeParameters = const [];
  List<FieldFragmentImpl> _fields = _Sentinel.fieldFragment;
  List<GetterFragmentImpl> _getters = _Sentinel.getterFragment;
  List<SetterFragmentImpl> _setters = _Sentinel.setterFragment;
  List<MethodFragmentImpl> _methods = _Sentinel.methodFragment;

  InstanceFragmentImpl({required this.name});

  List<PropertyAccessorFragmentImpl> get accessors {
    return [...getters, ...setters];
  }

  @override
  InstanceElementImpl get element;

  @override
  LibraryFragmentImpl get enclosingFragment =>
      super.enclosingFragment as LibraryFragmentImpl;

  @override
  List<FieldFragmentImpl> get fields {
    if (!identical(_fields, _Sentinel.fieldFragment)) {
      return _fields;
    }

    element.ensureReadMembers();
    _ensureReadResolution();
    return _fields;
  }

  set fields(List<FieldFragmentImpl> fields) {
    for (var field in fields) {
      field.enclosingFragment = this;
    }
    _fields = fields;
  }

  @override
  List<GetterFragmentImpl> get getters {
    if (!identical(_getters, _Sentinel.getterFragment)) {
      return _getters;
    }

    element.ensureReadMembers();
    _ensureReadResolution();
    return _getters;
  }

  set getters(List<GetterFragmentImpl> getters) {
    for (var getter in getters) {
      getter.enclosingFragment = this;
    }
    _getters = getters;
  }

  @override
  LibraryFragmentImpl get libraryFragment => enclosingUnit;

  @override
  MetadataImpl get metadata {
    _ensureReadResolution();
    return super.metadata;
  }

  @override
  List<MethodFragmentImpl> get methods {
    if (!identical(_methods, _Sentinel.methodFragment)) {
      return _methods;
    }

    element.ensureReadMembers();
    _ensureReadResolution();
    return _methods;
  }

  set methods(List<MethodFragmentImpl> methods) {
    for (var method in methods) {
      method.enclosingFragment = this;
    }
    _methods = methods;
  }

  @override
  int get offset => nameOffset ?? firstTokenOffset!;

  @override
  List<SetterFragmentImpl> get setters {
    if (!identical(_setters, _Sentinel.setterFragment)) {
      return _setters;
    }

    element.ensureReadMembers();
    _ensureReadResolution();
    return _setters;
  }

  set setters(List<SetterFragmentImpl> setters) {
    for (var setter in setters) {
      setter.enclosingFragment = this;
    }
    _setters = setters;
  }

  @override
  List<TypeParameterFragmentImpl> get typeParameters {
    _ensureReadResolution();
    return _typeParameters;
  }

  set typeParameters(List<TypeParameterFragmentImpl> typeParameters) {
    for (var typeParameter in typeParameters) {
      typeParameter.enclosingFragment = this;
    }
    _typeParameters = typeParameters;
  }

  void addField(FieldFragmentImpl fragment) {
    if (identical(_fields, _Sentinel.fieldFragment)) {
      _fields = [];
    }
    _fields.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addGetter(GetterFragmentImpl fragment) {
    if (identical(_getters, _Sentinel.getterFragment)) {
      _getters = [];
    }
    _getters.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addMethod(MethodFragmentImpl fragment) {
    if (identical(_methods, _Sentinel.methodFragment)) {
      _methods = [];
    }
    _methods.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addSetter(SetterFragmentImpl fragment) {
    if (identical(_setters, _Sentinel.setterFragment)) {
      _setters = [];
    }
    _setters.add(fragment);
    fragment.enclosingFragment = this;
  }
}

@elementClass
@GenerateElementFlags(flags: _InterfaceElementFlags.values)
sealed class InterfaceElementImpl extends InstanceElementImpl
    implements InterfaceElement {
  /// The non-nullable instance of this element, without alias.
  /// Should be used only when the element has no type parameters.
  InterfaceTypeImpl? _nonNullableInstance;

  /// The nullable instance of this element, without alias.
  /// Should be used only when the element has no type parameters.
  InterfaceTypeImpl? _nullableInstance;

  InterfaceTypeImpl? _supertype;
  List<InterfaceTypeImpl> _mixins = const [];
  List<InterfaceTypeImpl> _interfaces = const [];

  InterfaceTypeImpl? _thisType;

  /// If not `null`, this element was part of a supertypes cycle. The cycle
  /// is broken by clearing supertypes for all cycle elements.
  @trackedIncludedInId
  List<InterfaceElementImpl>? interfaceCycle;

  /// The cached result of [allSupertypes].
  List<InterfaceTypeImpl>? _allSupertypes;

  List<ConstructorElementImpl> _constructors = _Sentinel.constructorElement;

  /// This callback is set during mixins inference to handle reentrant calls.
  @trackedInternal
  List<InterfaceTypeImpl>? Function(InterfaceElementImpl)?
  mixinInferenceCallback;

  /// Storage for [hasNonFinalField].
  bool _hasNonFinalField = false;

  @override
  @trackedIncludedInId
  List<InterfaceTypeImpl> get allSupertypes {
    return _allSupertypes ??= library.internal.classHierarchy
        .implementedInterfaces(this);
  }

  @override
  @trackedIndirectly
  List<ElementImpl> get children {
    return [...super.children, ...constructors];
  }

  @override
  @trackedDirectlyExpensive
  List<ConstructorElementImpl> get constructors {
    globalResultRequirements?.record_instanceElement_constructors(
      element: this,
    );
    ensureReadMembers();
    if (!identical(_constructors, _Sentinel.constructorElement)) {
      return _constructors;
    }

    _buildMixinAppConstructors();
    return _constructors;
  }

  set constructors(List<ConstructorElementImpl> value) {
    _constructors = value;
  }

  @override
  InterfaceFragmentImpl get firstFragment;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {...super.flagsForTesting, 'hasNonFinalField': hasNonFinalField};
  }

  @override
  @trackedDirectlyOpaque
  List<InterfaceFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return [
      for (
        InterfaceFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  /// Whether the class or its superclass declares a non-final instance field.
  @trackedDirectly
  bool get hasNonFinalField {
    globalResultRequirements?.record_interfaceElement_hasNonFinalField(
      element: this,
    );
    return _hasNonFinalField;
  }

  set hasNonFinalField(bool value) {
    _hasNonFinalField = value;
  }

  @trackedIndirectly
  InheritanceManager3 get inheritanceManager {
    return library.internal.inheritanceManager;
  }

  @override
  @trackedDirectlyOpaque
  Map<Name, InternalExecutableElement> get inheritedConcreteMembers {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueInheritedConcreteMembers,
      target: this,
      method: 'inheritedConcreteMembers',
    );
    return inheritanceManager.getInheritedConcreteMap(this);
  }

  @override
  @trackedDirectlyOpaque
  Map<Name, InternalExecutableElement> get inheritedMembers {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueInheritedMembers,
      target: this,
      method: 'inheritedMembers',
    );
    return inheritanceManager.getInheritedMap(this);
  }

  @override
  @trackedDirectlyOpaque
  Map<Name, InternalExecutableElement> get interfaceMembers {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueInterfaceMembers,
      target: this,
      method: 'interfaceMembers',
    );
    return inheritanceManager.getInterface(this).map;
  }

  @override
  @trackedIncludedInId
  List<InterfaceTypeImpl> get interfaces {
    _ensureReadResolution();
    return _interfaces;
  }

  set interfaces(List<InterfaceType> interfaces) {
    // TODO(paulberry): eliminate this cast by changing the type of the
    // `interfaces` parameter.
    _interfaces = interfaces.cast();
  }

  /// Return `true` if this class represents the class '_Enum' defined in the
  /// dart:core library.
  @trackedIncludedInId
  bool get isDartCoreEnumImpl {
    return name == '_Enum' && library.isDartCore;
  }

  @override
  @trackedIncludedInId
  List<InterfaceTypeImpl> get mixins {
    if (mixinInferenceCallback case var mixinInferenceCallback?) {
      var mixins = mixinInferenceCallback(this);
      if (mixins != null) {
        return _mixins = mixins;
      }
    }

    _ensureReadResolution();
    return _mixins;
  }

  set mixins(List<InterfaceType> mixins) {
    // TODO(paulberry): eliminate this cast by changing the type of the `mixins`
    // parameter.
    _mixins = mixins.cast();
  }

  @override
  @trackedIndirectly
  ConstructorElementImpl? get primaryConstructor {
    var result = constructors.firstOrNull;
    if (result != null && result.isPrimary) {
      return result;
    }
    return null;
  }

  @override
  @trackedIncludedInId
  InterfaceTypeImpl? get supertype {
    _ensureReadResolution();
    return _supertype;
  }

  set supertype(InterfaceTypeImpl? value) {
    _supertype = value;
  }

  @override
  @trackedIncludedInId
  InterfaceTypeImpl get thisType {
    if (_thisType == null) {
      List<TypeImpl> typeArguments;
      if (typeParameters.isNotEmpty) {
        typeArguments = List.generate(
          typeParameters.length,
          (index) => typeParameters[index].instantiate(
            nullabilitySuffix: NullabilitySuffix.none,
          ),
          growable: false,
        );
      } else {
        typeArguments = const [];
      }
      return _thisType = instantiateImpl(
        typeArguments: typeArguments,
        nullabilitySuffix: NullabilitySuffix.none,
      );
    }
    return _thisType!;
  }

  @override
  @trackedIndirectly
  ConstructorElementImpl? get unnamedConstructor {
    return getNamedConstructor('new');
  }

  @override
  InterfaceFragmentImpl get _firstFragment;

  @trackedInternal
  void addConstructor(ConstructorElementImpl element) {
    if (identical(_constructors, _Sentinel.constructorElement)) {
      _constructors = [];
    }
    _constructors.add(element);
  }

  @override
  @trackedIndirectly
  ExecutableElement? getInheritedConcreteMember(Name name) =>
      inheritedConcreteMembers[name];

  @override
  @trackedDirectlyOpaque
  ExecutableElement? getInheritedMember(Name name) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueGetInheritedMember,
      target: this,
      method: 'getInheritedMember',
    );
    return inheritanceManager.getInherited(this, name);
  }

  @override
  @trackedIndirectly
  ExecutableElement? getInterfaceMember(Name name) {
    return inheritanceManager.getMember(this, name);
  }

  @override
  @trackedDirectly
  ConstructorElementImpl? getNamedConstructor(String name) {
    globalResultRequirements?.record_interfaceElement_getNamedConstructor(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      for (var e in constructors) {
        if (e.name == name) return e;
      }
      return null;
    });
  }

  @override
  @trackedDirectlyOpaque
  List<ExecutableElement>? getOverridden(Name name) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueGetOverridden,
      target: this,
      method: 'getOverridden',
    );
    return inheritanceManager.getOverridden(this, name);
  }

  @override
  @trackedIndirectly
  InterfaceTypeImpl instantiate({
    required List<DartType> typeArguments,
    required NullabilitySuffix nullabilitySuffix,
  }) {
    return instantiateImpl(
      typeArguments: typeArguments.cast<TypeImpl>(),
      nullabilitySuffix: nullabilitySuffix,
    );
  }

  @trackedIndirectly
  InterfaceTypeImpl instantiateImpl({
    required List<TypeImpl> typeArguments,
    required NullabilitySuffix nullabilitySuffix,
  }) {
    assert(typeArguments.length == typeParameters.length);

    if (typeArguments.isEmpty) {
      switch (nullabilitySuffix) {
        case NullabilitySuffix.none:
          if (_nonNullableInstance case var instance?) {
            return instance;
          }
        case NullabilitySuffix.question:
          if (_nullableInstance case var instance?) {
            return instance;
          }
        case NullabilitySuffix.star:
          // TODO(scheglov): remove together with `star`
          break;
      }
    }

    var result = InterfaceTypeImpl(
      element: this,
      typeArguments: typeArguments,
      nullabilitySuffix: nullabilitySuffix,
    );

    if (typeArguments.isEmpty) {
      switch (nullabilitySuffix) {
        case NullabilitySuffix.none:
          _nonNullableInstance = result;
        case NullabilitySuffix.question:
          _nullableInstance = result;
        case NullabilitySuffix.star:
          // TODO(scheglov): remove together with `star`
          break;
      }
    }

    return result;
  }

  @override
  @trackedIndirectly
  MethodElement? lookUpConcreteMethod(
    String methodName,
    LibraryElement library,
  ) {
    return _implementationsOfMethod(methodName).firstWhereOrNull(
      (method) => !method.isAbstract && method.isAccessibleIn(library),
    );
  }

  @trackedIndirectly
  PropertyAccessorElement? lookUpInheritedConcreteGetter(
    String getterName,
    LibraryElement library,
  ) {
    return _implementationsOfGetter(getterName).firstWhereOrNull(
      (getter) =>
          !getter.isAbstract &&
          !getter.isStatic &&
          getter.isAccessibleIn(library) &&
          getter.enclosingElement != this,
    );
  }

  @trackedIndirectly
  MethodElement? lookUpInheritedConcreteMethod(
    String methodName,
    LibraryElement library,
  ) {
    return _implementationsOfMethod(methodName).firstWhereOrNull(
      (method) =>
          !method.isAbstract &&
          !method.isStatic &&
          method.isAccessibleIn(library) &&
          method.enclosingElement != this,
    );
  }

  @trackedIndirectly
  PropertyAccessorElement? lookUpInheritedConcreteSetter(
    String setterName,
    LibraryElement library,
  ) {
    return _implementationsOfSetter(setterName).firstWhereOrNull(
      (setter) =>
          !setter.isAbstract &&
          !setter.isStatic &&
          setter.isAccessibleIn(library) &&
          setter.enclosingElement != this,
    );
  }

  @override
  @trackedDirectlyOpaque
  MethodElement? lookUpInheritedMethod({
    required String methodName,
    required LibraryElement library,
  }) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLookUpInheritedMethod,
      target: this,
      method: 'lookUpInheritedMethod',
    );
    return inheritanceManager
        .getInherited(this, Name.forLibrary(library, methodName))
        .tryCast();
  }

  /// Return the static getter with the [name], accessible to the [library].
  ///
  /// This method should be used only for error recovery during analysis,
  /// when instance access to a static class member, defined in this class,
  /// or a superclass.
  @trackedIndirectly
  InternalGetterElement? lookupStaticGetter(
    String name,
    LibraryElement library,
  ) {
    return _implementationsOfGetter(name)
        .firstWhereOrNull(
          (element) => element.isStatic && element.isAccessibleIn(library),
        )
        .tryCast();
  }

  /// Return the static method with the [name], accessible to the [library].
  ///
  /// This method should be used only for error recovery during analysis,
  /// when instance access to a static class member, defined in this class,
  /// or a superclass.
  @trackedIndirectly
  InternalMethodElement? lookupStaticMethod(
    String name,
    LibraryElement library,
  ) {
    return _implementationsOfMethod(name).firstWhereOrNull(
      (element) => element.isStatic && element.isAccessibleIn(library),
    );
  }

  /// Return the static setter with the [name], accessible to the [library].
  ///
  /// This method should be used only for error recovery during analysis,
  /// when instance access to a static class member, defined in this class,
  /// or a superclass.
  @trackedIndirectly
  InternalSetterElement? lookupStaticSetter(
    String name,
    LibraryElement library,
  ) {
    return _implementationsOfSetter(name)
        .firstWhereOrNull(
          (element) => element.isStatic && element.isAccessibleIn(library),
        )
        .tryCast();
  }

  @trackedInternal
  void resetCachedAllSupertypes() {
    _allSupertypes = null;
  }

  /// Builds constructors for this mixin application.
  void _buildMixinAppConstructors() {}
}

abstract class InterfaceFragmentImpl extends InstanceFragmentImpl
    implements InterfaceFragment {
  List<ConstructorFragmentImpl> _constructors = _Sentinel.constructorFragment;

  /// Start index in the element's `mixins` for this fragment's `with` clause.
  int withClauseMixinStartIndex = 0;

  /// Initialize a newly created class element to have the given [name] at the
  /// given [offset] in the file that contains the declaration of this element.
  InterfaceFragmentImpl({required super.name});

  @override
  List<FragmentImpl> get children => [
    ...constructors,
    ...fields,
    ...getters,
    ...methods,
    ...setters,
    ...typeParameters,
  ];

  @override
  List<ConstructorFragmentImpl> get constructors {
    element.ensureReadMembers();
    if (!identical(_constructors, _Sentinel.constructorFragment)) {
      return _constructors;
    }

    // This will also create constructor fragments.
    element._buildMixinAppConstructors();
    return _constructors;
  }

  set constructors(List<ConstructorFragmentImpl> constructors) {
    for (var constructor in constructors) {
      constructor.enclosingFragment = this;
    }
    _constructors = constructors;
  }

  @override
  String get displayName => name ?? '';

  @override
  InterfaceElementImpl get element;

  @override
  InterfaceFragmentImpl? get nextFragment {
    return super.nextFragment as InterfaceFragmentImpl?;
  }

  @override
  InterfaceFragmentImpl? get previousFragment {
    return super.previousFragment as InterfaceFragmentImpl?;
  }

  void addConstructor(ConstructorFragmentImpl fragment) {
    if (identical(_constructors, _Sentinel.constructorFragment)) {
      _constructors = [];
    }
    _constructors.add(fragment);
    fragment.enclosingFragment = this;
  }
}

mixin InternalConstructorElement on InternalExecutableElement
    implements ConstructorElement {
  @override
  ConstructorElementImpl get baseElement;

  @override
  InterfaceElementImpl get enclosingElement;

  @override
  ConstructorFragmentImpl get firstFragment;

  /// The location of [firstFragment], without recording opaque requirement.
  @trackedIncludedInId
  FirstFragmentLocation get firstFragmentLocation;

  @override
  List<ConstructorFragmentImpl> get fragments;

  @override
  LibraryElementImpl get library;

  @override
  InternalConstructorElement? get redirectedConstructor;

  @override
  InterfaceTypeImpl get returnType;

  @override
  InternalConstructorElement? get superConstructor;

  @override
  InternalConstructorElement substitute(MapSubstitution substitution);
}

mixin InternalExecutableElement implements ExecutableElement {
  @override
  ExecutableElementImpl get baseElement;

  @override
  ExecutableFragmentImpl get firstFragment;

  @override
  List<InternalFormalParameterElement> get formalParameters;

  @override
  List<ExecutableFragmentImpl> get fragments;

  @override
  MetadataImpl get metadata;

  @override
  TypeImpl get returnType;

  @override
  FunctionTypeImpl get type;

  @override
  List<TypeParameterElementImpl> get typeParameters;

  /// Returns this executable element with the given [substitution] applied.
  InternalExecutableElement substitute(MapSubstitution substitution);
}

mixin InternalFieldElement on InternalPropertyInducingElement
    implements FieldElement {
  @override
  FieldElementImpl get baseElement;

  @override
  FieldFragmentImpl get firstFragment;

  @override
  List<FieldFragmentImpl> get fragments;

  /// Returns this field with the given [substitution] applied.
  InternalFieldElement substitute(MapSubstitution substitution);
}

mixin InternalFieldFormalParameterElement on InternalFormalParameterElement
    implements FieldFormalParameterElement {
  @override
  FieldFormalParameterElementImpl get baseElement;

  @override
  FormalParameterDeclarationForm get declarationForm {
    return FormalParameterDeclarationForm.fieldFormal;
  }
}

mixin InternalFormalParameterElement on InternalVariableElement
    implements FormalParameterElement, SharedNamedFunctionParameter {
  @override
  FormalParameterElementImpl get baseElement;

  FormalParameterDeclarationForm get declarationForm {
    return FormalParameterDeclarationForm.regular;
  }

  @override
  FormalParameterFragmentImpl get firstFragment;

  @override
  List<FormalParameterFragmentImpl> get fragments;

  ParameterKind get parameterKind;

  @override
  TypeImpl get type;

  @Deprecated('Use the function type of this parameter instead')
  @override
  void appendToWithoutDelimiters(StringBuffer buffer) {
    buffer.write(type.getDisplayString());
    buffer.write(' ');
    buffer.write(displayName);
    if (defaultValueCode != null) {
      buffer.write(' = ');
      buffer.write(defaultValueCode);
    }
  }

  /// Returns this formal parameter with the given [substitution] applied.
  InternalFormalParameterElement substitute(MapSubstitution substitution);
}

mixin InternalGetterElement on InternalPropertyAccessorElement
    implements GetterElement {
  @override
  GetterElementImpl get baseElement;

  @override
  GetterFragmentImpl get firstFragment;

  @override
  List<GetterFragmentImpl> get fragments;

  @override
  InternalGetterElement substitute(MapSubstitution substitution);
}

mixin InternalMethodElement on InternalExecutableElement
    implements MethodElement {
  @override
  MethodElementImpl get baseElement;

  @override
  MethodFragmentImpl get firstFragment;

  @override
  List<MethodFragmentImpl> get fragments;

  @override
  InternalMethodElement substitute(MapSubstitution substitution);
}

mixin InternalPropertyAccessorElement on InternalExecutableElement
    implements PropertyAccessorElement {
  @override
  PropertyAccessorElementImpl get baseElement;

  @override
  PropertyAccessorFragmentImpl get firstFragment;

  @override
  List<PropertyAccessorFragmentImpl> get fragments;

  @override
  InternalPropertyInducingElement get variable;
}

mixin InternalPropertyInducingElement on InternalVariableElement
    implements PropertyInducingElement {
  @override
  PropertyInducingElementImpl get baseElement;

  @override
  PropertyInducingFragmentImpl get firstFragment;

  @override
  List<PropertyInducingFragmentImpl> get fragments;

  @override
  InternalGetterElement? get getter;

  @override
  LibraryElementImpl get library;

  @override
  MetadataImpl get metadata;

  @override
  InternalSetterElement? get setter;
}

mixin InternalSetterElement on InternalPropertyAccessorElement
    implements SetterElement {
  @override
  SetterElementImpl get baseElement;

  @override
  SetterFragmentImpl get firstFragment;

  @override
  List<SetterFragmentImpl> get fragments;

  @override
  InternalSetterElement substitute(MapSubstitution substitution);
}

mixin InternalSuperFormalParameterElement on InternalFormalParameterElement
    implements SuperFormalParameterElement {
  @override
  SuperFormalParameterElementImpl get baseElement;

  @override
  FormalParameterDeclarationForm get declarationForm {
    return FormalParameterDeclarationForm.superFormal;
  }

  @override
  InternalFormalParameterElement? get superConstructorParameter;
}

mixin InternalVariableElement implements VariableElement {
  @override
  VariableFragmentImpl get firstFragment;

  @override
  List<VariableFragmentImpl> get fragments;

  @override
  MetadataImpl get metadata;

  @override
  TypeImpl get type;
}

class JoinPatternVariableElementImpl extends PatternVariableElementImpl
    implements JoinPatternVariableElement {
  JoinPatternVariableElementImpl(super.firstFragment);

  @override
  JoinPatternVariableFragmentImpl get firstFragment => _firstFragment;

  @override
  List<JoinPatternVariableFragmentImpl> get fragments {
    return [
      for (
        JoinPatternVariableFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  shared.JoinedPatternVariableInconsistency get inconsistency =>
      _firstFragment.inconsistency;

  set inconsistency(shared.JoinedPatternVariableInconsistency value) =>
      _firstFragment.inconsistency = value;

  @override
  bool get isConsistent {
    return _firstFragment.inconsistency ==
        shared.JoinedPatternVariableInconsistency.none;
  }

  set isFinal(bool value) => _firstFragment.isFinal = value;

  /// The name tokens that reference this element.
  List<Token> get references => _firstFragment.references;

  /// Returns this variable, and variables that join into it.
  List<PatternVariableElementImpl> get transitiveVariables {
    var result = <PatternVariableElementImpl>[];

    void append(PatternVariableElementImpl variable) {
      result.add(variable);
      if (variable is JoinPatternVariableElementImpl) {
        for (var variable in variable.variables) {
          append(variable);
        }
      }
    }

    append(this);
    return result;
  }

  @override
  List<PatternVariableElementImpl> get variables =>
      _firstFragment.variables.map((fragment) => fragment.element).toList();

  @override
  JoinPatternVariableFragmentImpl get _firstFragment =>
      super._firstFragment as JoinPatternVariableFragmentImpl;
}

class JoinPatternVariableFragmentImpl extends PatternVariableFragmentImpl
    implements JoinPatternVariableFragment {
  /// The variables that join into this variable.
  final List<PatternVariableFragmentImpl> variables;

  shared.JoinedPatternVariableInconsistency inconsistency;

  /// The name tokens that reference this element.
  final List<Token> references = [];

  JoinPatternVariableFragmentImpl({
    required super.name,
    required super.firstTokenOffset,
    required this.variables,
    required this.inconsistency,
  }) {
    for (var component in variables) {
      component.join = this;
    }
  }

  @override
  JoinPatternVariableElementImpl get element =>
      super.element as JoinPatternVariableElementImpl;

  @override
  JoinPatternVariableFragmentImpl? get nextFragment =>
      super.nextFragment as JoinPatternVariableFragmentImpl?;

  @override
  int get offset => variables[0].offset;

  @override
  JoinPatternVariableFragmentImpl? get previousFragment =>
      super.previousFragment as JoinPatternVariableFragmentImpl?;

  /// Returns this variable, and variables that join into it.
  List<PatternVariableFragmentImpl> get transitiveVariables {
    var result = <PatternVariableFragmentImpl>[];

    void append(PatternVariableFragmentImpl variable) {
      result.add(variable);
      if (variable is JoinPatternVariableFragmentImpl) {
        for (var variable in variable.variables) {
          append(variable);
        }
      }
    }

    append(this);
    return result;
  }
}

class LabelElementImpl extends ElementImpl implements LabelElement {
  @override
  final LabelFragmentImpl _firstFragment;

  LabelElementImpl(this._firstFragment);

  @override
  LabelElement get baseElement => this;

  @override
  ExecutableElement? get enclosingElement => null;

  @override
  LabelFragmentImpl get firstFragment => _firstFragment;

  @override
  List<LabelFragmentImpl> get fragments {
    return [_firstFragment];
  }

  /// Return `true` if this label is associated with a `switch` member (`case`
  /// or `default`).
  bool get isOnSwitchMember => _firstFragment.isOnSwitchMember;

  @override
  ElementKind get kind => ElementKind.LABEL;

  @override
  LibraryElementImpl get library => super.library!;

  @override
  String? get name => _firstFragment.name;

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return visitor.visitLabelElement(this);
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeLabelElement(this);
  }

  @override
  void visitChildren<T>(ElementVisitor2<T> visitor) {}
}

class LabelFragmentImpl extends FragmentImpl implements LabelFragment {
  @override
  late final LabelElementImpl element = LabelElementImpl(this);

  @override
  final String? name;

  /// A flag indicating whether this label is associated with a `switch` member
  /// (`case` or `default`).
  // TODO(brianwilkerson): Make this a modifier.
  final bool _onSwitchMember;

  /// Initialize a newly created label element to have the given [name].
  /// [_onSwitchMember] should be `true` if this label is associated with a
  /// `switch` member.
  LabelFragmentImpl({
    required this.name,
    required super.firstTokenOffset,
    required bool onSwitchMember,
  }) : _onSwitchMember = onSwitchMember;

  @override
  List<FragmentImpl> get children => const [];

  @override
  String get displayName => name ?? '';

  @override
  ExecutableFragmentImpl get enclosingFragment =>
      super.enclosingFragment as ExecutableFragmentImpl;

  @override
  int get firstTokenOffset => super.firstTokenOffset!;

  /// Return `true` if this label is associated with a `switch` member (`case`
  /// or `default`).
  bool get isOnSwitchMember => _onSwitchMember;

  @override
  LibraryFragmentImpl get libraryFragment => enclosingUnit;

  @override
  // TODO(scheglov): make it a nullable field
  int? get nameOffset => firstTokenOffset;

  @override
  LabelFragmentImpl? get nextFragment => null;

  @override
  int get offset => firstTokenOffset;

  @override
  LabelFragmentImpl? get previousFragment => null;
}

/// A concrete implementation of [LibraryElement].
@elementClass
@GenerateElementFlags(flags: _LibraryElementFlags.values)
class LibraryElementImpl extends ElementImpl
    with DeferredResolutionReadingMixin
    implements LibraryElement {
  final AnalysisContext _context;

  @override
  @trackedIncludedInId
  LibraryReference? reference;

  MetadataImpl _metadata = MetadataImpl(const []);

  String? _documentationComment;

  AnalysisSessionImpl _session;

  /// The first (defining) fragment of this library.
  @override
  late LibraryFragmentImpl _firstFragment;

  /// The language version for the library.
  LibraryLanguageVersion? _languageVersion;

  @trackedInternal
  bool hasTypeProviderSystemSet = false;

  @override
  @trackedIndirectly
  late TypeProviderImpl typeProvider;

  @override
  @trackedIndirectly
  late TypeSystemImpl typeSystem;

  @trackedInternal
  late List<ExportEntry> exportEntries;

  /// The union of names for all searchable elements in this library.
  @trackedInternal
  ElementNameUnion nameUnion = ElementNameUnion.empty();

  final FeatureSet _featureSet;

  /// The entry point for this library, or `null` if this library does not have
  /// an entry point.
  TopLevelFunctionElementImpl? _entryPoint;

  /// The provider for the synthetic function `loadLibrary` that is defined
  /// for this library.
  @trackedInternal
  late final LoadLibraryFunctionProvider loadLibraryProvider;

  String _name;
  int _nameOffset;
  int _nameLength;

  List<ClassElementImpl> _classes = [];
  List<EnumElementImpl> _enums = [];
  List<ExtensionElementImpl> _extensions = [];
  List<ExtensionTypeElementImpl> _extensionTypes = [];
  List<GetterElementImpl> _getters = [];
  List<SetterElementImpl> _setters = [];
  List<MixinElementImpl> _mixins = [];
  List<TopLevelFunctionElementImpl> _topLevelFunctions = [];
  List<TopLevelVariableElementImpl> _topLevelVariables = [];
  List<TypeAliasElementImpl> _typeAliases = [];

  /// The export [Namespace] of this library, `null` if it has not been
  /// computed yet.
  Namespace? _exportNamespace;

  /// The public [Namespace] of this library, `null` if it has not been
  /// computed yet.
  Namespace? _publicNamespace;

  /// Information about why non-promotable private fields in the library are not
  /// promotable.
  ///
  /// See [fieldNameNonPromotabilityInfo].
  Map<String, FieldNameNonPromotabilityInfo>? _fieldNameNonPromotabilityInfo;

  /// The map of top-level declarations, from all units.
  LibraryDeclarations? _libraryDeclarations;

  /// With fine-grained dependencies, the manifest of the library.
  @trackedInternal
  LibraryManifestHandle? manifest;

  @trackedInternal
  LibraryElementRequirementState requirementState =
      LibraryElementRequirementState();

  @trackedInternal
  late final LibraryElementImplInternal internal = LibraryElementImplInternal(
    this,
  );

  /// Initialize a newly created library element in the given [context] to have
  /// the given [name] and [nameOffset].
  LibraryElementImpl(
    this._context,
    this._session,
    this._name,
    this._nameOffset,
    this._nameLength,
    this._featureSet,
  );

  @override
  @trackedIncludedInId
  LibraryElementImpl get baseElement => this;

  @override
  @trackedIndirectly
  List<ElementImpl> get children {
    return [
      ...classes,
      ...enums,
      ...extensions,
      ...extensionTypes,
      ...getters,
      ...mixins,
      ...setters,
      ...topLevelFunctions,
      ...topLevelVariables,
      ...typeAliases,
    ];
  }

  @override
  @trackedDirectlyExpensive
  List<ClassElementImpl> get classes {
    globalResultRequirements?.record_library_allClasses(element: this);
    return _classes;
  }

  set classes(List<ClassElementImpl> value) {
    _classes = value;
  }

  @trackedDirectlyOpaque
  AnalysisContext get context {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueContext,
      target: this,
      method: 'context',
    );
    return _context;
  }

  @trackedIncludedInId
  DeclaredVariables get declaredVariables {
    return _context.declaredVariables;
  }

  @override
  @trackedDirectlyOpaque
  String? get documentationComment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueDocumentationComment,
      target: this,
      method: 'documentationComment',
    );
    return _documentationComment;
  }

  set documentationComment(String? value) {
    _documentationComment = value;
  }

  @override
  @trackedIncludedInId
  Null get enclosingElement => null;

  @override
  @trackedDirectly
  TopLevelFunctionElementImpl? get entryPoint {
    _ensureReadResolution();
    globalResultRequirements?.record_library_entryPoint(element: this);
    return _entryPoint;
  }

  set entryPoint(TopLevelFunctionElementImpl? value) {
    _entryPoint = value;
  }

  @override
  @trackedDirectlyExpensive
  List<EnumElementImpl> get enums {
    globalResultRequirements?.record_library_allEnums(element: this);
    return _enums;
  }

  set enums(List<EnumElementImpl> value) {
    _enums = value;
  }

  @override
  @trackedDirectly
  List<LibraryElementImpl> get exportedLibraries {
    globalResultRequirements?.record_library_exportedLibraries(element: this);
    return _fragments
        .expand((fragment) => fragment.libraryExports)
        .map((export) => export.exportedLibrary)
        .nonNulls
        .toSet()
        .toList();
  }

  @override
  @trackedDirectly
  Namespace get exportNamespace {
    _ensureReadResolution();
    return RecordingExportNamespace(
      owner: this,
      base: _exportNamespace ??= Namespace({}),
    );
  }

  set exportNamespace(Namespace exportNamespace) {
    _exportNamespace = exportNamespace;
  }

  @override
  @trackedDirectlyExpensive
  List<ExtensionElementImpl> get extensions {
    globalResultRequirements?.record_library_allExtensions(element: this);
    return _extensions;
  }

  set extensions(List<ExtensionElementImpl> value) {
    _extensions = value;
  }

  @override
  @trackedDirectlyExpensive
  List<ExtensionTypeElementImpl> get extensionTypes {
    globalResultRequirements?.record_library_allExtensionTypes(element: this);
    return _extensionTypes;
  }

  set extensionTypes(List<ExtensionTypeElementImpl> value) {
    _extensionTypes = value;
  }

  @override
  @trackedDirectly
  FeatureSet get featureSet {
    globalResultRequirements?.record_library_featureSet(element: this);
    return _featureSet;
  }

  /// Information about why non-promotable private fields in the library are not
  /// promotable.
  ///
  /// If field promotion is not enabled in this library, this field is still
  /// populated, so that the analyzer can figure out whether enabling field
  /// promotion would cause a field to be promotable.
  ///
  /// There are two ways an access to a private property name might not be
  /// promotable: the property might be non-promotable for a reason inherent to
  /// itself (e.g. it's declared as a concrete getter rather than a field, or
  /// it's a non-final field), or the property might have the same name as an
  /// inherently non-promotable property elsewhere in the same library (in which
  /// case the inherently non-promotable property is said to be "conflicting").
  ///
  /// When a compile-time error occurs because a property is non-promotable due
  /// conflicting properties elsewhere in the library, the analyzer needs to be
  /// able to find the conflicting properties in order to generate context
  /// messages. This data structure allows that, by mapping each non-promotable
  /// private name to the set of conflicting declarations.
  ///
  /// If a field in the library has a private name and that name does not appear
  /// as a key in this map, the field is promotable.
  @trackedDirectlyOpaque
  Map<String, FieldNameNonPromotabilityInfo> get fieldNameNonPromotabilityInfo {
    _ensureReadResolution();
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFieldNameNonPromotabilityInfo,
      target: this,
      method: 'fieldNameNonPromotabilityInfo',
    );
    return _fieldNameNonPromotabilityInfo!;
  }

  set fieldNameNonPromotabilityInfo(
    Map<String, FieldNameNonPromotabilityInfo>? value,
  ) {
    _fieldNameNonPromotabilityInfo = value;
  }

  @override
  @trackedDirectlyOpaque
  LibraryFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  set firstFragment(LibraryFragmentImpl value) {
    _firstFragment = value;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {...super.flagsForTesting, 'isSynthetic': isSynthetic};
  }

  @override
  @trackedDirectlyOpaque
  List<LibraryFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedDirectlyExpensive
  List<GetterElementImpl> get getters {
    globalResultRequirements?.record_library_allGetters(element: this);
    return _getters;
  }

  set getters(List<GetterElementImpl> value) {
    _getters = value;
  }

  @override
  @trackedIndirectly
  String get identifier => '$uri';

  @override
  @trackedIndirectly
  bool get isDartAsync => name == "dart.async";

  @override
  @trackedIndirectly
  bool get isDartCore => name == "dart.core";

  @override
  @trackedIndirectly
  bool get isInSdk {
    return DartUriResolver.isDartUri(uri);
  }

  @trackedIndirectly
  bool get isInternalSdkLibrary {
    return '$uri'.startsWith('dart:_');
  }

  @override
  @trackedDirectly
  bool get isOriginNotExistingFile {
    globalResultRequirements?.record_library_isOriginNotExistingFile(
      element: this,
    );
    return _firstFragment.isOriginNotExistingFile;
  }

  @generated
  @trackedInternal
  bool get isSynthetic {
    return hasFlag(_ElementStorageFlag.libraryElement_isSynthetic);
  }

  @generated
  set isSynthetic(bool value) {
    setFlag(_ElementStorageFlag.libraryElement_isSynthetic, value);
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.LIBRARY;

  @override
  @trackedDirectly
  LibraryLanguageVersion get languageVersion {
    globalResultRequirements?.record_library_languageVersion(element: this);
    return _languageVersion ??= LibraryLanguageVersion(
      package: ExperimentStatus.currentVersion,
      override: null,
    );
  }

  set languageVersion(LibraryLanguageVersion languageVersion) {
    _languageVersion = languageVersion;
  }

  @override
  @trackedIncludedInId
  LibraryElementImpl get library => this;

  @trackedInternal
  LibraryDeclarations get libraryDeclarations {
    return _libraryDeclarations ??= LibraryDeclarations(this);
  }

  @override
  @trackedIndirectly
  TopLevelFunctionElementImpl get loadLibraryFunction {
    return loadLibraryProvider.getElement(this);
  }

  @override
  @trackedIncludedInId
  String? get lookupName => null;

  @override
  @trackedDirectly
  MetadataImpl get metadata {
    _ensureReadResolution();
    globalResultRequirements?.record_library_metadata(element: this);
    return _metadata;
  }

  set metadata(MetadataImpl value) {
    _metadata = value;
  }

  @override
  @trackedDirectlyExpensive
  List<MixinElementImpl> get mixins {
    globalResultRequirements?.record_library_allMixins(element: this);
    return _mixins;
  }

  set mixins(List<MixinElementImpl> value) {
    _mixins = value;
  }

  @override
  @trackedDirectly
  String get name {
    globalResultRequirements?.record_library_getName(element: this);
    return _name;
  }

  set name(String name) {
    _name = name;
  }

  @trackedDirectlyOpaque
  int get nameLength {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueNameLength,
      target: this,
      method: 'nameLength',
    );
    return _nameLength;
  }

  set nameLength(int nameLength) {
    _nameLength = nameLength;
  }

  @trackedDirectlyOpaque
  int get nameOffset {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueNameOffset,
      target: this,
      method: 'nameOffset',
    );
    return _nameOffset;
  }

  set nameOffset(int nameOffset) {
    _nameOffset = nameOffset;
  }

  @override
  @trackedIncludedInId
  LibraryElementImpl get nonSynthetic => this;

  @override
  @trackedDirectlyOpaque
  Namespace get publicNamespace {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaquePublicNamespace,
      target: this,
      method: 'publicNamespace',
    );
    return _publicNamespace ??= NamespaceBuilder()
        .createPublicNamespaceForLibrary(this);
  }

  set publicNamespace(Namespace publicNamespace) {
    _publicNamespace = publicNamespace;
  }

  @override
  @trackedDirectlyOpaque
  AnalysisSessionImpl get session {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueSession,
      target: this,
      method: 'session',
    );
    return _session;
  }

  set session(AnalysisSessionImpl value) {
    _session = value;
  }

  @override
  @trackedDirectlyExpensive
  List<SetterElementImpl> get setters {
    globalResultRequirements?.record_library_allSetters(element: this);
    return _setters;
  }

  set setters(List<SetterElementImpl> value) {
    _setters = value;
  }

  // TODO(scheglov): prefer `firstFragment.source`
  @trackedIncludedInId
  Source get source {
    return _firstFragment.source;
  }

  @override
  @trackedDirectlyExpensive
  List<TopLevelFunctionElementImpl> get topLevelFunctions {
    globalResultRequirements?.record_library_allTopLevelFunctions(
      element: this,
    );
    return _topLevelFunctions;
  }

  set topLevelFunctions(List<TopLevelFunctionElementImpl> value) {
    _topLevelFunctions = value;
  }

  @override
  @trackedDirectlyExpensive
  List<TopLevelVariableElementImpl> get topLevelVariables {
    globalResultRequirements?.record_library_allTopLevelVariables(
      element: this,
    );
    return _topLevelVariables;
  }

  set topLevelVariables(List<TopLevelVariableElementImpl> value) {
    _topLevelVariables = value;
  }

  @override
  @trackedDirectlyExpensive
  List<TypeAliasElementImpl> get typeAliases {
    globalResultRequirements?.record_library_allTypeAliases(element: this);
    return _typeAliases;
  }

  set typeAliases(List<TypeAliasElementImpl> value) {
    _typeAliases = value;
  }

  @override
  @trackedIncludedInId
  Uri get uri => _firstFragment.source.uri;

  List<LibraryFragmentImpl> get _fragments {
    return [_firstFragment, ..._partUnits];
  }

  List<LibraryFragmentImpl> get _partUnits {
    var result = <LibraryFragmentImpl>[];

    void visitParts(LibraryFragmentImpl unit) {
      for (var part in unit.parts) {
        if (part.uri case DirectiveUriWithUnitImpl uri) {
          var unit = uri.libraryFragment;
          result.add(unit);
          visitParts(unit);
        }
      }
    }

    visitParts(_firstFragment);
    return result;
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitLibraryElement(this);
  }

  @trackedInternal
  void addClass(ClassElementImpl element) {
    _classes.add(element);
  }

  @trackedInternal
  void addEnum(EnumElementImpl element) {
    _enums.add(element);
  }

  @trackedInternal
  void addExtension(ExtensionElementImpl element) {
    _extensions.add(element);
  }

  @trackedInternal
  void addExtensionType(ExtensionTypeElementImpl element) {
    _extensionTypes.add(element);
  }

  @trackedInternal
  void addGetter(GetterElementImpl element) {
    _getters.add(element);
  }

  @trackedInternal
  void addMixin(MixinElementImpl element) {
    _mixins.add(element);
  }

  @trackedInternal
  void addSetter(SetterElementImpl element) {
    _setters.add(element);
  }

  @trackedInternal
  void addTopLevelFunction(TopLevelFunctionElementImpl element) {
    _topLevelFunctions.add(element);
  }

  @trackedInternal
  void addTopLevelVariable(TopLevelVariableElementImpl element) {
    _topLevelVariables.add(element);
  }

  @trackedInternal
  void addTypeAlias(TypeAliasElementImpl element) {
    _typeAliases.add(element);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeLibraryElement(this);
  }

  @override
  @trackedDirectly
  ClassElementImpl? getClass(String name) {
    globalResultRequirements?.record_library_getClass(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(classes, name);
    });
  }

  @override
  @trackedDirectly
  EnumElementImpl? getEnum(String name) {
    globalResultRequirements?.record_library_getEnum(element: this, name: name);

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(enums, name);
    });
  }

  @override
  @trackedIndirectly
  String getExtendedDisplayName({String? shortName}) {
    shortName ??= displayName;
    var source = this.source;
    return "$shortName (${source.fullName})";
  }

  @override
  @trackedDirectly
  ExtensionElementImpl? getExtension(String name) {
    globalResultRequirements?.record_library_getExtension(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(extensions, name);
    });
  }

  @override
  @trackedDirectly
  ExtensionTypeElementImpl? getExtensionType(String name) {
    globalResultRequirements?.record_library_getExtensionType(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(extensionTypes, name);
    });
  }

  @override
  @trackedDirectly
  GetterElement? getGetter(String name) {
    globalResultRequirements?.record_library_getGetter(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(getters, name);
    });
  }

  @override
  @trackedDirectly
  MixinElementImpl? getMixin(String name) {
    globalResultRequirements?.record_library_getMixin(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(mixins, name);
    });
  }

  @override
  @trackedDirectly
  SetterElement? getSetter(String name) {
    globalResultRequirements?.record_library_getSetter(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(setters, name);
    });
  }

  @override
  @trackedDirectly
  TopLevelFunctionElement? getTopLevelFunction(String name) {
    globalResultRequirements?.record_library_getTopLevelFunction(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(topLevelFunctions, name);
    });
  }

  @override
  @trackedDirectly
  TopLevelVariableElement? getTopLevelVariable(String name) {
    globalResultRequirements?.record_library_getTopLevelVariable(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(topLevelVariables, name);
    });
  }

  @override
  @trackedDirectly
  TypeAliasElement? getTypeAlias(String name) {
    globalResultRequirements?.record_library_getTypeAlias(
      element: this,
      name: name,
    );

    return globalResultRequirements.alreadyRecorded(() {
      return _getElementByName(typeAliases, name);
    });
  }

  @override
  @trackedIncludedInId
  bool isAccessibleIn(LibraryElement library) {
    return true;
  }

  /// Return `true` if [entry] comes only from deprecated exports.
  @trackedInternal
  bool isFromDeprecatedExport(ExportEntry entry) {
    if (entry.isReExported) {
      for (var location in entry.locations) {
        var fragment = _fragmentAt(location.fragmentIndex);
        var export = fragment.libraryExports[location.exportIndex];
        if (!export.metadata.hasDeprecated) {
          return false;
        }
      }
      return true;
    }
    return false;
  }

  @trackedInternal
  void recordGetDeclaredClass(String name) {
    globalResultRequirements?.record_library_getClass(
      element: this,
      name: name,
    );
  }

  @trackedInternal
  void resetScope() {
    _libraryDeclarations = null;
    for (var fragment in fragments) {
      fragment._scope = null;
    }
  }

  @override
  @trackedIncludedInId
  LibraryElementImpl? thisOrAncestorMatching(bool Function(Element) predicate) {
    return predicate(this) ? this : null;
  }

  @override
  @trackedIncludedInId
  E? thisOrAncestorOfType<E extends Element>() {
    return E is LibraryElement ? this as E : null;
  }

  @override
  @trackedDirectlyOpaque
  void visitChildren<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueVisitChildren,
      target: this,
      method: 'visitChildren',
    );
    for (var child in children) {
      child.accept(visitor);
    }
  }

  /// Optimization of [_fragments] when using a single element.
  LibraryFragmentImpl _fragmentAt(int index) {
    return index == 0 ? _firstFragment : _partUnits[index - 1];
  }

  static T? _getElementByName<T extends Element>(
    List<T> elements,
    String name,
  ) {
    return elements.firstWhereOrNull((e) => e.name == name);
  }
}

/// Exposes [LibraryElementImpl] properties that normally are not intended
/// to be used during resolution, and would cause opaque API requirement
/// recorded, but necessary during the element model building or loading.
class LibraryElementImplInternal {
  final LibraryElementImpl _library;

  LibraryElementImplInternal(this._library);

  ClassHierarchy get classHierarchy {
    return _library._session.classHierarchy;
  }

  LinkedElementFactory get elementFactory {
    return _library._session.elementFactory;
  }

  LibraryFragmentImpl get firstFragment => _library._firstFragment;

  List<LibraryFragmentImpl> get fragments => _library._fragments;

  InheritanceManager3 get inheritanceManager {
    return _library._session.inheritanceManager;
  }

  List<Uri> allUnitSourceUris() {
    var unitUris = <Uri>{};

    void appendUnitUris(
      LibraryFragmentImpl? fragment,
      DirectiveUri? partDirectiveUri,
    ) {
      // We start with a fragment, but recurse with a directive URI.
      fragment =
          fragment ??
          (partDirectiveUri is DirectiveUriWithUnitImpl
              ? partDirectiveUri.libraryFragment
              : null);

      // If there is a `Source`, bundle reader will resolve its URI.
      // Even if there is no valid fragment for this source.
      Source source;
      if (fragment != null) {
        source = fragment.source;
      } else if (partDirectiveUri is DirectiveUriWithSourceImpl) {
        source = partDirectiveUri.source;
      } else {
        return;
      }

      if (!unitUris.add(source.uri)) {
        return;
      }

      // If we have a fragment (usually), recurse into parts.
      if (fragment != null) {
        for (var partInclude in fragment.partIncludes) {
          appendUnitUris(null, partInclude.uri);
        }
      }
    }

    appendUnitUris(_library._firstFragment, null);
    return unitUris.toList();
  }
}

class LibraryExportImpl extends ElementDirectiveImpl implements LibraryExport {
  @override
  final List<NamespaceCombinator> combinators;

  @override
  int exportKeywordOffset;

  LibraryExportImpl({
    required super.uri,
    required this.combinators,
    required this.exportKeywordOffset,
  });

  @override
  LibraryElementImpl? get exportedLibrary {
    if (uri case DirectiveUriWithLibraryImpl uri) {
      return uri.library;
    }
    return null;
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeLibraryExport(this);
  }
}

/// A concrete implementation of [LibraryFragment].
@GenerateElementFlags(flags: _LibraryElementFlags.values)
class LibraryFragmentImpl extends FragmentImpl
    with DeferredResolutionReadingMixin
    implements LibraryFragment {
  @override
  final Source source;

  @override
  LineInfo lineInfo;

  final LibraryElementImpl library;

  /// The libraries exported by this unit.
  List<LibraryExportImpl> _libraryExports = _Sentinel.libraryExport;

  /// The libraries imported by this unit.
  List<LibraryImportImpl> _libraryImports = _Sentinel.libraryImport;

  /// The cached list of prefixes from [prefixes].
  List<PrefixElementImpl>? _libraryImportPrefixes;

  /// Library import prefix elements keyed by their fragment-local id.
  final Map<String, PrefixElementImpl> _libraryImportPrefixesById = {};

  /// The parts included by this unit.
  List<PartIncludeImpl> _parts = const <PartIncludeImpl>[];

  /// All top-level getters in this compilation unit.
  List<GetterFragmentImpl> _getters = _Sentinel.getterFragment;

  /// All top-level setters in this compilation unit.
  List<SetterFragmentImpl> _setters = _Sentinel.setterFragment;

  List<ClassFragmentImpl> _classes = _Sentinel.classFragment;

  /// A list containing all of the enums contained in this compilation unit.
  List<EnumFragmentImpl> _enums = _Sentinel.enumFragment;

  /// A list containing all of the extensions contained in this compilation
  /// unit.
  List<ExtensionFragmentImpl> _extensions = _Sentinel.extensionFragment;

  List<ExtensionTypeFragmentImpl> _extensionTypes =
      _Sentinel.extensionTypeFragment;

  /// A list containing all of the top-level functions contained in this
  /// compilation unit.
  List<TopLevelFunctionFragmentImpl> _functions =
      _Sentinel.topLevelFunctionFragment;

  List<MixinFragmentImpl> _mixins = _Sentinel.mixinFragment;

  /// A list containing all of the type aliases contained in this compilation
  /// unit.
  List<TypeAliasFragmentImpl> _typeAliases = _Sentinel.typeAliasFragment;

  /// A list containing all of the variables contained in this compilation unit.
  List<TopLevelVariableFragmentImpl> _variables =
      _Sentinel.topLevelVariableFragment;

  /// The scope of this fragment, `null` if it has not been created yet.
  LibraryFragmentScope? _scope;

  LibraryFragmentImpl({
    required this.library,
    required this.source,
    required this.lineInfo,
  }) : super(firstTokenOffset: 0);

  @override
  List<ExtensionElement> get accessibleExtensions {
    return scope.accessibleExtensions;
  }

  List<PropertyAccessorFragmentImpl> get accessors {
    return [...getters, ...setters];
  }

  @override
  List<FragmentImpl> get children {
    return [
      ...classes,
      ...enums,
      ...extensions,
      ...extensionTypes,
      ...functions,
      ...getters,
      ...mixins,
      ...setters,
      ...typeAliases,
      ...topLevelVariables,
    ];
  }

  @override
  List<ClassFragmentImpl> get classes => _classes;

  /// Set the classes contained in this compilation unit to [classes].
  set classes(List<ClassFragmentImpl> classes) {
    for (var class_ in classes) {
      class_.enclosingFragment = this;
    }
    _classes = classes;
  }

  @override
  LibraryElementImpl get element => library;

  @override
  LibraryFragmentImpl? get enclosingFragment =>
      super.enclosingFragment as LibraryFragmentImpl?;

  @override
  LibraryFragmentImpl get enclosingUnit {
    return this;
  }

  @override
  List<EnumFragmentImpl> get enums => _enums;

  /// Set the enums contained in this compilation unit to the given [enums].
  set enums(List<EnumFragmentImpl> enums) {
    for (var fragment in enums) {
      fragment.enclosingFragment = this;
    }
    _enums = enums;
  }

  @override
  List<ExtensionFragmentImpl> get extensions => _extensions;

  /// Set the extensions contained in this compilation unit to the given
  /// [extensions].
  set extensions(List<ExtensionFragmentImpl> extensions) {
    for (var extension in extensions) {
      extension.enclosingFragment = this;
    }
    _extensions = extensions;
  }

  @override
  List<ExtensionTypeFragmentImpl> get extensionTypes => _extensionTypes;

  set extensionTypes(List<ExtensionTypeFragmentImpl> fragments) {
    for (var fragment in fragments) {
      fragment.enclosingFragment = this;
    }
    _extensionTypes = fragments;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginNotExistingFile': isOriginNotExistingFile,
    };
  }

  @override
  List<TopLevelFunctionFragmentImpl> get functions {
    return _functions;
  }

  /// Set the top-level functions contained in this compilation unit to the
  ///  given[functions].
  set functions(List<TopLevelFunctionFragmentImpl> functions) {
    for (var function in functions) {
      function.enclosingFragment = this;
    }
    _functions = functions;
  }

  @override
  List<GetterFragmentImpl> get getters => _getters;

  set getters(List<GetterFragmentImpl> getters) {
    for (var getter in getters) {
      getter.enclosingFragment = this;
    }
    _getters = getters;
  }

  @override
  int get hashCode => source.hashCode;

  @override
  List<LibraryElement> get importedLibraries {
    return libraryImports
        .map((import) => import.importedLibrary)
        .nonNulls
        .toSet()
        .toList();
  }

  @generated
  @override
  bool get isOriginNotExistingFile {
    return hasFlag(
      _FragmentStorageFlag.libraryFragment_isOriginNotExistingFile,
    );
  }

  @generated
  set isOriginNotExistingFile(bool value) {
    setFlag(
      _FragmentStorageFlag.libraryFragment_isOriginNotExistingFile,
      value,
    );
  }

  @override
  List<LibraryExportImpl> get libraryExports {
    _ensureReadResolution();
    return _libraryExports;
  }

  set libraryExports(List<LibraryExportImpl> exports) {
    for (var exportElement in exports) {
      exportElement.libraryFragment = this;
    }
    _libraryExports = exports;
  }

  @override
  LibraryFragmentImpl get libraryFragment => this;

  @override
  List<LibraryImportImpl> get libraryImports {
    _ensureReadResolution();
    return _libraryImports;
  }

  set libraryImports(List<LibraryImportImpl> imports) {
    for (var importElement in imports) {
      importElement.libraryFragment = this;
      importElement.prefix?.enclosingFragment = this;
    }
    _libraryImports = imports;
  }

  @override
  List<MixinFragmentImpl> get mixins => _mixins;

  /// Set the mixins contained in this compilation unit to the given [mixins].
  set mixins(List<MixinFragmentImpl> mixins) {
    for (var mixin_ in mixins) {
      mixin_.enclosingFragment = this;
    }
    _mixins = mixins;
  }

  @override
  String? get name => null;

  @override
  int? get nameOffset => null;

  @override
  LibraryFragmentImpl? get nextFragment {
    var fragments = library.fragments;
    var index = fragments.indexOf(this);
    return fragments.elementAtOrNull(index + 1);
  }

  @override
  int get offset {
    if (!identical(this, library.firstFragment)) {
      // Not the first fragment, so there is no name; return an offset of 0
      return 0;
    }
    if (library.nameOffset < 0) {
      // There is no name, so return an offset of 0
      return 0;
    }
    return library.nameOffset;
  }

  @override
  List<PartInclude> get partIncludes => parts.cast<PartInclude>();

  /// The parts included by this unit.
  List<PartIncludeImpl> get parts => _parts;

  set parts(List<PartIncludeImpl> parts) {
    for (var part in parts) {
      part.libraryFragment = this;
      if (part.uri case DirectiveUriWithUnitImpl uri) {
        uri.libraryFragment.enclosingFragment = this;
      }
    }
    _parts = parts;
  }

  @override
  List<PrefixElementImpl> get prefixes {
    return _libraryImportPrefixes ??= _buildLibraryImportPrefixes();
  }

  @override
  LibraryFragmentImpl? get previousFragment {
    var fragments = library.fragments;
    var index = fragments.indexOf(this);
    if (index >= 1) {
      return fragments[index - 1];
    }
    return null;
  }

  @override
  LibraryFragmentScope get scope {
    return _scope ??= LibraryFragmentScope(this);
  }

  @override
  List<SetterFragmentImpl> get setters => _setters;

  set setters(List<SetterFragmentImpl> setters) {
    for (var setter in setters) {
      setter.enclosingFragment = this;
    }
    _setters = setters;
  }

  @override
  List<TopLevelVariableFragmentImpl> get topLevelVariables => _variables;

  /// Set the top-level variables contained in this compilation unit to the
  ///  given[variables].
  set topLevelVariables(List<TopLevelVariableFragmentImpl> variables) {
    for (var variable in variables) {
      variable.enclosingFragment = this;
    }
    _variables = variables;
  }

  @override
  List<TypeAliasFragmentImpl> get typeAliases {
    return _typeAliases;
  }

  /// Set the type aliases contained in this compilation unit to [typeAliases].
  set typeAliases(List<TypeAliasFragmentImpl> typeAliases) {
    for (var typeAlias in typeAliases) {
      typeAlias.enclosingFragment = this;
    }
    _typeAliases = typeAliases;
  }

  void addClass(ClassFragmentImpl fragment) {
    if (identical(_classes, _Sentinel.classFragment)) {
      _classes = [];
    }
    _classes.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addEnum(EnumFragmentImpl fragment) {
    if (identical(_enums, _Sentinel.enumFragment)) {
      _enums = [];
    }
    _enums.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addExtension(ExtensionFragmentImpl fragment) {
    if (identical(_extensions, _Sentinel.extensionFragment)) {
      _extensions = [];
    }
    _extensions.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addExtensionType(ExtensionTypeFragmentImpl fragment) {
    if (identical(_extensionTypes, _Sentinel.extensionTypeFragment)) {
      _extensionTypes = [];
    }
    _extensionTypes.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addFunction(TopLevelFunctionFragmentImpl fragment) {
    if (identical(_functions, _Sentinel.topLevelFunctionFragment)) {
      _functions = [];
    }
    _functions.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addGetter(GetterFragmentImpl fragment) {
    if (identical(_getters, _Sentinel.getterFragment)) {
      _getters = [];
    }
    _getters.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addMixin(MixinFragmentImpl fragment) {
    if (identical(_mixins, _Sentinel.mixinFragment)) {
      _mixins = [];
    }
    _mixins.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addSetter(SetterFragmentImpl fragment) {
    if (identical(_setters, _Sentinel.setterFragment)) {
      _setters = [];
    }
    _setters.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addTopLevelVariable(TopLevelVariableFragmentImpl fragment) {
    if (identical(_variables, _Sentinel.topLevelVariableFragment)) {
      _variables = [];
    }
    _variables.add(fragment);
    fragment.enclosingFragment = this;
  }

  void addTypeAlias(TypeAliasFragmentImpl fragment) {
    if (identical(_typeAliases, _Sentinel.typeAliasFragment)) {
      _typeAliases = [];
    }
    _typeAliases.add(fragment);
    fragment.enclosingFragment = this;
  }

  /// Binds the given [fragment] to a [PrefixElementImpl] identified by a
  /// fragment-local [id].
  ///
  /// If a prefix element with the given [id] does not exist yet, it is created
  /// with the [fragment] as its first fragment. Otherwise, the [fragment] is
  /// added to the existing element.
  PrefixElementImpl bindLibraryImportPrefixElement({
    required String id,
    required PrefixFragmentImpl fragment,
  }) {
    var element = _libraryImportPrefixesById[id];
    if (element == null) {
      element = PrefixElementImpl(localId: id, firstFragment: fragment);
      _libraryImportPrefixesById[id] = element;
    } else {
      element.addFragment(fragment);
    }
    fragment.element = element;
    _libraryImportPrefixes = null;
    return element;
  }

  /// Returns the [PrefixElementImpl] for the given fragment-local [id].
  PrefixElementImpl libraryImportPrefixById(String id) {
    return _libraryImportPrefixesById[id]!;
  }

  /// Indicates whether it is unnecessary to report an undefined identifier
  /// error for an identifier reference with the given [name] and optional
  /// [prefix].
  ///
  /// This method is intended to reduce spurious errors in circumstances where
  /// an undefined identifier occurs as the result of a missing (most likely
  /// code generated) file.  It will only return `true` in a circumstance where
  /// the current library is guaranteed to have at least one other error (due to
  /// a missing part or import), so there is no risk that ignoring the undefined
  /// identifier would cause an invalid program to be treated as valid.
  bool shouldIgnoreUndefined({required String? prefix, required String name}) {
    for (var libraryFragment in withEnclosing) {
      for (var importElement in libraryFragment.libraryImports) {
        if (importElement.prefix?.element.name == prefix) {
          var importedLibrary = importElement.importedLibrary;
          if (importedLibrary == null ||
              importedLibrary.isOriginNotExistingFile) {
            var showCombinators = importElement.showCombinators.toList();
            if (prefix != null && showCombinators.isEmpty) {
              return true;
            }
            for (var combinator in showCombinators) {
              if (combinator.shownNames.contains(name)) {
                return true;
              }
            }
          }
        }
      }
    }

    if (prefix == null && name.startsWith(r'_$')) {
      for (var partElement in parts) {
        var uri = partElement.uri;
        if (uri is DirectiveUriWithSourceImpl &&
            uri is! DirectiveUriWithUnitImpl &&
            file_paths.isGenerated(uri.relativeUriString)) {
          return true;
        }
      }
    }

    return false;
  }

  /// Convenience wrapper around [shouldIgnoreUndefined] that calls it for a
  /// given (possibly prefixed) named type [node].
  bool shouldIgnoreUndefinedNamedType(NamedType node) {
    return shouldIgnoreUndefined(
      prefix: node.importPrefix?.name.lexeme,
      name: node.name.lexeme,
    );
  }

  List<PrefixElementImpl> _buildLibraryImportPrefixes() {
    var prefixes = <PrefixElementImpl>{};
    for (var import in libraryImports) {
      var prefix = import.prefix?.element;
      if (prefix != null) {
        prefixes.add(prefix);
      }
    }
    return prefixes.toFixedList();
  }
}

class LibraryImportImpl extends ElementDirectiveImpl implements LibraryImport {
  @override
  final bool isSynthetic;

  @override
  final List<NamespaceCombinator> combinators;

  @override
  int importKeywordOffset;

  @override
  final PrefixFragmentImpl? prefix;

  Namespace? _namespace;

  LibraryImportImpl({
    required super.uri,
    required this.isSynthetic,
    required this.combinators,
    required this.importKeywordOffset,
    required this.prefix,
  });

  @override
  LibraryElementImpl? get importedLibrary {
    if (uri case DirectiveUriWithLibraryImpl uri) {
      return uri.library;
    }
    return null;
  }

  @override
  Namespace get namespace {
    var uri = this.uri;
    if (uri is DirectiveUriWithLibraryImpl) {
      return _namespace ??= NamespaceBuilder()
          .createImportNamespaceForDirective(
            importedLibrary: uri.library,
            combinators: combinators,
            prefix: prefix,
          );
    }
    return Namespace.EMPTY;
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeLibraryImport(this);
  }
}

/// The provider for the lazily created `loadLibrary` function.
final class LoadLibraryFunctionProvider {
  final TopLevelReference elementReference;
  TopLevelFunctionElementImpl? _element;

  LoadLibraryFunctionProvider({required this.elementReference});

  TopLevelFunctionElementImpl getElement(LibraryElementImpl library) {
    return _element ??= _create(library);
  }

  TopLevelFunctionElementImpl _create(LibraryElementImpl library) {
    var name = TopLevelFunctionElement.LOAD_LIBRARY_NAME;

    var fragment = TopLevelFunctionFragmentImpl(name: name);
    fragment.isOriginLoadLibrary = true;
    fragment.isStatic = true;
    fragment.enclosingFragment = library.firstFragment;

    return TopLevelFunctionElementImpl(elementReference, fragment)
      ..returnType = library.typeProvider.futureDynamicType;
  }
}

class LocalFunctionElementImpl extends ExecutableElementImpl
    implements LocalFunctionElement {
  @override
  final LocalFunctionFragmentImpl _firstFragment;

  LocalFunctionElementImpl(this._firstFragment);

  @override
  // Local functions belong to Fragments, not Elements.
  Element? get enclosingElement => null;

  @override
  LocalFunctionFragmentImpl get firstFragment => _firstFragment;

  @override
  @trackedDirectlyOpaque
  List<LocalFunctionFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  ElementKind get kind => ElementKind.FUNCTION;

  @override
  String? get name => _firstFragment.name;

  @override
  List<LocalFunctionFragmentImpl> get _fragments {
    return [
      for (
        LocalFunctionFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return visitor.visitLocalFunctionElement(this);
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeLocalFunctionElement(this);
  }
}

/// A concrete implementation of a [LocalFunctionFragment].
class LocalFunctionFragmentImpl extends FunctionFragmentImpl
    implements LocalFunctionFragment {
  /// The element corresponding to this fragment.
  @override
  late final LocalFunctionElementImpl element = LocalFunctionElementImpl(this);

  @override
  LocalFunctionFragmentImpl? previousFragment;

  @override
  LocalFunctionFragmentImpl? nextFragment;

  LocalFunctionFragmentImpl({
    required super.name,
    required super.firstTokenOffset,
  });
}

class LocalVariableElementImpl extends PromotableElementImpl
    implements LocalVariableElement {
  @override
  final LocalVariableFragmentImpl _firstFragment;

  @override
  TypeImpl type = InvalidTypeImpl.instance;

  LocalVariableElementImpl(this._firstFragment);

  @override
  LocalVariableElement get baseElement => this;

  @override
  String? get documentationComment => null;

  @override
  Element? get enclosingElement {
    return _firstFragment.enclosingFragment.element;
  }

  @override
  LocalVariableFragmentImpl get firstFragment => _firstFragment;

  @override
  List<LocalVariableFragmentImpl> get fragments {
    return [_firstFragment];
  }

  @override
  ElementKind get kind => ElementKind.LOCAL_VARIABLE;

  @override
  LibraryElementImpl get library => super.library!;

  @override
  MetadataImpl get metadata => _firstFragment.metadata;

  @override
  String? get name => _firstFragment.name;

  @override
  List<LocalVariableFragmentImpl> get _fragments {
    return [_firstFragment];
  }

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return visitor.visitLocalVariableElement(this);
  }
}

class LocalVariableFragmentImpl extends NonParameterVariableFragmentImpl
    implements LocalVariableFragment {
  late LocalVariableElementImpl _element2 = switch (this) {
    BindPatternVariableFragmentImpl() => BindPatternVariableElementImpl(this),
    JoinPatternVariableFragmentImpl() => JoinPatternVariableElementImpl(this),
    PatternVariableFragmentImpl() => PatternVariableElementImpl(this),
    _ => LocalVariableElementImpl(this),
  };

  @override
  final String? name;

  @override
  int? nameOffset;

  /// Initialize a newly created method element to have the given [name] and
  /// [offset].
  LocalVariableFragmentImpl({
    required this.name,
    required super.firstTokenOffset,
  });

  @override
  List<FragmentImpl> get children => const [];

  @override
  LocalVariableElementImpl get element => _element2;

  @override
  LibraryFragmentImpl get libraryFragment => enclosingUnit;

  @override
  LocalVariableFragmentImpl? get nextFragment => null;

  @override
  LocalVariableFragmentImpl? get previousFragment => null;
}

final class MetadataImpl implements Metadata {
  static final MetadataImpl empty = MetadataImpl(const []);

  static const _isReady = 1 << 0;
  static const _hasDeprecated = 1 << 1;
  static const _hasOverride = 1 << 2;

  /// Cached flags denoting presence of specific annotations.
  int _metadataFlags2 = 0;

  @override
  final List<ElementAnnotationImpl> annotations;

  MetadataImpl(this.annotations);

  @override
  bool get hasAlwaysThrows {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isAlwaysThrows) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasAwaitNotRequired {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isAwaitNotRequired) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasDeprecated {
    return (_getMetadataFlags() & _hasDeprecated) != 0;
  }

  @override
  bool get hasDoNotStore {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isDoNotStore) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasDoNotSubmit {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isDoNotSubmit) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasExperimental {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isExperimental) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasFactory {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isFactory) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasImmutable {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isImmutable) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasInternal {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isInternal) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasIsTest {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isIsTest) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasIsTestGroup {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isIsTestGroup) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasJS {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isJS) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasLiteral {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isLiteral) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasMustBeConst {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isMustBeConst) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasMustBeOverridden {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isMustBeOverridden) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasMustCallSuper {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isMustCallSuper) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasNonVirtual {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isNonVirtual) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasOptionalTypeArgs {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isOptionalTypeArgs) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasOverride {
    return (_getMetadataFlags() & _hasOverride) != 0;
  }

  /// Return `true` if this element has an annotation of the form
  /// `@pragma("vm:entry-point")`.
  bool get hasPragmaVmEntryPoint {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isPragmaVmEntryPoint) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasProtected {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isProtected) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasRedeclare {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isRedeclare) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasReopen {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isReopen) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasRequired {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isRequired) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasSealed {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isSealed) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasUseResult {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isUseResult) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasVisibleForOverriding {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isVisibleForOverriding) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasVisibleForTemplate {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isVisibleForTemplate) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasVisibleForTesting {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isVisibleForTesting) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasVisibleOutsideTemplate {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isVisibleOutsideTemplate) {
        return true;
      }
    }
    return false;
  }

  @override
  bool get hasWidgetFactory {
    var annotations = this.annotations;
    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isWidgetFactory) {
        return true;
      }
    }
    return false;
  }

  void resetCache() {
    _metadataFlags2 = 0;
  }

  /// Return flags that denote presence of a few specific annotations.
  int _getMetadataFlags() {
    var result = _metadataFlags2;

    // Has at least `_metadataFlag_isReady`.
    if (result != 0) {
      return result;
    }

    for (var i = 0; i < annotations.length; i++) {
      var annotation = annotations[i];
      if (annotation.isDeprecated) {
        result |= _hasDeprecated;
      } else if (annotation.isOverride) {
        result |= _hasOverride;
      }
    }

    result |= _isReady;
    return _metadataFlags2 = result;
  }
}

@elementClass
@GenerateElementFlags(flags: _MethodElementFlags.values)
class MethodElementImpl extends ExecutableElementImpl
    with InternalMethodElement {
  @override
  @trackedIncludedInId
  final MemberReference reference;

  @override
  @trackedIncludedInId
  final String? name;

  @override
  final MethodFragmentImpl _firstFragment;

  /// Is `true` if this method is `operator==`, and there is no explicit
  /// type specified for its formal parameter, in this method or in any
  /// overridden methods other than the one declared in `Object`.
  @trackedIncludedInId
  bool isOperatorEqualWithParameterTypeFromObject = false;

  /// The error reported during type inference for this variable, or `null` if
  /// this variable is not a subject of type inference, or there was no error.
  @trackedIncludedInId
  TopLevelInferenceError? typeInferenceError;

  MethodElementImpl({
    required this.name,
    required this.reference,
    required MethodFragmentImpl firstFragment,
  }) : _firstFragment = firstFragment {
    reference.element = this;
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  @override
  @trackedIncludedInId
  MethodElementImpl get baseElement => this;

  @override
  @trackedIndirectly
  String get displayName {
    return lookupName ?? '<unnamed>';
  }

  @override
  @trackedIncludedInId
  InstanceElementImpl get enclosingElement {
    return _firstFragment.enclosingFragment.element;
  }

  @override
  @trackedDirectlyOpaque
  MethodFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginInterface': isOriginInterface,
    };
  }

  @override
  @trackedDirectlyOpaque
  List<MethodFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  bool get isOperator => _firstFragment.isOperator;

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginDeclaration {
    return _firstFragment.isOriginDeclaration;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginInterface {
    return _firstFragment.isOriginInterface;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.METHOD;

  @override
  @trackedDirectlyOpaque
  MethodFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );
    return super.lastFragment as MethodFragmentImpl;
  }

  @override
  @trackedIndirectly
  String? get lookupName {
    if (name == '-' && formalParameters.isEmpty) {
      return 'unary-';
    }
    return name;
  }

  @override
  List<MethodFragmentImpl> get _fragments {
    return [
      for (
        MethodFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitMethodElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeMethodElement(this);
  }

  @trackedInternal
  void linkFragments(List<MethodFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    TypeParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.typeParameters,
    );
    FormalParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.formalParameters,
    );
  }

  @override
  @trackedIndirectly
  InternalMethodElement substitute(MapSubstitution substitution) {
    if (substitution.map.isEmpty) {
      return this;
    }
    if (!hasEnclosingTypeParameterReference) {
      return this;
    }
    return SubstitutedMethodElementImpl(
      baseElement: this,
      substitution: substitution,
    );
  }
}

@GenerateElementFlags(flags: _MethodElementFlags.values)
class MethodFragmentImpl extends ExecutableFragmentImpl
    implements MethodFragment {
  @override
  late final MethodElementImpl element;

  @override
  final String? name;

  @override
  int? nameOffset;

  @override
  MethodFragmentImpl? previousFragment;

  @override
  MethodFragmentImpl? nextFragment;

  /// Initialize a newly created method element to have the given [name] at the
  /// given [offset].
  MethodFragmentImpl({required this.name});

  @override
  String get displayName {
    String displayName = super.displayName;
    if ("unary-" == displayName) {
      return "-";
    }
    return displayName;
  }

  @override
  InstanceFragmentImpl get enclosingFragment =>
      super.enclosingFragment as InstanceFragmentImpl;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginInterface': isOriginInterface,
    };
  }

  @override
  bool get isOperator {
    String name = displayName;
    if (name.isEmpty) {
      return false;
    }
    int first = name.codeUnitAt(0);
    return !((0x61 <= first && first <= 0x7A) ||
        (0x41 <= first && first <= 0x5A) ||
        first == 0x5F ||
        first == 0x24);
  }

  @generated
  bool get isOriginDeclaration {
    return hasFlag(_FragmentStorageFlag.methodFragment_isOriginDeclaration);
  }

  @generated
  set isOriginDeclaration(bool value) {
    setFlag(_FragmentStorageFlag.methodFragment_isOriginDeclaration, value);
  }

  @generated
  bool get isOriginInterface {
    return hasFlag(_FragmentStorageFlag.methodFragment_isOriginInterface);
  }

  @generated
  set isOriginInterface(bool value) {
    setFlag(_FragmentStorageFlag.methodFragment_isOriginInterface, value);
  }

  @override
  String? get lookupName {
    if (name == '-' && formalParameters.isEmpty) {
      return 'unary-';
    }
    return name;
  }

  void addFragment(MethodFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

@elementClass
@GenerateElementFlags(flags: _MixinElementFlags.values)
class MixinElementImpl extends InterfaceElementImpl implements MixinElement {
  @override
  @trackedIncludedInId
  final MemberContainerReference reference;

  @override
  final MixinFragmentImpl _firstFragment;

  List<InterfaceTypeImpl> _superclassConstraints = const [];

  MixinElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  @override
  @trackedDirectlyOpaque
  MixinFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {...super.flagsForTesting, 'isBase': isBase};
  }

  @override
  @trackedDirectlyOpaque
  List<MixinFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isBase {
    return _firstFragment.isBase;
  }

  @override
  @trackedIndirectly
  bool get isImplementableOutside => !isBase;

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.MIXIN;

  @override
  set mixins(List<InterfaceType> mixins) {
    throw StateError('Attempt to set mixins for a mixin declaration.');
  }

  @override
  @trackedIncludedInId
  List<InterfaceTypeImpl> get superclassConstraints {
    _ensureReadResolution();
    return _superclassConstraints;
  }

  set superclassConstraints(List<InterfaceTypeImpl> value) {
    _superclassConstraints = value;
  }

  /// Names of methods, getters, setters, and operators that this mixin
  /// declaration super-invokes.  For setters this includes the trailing "=".
  /// The list will be empty if this class is not a mixin declaration.
  @trackedIncludedInId
  List<String> get superInvokedNames => _firstFragment.superInvokedNames;

  @override
  set supertype(InterfaceType? supertype) {
    throw StateError('Attempt to set a supertype for a mixin declaration.');
  }

  List<MixinFragmentImpl> get _fragments {
    return [
      for (
        MixinFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitMixinElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeMixinElement(this);
  }

  @trackedInternal
  void ensureReadMembersForFragments() {
    for (var fragment in _fragments) {
      fragment.ensureReadMembers();
    }
  }

  @trackedInternal
  void linkFragments(List<MixinFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    TypeParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.typeParameters,
    );
  }
}

/// A [ClassFragmentImpl] representing a mixin declaration.
@GenerateElementFlags(flags: _MixinElementFlags.values)
class MixinFragmentImpl extends InterfaceFragmentImpl implements MixinFragment {
  @override
  late final MixinElementImpl element;

  /// Names of methods, getters, setters, and operators that this mixin
  /// declaration super-invokes.  For setters this includes the trailing "=".
  /// The list will be empty if this class is not a mixin declaration.
  late List<String> superInvokedNames;

  /// Initialize a newly created class element to have the given [name] at the
  /// given [offset] in the file that contains the declaration of this element.
  MixinFragmentImpl({required super.name});

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {...super.flagsForTesting, 'isBase': isBase};
  }

  @generated
  bool get isBase {
    return hasFlag(_FragmentStorageFlag.mixinFragment_isBase);
  }

  @generated
  set isBase(bool value) {
    setFlag(_FragmentStorageFlag.mixinFragment_isBase, value);
  }

  @override
  MixinFragmentImpl? get nextFragment =>
      super.nextFragment as MixinFragmentImpl?;

  @override
  MixinFragmentImpl? get previousFragment =>
      super.previousFragment as MixinFragmentImpl?;

  void addFragment(MixinFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

class MultiplyDefinedElementImpl extends ElementImpl
    implements MultiplyDefinedElement {
  final LibraryFragmentImpl libraryFragment;

  @override
  final String name;

  @override
  final List<Element> conflictingElements;

  @override
  late final MultiplyDefinedFragmentImpl _firstFragment =
      MultiplyDefinedFragmentImpl(this);

  MultiplyDefinedElementImpl(
    this.libraryFragment,
    this.name,
    this.conflictingElements,
  ) : assert(conflictingElements.isNotEmpty);

  @override
  MultiplyDefinedElementImpl get baseElement => this;

  @override
  List<ElementImpl> get children => const [];

  @override
  String get displayName => name;

  @override
  Null get enclosingElement => null;

  @override
  MultiplyDefinedFragmentImpl get firstFragment => _firstFragment;

  @override
  List<MultiplyDefinedFragmentImpl> get fragments {
    return [_firstFragment];
  }

  @override
  bool get isPrivate => false;

  @override
  bool get isPublic => true;

  bool get isVisibleForTemplate => false;

  bool get isVisibleOutsideTemplate => false;

  @override
  ElementKind get kind => ElementKind.ERROR;

  @override
  LibraryElementImpl get library => libraryFragment.element;

  @override
  Element get nonSynthetic => this;

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return visitor.visitMultiplyDefinedElement(this);
  }

  @override
  String displayString({
    bool multiline = false,
    bool preferTypeAlias = false,
    bool includePositionalParameterNames = false,
  }) {
    var elementsStr = conflictingElements
        .map((e) {
          return e.displayString();
        })
        .join(', ');
    return '[$elementsStr]';
  }

  @override
  bool isAccessibleIn(LibraryElement library) {
    for (var element in conflictingElements) {
      if (element.isAccessibleIn(library)) {
        return true;
      }
    }
    return false;
  }

  @override
  Element? thisOrAncestorMatching(bool Function(Element p1) predicate) {
    return null;
  }

  @override
  E? thisOrAncestorOfType<E extends Element>() {
    return null;
  }

  @override
  String toString() {
    StringBuffer buffer = StringBuffer();
    bool needsSeparator = false;
    void writeList(List<Element> elements) {
      for (var element in elements) {
        if (needsSeparator) {
          buffer.write(", ");
        } else {
          needsSeparator = true;
        }
        buffer.write(element.displayString());
      }
    }

    buffer.write("[");
    writeList(conflictingElements);
    buffer.write("]");
    return buffer.toString();
  }

  @override
  void visitChildren<T>(ElementVisitor2<T> visitor) {
    for (var child in children) {
      child.accept(visitor);
    }
  }
}

class MultiplyDefinedFragmentImpl extends FragmentImpl
    implements MultiplyDefinedFragment {
  @override
  final MultiplyDefinedElementImpl element;

  MultiplyDefinedFragmentImpl(this.element);

  @override
  List<FragmentImpl> get children => const [];

  @override
  String? get documentationComment => null;

  @override
  LibraryFragmentImpl get enclosingFragment => element.libraryFragment;

  @override
  LibraryFragmentImpl get libraryFragment => enclosingFragment;

  @override
  MetadataImpl get metadata => MetadataImpl.empty;

  @override
  String? get name => element.name;

  @override
  Null get nameOffset => null;

  @override
  Null get nextFragment => null;

  @override
  int get offset => 0;

  @override
  Null get previousFragment => null;
}

/// The synthetic element representing the declaration of the type `Never`.
class NeverElementImpl extends ElementImpl {
  /// The unique instance of this class.
  static final instance = NeverElementImpl._();

  NeverElementImpl._();

  @override
  Null get documentationComment => null;

  @override
  Element? get enclosingElement => null;

  @override
  NeverFragmentImpl get firstFragment => _firstFragment;

  @override
  List<NeverFragmentImpl> get fragments {
    return [_firstFragment];
  }

  @override
  ElementKind get kind => ElementKind.NEVER;

  @override
  Null get library => null;

  @override
  MetadataImpl get metadata {
    return MetadataImpl(const []);
  }

  @override
  String get name => 'Never';

  @override
  NeverFragmentImpl get _firstFragment => NeverFragmentImpl.instance;

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return null;
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeNeverElement(this);
  }

  DartType instantiate({required NullabilitySuffix nullabilitySuffix}) {
    switch (nullabilitySuffix) {
      case NullabilitySuffix.question:
        return NeverTypeImpl.instanceNullable;
      case NullabilitySuffix.star:
        // TODO(scheglov): remove together with `star`
        return NeverTypeImpl.instanceNullable;
      case NullabilitySuffix.none:
        return NeverTypeImpl.instance;
    }
  }
}

/// The synthetic element representing the declaration of the type `Never`.
class NeverFragmentImpl extends FragmentImpl {
  /// The unique instance of this class.
  static final instance = NeverFragmentImpl._();

  /// Initialize a newly created instance of this class. Instances of this class
  /// should <b>not</b> be created except as part of creating the type
  /// associated with this element. The single instance of this class should be
  /// accessed through the method [instance].
  NeverFragmentImpl._() : super(firstTokenOffset: null);

  @override
  List<FragmentImpl> get children => const [];

  @override
  NeverElementImpl get element => NeverElementImpl.instance;

  @override
  Null get enclosingFragment => null;

  @override
  Null get libraryFragment => null;

  @override
  String get name => 'Never';

  @override
  Null get nameOffset => null;

  @override
  Null get nextFragment => null;

  @override
  int get offset => 0;

  @override
  Null get previousFragment => null;

  DartType instantiate({required NullabilitySuffix nullabilitySuffix}) {
    switch (nullabilitySuffix) {
      case NullabilitySuffix.question:
        return NeverTypeImpl.instanceNullable;
      case NullabilitySuffix.star:
        // TODO(scheglov): remove together with `star`
        return NeverTypeImpl.instanceNullable;
      case NullabilitySuffix.none:
        return NeverTypeImpl.instance;
    }
  }
}

/// A [VariableFragmentImpl], which is not a parameter.
@GenerateElementFlags(flags: _NonParameterVariableElementFlags.values)
abstract class NonParameterVariableFragmentImpl extends VariableFragmentImpl {
  /// Initialize a newly created variable element to have the given [name] and
  /// [offset].
  NonParameterVariableFragmentImpl({super.firstTokenOffset});

  @override
  FragmentImpl get enclosingFragment {
    return super.enclosingFragment as FragmentImpl;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {...super.flagsForTesting, 'hasInitializer': hasInitializer};
  }

  @generated
  bool get hasInitializer {
    return hasFlag(
      _FragmentStorageFlag.nonParameterVariableFragment_hasInitializer,
    );
  }

  @generated
  set hasInitializer(bool value) {
    setFlag(
      _FragmentStorageFlag.nonParameterVariableFragment_hasInitializer,
      value,
    );
  }

  @override
  NonParameterVariableFragmentImpl? get nextFragment;

  @override
  NonParameterVariableFragmentImpl? get previousFragment;
}

class PartIncludeImpl extends ElementDirectiveImpl implements PartInclude {
  @override
  int partKeywordOffset;

  PartIncludeImpl({required super.uri, required this.partKeywordOffset});

  @override
  LibraryFragmentImpl? get includedFragment {
    if (uri case DirectiveUriWithUnitImpl uri) {
      return uri.libraryFragment;
    }
    return null;
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writePartInclude(this);
  }
}

class PatternVariableElementImpl extends LocalVariableElementImpl
    implements PatternVariableElement {
  PatternVariableElementImpl(super.firstFragment);

  @override
  PatternVariableFragmentImpl get firstFragment => _firstFragment;

  @override
  List<PatternVariableFragmentImpl> get fragments {
    return [
      for (
        PatternVariableFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  /// This flag is set to `true` while we are visiting the [WhenClause] of
  /// the [GuardedPattern] that declares this variable.
  bool get isVisitingWhenClause => _firstFragment.isVisitingWhenClause;

  /// This flag is set to `true` while we are visiting the [WhenClause] of
  /// the [GuardedPattern] that declares this variable.
  set isVisitingWhenClause(bool value) =>
      _firstFragment.isVisitingWhenClause = value;

  @override
  JoinPatternVariableElementImpl? get join {
    return _firstFragment.join?.element;
  }

  /// Return the root [join], or self.
  PatternVariableElementImpl get rootVariable {
    return join?.rootVariable ?? this;
  }

  @override
  PatternVariableFragmentImpl get _firstFragment =>
      super._firstFragment as PatternVariableFragmentImpl;

  static PatternVariableElement fromElement(
    PatternVariableFragmentImpl fragment,
  ) {
    if (fragment is JoinPatternVariableFragmentImpl) {
      return JoinPatternVariableElementImpl(fragment);
    } else if (fragment is BindPatternVariableFragmentImpl) {
      return BindPatternVariableElementImpl(fragment);
    }
    return PatternVariableElementImpl(fragment);
  }
}

class PatternVariableFragmentImpl extends LocalVariableFragmentImpl
    implements PatternVariableFragment {
  @override
  JoinPatternVariableFragmentImpl? join;

  /// This flag is set to `true` while we are visiting the [WhenClause] of
  /// the [GuardedPattern] that declares this variable.
  bool isVisitingWhenClause = false;

  PatternVariableFragmentImpl({
    required super.name,
    required super.firstTokenOffset,
  });

  @override
  PatternVariableElementImpl get element =>
      super.element as PatternVariableElementImpl;

  @override
  PatternVariableFragmentImpl? get nextFragment =>
      super.nextFragment as PatternVariableFragmentImpl?;

  @override
  PatternVariableFragmentImpl? get previousFragment =>
      super.previousFragment as PatternVariableFragmentImpl?;

  /// Return the root [join], or self.
  PatternVariableFragmentImpl get rootVariable {
    return join?.rootVariable ?? this;
  }
}

class PrefixElementImpl extends ElementImpl implements PrefixElement {
  /// A fragment-local id used to merge and restore this library import prefix.
  ///
  /// This is usually the declared prefix name. When a prefix fragment does not
  /// have a usable name, we assign a synthetic `#...` id instead.
  @trackedIncludedInId
  final String localId;

  @override
  final PrefixFragmentImpl _firstFragment;

  PrefixFragmentImpl lastFragment;

  /// The scope of this prefix, `null` if not set yet.
  PrefixScope? _scope;

  PrefixElementImpl({
    required this.localId,
    required PrefixFragmentImpl firstFragment,
  }) : _firstFragment = firstFragment,
       lastFragment = firstFragment;

  @override
  Null get enclosingElement => null;

  @override
  PrefixFragmentImpl get firstFragment => _firstFragment;

  @override
  List<PrefixFragmentImpl> get fragments {
    return [
      for (
        PrefixFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  List<LibraryImportImpl> get imports {
    return _firstFragment.enclosingFragment.libraryImports
        .where((import) => import.prefix?.element == this)
        .toList();
  }

  /// Whether this prefix is declared by a `deferred` import.
  bool get isDeferred {
    for (
      PrefixFragmentImpl? fragment = _firstFragment;
      fragment != null;
      fragment = fragment.nextFragment
    ) {
      if (fragment.isDeferred) {
        return true;
      }
    }
    return false;
  }

  @override
  ElementKind get kind => ElementKind.PREFIX;

  @override
  LibraryElementImpl get library => super.library!;

  @override
  String? get name => _firstFragment.name;

  @override
  PrefixScope get scope {
    _firstFragment.enclosingFragment.scope;
    // SAFETY: The previous statement initializes this field.
    return _scope!;
  }

  set scope(PrefixScope value) {
    _scope = value;
  }

  @override
  List<LibraryElementImpl> get scopeLibraries {
    return scope.libraries;
  }

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return visitor.visitPrefixElement(this);
  }

  void addFragment(PrefixFragmentImpl fragment) {
    lastFragment.nextFragment = fragment;
    fragment.previousFragment = lastFragment;
    lastFragment = fragment;
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writePrefixElement(this);
  }

  @override
  void visitChildren<T>(ElementVisitor2<T> visitor) {}
}

class PrefixFragmentImpl extends FragmentImpl implements PrefixFragment {
  @override
  final String? name;

  @override
  int? nameOffset;

  @override
  int offset = 0;

  @override
  final bool isDeferred;

  @override
  late final PrefixElementImpl element;

  @override
  PrefixFragmentImpl? previousFragment;

  @override
  PrefixFragmentImpl? nextFragment;

  PrefixFragmentImpl({
    required this.name,
    required this.nameOffset,
    required super.firstTokenOffset,
    required this.isDeferred,
  });

  @override
  List<FragmentImpl> get children => const [];

  @override
  LibraryFragmentImpl get enclosingFragment =>
      super.enclosingFragment as LibraryFragmentImpl;

  @override
  LibraryFragmentImpl get libraryFragment => enclosingFragment;
}

abstract class PromotableElementImpl extends VariableElementImpl {}

@elementClass
@GenerateElementFlags(flags: _PropertyAccessorElementFlags.values)
abstract class PropertyAccessorElementImpl extends ExecutableElementImpl
    with InternalPropertyAccessorElement {
  PropertyInducingElementImpl? _variable3;

  @override
  @trackedIncludedInId
  PropertyAccessorElementImpl get baseElement => this;

  @override
  @trackedIncludedInId
  Element get enclosingElement => _firstFragment.enclosingFragment.element;

  @override
  PropertyAccessorFragmentImpl get firstFragment;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginInterface': isOriginInterface,
      'isOriginVariable': isOriginVariable,
    };
  }

  @override
  List<PropertyAccessorFragmentImpl> get fragments;

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginDeclaration {
    return _firstFragment.isOriginDeclaration;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginInterface {
    return _firstFragment.isOriginInterface;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginVariable {
    return _firstFragment.isOriginVariable;
  }

  @override
  @trackedDirectlyOpaque
  PropertyAccessorFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );
    return super.lastFragment as PropertyAccessorFragmentImpl;
  }

  @override
  @trackedIncludedInId
  String? get name => _firstFragment.name;

  @override
  List<TypeParameterElementImpl> get typeParameters;

  @override
  @trackedDirectly
  PropertyInducingElementImpl get variable {
    globalResultRequirements?.record_propertyAccessorElement_variable(
      element: this,
      name: name,
    );

    return _variable3!;
  }

  set variable(PropertyInducingElementImpl? value) {
    _variable3 = value;
  }

  @override
  PropertyAccessorFragmentImpl get _firstFragment;
}

@GenerateElementFlags(flags: _PropertyAccessorElementFlags.values)
sealed class PropertyAccessorFragmentImpl extends ExecutableFragmentImpl
    implements PropertyAccessorFragment {
  @override
  final String? name;

  @override
  int? nameOffset;

  PropertyInducingFragmentImpl? _inducingVariable;

  /// Initialize a newly created property accessor element to have the given
  /// [name] and [offset].
  PropertyAccessorFragmentImpl({required this.name, super.firstTokenOffset});

  @override
  PropertyAccessorElementImpl get element;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginInterface': isOriginInterface,
      'isOriginVariable': isOriginVariable,
    };
  }

  @override
  PropertyInducingFragmentImpl? get inducingVariable => _inducingVariable;

  @generated
  bool get isOriginDeclaration {
    return hasFlag(
      _FragmentStorageFlag.propertyAccessorFragment_isOriginDeclaration,
    );
  }

  @generated
  set isOriginDeclaration(bool value) {
    setFlag(
      _FragmentStorageFlag.propertyAccessorFragment_isOriginDeclaration,
      value,
    );
  }

  @generated
  bool get isOriginInterface {
    return hasFlag(
      _FragmentStorageFlag.propertyAccessorFragment_isOriginInterface,
    );
  }

  @generated
  set isOriginInterface(bool value) {
    setFlag(
      _FragmentStorageFlag.propertyAccessorFragment_isOriginInterface,
      value,
    );
  }

  @generated
  bool get isOriginVariable {
    return hasFlag(
      _FragmentStorageFlag.propertyAccessorFragment_isOriginVariable,
    );
  }

  @generated
  set isOriginVariable(bool value) {
    setFlag(
      _FragmentStorageFlag.propertyAccessorFragment_isOriginVariable,
      value,
    );
  }

  @override
  MetadataImpl get metadata {
    _ensureReadResolution();
    return super.metadata;
  }

  @override
  PropertyAccessorFragmentImpl? get nextFragment;

  @override
  int get offset {
    if (nameOffset case var nameOffset?) {
      return nameOffset;
    }
    if (isOriginVariable) {
      return inducingVariable!.offset;
    }
    return firstTokenOffset!;
  }

  @override
  PropertyAccessorFragmentImpl? get previousFragment;
}

@elementClass
@GenerateElementFlags(flags: _PropertyInducingElementFlags.values)
abstract class PropertyInducingElementImpl extends VariableElementImpl
    with InternalPropertyInducingElement, DeferredResolutionReadingMixin {
  @override
  @trackedInternal
  GetterElementImpl? getter;

  @override
  @trackedInternal
  SetterElementImpl? setter;

  TypeImpl? _type;

  /// This field is set during linking, and performs type inference for
  /// this property. After linking this field is always `null`.
  @trackedInternal
  PropertyInducingElementTypeInference? typeInference;

  /// The error reported during type inference for this variable, or `null` if
  /// this variable is not a subject of type inference, or there was no error.
  @trackedIncludedInId
  TopLevelInferenceError? typeInferenceError;

  @trackedInternal
  late final PropertyInducingElementImplInternal internal =
      PropertyInducingElementImplInternal(this);

  PropertyInducingElementImpl();

  @override
  PropertyInducingFragmentImpl get firstFragment;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasInitializer': hasInitializer,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginGetterSetter': isOriginGetterSetter,
      'isTypeInferredFromInitializer': isTypeInferredFromInitializer,
      'isTypeInferredFromOverride': isTypeInferredFromOverride,
    };
  }

  @override
  @trackedDirectlyOpaque
  List<PropertyInducingFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  bool get hasInitializer {
    return _fragments.any((f) => f.hasInitializer);
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginDeclaration {
    return _firstFragment.isOriginDeclaration;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginGetterSetter {
    return _firstFragment.isOriginGetterSetter;
  }

  @generated
  @trackedIncludedInId
  bool get isTypeInferredFromInitializer {
    return hasFlag(
      _ElementStorageFlag.propertyInducingElement_isTypeInferredFromInitializer,
    );
  }

  @generated
  set isTypeInferredFromInitializer(bool value) {
    setFlag(
      _ElementStorageFlag.propertyInducingElement_isTypeInferredFromInitializer,
      value,
    );
  }

  @generated
  @trackedIncludedInId
  bool get isTypeInferredFromOverride {
    return hasFlag(
      _ElementStorageFlag.propertyInducingElement_isTypeInferredFromOverride,
    );
  }

  @generated
  set isTypeInferredFromOverride(bool value) {
    setFlag(
      _ElementStorageFlag.propertyInducingElement_isTypeInferredFromOverride,
      value,
    );
  }

  @override
  @trackedIncludedInId
  LibraryElementImpl get library => super.library!;

  @override
  @trackedIndirectly
  Element get nonSynthetic {
    if (isOriginDeclaration) {
      return this;
    } else if (this case FieldElementImpl(
      isOriginDeclaringFormalParameter: true,
    )) {
      return this;
    } else {
      if (enclosingElement case EnumElementImpl enclosingElement) {
        // TODO(scheglov): remove 'index'?
        if (name == 'index' || name == 'values') {
          return enclosingElement;
        }
      }
      return (getter ?? setter)!;
    }
  }

  @override
  Reference get reference;

  @override
  @trackedIncludedInId
  TypeImpl get type {
    _ensureReadResolution();
    if (_type case var type?) {
      return type;
    }

    // We must be linking, and the type has not been set yet.
    if (typeInference?.perform() case var result?) {
      isTypeInferredFromInitializer = result.isTypeInferredFromInitializer;
      return type = result.type;
    }

    return type = InvalidTypeImpl.instance;
  }

  @override
  set type(TypeImpl value) {
    _type = value;

    if (getter case var getter?) {
      if (getter.isOriginVariable) {
        getter.returnType = type;
      }
    }

    if (setter case var setter?) {
      if (setter.isOriginVariable) {
        setter.returnType = VoidTypeImpl.instance;
        setter.valueFormalParameter.type = type;
      }
    }
  }

  @override
  PropertyInducingFragmentImpl get _firstFragment;

  @override
  List<PropertyInducingFragmentImpl> get _fragments;

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeVariableElement(this);
  }
}

/// Exposes [PropertyInducingElementImpl] properties needed while building or
/// loading the element model, without recording opaque API requirements.
class PropertyInducingElementImplInternal {
  final PropertyInducingElementImpl _element;

  PropertyInducingElementImplInternal(this._element);

  List<PropertyInducingFragmentImpl> get fragments => _element._fragments;
}

/// Instances of this class are set for fields and top-level variables
/// to perform top-level type inference during linking.
abstract class PropertyInducingElementTypeInference {
  ({TypeImpl type, bool isTypeInferredFromInitializer}) perform();
}

@GenerateElementFlags(flags: _PropertyInducingElementFlags.values)
abstract class PropertyInducingFragmentImpl
    extends NonParameterVariableFragmentImpl
    with DeferredResolutionReadingMixin
    implements PropertyInducingFragment {
  @override
  final String? name;

  @override
  int? nameOffset;

  GetterFragmentImpl? _inducedGetter;

  SetterFragmentImpl? _inducedSetter;

  @override
  PropertyInducingFragmentImpl? previousFragment;

  @override
  PropertyInducingFragmentImpl? nextFragment;

  /// Initialize a newly created synthetic element to have the given [name] and
  /// [offset].
  PropertyInducingFragmentImpl({required this.name});

  @override
  List<FragmentImpl> get children => const [];

  @override
  PropertyInducingElementImpl get element;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginGetterSetter': isOriginGetterSetter,
    };
  }

  /// Return `true` if this variable needs the setter.
  bool get hasSetter {
    if (isConst) {
      return false;
    }

    if (isLate) {
      return !isFinal || !hasInitializer;
    }

    return !isFinal;
  }

  @override
  GetterFragmentImpl? get inducedGetter => _inducedGetter;

  set inducedGetter(GetterFragmentImpl value) {
    assert(_inducedGetter == null);
    assert(value._inducingVariable == null);
    _inducedGetter = value;
    value._inducingVariable = this;
  }

  @override
  SetterFragmentImpl? get inducedSetter => _inducedSetter;

  set inducedSetter(SetterFragmentImpl value) {
    assert(_inducedSetter == null);
    assert(value._inducingVariable == null);
    _inducedSetter = value;
    value._inducingVariable = this;
  }

  @generated
  bool get isOriginDeclaration {
    return hasFlag(
      _FragmentStorageFlag.propertyInducingFragment_isOriginDeclaration,
    );
  }

  @generated
  set isOriginDeclaration(bool value) {
    setFlag(
      _FragmentStorageFlag.propertyInducingFragment_isOriginDeclaration,
      value,
    );
  }

  @generated
  bool get isOriginGetterSetter {
    return hasFlag(
      _FragmentStorageFlag.propertyInducingFragment_isOriginGetterSetter,
    );
  }

  @generated
  set isOriginGetterSetter(bool value) {
    setFlag(
      _FragmentStorageFlag.propertyInducingFragment_isOriginGetterSetter,
      value,
    );
  }

  @override
  LibraryFragmentImpl get libraryFragment {
    return enclosingFragment.libraryFragment!;
  }
}

@elementClass
class SetterElementImpl extends PropertyAccessorElementImpl
    with InternalSetterElement {
  @override
  @trackedIncludedInId
  DeclarationReference reference;

  @override
  final SetterFragmentImpl _firstFragment;

  SetterElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    SetterFragmentImpl? fragment = _firstFragment;
    while (fragment != null) {
      fragment.element = this;
      fragment = fragment.nextFragment;
    }
  }

  @override
  @trackedIncludedInId
  SetterElementImpl get baseElement => this;

  @override
  @trackedIndirectly
  GetterElement? get correspondingGetter {
    return variable.getter;
  }

  @override
  @trackedIncludedInId
  Element get enclosingElement => _firstFragment.enclosingFragment.element;

  @override
  @trackedDirectlyOpaque
  SetterFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @override
  @trackedDirectlyOpaque
  List<SetterFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.SETTER;

  @override
  @trackedDirectlyOpaque
  SetterFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );
    return super.lastFragment as SetterFragmentImpl;
  }

  @override
  @trackedIndirectly
  String? get lookupName {
    if (name case var name?) {
      return '$name=';
    }
    return null;
  }

  @override
  @trackedIndirectly
  Element get nonSynthetic {
    if (isOriginVariable) {
      return variable.nonSynthetic;
    } else {
      return this;
    }
  }

  @override
  @trackedIndirectly
  Version? get sinceSdkVersion {
    if (isOriginVariable) {
      return variable.sinceSdkVersion;
    }
    return super.sinceSdkVersion;
  }

  @trackedIncludedInId
  FormalParameterElementImpl get valueFormalParameter {
    return formalParameters.single;
  }

  @override
  List<SetterFragmentImpl> get _fragments {
    return [
      for (
        SetterFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitSetterElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeSetterElement(this);
  }

  @trackedInternal
  void linkFragments(List<SetterFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    FormalParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.formalParameters,
    );
  }

  @override
  @trackedIndirectly
  InternalSetterElement substitute(MapSubstitution substitution) {
    if (substitution.map.isEmpty) {
      return this;
    }
    if (enclosingElement is! InstanceElement) {
      throw StateError('Cannot substitute a non-member: $this');
    }
    if (!hasEnclosingTypeParameterReference) {
      return this;
    }
    return SubstitutedSetterElementImpl(
      baseElement: this,
      substitution: substitution,
    );
  }
}

class SetterFragmentImpl extends PropertyAccessorFragmentImpl
    implements SetterFragment {
  @override
  late SetterElementImpl element;

  @override
  SetterFragmentImpl? previousFragment;

  @override
  SetterFragmentImpl? nextFragment;

  SetterFragmentImpl({required super.name});

  @override
  String? get lookupName {
    if (name case var name?) {
      return '$name=';
    }
    return null;
  }

  FormalParameterFragmentImpl get valueFormalParameter {
    return formalParameters.single;
  }

  void addFragment(SetterFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

/// A concrete implementation of a [ShowElementCombinator].
class ShowElementCombinatorImpl implements ShowElementCombinator {
  @override
  List<String> shownNames = const [];

  @override
  int offset = 0;

  @override
  int end = -1;

  @override
  String toString() {
    StringBuffer buffer = StringBuffer();
    buffer.write("show ");
    int count = shownNames.length;
    for (int i = 0; i < count; i++) {
      if (i > 0) {
        buffer.write(", ");
      }
      buffer.write(shownNames[i]);
    }
    return buffer.toString();
  }
}

class SuperFormalParameterElementImpl extends FormalParameterElementImpl
    with InternalSuperFormalParameterElement {
  SuperFormalParameterElementImpl(super.firstFragment);

  @override
  SuperFormalParameterElementImpl get baseElement => this;

  @override
  String? get defaultValueCode {
    if (isRequired) {
      return null;
    }

    var constantInitializer = constantInitializer2;
    if (constantInitializer != null) {
      return constantInitializer.toSource();
    }

    if (_superConstructorParameterDefaultValue != null) {
      return superConstructorParameter?.defaultValueCode;
    }

    return null;
  }

  @override
  Constant? get evaluationResult {
    if (constantInitializer2 != null) {
      return super.evaluationResult;
    }

    var superConstructorParameter = this.superConstructorParameter?.baseElement;
    if (superConstructorParameter != null) {
      return superConstructorParameter.evaluationResult;
    }

    return null;
  }

  @override
  bool get isFinal => true;

  @override
  InternalFormalParameterElement? get superConstructorParameter {
    var enclosingElement = this.enclosingElement;
    if (enclosingElement is ConstructorElementImpl) {
      var superConstructor = enclosingElement.superConstructor;
      if (superConstructor != null) {
        var superParameters = superConstructor.formalParameters;
        if (isNamed) {
          return superParameters.firstWhereOrNull(
            (e) => e.isNamed && e.name == name,
          );
        } else {
          var index = indexIn(enclosingElement);
          var positionalSuperParameters = superParameters
              .where((e) => e.isPositional)
              .toList();
          if (index >= 0 && index < positionalSuperParameters.length) {
            return positionalSuperParameters[index];
          }
        }
      }
    }
    return null;
  }

  DartObject? get _superConstructorParameterDefaultValue {
    var superDefault = superConstructorParameter?.computeConstantValue();
    if (superDefault == null) {
      return null;
    }

    // TODO(scheglov): eliminate this cast
    superDefault as DartObjectImpl;
    var superDefaultType = superDefault.type;

    var typeSystem = library?.typeSystem;
    if (typeSystem == null) {
      return null;
    }

    var requiredType = type.extensionTypeErasure;
    if (typeSystem.isSubtypeOf(superDefaultType, requiredType)) {
      return superDefault;
    }

    return null;
  }

  @override
  DartObject? computeConstantValue() {
    if (constantInitializer2 != null) {
      return super.computeConstantValue();
    }

    return _superConstructorParameterDefaultValue;
  }

  /// Return the index of this super-formal parameter among other super-formals.
  int indexIn(ConstructorElementImpl enclosingElement) {
    return enclosingElement.formalParameters
        .whereType<SuperFormalParameterElementImpl>()
        .toList()
        .indexOf(this);
  }

  @override
  InternalSuperFormalParameterElement substitute(MapSubstitution substitution) {
    if (substitution.map.isEmpty) {
      return this;
    }
    return SubstitutedSuperFormalParameterElementImpl(
      baseElement: this,
      substitution: substitution,
    );
  }
}

class SuperFormalParameterFragmentImpl extends FormalParameterFragmentImpl
    implements SuperFormalParameterFragment {
  /// Initialize a newly created parameter element to have the given [name] and
  /// [nameOffset].
  SuperFormalParameterFragmentImpl({
    super.firstTokenOffset,
    required super.name,
    required super.nameOffset,
    required super.parameterKind,
  });

  /// Super parameters are visible only in the initializer list scope,
  /// and introduce final variables.
  @override
  bool get isFinal => true;
}

@elementClass
@GenerateElementFlags(flags: _TopLevelFunctionElementFlags.values)
class TopLevelFunctionElementImpl extends ExecutableElementImpl
    implements TopLevelFunctionElement {
  @override
  @trackedIncludedInId
  final TopLevelReference reference;

  @override
  final TopLevelFunctionFragmentImpl _firstFragment;

  TopLevelFunctionElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  @override
  @trackedIncludedInId
  TopLevelFunctionElementImpl get baseElement => this;

  @override
  @trackedIncludedInId
  LibraryElementImpl get enclosingElement => library;

  @override
  @trackedDirectlyOpaque
  TopLevelFunctionFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginLoadLibrary': isOriginLoadLibrary,
    };
  }

  @override
  @trackedDirectlyOpaque
  List<TopLevelFunctionFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  bool get isDartCoreIdentical {
    return name == 'identical' && library.isDartCore;
  }

  @override
  @trackedIndirectly
  bool get isEntryPoint {
    return displayName == TopLevelFunctionElement.MAIN_FUNCTION_NAME;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginDeclaration {
    return _firstFragment.isOriginDeclaration;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isOriginLoadLibrary {
    return _firstFragment.isOriginLoadLibrary;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.FUNCTION;

  @override
  @trackedDirectlyOpaque
  TopLevelFunctionFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );
    return super.lastFragment as TopLevelFunctionFragmentImpl;
  }

  @override
  @trackedIncludedInId
  String? get name => _firstFragment.name;

  @override
  List<TopLevelFunctionFragmentImpl> get _fragments {
    return [
      for (
        TopLevelFunctionFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitTopLevelFunctionElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeTopLevelFunctionElement(this);
  }

  @trackedInternal
  void linkFragments(List<TopLevelFunctionFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
    TypeParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.typeParameters,
    );
    FormalParameterFragmentImpl._linkFragments(
      fragments,
      getFragments: (f) => f.formalParameters,
    );
  }
}

/// A concrete implementation of a [TopLevelFunctionFragment].
@GenerateElementFlags(flags: _TopLevelFunctionElementFlags.values)
class TopLevelFunctionFragmentImpl extends FunctionFragmentImpl
    implements TopLevelFunctionFragment {
  /// The element corresponding to this fragment.
  @override
  late TopLevelFunctionElementImpl element;

  @override
  TopLevelFunctionFragmentImpl? previousFragment;

  @override
  TopLevelFunctionFragmentImpl? nextFragment;

  TopLevelFunctionFragmentImpl({required super.name});

  @override
  LibraryFragmentImpl get enclosingFragment =>
      super.enclosingFragment as LibraryFragmentImpl;

  @override
  set enclosingFragment(covariant LibraryFragmentImpl fragment);

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginDeclaration': isOriginDeclaration,
      'isOriginLoadLibrary': isOriginLoadLibrary,
    };
  }

  @generated
  bool get isOriginDeclaration {
    return hasFlag(
      _FragmentStorageFlag.topLevelFunctionFragment_isOriginDeclaration,
    );
  }

  @generated
  set isOriginDeclaration(bool value) {
    setFlag(
      _FragmentStorageFlag.topLevelFunctionFragment_isOriginDeclaration,
      value,
    );
  }

  @generated
  bool get isOriginLoadLibrary {
    return hasFlag(
      _FragmentStorageFlag.topLevelFunctionFragment_isOriginLoadLibrary,
    );
  }

  @generated
  set isOriginLoadLibrary(bool value) {
    setFlag(
      _FragmentStorageFlag.topLevelFunctionFragment_isOriginLoadLibrary,
      value,
    );
  }

  void addFragment(TopLevelFunctionFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

@elementClass
class TopLevelVariableElementImpl extends PropertyInducingElementImpl
    implements TopLevelVariableElement {
  @override
  @trackedIncludedInId
  final TopLevelReference reference;

  @override
  final TopLevelVariableFragmentImpl _firstFragment;

  TopLevelVariableElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    _firstFragment.element = this;
  }

  @override
  @trackedIncludedInId
  TopLevelVariableElementImpl get baseElement => this;

  @override
  @trackedIncludedInId
  LibraryElementImpl get enclosingElement => library;

  @override
  @trackedDirectlyOpaque
  TopLevelVariableFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @override
  @trackedDirectlyOpaque
  List<TopLevelVariableFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;

  @trackedDirectlyOpaque
  TopLevelVariableFragmentImpl get lastFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueLastFragment,
      target: this,
      method: 'lastFragment',
    );
    var current = firstFragment;
    while (current.nextFragment != null) {
      current = current.nextFragment!;
    }
    return current;
  }

  @override
  @trackedIncludedInId
  MetadataImpl get metadata {
    return _firstFragment.elementMetadata;
  }

  @override
  @trackedIncludedInId
  String? get name => _firstFragment.name;

  @override
  List<TopLevelVariableFragmentImpl> get _fragments {
    return [
      for (
        TopLevelVariableFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitTopLevelVariableElement(this);
  }

  @trackedInternal
  void linkFragments(List<TopLevelVariableFragmentImpl> fragments) {
    assert(identical(fragments[0], _firstFragment));
    fragments.reduce((previous, current) {
      previous.addFragment(current);
      return current;
    });
  }
}

class TopLevelVariableFragmentImpl extends PropertyInducingFragmentImpl
    implements TopLevelVariableFragment {
  @override
  late TopLevelVariableElementImpl element;

  /// Initialize a newly created synthetic top-level variable element to have
  /// the given [name] and [offset].
  TopLevelVariableFragmentImpl({required super.name});

  @override
  ExpressionImpl? get constantInitializer2 {
    _ensureReadResolution();
    return super.constantInitializer2;
  }

  @override
  bool get isStatic => true;

  @override
  LibraryFragmentImpl get libraryFragment => enclosingUnit;

  @override
  MetadataImpl get metadata {
    _ensureReadResolution();
    return super.metadata;
  }

  @override
  TopLevelVariableFragmentImpl? get nextFragment =>
      super.nextFragment as TopLevelVariableFragmentImpl?;

  @override
  TopLevelVariableFragmentImpl? get previousFragment =>
      super.previousFragment as TopLevelVariableFragmentImpl?;

  void addFragment(TopLevelVariableFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }
}

@elementClass
@GenerateElementFlags(flags: _TypeAliasElementFlags.values)
class TypeAliasElementImpl extends ElementImpl
    with DeferredResolutionReadingMixin
    implements TypeAliasElement {
  @override
  @trackedIncludedInId
  final TopLevelReference reference;

  @override
  final TypeAliasFragmentImpl _firstFragment;

  TypeImpl? _aliasedType;

  TypeAliasElementImpl(this.reference, this._firstFragment) {
    reference.element = this;
    _firstFragment.element = this;

    for (var typeParameter in _firstFragment._typeParameters) {
      TypeParameterElementImpl(firstFragment: typeParameter);
    }
  }

  @override
  @trackedIncludedInId
  TypeImpl get aliasedType {
    _ensureReadResolution();
    return _aliasedType!;
  }

  set aliasedType(DartType rawType) {
    // TODO(paulberry): eliminate this cast by changing the type of the
    // `rawType` parameter.
    _aliasedType = rawType as TypeImpl;
  }

  /// The aliased type, might be `null` if not yet linked.
  @trackedInternal
  TypeImpl? get aliasedTypeRaw => _aliasedType;

  @override
  @trackedIncludedInId
  TypeAliasElementImpl get baseElement => this;

  @override
  @trackedIncludedInId
  LibraryElementImpl get enclosingElement => library;

  @override
  @trackedDirectlyOpaque
  TypeAliasFragmentImpl get firstFragment {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFirstFragment,
      target: this,
      method: 'firstFragment',
    );
    return _firstFragment;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasSelfReference': hasSelfReference,
      'isSimplyBounded': isSimplyBounded,
    };
  }

  @override
  @trackedDirectlyOpaque
  List<TypeAliasFragmentImpl> get fragments {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueFragments,
      target: this,
      method: 'fragments',
    );
    return _fragments;
  }

  /// Whether this alias references itself, directly or indirectly, from
  /// anywhere except a class element or type parameter bounds.
  @generated
  @trackedIncludedInId
  bool get hasSelfReference {
    return hasFlag(_ElementStorageFlag.typeAliasElement_hasSelfReference);
  }

  @generated
  set hasSelfReference(bool value) {
    setFlag(_ElementStorageFlag.typeAliasElement_hasSelfReference, value);
  }

  @trackedIncludedInId
  bool get isNonFunctionTypeAliasesEnabled {
    return library.featureSet.isEnabled(Feature.nonfunction_type_aliases);
  }

  /// Whether this alias is a "proper rename" of [aliasedType], as defined in
  /// the constructor-tearoffs specification.
  @trackedIndirectly
  bool get isProperRename {
    var aliasedType_ = aliasedType;
    if (aliasedType_ is! InterfaceTypeImpl) {
      return false;
    }
    var typeParameters = this.typeParameters;
    var aliasedClass = aliasedType_.element;
    var typeArguments = aliasedType_.typeArguments;
    var typeParameterCount = typeParameters.length;
    if (typeParameterCount != aliasedClass.typeParameters.length) {
      return false;
    }
    for (var i = 0; i < typeParameterCount; i++) {
      var bound = typeParameters[i].bound ?? DynamicTypeImpl.instance;
      var aliasedBound =
          aliasedClass.typeParameters[i].bound ??
          library.typeProvider.dynamicType;
      if (!library.typeSystem.isSubtypeOf(bound, aliasedBound) ||
          !library.typeSystem.isSubtypeOf(aliasedBound, bound)) {
        return false;
      }
      var typeArgument = typeArguments[i];
      if (typeArgument is TypeParameterType &&
          typeParameters[i] != typeArgument.element) {
        return false;
      }
    }
    return true;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isSimplyBounded {
    return hasFlag(_ElementStorageFlag.typeAliasElement_isSimplyBounded);
  }

  @generated
  set isSimplyBounded(bool value) {
    setFlag(_ElementStorageFlag.typeAliasElement_isSimplyBounded, value);
  }

  @override
  @trackedIncludedInId
  ElementKind get kind => ElementKind.TYPE_ALIAS;

  @override
  @trackedIncludedInId
  LibraryElementImpl get library => super.library!;

  @override
  @trackedIncludedInId
  MetadataImpl get metadata {
    return _firstFragment.elementMetadata;
  }

  @override
  @trackedIncludedInId
  String? get name => _firstFragment.name;

  @override
  @trackedIncludedInId
  List<TypeParameterElementImpl> get typeParameters {
    _ensureReadResolution();
    return _firstFragment.typeParameters
        .map((fragment) => fragment.element)
        .toList();
  }

  List<TypeAliasFragmentImpl> get _fragments {
    return [
      for (
        TypeAliasFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  @trackedDirectlyOpaque
  T? accept<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueAccept,
      target: this,
      method: 'accept',
    );
    return visitor.visitTypeAliasElement(this);
  }

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeTypeAliasElement(this);
  }

  @override
  @trackedIndirectly
  TypeImpl instantiate({
    required List<DartType> typeArguments,
    required NullabilitySuffix nullabilitySuffix,
  }) {
    return instantiateImpl(
      typeArguments: typeArguments.cast<TypeImpl>(),
      nullabilitySuffix: nullabilitySuffix,
    );
  }

  @trackedIndirectly
  TypeImpl instantiateImpl({
    required List<TypeImpl> typeArguments,
    required NullabilitySuffix nullabilitySuffix,
  }) {
    if (hasSelfReference) {
      if (isNonFunctionTypeAliasesEnabled) {
        return DynamicTypeImpl.instance;
      } else {
        return _errorFunctionType(nullabilitySuffix);
      }
    }

    var substitution = Substitution.fromPairs2(typeParameters, typeArguments);
    var type = substitution.substituteType(aliasedType);

    var resultNullability = type.nullabilitySuffix == NullabilitySuffix.question
        ? NullabilitySuffix.question
        : nullabilitySuffix;

    var alias = InstantiatedTypeAliasElementImpl(
      element: this,
      typeArguments: typeArguments,
      nullabilitySuffix: nullabilitySuffix,
    );

    return type.withNullability(resultNullability).withAlias(alias);
  }

  FunctionTypeImpl _errorFunctionType(NullabilitySuffix nullabilitySuffix) {
    return FunctionTypeImpl(
      typeParameters: const [],
      formalParameters: const [],
      returnType: DynamicTypeImpl.instance,
      nullabilitySuffix: nullabilitySuffix,
    );
  }
}

/// An element that represents [GenericTypeAlias].
///
/// Clients may not extend, implement or mix-in this class.
class TypeAliasFragmentImpl extends FragmentImpl
    with DeferredResolutionReadingMixin
    implements TypeAliasFragment {
  @override
  final String? name;

  @override
  int? nameOffset;

  List<TypeParameterFragmentImpl> _typeParameters = const [];

  @override
  Null previousFragment;

  @override
  Null nextFragment;

  @override
  late TypeAliasElementImpl element;

  TypeAliasFragmentImpl({required this.name, required super.firstTokenOffset});

  @override
  List<FragmentImpl> get children => const [];

  @override
  String get displayName => name ?? '';

  @override
  LibraryFragmentImpl get enclosingFragment =>
      super.enclosingFragment as LibraryFragmentImpl;

  @override
  LibraryFragmentImpl get libraryFragment => enclosingUnit;

  @override
  MetadataImpl get metadata {
    _ensureReadResolution();
    return super.metadata;
  }

  @override
  int get offset => nameOffset ?? firstTokenOffset!;

  @override
  List<TypeParameterFragmentImpl> get typeParameters {
    _ensureReadResolution();
    return _typeParameters;
  }

  set typeParameters(List<TypeParameterFragmentImpl> typeParameters) {
    for (var typeParameter in typeParameters) {
      typeParameter.enclosingFragment = this;
    }
    _typeParameters = typeParameters;
  }
}

class TypeParameterElementImpl extends ElementImpl
    implements TypeParameterElement, SharedTypeParameter {
  @override
  final TypeParameterFragmentImpl _firstFragment;

  /// The value representing the variance modifier keyword, or `null` if
  /// there is no explicit variance modifier, meaning legacy covariance.
  shared.Variance? _variance;

  @override
  TypeImpl? bound;

  /// The default value of the type parameter. It is used to provide the
  /// corresponding missing type argument in type annotations and as the
  /// fall-back type value in type inference.
  TypeImpl? defaultType;

  TypeParameterElementImpl({required TypeParameterFragmentImpl firstFragment})
    : _firstFragment = firstFragment {
    assert(firstFragment.previousFragment == null);
    assert(firstFragment.nextFragment == null);
    firstFragment.element = this;
  }

  factory TypeParameterElementImpl.synthetic({required String name}) {
    var fragment = TypeParameterFragmentImpl.synthetic(name: name);
    return TypeParameterElementImpl(firstFragment: fragment);
  }

  @override
  TypeParameterElementImpl get baseElement => this;

  @override
  TypeImpl? get boundShared => bound;

  @override
  Element? get enclosingElement {
    return _firstFragment.enclosingFragment?.element;
  }

  @override
  TypeParameterFragmentImpl get firstFragment => _firstFragment;

  @override
  List<TypeParameterFragmentImpl> get fragments {
    return [
      for (
        TypeParameterFragmentImpl? fragment = _firstFragment;
        fragment != null;
        fragment = fragment.nextFragment
      )
        fragment,
    ];
  }

  @override
  bool get isLegacyCovariant {
    return _variance == null;
  }

  @override
  ElementKind get kind => ElementKind.TYPE_PARAMETER;

  @override
  MetadataImpl get metadata {
    return _firstFragment.elementMetadata;
  }

  @override
  String? get name => _firstFragment.name;

  @override
  shared.Variance get variance {
    return _variance ?? shared.Variance.covariant;
  }

  set variance(shared.Variance? newVariance) => _variance = newVariance;

  @override
  T? accept<T>(ElementVisitor2<T> visitor) {
    return visitor.visitTypeParameterElement(this);
  }

  @override
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeTypeParameterElement(this);
  }

  /// Computes the variance of the type parameters in the [type].
  shared.Variance computeVarianceInType(DartType type) {
    if (type is TypeParameterTypeImpl) {
      if (type.element == this) {
        return shared.Variance.covariant;
      } else {
        return shared.Variance.unrelated;
      }
    } else if (type is InterfaceTypeImpl) {
      var result = shared.Variance.unrelated;
      for (int i = 0; i < type.typeArguments.length; ++i) {
        var argument = type.typeArguments[i];
        var parameter = type.element.typeParameters[i];

        var parameterVariance = parameter.variance;
        result = result.meet(
          parameterVariance.combine(computeVarianceInType(argument)),
        );
      }
      return result;
    } else if (type is FunctionType) {
      var result = computeVarianceInType(type.returnType);

      for (var parameter in type.typeParameters) {
        // If [parameter] is referenced in the bound at all, it makes the
        // variance of [parameter] in the entire type invariant.  The invocation
        // of [computeVariance] below is made to simply figure out if [variable]
        // occurs in the bound.
        var bound = parameter.bound;
        if (bound != null && !computeVarianceInType(bound).isUnrelated) {
          result = shared.Variance.invariant;
        }
      }

      for (var formalParameter in type.formalParameters) {
        result = result.meet(
          shared.Variance.contravariant.combine(
            computeVarianceInType(formalParameter.type),
          ),
        );
      }
      return result;
    }
    return shared.Variance.unrelated;
  }

  @override
  TypeParameterTypeImpl instantiate({
    required NullabilitySuffix nullabilitySuffix,
  }) {
    return TypeParameterTypeImpl(
      element: this,
      nullabilitySuffix: nullabilitySuffix,
    );
  }

  @override
  void visitChildren<T>(ElementVisitor2<T> visitor) {
    for (var child in children) {
      child.accept(visitor);
    }
  }
}

@GenerateElementFlags(flags: _TypeParameterElementFlags.values)
class TypeParameterFragmentImpl extends FragmentImpl
    implements TypeParameterFragment {
  @override
  final String? name;

  @override
  int? nameOffset;

  @override
  TypeParameterFragmentImpl? previousFragment;

  @override
  TypeParameterFragmentImpl? nextFragment;

  @override
  late final TypeParameterElementImpl element;

  /// Initialize a newly created type parameter fragment to have the given
  /// [name] and [offset].
  TypeParameterFragmentImpl({required this.name, super.firstTokenOffset});

  TypeParameterFragmentImpl.synthetic({required this.name})
    : super(firstTokenOffset: null);

  @override
  List<FragmentImpl> get children => const [];

  @override
  String get displayName => name ?? '';

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'isOriginOtherFragmentOfEnclosing': isOriginOtherFragmentOfEnclosing,
    };
  }

  @generated
  bool get isOriginOtherFragmentOfEnclosing {
    return hasFlag(
      _FragmentStorageFlag
          .typeParameterFragment_isOriginOtherFragmentOfEnclosing,
    );
  }

  @generated
  set isOriginOtherFragmentOfEnclosing(bool value) {
    setFlag(
      _FragmentStorageFlag
          .typeParameterFragment_isOriginOtherFragmentOfEnclosing,
      value,
    );
  }

  @override
  LibraryFragmentImpl? get libraryFragment {
    return enclosingFragment?.libraryFragment;
  }

  @override
  int get offset =>
      nameOffset ?? firstTokenOffset ?? enclosingFragment?.offset ?? -1;

  void addFragment(TypeParameterFragmentImpl fragment) {
    fragment.element = element;
    fragment.previousFragment = this;
    nextFragment = fragment;
  }

  static void _linkFragments<T extends FragmentImpl>(
    List<T> fragments, {
    required List<TypeParameterFragmentImpl> Function(T) getFragments,
  }) {
    DeferredResolutionReadingHelper.withoutLoadingResolution(() {
      var firstFragments = getFragments(fragments.first);
      for (var i = 0; i < firstFragments.length; i++) {
        fragments.reduce((previous, current) {
          getFragments(previous)[i].addFragment(getFragments(current)[i]);
          return current;
        });
      }
    });
  }
}

@elementClass
@GenerateElementFlags(flags: _VariableElementFlags.values)
abstract class VariableElementImpl extends ElementImpl
    with InternalVariableElement
    implements ConstantEvaluationTarget {
  ConstantInitializerImpl? _constantInitializerData;

  /// The result of evaluating [constantInitializer2].
  ///
  /// Is `null` if [constantInitializer2] is `null`, or if the value could not
  /// be computed because of errors.
  @trackedInternal
  Constant? evaluationResult;

  @ToBeDeprecated('Use constantInitializer2 instead.')
  @override
  @trackedIncludedInId
  ExpressionImpl? get constantInitializer {
    var initializer = constantInitializer2;
    return initializer == null
        ? null
        : V1Projection.toV1Expression(initializer);
  }

  @override
  @trackedIncludedInId
  ExpressionImpl? get constantInitializer2 {
    return constantInitializerData?.expression;
  }

  // TODO(scheglov): remove this wrapper once fragment provenance is no longer
  // needed by top-level inference and element text output.
  @trackedIncludedInId
  ConstantInitializerImpl? get constantInitializerData {
    if (_constantInitializerData case var result?) {
      return result;
    }

    for (var fragment in _fragments.reversed) {
      if (fragment.constantInitializer2 case ExpressionImpl expression) {
        return _constantInitializerData = ConstantInitializerImpl(
          fragment: fragment,
          expression: expression,
        );
      }
    }

    return null;
  }

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasImplicitType': hasImplicitType,
      'isAbstract': isAbstract,
      'isConst': isConst,
      'isExternal': isExternal,
      'isFinal': isFinal,
      'isLate': isLate,
      'isStatic': isStatic,
    };
  }

  @generated
  @override
  @trackedIncludedInId
  bool get hasImplicitType {
    return _firstFragment.hasImplicitType;
  }

  @generated
  @trackedIncludedInId
  bool get isAbstract {
    return _firstFragment.isAbstract;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isConst {
    return _firstFragment.isConst;
  }

  @override
  @trackedInternal
  bool get isConstantEvaluated => evaluationResult != null;

  @generated
  @trackedIncludedInId
  bool get isExternal {
    return _firstFragment.isExternal;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isFinal {
    return _firstFragment.isFinal;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isLate {
    return _firstFragment.isLate;
  }

  @generated
  @override
  @trackedIncludedInId
  bool get isStatic {
    return _firstFragment.isStatic;
  }

  @override
  @trackedIncludedInId
  LibraryFragmentImpl? get libraryFragment => _firstFragment.libraryFragment;

  set type(TypeImpl type) {
    // TODO(scheglov): eventually move logic from PropertyInducingElementImpl
  }

  @override
  VariableFragmentImpl get _firstFragment;

  List<VariableFragmentImpl> get _fragments;

  @override
  @trackedIndirectly
  void appendTo(ElementDisplayStringBuilder builder) {
    builder.writeVariableElement(this);
  }

  /// Return a representation of the value of this variable, forcing the value
  /// to be computed if it had not previously been computed, or `null` if either
  /// this variable was not declared with the 'const' modifier or if the value
  /// of this variable could not be computed because of errors.
  @override
  @trackedIndirectly
  DartObject? computeConstantValue() {
    if (evaluationResult == null) {
      var library = libraryFragment?.element;
      // TODO(scheglov): https://github.com/dart-lang/sdk/issues/47915
      if (library == null) {
        return null;
      }
      computeConstants(
        declaredVariables: library.declaredVariables,
        constants: [this],
        featureSet: library.featureSet,
        configuration: ConstantEvaluationConfiguration(),
      );
    }

    if (evaluationResult case DartObjectImpl result) {
      return result;
    }
    return null;
  }

  @trackedInternal
  void resetConstantInitializer() {
    _constantInitializerData = null;
  }

  @override
  @trackedDirectlyOpaque
  void visitChildren<T>(ElementVisitor2<T> visitor) {
    globalResultRequirements?.recordOpaqueApiUse(
      kindId: RequirementFailureKindId.opaqueVisitChildren,
      target: this,
      method: 'visitChildren',
    );
    for (var child in children) {
      child.accept(visitor);
    }
  }
}

@GenerateElementFlags(flags: _VariableElementFlags.values)
abstract class VariableFragmentImpl extends FragmentImpl
    implements VariableFragment {
  /// If this element represents a constant variable, and it has an initializer,
  /// a copy of the initializer for the constant.  Otherwise `null`.
  ///
  /// Note that in correct Dart code, all constant variables must have
  /// initializers.  However, analyzer also needs to handle incorrect Dart code,
  /// in which case there might be some constant variables that lack
  /// initializers.
  ExpressionImpl? constantInitializer2;

  /// Initialize a newly created variable element to have the given [name] and
  /// [offset].
  VariableFragmentImpl({required super.firstTokenOffset});

  @ToBeDeprecated('Use constantInitializer2 instead.')
  ExpressionImpl? get constantInitializer {
    var initializer = constantInitializer2;
    return initializer == null
        ? null
        : V1Projection.toV1Expression(initializer);
  }

  @override
  String get displayName => name ?? '';

  @override
  VariableElementImpl get element;

  @generated
  @override
  @visibleForTesting
  @trackedInternal
  Map<String, bool> get flagsForTesting {
    return {
      ...super.flagsForTesting,
      'hasImplicitType': hasImplicitType,
      'isAbstract': isAbstract,
      'isConst': isConst,
      'isExternal': isExternal,
      'isFinal': isFinal,
      'isLate': isLate,
      'isStatic': isStatic,
    };
  }

  /// Whether the variable element did not have an explicit type specified
  /// for it.
  @generated
  bool get hasImplicitType {
    return hasFlag(_FragmentStorageFlag.variableFragment_hasImplicitType);
  }

  @generated
  set hasImplicitType(bool value) {
    setFlag(_FragmentStorageFlag.variableFragment_hasImplicitType, value);
  }

  // TODO(scheglov): remove this
  ExpressionImpl? get initializer {
    return constantInitializer2;
  }

  /// Whether the executable element is abstract.
  ///
  /// Executable elements are abstract if they are not external, and have no
  /// body.
  @generated
  bool get isAbstract {
    return hasFlag(_FragmentStorageFlag.variableFragment_isAbstract);
  }

  @generated
  set isAbstract(bool value) {
    setFlag(_FragmentStorageFlag.variableFragment_isAbstract, value);
  }

  @generated
  bool get isConst {
    return hasFlag(_FragmentStorageFlag.variableFragment_isConst);
  }

  @generated
  set isConst(bool value) {
    setFlag(_FragmentStorageFlag.variableFragment_isConst, value);
  }

  /// Executable elements are external if they are explicitly marked as such
  /// using the 'external' keyword.
  @generated
  bool get isExternal {
    return hasFlag(_FragmentStorageFlag.variableFragment_isExternal);
  }

  @generated
  set isExternal(bool value) {
    setFlag(_FragmentStorageFlag.variableFragment_isExternal, value);
  }

  /// Whether the variable was declared with the 'final' modifier.
  ///
  /// Variables that are declared with the 'const' modifier will return `false`
  /// even though they are implicitly final.
  @generated
  bool get isFinal {
    return hasFlag(_FragmentStorageFlag.variableFragment_isFinal);
  }

  @generated
  set isFinal(bool value) {
    setFlag(_FragmentStorageFlag.variableFragment_isFinal, value);
  }

  @generated
  bool get isLate {
    return hasFlag(_FragmentStorageFlag.variableFragment_isLate);
  }

  @generated
  set isLate(bool value) {
    setFlag(_FragmentStorageFlag.variableFragment_isLate, value);
  }

  /// Whether the element is a static variable, as per section 8 of the Dart
  /// Language Specification:
  ///
  /// > A static variable is a variable that is not associated with a particular
  /// > instance, but rather with an entire library or class. Static variables
  /// > include library variables and class variables. Class variables are
  /// > variables whose declaration is immediately nested inside a class
  /// > declaration and includes the modifier static. A library variable is
  /// > implicitly static.
  @generated
  bool get isStatic {
    return hasFlag(_FragmentStorageFlag.variableFragment_isStatic);
  }

  @generated
  set isStatic(bool value) {
    setFlag(_FragmentStorageFlag.variableFragment_isStatic, value);
  }

  @override
  VariableFragmentImpl? get nextFragment;

  @override
  int get offset {
    if (nameOffset ?? firstTokenOffset case var result?) {
      return result;
    }
    if (this case PropertyInducingFragmentImpl property) {
      var getter = property.element.getter?._firstFragment;
      var setter = property.element.setter?._firstFragment;
      return (getter ?? setter)!.offset;
    }
    if (this case FormalParameterFragmentImpl()) {
      return enclosingFragment!.offset;
    }
    throw StateError('($runtimeType) $this');
  }

  @override
  VariableFragmentImpl? get previousFragment;
}

enum _ClassElementFlags {
  hasExtendsClause(fragment: true),
  isAbstract(fragment: true, element: _ElementFlagSource.stored),
  isBase(fragment: true, element: _ElementFlagSource.stored),
  isFinal(fragment: true, element: _ElementFlagSource.stored),
  isInterface(fragment: true, element: _ElementFlagSource.stored),
  isMixinApplication(fragment: true, element: _ElementFlagSource.firstFragment),
  isMixinClass(fragment: true, element: _ElementFlagSource.firstFragment),
  isSealed(fragment: true, element: _ElementFlagSource.firstFragment);

  final bool fragment;
  final _ElementFlagSource element;

  const _ClassElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _ConstructorElementFlags {
  isConst(fragment: true, element: _ElementFlagSource.firstFragment),
  isFactory(fragment: true, element: _ElementFlagSource.firstFragment),
  isInRedirectingConstructorCycle(element: _ElementFlagSource.stored),
  isOriginDeclaration(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isOriginExtensionTypeRecovery(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isOriginImplicitDefault(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isOriginMixinApplication(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isPrimary(fragment: true, element: _ElementFlagSource.firstFragment),
  isRedirecting(fragment: true, element: _ElementFlagSource.computed);

  final bool fragment;
  final _ElementFlagSource element;

  const _ConstructorElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _ElementFlags {
  hasSinceSdkVersionComputed(element: _ElementFlagSource.stored),
  hasSinceSdkVersionValue(element: _ElementFlagSource.stored);

  final bool fragment;
  final _ElementFlagSource element;

  const _ElementFlags({this.element = _ElementFlagSource.none})
    : fragment = false;
}

enum _ElementFlagSource { none, firstFragment, stored, computed }

@generated
enum _ElementStorageFlag {
  classElement_isAbstract,
  classElement_isBase,
  classElement_isFinal,
  classElement_isInterface,
  constructorElement_isInRedirectingConstructorCycle,
  element_hasSinceSdkVersionComputed,
  element_hasSinceSdkVersionValue,
  executableElement_hasEnclosingTypeParameterReference,
  executableElement_isExtensionTypeMember,
  fieldElement_hasEnclosingTypeParameterReference,
  formalParameterElement_isCovariant,
  instanceElement_isSimplyBounded,
  libraryElement_isSynthetic,
  propertyInducingElement_isTypeInferredFromInitializer,
  propertyInducingElement_isTypeInferredFromOverride,
  typeAliasElement_hasSelfReference,
  typeAliasElement_isSimplyBounded,
}

enum _ExecutableElementFlags {
  hasEnclosingTypeParameterReference(element: _ElementFlagSource.stored),
  hasImplicitReturnType(fragment: true, element: _ElementFlagSource.computed),
  invokesSuperSelf(fragment: true, element: _ElementFlagSource.firstFragment),
  isAbstract(fragment: true),
  isAsynchronous(fragment: true),
  isExtensionTypeMember(element: _ElementFlagSource.stored),
  isExternal(fragment: true, element: _ElementFlagSource.computed),
  isGenerator(fragment: true),
  isStatic(fragment: true, element: _ElementFlagSource.firstFragment);

  final bool fragment;
  final _ElementFlagSource element;

  const _ExecutableElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _FieldElementFlags {
  hasEnclosingTypeParameterReference(element: _ElementFlagSource.stored),
  isCovariant(element: _ElementFlagSource.computed),
  isEnumConstant(fragment: true, element: _ElementFlagSource.firstFragment),
  isExplicitlyCovariant(fragment: true),
  isOriginDeclaringFormalParameter(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isOriginEnumValues(fragment: true, element: _ElementFlagSource.firstFragment),
  isOriginExtensionTypeRecoveryRepresentation(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isPromotable(fragment: true, element: _ElementFlagSource.firstFragment);

  final bool fragment;
  final _ElementFlagSource element;

  const _FieldElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _FieldFormalParameterElementFlags {
  isDeclaring(fragment: true, element: _ElementFlagSource.computed);

  final bool fragment;
  final _ElementFlagSource element;

  const _FieldFormalParameterElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _FormalParameterElementFlags {
  hasDefaultValue(element: _ElementFlagSource.computed),
  isCovariant(element: _ElementFlagSource.stored),
  isExplicitlyCovariant(fragment: true),
  isOriginDeclaration(fragment: true),
  isOriginMixinApplicationClassConstructor(fragment: true),
  isOriginOtherFragmentOfEnclosing(fragment: true);

  final bool fragment;
  final _ElementFlagSource element;

  const _FormalParameterElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _FragmentFlags {
  isAugmentation(fragment: true),
  isComplete(fragment: true);

  final bool fragment;
  final _ElementFlagSource element;

  const _FragmentFlags({this.fragment = false})
    : element = _ElementFlagSource.none;
}

@generated
enum _FragmentStorageFlag {
  classFragment_hasExtendsClause,
  classFragment_isAbstract,
  classFragment_isBase,
  classFragment_isFinal,
  classFragment_isInterface,
  classFragment_isMixinApplication,
  classFragment_isMixinClass,
  classFragment_isSealed,
  constructorFragment_isConst,
  constructorFragment_isFactory,
  constructorFragment_isOriginDeclaration,
  constructorFragment_isOriginExtensionTypeRecovery,
  constructorFragment_isOriginImplicitDefault,
  constructorFragment_isOriginMixinApplication,
  constructorFragment_isPrimary,
  constructorFragment_isRedirecting,
  executableFragment_hasImplicitReturnType,
  executableFragment_invokesSuperSelf,
  executableFragment_isAbstract,
  executableFragment_isAsynchronous,
  executableFragment_isExternal,
  executableFragment_isGenerator,
  executableFragment_isStatic,
  fieldFormalParameterFragment_isDeclaring,
  fieldFragment_isEnumConstant,
  fieldFragment_isExplicitlyCovariant,
  fieldFragment_isOriginDeclaringFormalParameter,
  fieldFragment_isOriginEnumValues,
  fieldFragment_isOriginExtensionTypeRecoveryRepresentation,
  fieldFragment_isPromotable,
  formalParameterFragment_isExplicitlyCovariant,
  formalParameterFragment_isOriginDeclaration,
  formalParameterFragment_isOriginMixinApplicationClassConstructor,
  formalParameterFragment_isOriginOtherFragmentOfEnclosing,
  fragment_isAugmentation,
  fragment_isComplete,
  libraryFragment_isOriginNotExistingFile,
  methodFragment_isOriginDeclaration,
  methodFragment_isOriginInterface,
  mixinFragment_isBase,
  nonParameterVariableFragment_hasInitializer,
  propertyAccessorFragment_isOriginDeclaration,
  propertyAccessorFragment_isOriginInterface,
  propertyAccessorFragment_isOriginVariable,
  propertyInducingFragment_isOriginDeclaration,
  propertyInducingFragment_isOriginGetterSetter,
  topLevelFunctionFragment_isOriginDeclaration,
  topLevelFunctionFragment_isOriginLoadLibrary,
  typeParameterFragment_isOriginOtherFragmentOfEnclosing,
  variableFragment_hasImplicitType,
  variableFragment_isAbstract,
  variableFragment_isConst,
  variableFragment_isExternal,
  variableFragment_isFinal,
  variableFragment_isLate,
  variableFragment_isStatic,
}

class _Generated {
  const _Generated();
}

enum _InstanceElementFlags {
  isSimplyBounded(element: _ElementFlagSource.stored);

  final bool fragment;
  final _ElementFlagSource element;

  const _InstanceElementFlags({this.element = _ElementFlagSource.none})
    : fragment = false;
}

enum _InterfaceElementFlags {
  hasNonFinalField(element: _ElementFlagSource.computed);

  final bool fragment;
  final _ElementFlagSource element;

  const _InterfaceElementFlags({this.element = _ElementFlagSource.none})
    : fragment = false;
}

enum _LibraryElementFlags {
  isOriginNotExistingFile(fragment: true),
  isSynthetic(element: _ElementFlagSource.stored);

  final bool fragment;
  final _ElementFlagSource element;

  const _LibraryElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _MethodElementFlags {
  isOriginDeclaration(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isOriginInterface(fragment: true, element: _ElementFlagSource.firstFragment);

  final bool fragment;
  final _ElementFlagSource element;

  const _MethodElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _MixinElementFlags {
  isBase(fragment: true, element: _ElementFlagSource.firstFragment);

  final bool fragment;
  final _ElementFlagSource element;

  const _MixinElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _NonParameterVariableElementFlags {
  hasInitializer(fragment: true);

  final bool fragment;
  final _ElementFlagSource element;

  const _NonParameterVariableElementFlags({this.fragment = false})
    : element = _ElementFlagSource.none;
}

enum _PropertyAccessorElementFlags {
  isOriginDeclaration(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isOriginInterface(fragment: true, element: _ElementFlagSource.firstFragment),
  isOriginVariable(fragment: true, element: _ElementFlagSource.firstFragment);

  final bool fragment;
  final _ElementFlagSource element;

  const _PropertyAccessorElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _PropertyInducingElementFlags {
  hasInitializer(element: _ElementFlagSource.computed),
  isOriginDeclaration(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isOriginGetterSetter(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isTypeInferredFromInitializer(element: _ElementFlagSource.stored),
  isTypeInferredFromOverride(element: _ElementFlagSource.stored);

  final bool fragment;
  final _ElementFlagSource element;

  const _PropertyInducingElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

/// Instances of [List]s that are used as "not yet computed" values, they
/// must be not `null`, and not identical to `const <T>[]`.
class _Sentinel {
  static final List<ClassFragmentImpl> classFragment = List.unmodifiable([]);
  static final List<ConstructorFragmentImpl> constructorFragment =
      List.unmodifiable([]);
  static final List<EnumFragmentImpl> enumFragment = List.unmodifiable([]);
  static final List<ExtensionFragmentImpl> extensionFragment =
      List.unmodifiable([]);
  static final List<ExtensionTypeFragmentImpl> extensionTypeFragment =
      List.unmodifiable([]);
  static final List<FieldFragmentImpl> fieldFragment = List.unmodifiable([]);
  static final List<GetterFragmentImpl> getterFragment = List.unmodifiable([]);
  static final List<MethodFragmentImpl> methodFragment = List.unmodifiable([]);
  static final List<MixinFragmentImpl> mixinFragment = List.unmodifiable([]);
  static final List<SetterFragmentImpl> setterFragment = List.unmodifiable([]);
  static final List<TypeAliasFragmentImpl> typeAliasFragment =
      List.unmodifiable([]);
  static final List<TopLevelFunctionFragmentImpl> topLevelFunctionFragment =
      List.unmodifiable([]);
  static final List<TopLevelVariableFragmentImpl> topLevelVariableFragment =
      List.unmodifiable([]);

  static final List<ConstructorElementImpl> constructorElement =
      List.unmodifiable([]);

  static final List<LibraryExportImpl> libraryExport = List.unmodifiable([]);
  static final List<LibraryImportImpl> libraryImport = List.unmodifiable([]);
}

enum _TopLevelFunctionElementFlags {
  isOriginDeclaration(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  ),
  isOriginLoadLibrary(
    fragment: true,
    element: _ElementFlagSource.firstFragment,
  );

  final bool fragment;
  final _ElementFlagSource element;

  const _TopLevelFunctionElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}

enum _TypeAliasElementFlags {
  hasSelfReference(element: _ElementFlagSource.stored),
  isSimplyBounded(element: _ElementFlagSource.stored);

  final bool fragment;
  final _ElementFlagSource element;

  const _TypeAliasElementFlags({this.element = _ElementFlagSource.none})
    : fragment = false;
}

enum _TypeParameterElementFlags {
  isOriginOtherFragmentOfEnclosing(fragment: true);

  final bool fragment;
  final _ElementFlagSource element;

  const _TypeParameterElementFlags({this.fragment = false})
    : element = _ElementFlagSource.none;
}

enum _VariableElementFlags {
  hasImplicitType(fragment: true, element: _ElementFlagSource.firstFragment),
  isAbstract(fragment: true, element: _ElementFlagSource.firstFragment),
  isConst(fragment: true, element: _ElementFlagSource.firstFragment),
  isExternal(fragment: true, element: _ElementFlagSource.firstFragment),
  isFinal(fragment: true, element: _ElementFlagSource.firstFragment),
  isLate(fragment: true, element: _ElementFlagSource.firstFragment),
  isStatic(fragment: true, element: _ElementFlagSource.firstFragment);

  final bool fragment;
  final _ElementFlagSource element;

  const _VariableElementFlags({
    this.fragment = false,
    this.element = _ElementFlagSource.none,
  });
}