| // Copyright (c) 2024, 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. |
| |
| /// Defines the elements and fragments that are part of the element model. |
| /// |
| /// The element model describes the semantic (as opposed to syntactic) structure |
| /// of Dart code. The syntactic structure of the code is modeled by the |
| /// [AST structure](../dart_ast_ast/dart_ast_ast-library.html). |
| /// |
| /// The element model consists of three closely related kinds of objects: |
| /// elements (instances of a subclass of [Element2]), fragments (instances of a |
| /// subclass of [Fragment]) and types. This library defines the elements and |
| /// fragments; the types are defined in |
| /// [type.dart](../dart_element_type/dart_element_type-library.html). |
| /// |
| /// Generally speaking, an element represents something that is declared in the |
| /// code, such as a class, method, or variable. Elements are organized in a tree |
| /// structure in which the children of an element are the elements that are |
| /// logically (and often syntactically) part of the declaration of the parent. |
| /// For example, the elements representing the methods and fields in a class are |
| /// children of the element representing the class. |
| /// |
| /// Some elements, such as a [LocalVariableElement2] are declared by a single |
| /// declaration, but most elements can be declared by multiple declarations. A |
| /// fragment represents a single declararation when the corresponding element |
| /// can have multiple declarations. There is no fragment for an element that can |
| /// only have one declaration. |
| /// |
| /// As with elements, fragments are organized in a tree structure. The two |
| /// structures parallel each other. |
| /// |
| /// Every complete element structure is rooted by an instance of the class |
| /// [LibraryElement2]. A library element represents a single Dart library. Every |
| /// library is defined by one or more compilation units (the library and all of |
| /// its parts). The compilation units are represented by the class |
| /// [LibraryFragment]. |
| /// |
| /// The element model does not contain everything in the code, only those things |
| /// that are declared by the code. For example, it does not include any |
| /// representation of the statements in a method body, but if one of those |
| /// statements declares a local variable then the local variable will be |
| /// represented by an element. |
| /// |
| /// @docImport 'package:analyzer/src/dart/element/member.dart'; |
| library; |
| |
| import 'package:analyzer/dart/analysis/features.dart'; |
| import 'package:analyzer/dart/analysis/session.dart'; |
| import 'package:analyzer/dart/constant/value.dart'; |
| import 'package:analyzer/dart/element/element.dart' |
| show |
| DirectiveUri, |
| ElementAnnotation, |
| ElementKind, |
| ElementLocation, |
| LibraryLanguageVersion, |
| NamespaceCombinator; |
| import 'package:analyzer/dart/element/nullability_suffix.dart'; |
| import 'package:analyzer/dart/element/scope.dart'; |
| import 'package:analyzer/dart/element/type.dart'; |
| import 'package:analyzer/dart/element/type_provider.dart'; |
| import 'package:analyzer/dart/element/type_system.dart'; |
| import 'package:analyzer/source/line_info.dart'; |
| import 'package:analyzer/src/dart/resolver/scope.dart'; |
| import 'package:pub_semver/pub_semver.dart'; |
| |
| abstract class BindPatternVariableElement2 implements PatternVariableElement2 {} |
| |
| /// A class. |
| /// |
| /// The class can be defined by either a class declaration (with a class body), |
| /// or a mixin application (without a class body). |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class ClassElement2 implements InterfaceElement2 { |
| /// Whether the class or its superclass declares a non-final instance field. |
| bool get hasNonFinalField; |
| |
| /// Whether the class is abstract. |
| /// |
| /// A class is abstract if it has an explicit `abstract` modifier. Note, that |
| /// this definition of <i>abstract</i> is different from <i>has unimplemented |
| /// members</i>. |
| bool get isAbstract; |
| |
| /// Whether this class is a base class. |
| /// |
| /// A class is a base class if it has an explicit `base` modifier, or the |
| /// class has a `base` induced modifier and [isSealed] is `true` as well. |
| /// The base modifier allows the class to be extended but not implemented. |
| bool get isBase; |
| |
| /// Whether the class can be instantiated. |
| bool get isConstructable; |
| |
| /// Whether the class represents the class 'Enum' defined in `dart:core`. |
| bool get isDartCoreEnum; |
| |
| /// Whether the class represents the class 'Object' defined in `dart:core`. |
| bool get isDartCoreObject; |
| |
| /// Whether the class is exhaustive. |
| /// |
| /// A class is exhaustive if it has the property where, in a switch, if you |
| /// cover all of the subtypes of this element, then the compiler knows that |
| /// you have covered all possible instances of the type. |
| bool get isExhaustive; |
| |
| /// Whether the class is a final class. |
| /// |
| /// A class is a final class if it has an explicit `final` modifier, or the |
| /// class has a `final` induced modifier and [isSealed] is `true` as well. |
| /// The final modifier prohibits this class from being extended, implemented, |
| /// or mixed in. |
| bool get isFinal; |
| |
| /// Whether the class is an interface class. |
| /// |
| /// A class is an interface class if it has an explicit `interface` modifier, |
| /// or the class has an `interface` induced modifier and [isSealed] is `true` |
| /// as well. The interface modifier allows the class to be implemented, but |
| /// not extended or mixed in. |
| bool get isInterface; |
| |
| /// Whether the class is a mixin application. |
| /// |
| /// A class is a mixin application if it was declared using the syntax |
| /// `class A = B with C;`. |
| bool get isMixinApplication; |
| |
| /// Whether the class is a mixin class. |
| /// |
| /// A class is a mixin class if it has an explicit `mixin` modifier. |
| bool get isMixinClass; |
| |
| /// Whether the class is a sealed class. |
| /// |
| /// A class is a sealed class if it has an explicit `sealed` modifier. |
| bool get isSealed; |
| |
| /// Whether the class can validly be used as a mixin when defining another |
| /// class. |
| /// |
| /// For classes defined by a class declaration or a mixin application, the |
| /// behavior of this method is defined by the Dart Language Specification |
| /// in section 9: |
| /// <blockquote> |
| /// It is a compile-time error if a declared or derived mixin refers to super. |
| /// It is a compile-time error if a declared or derived mixin explicitly |
| /// declares a constructor. It is a compile-time error if a mixin is derived |
| /// from a class whose superclass is not Object. |
| /// </blockquote> |
| bool get isValidMixin; |
| |
| /// Whether the class, assuming that it is within scope, can be extended by |
| /// classes in the given [library]. |
| bool isExtendableIn2(LibraryElement2 library); |
| |
| /// Whether the class, assuming that it is within scope, can be implemented by |
| /// classes, mixins, and enums in the given [library]. |
| bool isImplementableIn2(LibraryElement2 library); |
| |
| /// Whether the class, assuming that it is within scope, can be mixed-in by |
| /// classes and enums in the given [library]. |
| bool isMixableIn2(LibraryElement2 library); |
| } |
| |
| /// The portion of a [ClassElement2] contributed by a single declaration. |
| /// |
| /// The fragment can be defined by either a class declaration (with a class |
| /// body), or a mixin application (without a class body). |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class ClassFragment implements InterfaceFragment {} |
| |
| /// An element representing a constructor defined by a class, enum, or extension |
| /// type. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class ConstructorElement2 implements ExecutableElement2, _Fragmented { |
| @override |
| ConstructorElement2 get baseElement; |
| |
| /// Whether the constructor is a const constructor. |
| bool get isConst; |
| |
| /// Whether the constructor can be used as a default constructor - unnamed, |
| /// and has no required parameters. |
| bool get isDefaultConstructor; |
| |
| /// Whether the constructor represents a factory constructor. |
| bool get isFactory; |
| |
| /// Whether the constructor represents a generative constructor. |
| bool get isGenerative; |
| |
| /// The constructor to which this constructor is redirecting. |
| /// |
| /// Returns `null` if this constructor does not redirect to another |
| /// constructor or if the library containing this constructor has not yet been |
| /// resolved. |
| ConstructorElement2? get redirectedConstructor2; |
| |
| /// The constructor of the superclass that this constructor invokes, or |
| /// `null` if this constructor redirects to another constructor, or if the |
| /// library containing this constructor has not yet been resolved. |
| ConstructorElement2? get superConstructor2; |
| } |
| |
| /// The portion of a [ConstructorElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class ConstructorFragment implements ExecutableFragment { |
| @override |
| ConstructorElement2 get element; |
| |
| @override |
| InstanceFragment? get enclosingFragment; |
| |
| /// The offset of the end of the name in this fragment. |
| /// |
| /// Returns `null` if the fragment has no name. |
| int? get nameEnd; |
| |
| @override |
| ConstructorFragment? get nextFragment; |
| |
| /// The offset of the `.` before the constructor name. |
| /// |
| /// Returns `null` if the constructor is unnamed. |
| int? get periodOffset; |
| |
| @override |
| ConstructorFragment? get previousFragment; |
| } |
| |
| /// The base class for all of the elements in the element model. |
| /// |
| /// Generally speaking, the element model is a semantic model of the program |
| /// that represents things that are declared with a name and hence can be |
| /// referenced elsewhere in the code. There are two exceptions to the general |
| /// case. |
| /// |
| /// First, there are elements in the element model that are created for the |
| /// convenience of various kinds of analysis but that don't have any |
| /// corresponding declaration within the source code. Such elements are marked |
| /// as being <i>synthetic</i>. Examples of synthetic elements include |
| /// - default constructors in classes that don't define any explicit |
| /// constructors, |
| /// - getters and setters that are induced by explicit field declarations, |
| /// - fields that are induced by explicit declarations of getters and setters, |
| /// and |
| /// - functions representing the initialization expression for a variable. |
| /// |
| /// Second, there are elements in the element model that don't have, or are not |
| /// required to have a name. These correspond to things like unnamed functions |
| /// or extensions. They exist in order to more accurately represent the semantic |
| /// structure of the program. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class Element2 { |
| /// The non-[Member] version of this element. |
| /// |
| /// If the receiver is a view on an element, such as a method from an |
| /// interface type with substituted type parameters, this getter will return |
| /// the corresponding element from the class, without any substitutions. |
| /// |
| /// If the receiver is already a non-[Member] element (or a synthetic element, |
| /// such as a synthetic property accessor), this getter will return the |
| /// receiver. |
| Element2? get baseElement; |
| |
| /// The children of this element. |
| /// |
| /// There is no guarantee of the order in which the children will be returned. |
| /// For example, they are not guaranteed to be in lexical order. |
| List<Element2> get children2; |
| |
| /// The display name of this element, or empty string if the element does not |
| /// have a name. |
| /// |
| /// In most cases the name and the display name are the same. They differ in |
| /// cases such as setters where the `name` of some setter (`set s(x)`) is `s=` |
| /// but the `displayName` is `s`. |
| String get displayName; |
| |
| /// The element that either physically or logically encloses this element. |
| /// |
| /// Returns `null` if this element is a library because libraries are the |
| /// top-level elements in the model. |
| Element2? get enclosingElement2; |
| |
| /// The unique integer identifier of this element. |
| int get id; |
| |
| /// Whether this element is private. |
| /// |
| /// Private elements are visible only within the library in which they are |
| /// declared. |
| bool get isPrivate; |
| |
| /// Whether this element is public. |
| /// |
| /// Public elements are visible within any library that imports the library |
| /// in which they are declared. |
| bool get isPublic; |
| |
| /// Whether this element is synthetic. |
| /// |
| /// A synthetic element is an element that is not represented in the source |
| /// code explicitly, but is implied by the source code, such as the default |
| /// constructor for a class that does not explicitly define any constructors. |
| bool get isSynthetic; |
| |
| /// The kind of this element. |
| ElementKind get kind; |
| |
| /// Library that contains this element. |
| /// |
| /// This will be the element itself if it's a library element. This will be |
| /// `null` if this element is a [MultiplyDefinedElement] that isn't contained |
| /// in a single library. |
| LibraryElement2? get library2; |
| |
| /// The location of this element in the element model. |
| /// |
| /// The object can be used to locate this element at a later time. |
| ElementLocation? get location; |
| |
| /// The name of this element. |
| /// |
| /// Returns `null` if this element doesn't have a name. |
| String? get name; |
| |
| /// The non-synthetic element that caused this element to be created. |
| /// |
| /// If this element is not synthetic, then the element itself is returned. |
| /// |
| /// If this element is synthetic, then the corresponding non-synthetic |
| /// element is returned. For example, for a synthetic getter of a |
| /// non-synthetic field the field is returned; for a synthetic constructor |
| /// the enclosing class is returned. |
| Element2 get nonSynthetic2; |
| |
| /// The analysis session in which this element is defined. |
| AnalysisSession? get session; |
| |
| /// The presentation of this element as it should appear when presented to |
| /// users. |
| /// |
| /// If [multiline] is `true`, then the string may be wrapped over multiple |
| /// lines with newlines to improve formatting. For example, function |
| /// signatures may be formatted as if they had trailing commas. |
| /// |
| /// If [preferTypeAlias] is `true` and the element represents a type defined |
| /// by a type alias, then the name of the type alias will be used in the |
| /// returned string rather than the name of the type being aliased. |
| /// |
| /// Clients should not depend on the content of the returned value as it will |
| /// be changed if doing so would improve the UX. |
| String displayString2({bool multiline = false, bool preferTypeAlias = false}); |
| |
| /// Whether the element, assuming that it is within scope, is accessible to |
| /// code in the given [library]. |
| /// |
| /// This is defined by the Dart Language Specification in section 6.2: |
| /// <blockquote> |
| /// A declaration <i>m</i> is accessible to a library <i>L</i> if <i>m</i> is |
| /// declared in <i>L</i> or if <i>m</i> is public. |
| /// </blockquote> |
| bool isAccessibleIn2(LibraryElement2 library); |
| |
| /// Returns either this element or the most immediate ancestor of this element |
| /// for which the [predicate] returns `true`. |
| /// |
| /// Returns `null` if there is no such element. |
| E? thisOrAncestorMatching2<E extends Element2>( |
| bool Function(Element2) predicate, |
| ); |
| |
| /// Returns either this element or the most immediate ancestor of this element |
| /// that has the given type. |
| /// |
| /// Returns `null` if there is no such element. |
| E? thisOrAncestorOfType2<E extends Element2>(); |
| } |
| |
| /// An element that represents an enum. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class EnumElement2 implements InterfaceElement2 { |
| /// The constants defined by the enum. |
| List<FieldElement2> get constants2; |
| } |
| |
| /// The portion of an [EnumElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class EnumFragment implements InterfaceFragment { |
| /// The constants defined by this fragment of the enum. |
| List<FieldElement2> get constants2; |
| } |
| |
| /// An element representing an executable object, including functions, methods, |
| /// constructors, getters, and setters. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class ExecutableElement2 implements FunctionTypedElement2 { |
| @override |
| ExecutableElement2 get baseElement; |
| |
| /// Whether the executable element did not have an explicit return type |
| /// specified for it in the original source. |
| bool get hasImplicitReturnType; |
| |
| /// Whether the executable element is abstract. |
| /// |
| /// Executable elements are abstract if they are not external, and have no |
| /// body. |
| bool get isAbstract; |
| |
| /// Whether the executable element is an extension type member. |
| bool get isExtensionTypeMember; |
| |
| /// Whether the executable element is external. |
| /// |
| /// Executable elements are external if they are explicitly marked as such |
| /// using the 'external' keyword. |
| bool get isExternal; |
| |
| /// Whether the element is a static element. |
| /// |
| /// A static element is an element that is not associated with a particular |
| /// instance, but rather with an entire library or class. |
| bool get isStatic; |
| } |
| |
| /// The portion of an [ExecutableElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class ExecutableFragment implements FunctionTypedFragment { |
| /// Whether the body is marked as being asynchronous. |
| bool get isAsynchronous; |
| |
| /// Whether the element is an augmentation. |
| /// |
| /// Executable elements are augmentations if they are explicitly marked as |
| /// such using the 'augment' modifier. |
| bool get isAugmentation; |
| |
| /// Whether the body is marked as being a generator. |
| bool get isGenerator; |
| |
| /// Whether the body is marked as being synchronous. |
| bool get isSynchronous; |
| } |
| |
| /// An extension. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class ExtensionElement2 implements InstanceElement2 { |
| /// The type that is extended by this extension. |
| DartType get extendedType; |
| } |
| |
| /// The portion of an [ExtensionElement2] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement, or mix-in this class. |
| abstract class ExtensionFragment implements InstanceFragment {} |
| |
| /// An extension type. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class ExtensionTypeElement2 implements InterfaceElement2 { |
| /// The primary constructor of this extension. |
| ConstructorElement2 get primaryConstructor2; |
| |
| /// The representation of this extension. |
| FieldElement2 get representation2; |
| |
| /// The extension type erasure, obtained by recursively replacing every |
| /// subterm which is an extension type by the corresponding representation |
| /// type. |
| DartType get typeErasure; |
| } |
| |
| /// The portion of an [ExtensionTypeElement2] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement, or mix-in this class. |
| abstract class ExtensionTypeFragment implements InterfaceFragment { |
| ConstructorFragment get primaryConstructor2; |
| |
| /// The representation of this extension. |
| FieldFragment get representation2; |
| } |
| |
| /// A field defined within a class, enum, extension, or mixin. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class FieldElement2 implements PropertyInducingElement2 { |
| @override |
| FieldElement2 get baseElement; |
| |
| /// Whether the field is abstract. |
| /// |
| /// Executable fields are abstract if they are declared with the `abstract` |
| /// keyword. |
| bool get isAbstract; |
| |
| /// Whether the field was explicitly marked as being covariant. |
| bool get isCovariant; |
| |
| /// Whether the element is an enum constant. |
| bool get isEnumConstant; |
| |
| /// Whether the field was explicitly marked as being external. |
| bool get isExternal; |
| |
| /// Whether the field can be type promoted. |
| bool get isPromotable; |
| } |
| |
| /// A field formal parameter defined within a constructor element. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class FieldFormalParameterElement2 implements FormalParameterElement { |
| /// The field element associated with this field formal parameter. |
| /// |
| /// Returns `null` if the parameter references a field that doesn't exist. |
| FieldElement2? get field2; |
| } |
| |
| /// The portion of a [FieldFormalParameterElement2] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement, or mix-in this class. |
| abstract class FieldFormalParameterFragment |
| implements FormalParameterFragment {} |
| |
| /// The portion of a [FieldElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement, or mix-in this class. |
| abstract class FieldFragment implements PropertyInducingFragment { |
| @override |
| FieldElement2 get element; |
| |
| @override |
| FieldFragment? get nextFragment; |
| |
| @override |
| FieldFragment? get previousFragment; |
| } |
| |
| /// A formal parameter defined by an executable element. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class FormalParameterElement |
| implements PromotableElement2, _Annotatable, _Fragmented { |
| @override |
| FormalParameterElement get baseElement; |
| |
| /// The code of the default value. |
| /// |
| /// Returns `null` if no default value. |
| String? get defaultValueCode; |
| |
| /// Whether the parameter has a default value. |
| bool get hasDefaultValue; |
| |
| /// Whether the parameter is covariant, meaning it is allowed to have a |
| /// narrower type in an override. |
| bool get isCovariant; |
| |
| /// Whether the parameter is an initializing formal parameter. |
| bool get isInitializingFormal; |
| |
| /// 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; |
| |
| /// 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; |
| |
| /// 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; |
| |
| /// Whether the parameter is both an optional and positional parameter. |
| bool get isOptionalPositional; |
| |
| /// Whether the parameter is a positional parameter. |
| /// |
| /// Positional parameters can either be required or optional. |
| bool get 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; |
| |
| /// 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; |
| |
| /// Whether the parameter is both a required and positional parameter. |
| bool get isRequiredPositional; |
| |
| /// Whether the parameter is a super formal parameter. |
| bool get isSuperFormal; |
| |
| /// The parameters defined by this parameter. |
| /// |
| /// A parameter will only define other parameters if it is a function typed |
| /// parameter. |
| List<FormalParameterElement> get parameters2; |
| |
| /// The type parameters defined by this parameter. |
| /// |
| /// A parameter will only define type parameters if it is a function typed |
| /// parameter. |
| List<TypeParameterElement2> get typeParameters2; |
| |
| /// Appends the type, name and possibly the default value of this parameter |
| /// to the given [buffer]. |
| void appendToWithoutDelimiters2(StringBuffer buffer); |
| } |
| |
| /// The portion of a [FormalParameterElement] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement, or mix-in this class. |
| abstract class FormalParameterFragment |
| implements PromotableFragment, _Annotatable { |
| @override |
| FormalParameterFragment? get nextFragment; |
| |
| @override |
| FormalParameterFragment? get previousFragment; |
| } |
| |
| /// A fragment that wholly or partially defines an element. |
| /// |
| /// When an element is defined by one or more fragments, those fragments form an |
| /// augmentation chain. This is represented in the element model as a |
| /// doubly-linked list. |
| /// |
| /// In valid code the first fragment is the base declaration and all of the |
| /// other fragments are augmentations. This can be violated in the element model |
| /// in the case of invalid code, such as when an augmentation is declared even |
| /// though there is no base declaration. |
| abstract class Fragment { |
| /// The children of this fragment. |
| /// |
| /// There is no guarantee of the order in which the children will be returned. |
| /// For example, they are not guaranteed to be in lexical order. |
| List<Fragment> get children3; |
| |
| /// The element composed from this fragment and possibly other fragments. |
| Element2 get element; |
| |
| /// The fragment that either physically or logically encloses this fragment. |
| /// |
| /// Returns `null` if this fragment is the root fragment of a library because |
| /// there are no fragments above the root fragment of a library. |
| Fragment? get enclosingFragment; |
| |
| /// The library fragment that contains this fragment. |
| /// |
| /// This will be the fragment itself if it is a library fragment. |
| LibraryFragment get libraryFragment; |
| |
| /// The name of this fragment. |
| /// |
| /// Returns `null` if this fragment doesn't have a name. |
| String? get name; |
| |
| /// The offset of the name in this fragment. |
| /// |
| /// Returns `null` if the fragment has no name. |
| int? get nameOffset; |
| |
| /// The next fragment in the augmentation chain. |
| /// |
| /// Returns `null` if this is the last fragment in the chain. |
| Fragment? get nextFragment; |
| |
| /// The previous fragment in the augmentation chain. |
| /// |
| /// Returns `null` if this is the first fragment in the chain. |
| Fragment? get previousFragment; |
| } |
| |
| /// An element that has a [FunctionType] as its [type]. |
| /// |
| /// This also provides convenient access to the parameters and return type. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class FunctionTypedElement2 implements TypeParameterizedElement2 { |
| /// The parameters defined by this element. |
| List<FormalParameterElement> get parameters2; |
| |
| /// The return type defined by this element. |
| DartType get returnType; |
| |
| /// The type defined by this element. |
| FunctionType get type; |
| } |
| |
| /// The portion of a [FunctionTypedElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement, or mix-in this class. |
| abstract class FunctionTypedFragment implements TypeParameterizedFragment { |
| /// The parameters defined by this fragment. |
| List<FormalParameterFragment> get parameters2; |
| } |
| |
| /// The pseudo-declaration that defines a generic function type. |
| /// |
| /// Clients may not extend, implement, or mix-in this class. |
| abstract class GenericFunctionTypeElement2 |
| implements FunctionTypedElement2, _Fragmented {} |
| |
| /// The portion of a [GenericFunctionTypeElement2] coming from a single |
| /// declaration. |
| abstract class GenericFunctionTypeFragment implements FunctionTypedFragment { |
| @override |
| GenericFunctionTypeElement2 get element; |
| |
| @override |
| LibraryFragment? get enclosingFragment; |
| |
| @override |
| GenericFunctionTypeFragment? get nextFragment; |
| |
| @override |
| GenericFunctionTypeFragment? get previousFragment; |
| } |
| |
| /// A getter. |
| /// |
| /// Getters can either be defined explicitly or they can be induced by either a |
| /// top-level variable or a field. Induced getters are synthetic. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class GetterElement implements ExecutableElement2, _Fragmented { |
| @override |
| GetterElement get baseElement; |
| |
| /// The setter that corresponds to (has the same name as) this getter, or |
| /// `null` if there is no corresponding setter. |
| SetterElement? get correspondingSetter2; |
| |
| /// The field or top-level variable associated with this getter. |
| /// |
| /// If this getter was explicitly defined (is not synthetic) then the variable |
| /// associated with it will be synthetic. |
| PropertyInducingElement2? get variable3; |
| } |
| |
| /// The portion of a [GetterElement] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class GetterFragment implements ExecutableFragment { |
| /// The setter that corresponds to (has the same name as) this getter, or |
| /// `null` if there is no corresponding setter. |
| SetterFragment? get correspondingSetter2; |
| |
| /// The field or top-level variable associated with this getter. |
| /// |
| /// If this getter was explicitly defined (is not synthetic) then the variable |
| /// associated with it will be synthetic. |
| PropertyInducingFragment? get variable3; |
| } |
| |
| /// An element whose instance members can refer to `this`. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class InstanceElement2 |
| implements TypeDefiningElement2, TypeParameterizedElement2 { |
| @override |
| LibraryElement2 get enclosingElement2; |
| |
| /// The fields declared in this element. |
| List<FieldElement2> get fields2; |
| |
| @override |
| InstanceFragment get firstFragment; |
| |
| /// The getters declared in this element. |
| List<GetterElement> get getters2; |
| |
| /// The methods declared in this element. |
| List<MethodElement2> get methods2; |
| |
| /// The setters declared in this element. |
| List<SetterElement> get setters2; |
| |
| /// The type of a `this` expression. |
| DartType get thisType; |
| } |
| |
| /// The portion of an [InstanceElement2] contributed by a single declaration. |
| abstract class InstanceFragment |
| implements TypeDefiningFragment, TypeParameterizedFragment { |
| @override |
| InstanceElement2 get element; |
| |
| @override |
| LibraryFragment? get enclosingFragment; |
| |
| /// The fields declared in this fragment. |
| List<FieldFragment> get fields2; |
| |
| /// The getters declared in this fragment. |
| List<GetterFragment> get getters; |
| |
| /// Whether the fragment is an augmentation. |
| /// |
| /// If `true`, the declaration has the explicit `augment` modifier. |
| bool get isAugmentation; |
| |
| /// The methods declared in this fragment. |
| List<MethodFragment> get methods2; |
| |
| @override |
| InstanceFragment? get nextFragment; |
| |
| @override |
| InstanceFragment? get previousFragment; |
| |
| /// The setters declared in this fragment. |
| List<SetterFragment> get setters; |
| } |
| |
| /// An element that defines an [InterfaceType]. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class InterfaceElement2 implements InstanceElement2 { |
| /// All the supertypes defined for this element and its supertypes. |
| /// |
| /// This includes superclasses, mixins, interfaces, and superclass |
| /// constraints. |
| List<InterfaceType> get allSupertypes; |
| |
| /// The constructors defined for this element. |
| /// |
| /// The list is empty for [MixinElement]. |
| List<ConstructorElement2> get constructors2; |
| |
| /// The interfaces that are implemented by this class. |
| /// |
| /// <b>Note:</b> Because the element model represents the state of the code, |
| /// it is possible for it to be semantically invalid. In particular, it is not |
| /// safe to assume that the inheritance structure of a class does not contain |
| /// a cycle. Clients that traverse the inheritance structure must explicitly |
| /// guard against infinite loops. |
| List<InterfaceType> get interfaces; |
| |
| /// The mixins that are applied to the class being extended in order to |
| /// derive the superclass of this class. |
| /// |
| /// [ClassElement] and [EnumElement] can have mixins. |
| /// |
| /// [MixinElement] cannot have mixins, so an empty list is returned. |
| /// |
| /// <b>Note:</b> Because the element model represents the state of the code, |
| /// it is possible for it to be semantically invalid. In particular, it is not |
| /// safe to assume that the inheritance structure of a class does not contain |
| /// a cycle. Clients that traverse the inheritance structure must explicitly |
| /// guard against infinite loops. |
| List<InterfaceType> get mixins; |
| |
| /// The superclass of this element. |
| /// |
| /// For [ClassElement] returns `null` only if this class is `Object`. If the |
| /// superclass is not explicitly specified, or the superclass cannot be |
| /// resolved, then the implicit superclass `Object` is returned. |
| /// |
| /// For [EnumElement] returns `Enum` from `dart:core`. |
| /// |
| /// For [MixinElement] always returns `null`. |
| /// |
| /// <b>Note:</b> Because the element model represents the state of the code, |
| /// it is possible for it to be semantically invalid. In particular, it is not |
| /// safe to assume that the inheritance structure of a class does not contain |
| /// a cycle. Clients that traverse the inheritance structure must explicitly |
| /// guard against infinite loops. |
| InterfaceType? get supertype; |
| |
| /// The unnamed constructor declared directly in this class. |
| /// |
| /// If the class does not declare any constructors, a synthetic default |
| /// constructor will be returned. |
| ConstructorElement2? get unnamedConstructor2; |
| |
| /// Create the [InterfaceType] for this element with the given |
| /// [typeArguments] and [nullabilitySuffix]. |
| InterfaceType instantiate({ |
| required List<DartType> typeArguments, |
| required NullabilitySuffix nullabilitySuffix, |
| }); |
| } |
| |
| /// The portion of an [InterfaceElement2] contributed by a single declaration. |
| abstract class InterfaceFragment implements InstanceFragment { |
| /// The constructors declared in this fragment. |
| /// |
| /// The list is empty for [MixinFragment]. |
| List<ConstructorFragment> get constructors2; |
| |
| /// The interfaces that are implemented by this fragment. |
| List<InterfaceType> get interfaces; |
| |
| /// The mixins that are applied by this fragment. |
| /// |
| /// [ClassFragment] and [EnumFragment] can have mixins. |
| /// |
| /// [MixinFragment] cannot have mixins, so the empty list is returned. |
| List<InterfaceType> get mixins; |
| |
| /// The superclass declared by this fragment. |
| InterfaceType? get supertype; |
| } |
| |
| /// A pattern variable that is a join of other pattern variables, created |
| /// for a logical-or patterns, or shared `case` bodies in `switch` statements. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class JoinPatternVariableElement2 implements PatternVariableElement2 { |
| /// Whether the [variables] are consistent, present in all branches, |
| /// and have the same type and finality. |
| bool get isConsistent; |
| |
| /// The variables that join into this variable. |
| List<PatternVariableElement2> get variables2; |
| } |
| |
| /// A label associated with a statement. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class LabelElement2 implements Element2 { |
| @override |
| // TODO(brianwilkerson): We shouldn't be inheriting this member. |
| ExecutableElement2 get enclosingElement2; |
| |
| /// The function in which the variable is defined. |
| ExecutableFragment get enclosingFunction; |
| |
| @override |
| LibraryElement2 get library2; |
| } |
| |
| /// A library. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class LibraryElement2 implements Element2, _Annotatable, _Fragmented { |
| /// The extension elements accessible within this library. |
| List<ExtensionElement2> get accessibleExtensions2; |
| |
| /// The classes defined in this library. |
| /// |
| /// There is no guarantee of the order in which the classes will be returned. |
| /// For example, they are not guaranteed to be in lexical order. |
| List<ClassElement2> get classes; |
| |
| /// The entry point for this library. |
| /// |
| /// Returns `null` if this library doesn't have an entry point. |
| /// |
| /// The entry point is defined to be a zero, one, or two argument top-level |
| /// function whose name is `main`. |
| TopLevelFunctionElement? get entryPoint2; |
| |
| /// The enums defined in this library. |
| /// |
| /// There is no guarantee of the order in which the enums will be returned. |
| /// For example, they are not guaranteed to be in lexical order. |
| List<EnumElement2> get enums; |
| |
| /// The libraries that are exported from this library. |
| /// |
| /// There is no guarantee of the order in which the libraries will be |
| /// returned. For example, they are not guaranteed to be in lexical order. |
| List<LibraryElement2> get exportedLibraries2; |
| |
| /// The export [Namespace] of this library. |
| Namespace get exportNamespace; |
| |
| /// The extensions defined in this library. |
| /// |
| /// There is no guarantee of the order in which the extensions will be |
| /// returned. For example, they are not guaranteed to be in lexical order. |
| List<ExtensionElement2> get extensions; |
| |
| /// The extension types defined in this library. |
| /// |
| /// There is no guarantee of the order in which the extension types will be |
| /// returned. For example, they are not guaranteed to be in lexical order. |
| List<ExtensionTypeElement2> get extensionTypes; |
| |
| /// The set of features available to this library. |
| /// |
| /// Determined by the combination of the language version for the enclosing |
| /// package, enabled experiments, and the presence of a `// @dart` language |
| /// version override comment at the top of the files that make up the library. |
| FeatureSet get featureSet; |
| |
| @override |
| LibraryFragment get firstFragment; |
| |
| /// The functions defined in this library. |
| /// |
| /// There is no guarantee of the order in which the functions will be |
| /// returned. For example, they are not guaranteed to be in lexical order. |
| List<TopLevelFunctionElement> get functions; |
| |
| /// The getters defined in this library. |
| /// |
| /// There is no guarantee of the order in which the getters will be returned. |
| /// For example, they are not guaranteed to be in lexical order. |
| List<GetterElement> get getters; |
| |
| /// The identifier that uniquely identifies this element among the children |
| /// of this element's parent. |
| String get identifier; |
| |
| /// Whether the library is the `dart:async` library. |
| bool get isDartAsync; |
| |
| /// Whether the library is the `dart:core` library. |
| bool get isDartCore; |
| |
| /// Whether the library is part of the SDK. |
| bool get isInSdk; |
| |
| /// The language version for this library. |
| LibraryLanguageVersion get languageVersion; |
| |
| @override |
| LibraryElement2 get library2; |
| |
| /// The element representing the synthetic function `loadLibrary`. |
| /// |
| /// Technically the function is implicitly defined for this library only if |
| /// the library is imported using a deferred import, but the element is always |
| /// defined for performance reasons. |
| TopLevelFunctionElement get loadLibraryFunction2; |
| |
| /// The mixins defined in this library. |
| /// |
| /// There is no guarantee of the order in which the mixins will be returned. |
| /// For example, they are not guaranteed to be in lexical order. |
| List<MixinElement2> get mixins; |
| |
| /// The public [Namespace] of this library. |
| Namespace get publicNamespace; |
| |
| /// The setters defined in this library. |
| /// |
| /// There is no guarantee of the order in which the setters will be returned. |
| /// For example, they are not guaranteed to be in lexical order. |
| List<SetterElement> get setters; |
| |
| /// The top level variables defined in this library. |
| /// |
| /// There is no guarantee of the order in which the top level variables will |
| /// be returned. For example, they are not guaranteed to be in lexical order. |
| List<TopLevelVariableElement2> get topLevelVariables; |
| |
| /// The type aliases defined in this library. |
| /// |
| /// There is no guarantee of the order in which the type aliases will be |
| /// returned. For example, they are not guaranteed to be in lexical order. |
| List<TypeAliasElement2> get typeAliases; |
| |
| /// The [TypeProvider] that is used in this library. |
| TypeProvider get typeProvider; |
| |
| /// The [TypeSystem] that is used in this library. |
| TypeSystem get typeSystem; |
| } |
| |
| /// An export directive within a library. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class LibraryExport { |
| /// The combinators that were specified as part of the `export` directive. |
| /// |
| /// The combinators are in the order in which they were specified. |
| List<NamespaceCombinator> get combinators; |
| |
| /// The [LibraryElement], if [uri] is a [DirectiveUriWithLibrary]. |
| LibraryElement2? get exportedLibrary2; |
| |
| /// The offset of the `export` keyword. |
| int get exportKeywordOffset; |
| |
| /// The interpretation of the URI specified in the directive. |
| DirectiveUri get uri; |
| } |
| |
| /// The portion of a [LibraryElement2] coming from a single compilation unit. |
| abstract class LibraryFragment implements Fragment, _Annotatable { |
| /// The fragments of the classes declared in this fragment. |
| List<ClassFragment> get classes2; |
| |
| @override |
| LibraryFragment? get enclosingFragment; |
| |
| /// The fragments of the enums declared in this fragment. |
| List<EnumFragment> get enums2; |
| |
| /// The fragments of the extensions declared in this fragment. |
| List<ExtensionFragment> get extensions2; |
| |
| /// The fragments of the extension types declared in this fragment. |
| List<ExtensionTypeFragment> get extensionTypes2; |
| |
| /// The `part` directives within this fragment. |
| List<LibraryFragmentInclude> get fragmentIncludes; |
| |
| /// The fragments of the top-level functions declared in this fragment. |
| List<TopLevelFunctionFragment> get functions2; |
| |
| /// The fragments of the top-level getters declared in this fragment. |
| List<GetterFragment> get getters; |
| |
| /// The libraries exported by this unit. |
| List<LibraryExport> get libraryExports2; |
| |
| /// The libraries imported by this unit. |
| List<LibraryImport> get libraryImports2; |
| |
| /// The [LineInfo] for the fragment. |
| LineInfo get lineInfo; |
| |
| /// The fragments of the mixins declared in this fragment. |
| List<MixinFragment> get mixins2; |
| |
| @override |
| LibraryFragment? get nextFragment; |
| |
| /// The prefixes used by [libraryImports2]. |
| /// |
| /// Each prefix can be used in more than one `import` directive. |
| List<PrefixElement2> get prefixes; |
| |
| @override |
| LibraryFragment? get previousFragment; |
| |
| /// The scope used to resolve names within the fragment. |
| /// |
| /// It includes all of the elements that are declared in the library, and all |
| /// of the elements imported into this fragment or parent fragments. |
| Scope get scope; |
| |
| /// The fragments of the top-level setters declared in this fragment. |
| List<SetterFragment> get setters; |
| |
| /// The fragments of the top-level variables declared in this fragment. |
| List<TopLevelVariableFragment> get topLevelVariables2; |
| |
| /// The fragments of the type aliases declared in this fragment. |
| List<TypeAliasFragment> get typeAliases2; |
| } |
| |
| /// A 'part' directive within a library fragment. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class LibraryFragmentInclude { |
| /// The interpretation of the URI specified in the directive. |
| DirectiveUri get uri; |
| } |
| |
| /// An import directive within a library. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class LibraryImport { |
| /// The combinators that were specified as part of the `import` directive. |
| /// |
| /// The combinators are in the order in which they were specified. |
| List<NamespaceCombinator> get combinators; |
| |
| /// The [LibraryElement], if [uri] is a [DirectiveUriWithLibrary]. |
| LibraryElement2? get importedLibrary2; |
| |
| /// The offset of the `import` keyword. |
| int get importKeywordOffset; |
| |
| /// Whether this import is synthetic. |
| /// |
| /// A synthetic import is an import that is not represented in the source |
| /// code explicitly, but is implied by the source code. This only happens for |
| /// an implicit import of `dart:core`. |
| bool get isSynthetic; |
| |
| /// The [Namespace] that this directive contributes to the containing library. |
| Namespace get namespace; |
| |
| /// The prefix fragment that was specified as part of the import directive. |
| /// |
| /// Returns `null` if there was no prefix specified. |
| PrefixFragment? get prefix2; |
| |
| /// The interpretation of the URI specified in the directive. |
| DirectiveUri get uri; |
| } |
| |
| /// A local function. |
| /// |
| /// This can be either a local function, a closure, or the initialization |
| /// expression for a field or variable. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class LocalFunctionElement implements ExecutableElement2 { |
| /// The function in which the variable is defined. |
| ExecutableFragment get enclosingFunction; |
| } |
| |
| /// A local variable. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class LocalVariableElement2 implements PromotableElement2 { |
| @override |
| LocalVariableElement2 get baseElement; |
| |
| /// The function in which the variable is defined. |
| ExecutableFragment get enclosingFunction; |
| |
| /// Whether the variable has an initializer at declaration. |
| bool get hasInitializer; |
| } |
| |
| /// A method. |
| /// |
| /// The method can be either an instance method, an operator, or a static |
| /// method. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class MethodElement2 implements ExecutableElement2, _Fragmented { |
| @override |
| MethodElement2 get baseElement; |
| |
| /// Whether the method defines an operator. |
| /// |
| /// The test might 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; |
| } |
| |
| /// The portion of a [MethodElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class MethodFragment implements ExecutableFragment { |
| @override |
| MethodElement2 get element; |
| |
| @override |
| InstanceFragment? get enclosingFragment; |
| |
| @override |
| MethodFragment? get nextFragment; |
| |
| @override |
| MethodFragment? get previousFragment; |
| } |
| |
| /// An element that represents a mixin. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class MixinElement2 implements InterfaceElement2 { |
| /// Whether the mixin is a base mixin. |
| /// |
| /// A mixin is a base mixin if it has an explicit `base` modifier. |
| /// The base modifier allows a mixin to be mixed in, but not implemented. |
| bool get isBase; |
| |
| /// The superclass constraints defined for this mixin. |
| /// |
| /// If the declaration does not have an `on` clause, then the list will |
| /// contain the type for the class `Object`. |
| /// |
| /// <b>Note:</b> Because the element model represents the state of the code, |
| /// it is possible for it to be semantically invalid. In particular, it is not |
| /// safe to assume that the inheritance structure of a class does not contain |
| /// a cycle. Clients that traverse the inheritance structure must explicitly |
| /// guard against infinite loops. |
| List<InterfaceType> get superclassConstraints; |
| |
| /// Whether the element, assuming that it is within scope, is |
| /// implementable to classes, mixins, and enums in the given [library]. |
| bool isImplementableIn2(LibraryElement2 library); |
| } |
| |
| /// The portion of a [PrefixElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class MixinFragment implements InterfaceFragment { |
| /// The superclass constraints defined for this mixin. |
| /// |
| /// If the declaration does not have an `on` clause, then the list will |
| /// contain the type for the class `Object`. |
| /// |
| /// <b>Note:</b> Because the element model represents the state of the code, |
| /// it is possible for it to be semantically invalid. In particular, it is not |
| /// safe to assume that the inheritance structure of a class does not contain |
| /// a cycle. Clients that traverse the inheritance structure must explicitly |
| /// guard against infinite loops. |
| List<InterfaceType> get superclassConstraints; |
| } |
| |
| /// A pseudo-element that represents multiple elements defined within a single |
| /// scope that have the same name. This situation is not allowed by the |
| /// language, so objects implementing this interface always represent an error. |
| /// As a result, most of the normal operations on elements do not make sense |
| /// and will return useless results. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class MultiplyDefinedElement2 implements Element2 { |
| /// The elements that were defined within the scope to have the same name. |
| List<Element2> get conflictingElements2; |
| } |
| |
| /// A pattern variable. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class PatternVariableElement2 implements LocalVariableElement2 { |
| /// The variable in which this variable joins with other pattern variables |
| /// with the same name, in a logical-or pattern, or shared case scope. |
| JoinPatternVariableElement2? get join2; |
| } |
| |
| /// A prefix used to import one or more libraries into another library. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class PrefixElement2 implements Element2, _Fragmented { |
| @override |
| LibraryElement2 get enclosingElement2; |
| |
| @override |
| PrefixFragment get firstFragment; |
| |
| /// The imports that share this prefix. |
| List<LibraryImport> get imports2; |
| |
| @override |
| LibraryElement2 get library2; |
| |
| /// The name lookup scope for this import prefix. |
| /// |
| /// It consists of elements imported into the enclosing library with this |
| /// prefix. The namespace combinators of the import directives are taken |
| /// into account. |
| Scope get scope; |
| } |
| |
| /// The portion of a [PrefixElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class PrefixFragment implements Fragment { |
| @override |
| PrefixElement2 get element; |
| |
| @override |
| LibraryFragment? get enclosingFragment; |
| |
| @override |
| PrefixFragment? get nextFragment; |
| |
| @override |
| PrefixFragment? get previousFragment; |
| } |
| |
| /// A variable that might be subject to type promotion. This might be a local |
| /// variable or a parameter. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class PromotableElement2 implements VariableElement2 {} |
| |
| /// The portion of a [PromotableElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class PromotableFragment implements VariableFragment {} |
| |
| /// A variable that has an associated getter and possibly a setter. Note that |
| /// explicitly defined variables implicitly define a synthetic getter and that |
| /// non-`final` explicitly defined variables implicitly define a synthetic |
| /// setter. Symmetrically, synthetic fields are implicitly created for |
| /// explicitly defined getters and setters. The following rules apply: |
| /// |
| /// * Every explicit variable is represented by a non-synthetic |
| /// [PropertyInducingElement]. |
| /// * Every explicit variable induces a getter and possibly a setter, both of |
| /// which are represented by synthetic [PropertyAccessorElement]s. |
| /// * Every explicit getter or setter is represented by a non-synthetic |
| /// [PropertyAccessorElement]. |
| /// * Every explicit getter or setter (or pair thereof if they have the same |
| /// name) induces a variable that is represented by a synthetic |
| /// [PropertyInducingElement]. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class PropertyInducingElement2 |
| implements VariableElement2, _Annotatable, _Fragmented { |
| /// The getter associated with this variable. |
| /// |
| /// If this variable was explicitly defined (is not synthetic) then the |
| /// getter associated with it will be synthetic. |
| GetterElement? get getter; |
| |
| /// The setter associated with this variable. |
| /// |
| /// Returns `null` if the variable is effectively `final` and therefore does |
| /// not have a setter associated with it. |
| /// |
| /// This can happen either because the variable is explicitly defined as |
| /// being `final` or because the variable is induced by an explicit getter |
| /// that does not have a corresponding setter. If this variable was |
| /// explicitly defined (is not synthetic) then the setter associated with |
| /// it will be synthetic. |
| SetterElement? get setter; |
| } |
| |
| /// The portion of a [PropertyInducingElement2] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class PropertyInducingFragment |
| implements VariableFragment, _Annotatable { |
| /// The getter associated with this variable. |
| /// |
| /// If this variable was explicitly defined (is not synthetic) then the |
| /// getter associated with it will be synthetic. |
| GetterFragment? get getter2; |
| |
| /// Whether the variable has an initializer at declaration. |
| bool get hasInitializer; |
| |
| /// Whether the element is an augmentation. |
| /// |
| /// Property indicing fragments are augmentations if they are explicitly |
| /// marked as such using the 'augment' modifier. |
| bool get isAugmentation; |
| |
| /// Whether the fragment is a static fragment. |
| /// |
| /// A static fragment is a fragment that is not associated with a particular |
| /// instance, but rather with an entire library or class. |
| bool get isStatic; |
| |
| /// Whether this fragment is synthetic. |
| /// |
| /// A synthetic fragment is a fragment that is not represented in the source |
| /// code explicitly, but is implied by the source code, such as the default |
| /// constructor for a class that does not explicitly define any constructors. |
| // TODO(brianwilkerson): Should synthetic elements have a fragment? |
| bool get isSynthetic; |
| |
| @override |
| PropertyInducingFragment? get nextFragment; |
| |
| @override |
| PropertyInducingFragment? get previousFragment; |
| |
| /// The setter associated with this variable. |
| /// |
| /// Returns `null` if the variable is effectively `final` and therefore |
| /// doesn't have a setter associated with it. |
| /// |
| /// This can happen either because the variable is explicitly defined as |
| /// being `final` or because the variable is induced by an explicit getter |
| /// that does not have a corresponding setter. If this variable was |
| /// explicitly defined (is not synthetic) then the setter associated with |
| /// it will be synthetic. |
| SetterFragment? get setter2; |
| } |
| |
| /// A setter. |
| /// |
| /// Setters can either be defined explicitly or they can be induced by either a |
| /// top-level variable or a field. Induced setters are synthetic. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class SetterElement implements ExecutableElement2, _Fragmented { |
| @override |
| SetterElement get baseElement; |
| |
| /// The getter that corresponds to (has the same name as) this setter, or |
| /// `null` if there is no corresponding getter. |
| GetterElement? get correspondingGetter2; |
| |
| /// The field or top-level variable associated with this setter. |
| /// |
| /// If this setter was explicitly defined (is not synthetic) then the variable |
| /// associated with it will be synthetic. |
| PropertyInducingElement2? get variable3; |
| } |
| |
| /// The portion of a [SetterElement] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class SetterFragment implements ExecutableFragment { |
| /// The getter that corresponds to (has the same name as) this setter, or |
| /// `null` if there is no corresponding getter. |
| GetterFragment? get correspondingGetter2; |
| |
| /// The field or top-level variable associated with this setter. |
| /// |
| /// If this setter was explicitly defined (is not synthetic) then the variable |
| /// associated with it will be synthetic. |
| PropertyInducingFragment? get variable3; |
| } |
| |
| /// A super formal parameter. |
| /// |
| /// Super formal parameters can only be defined within a constructor element. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class SuperFormalParameterElement2 implements FormalParameterElement { |
| /// The associated super-constructor parameter, from the super-constructor |
| /// that is referenced by the implicit or explicit super-constructor |
| /// invocation. |
| /// |
| /// Can be `null` for erroneous code - not existing super-constructor, |
| /// no corresponding parameter in the super-constructor. |
| FormalParameterElement? get superConstructorParameter2; |
| } |
| |
| /// The portion of a [SuperFormalParameterElement2] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class SuperFormalParameterFragment |
| implements FormalParameterFragment {} |
| |
| /// A top-level function. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TopLevelFunctionElement |
| implements ExecutableElement2, _Fragmented { |
| @override |
| TopLevelFunctionElement get baseElement; |
| |
| /// Whether the function represents `identical` from the `dart:core` library. |
| bool get isDartCoreIdentical; |
| |
| /// Whether the function is an entry point. |
| /// |
| /// A top-level function is an entry point if it has the name `main`. |
| bool get isEntryPoint; |
| } |
| |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| /// The portion of a [TopLevelFunctionElement] contributed by a single |
| /// declaration. |
| abstract class TopLevelFunctionFragment implements ExecutableFragment {} |
| |
| /// A top-level variable. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TopLevelVariableElement2 implements PropertyInducingElement2 { |
| @override |
| TopLevelVariableElement2 get baseElement; |
| |
| /// Whether the field was explicitly marked as being external. |
| bool get isExternal; |
| } |
| |
| /// The portion of a [TopLevelVariableElement2] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TopLevelVariableFragment implements PropertyInducingFragment { |
| @override |
| TopLevelVariableFragment? get nextFragment; |
| |
| @override |
| TopLevelVariableFragment? get previousFragment; |
| } |
| |
| /// A type alias (`typedef`). |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TypeAliasElement2 |
| implements TypeParameterizedElement2, TypeDefiningElement2 { |
| /// If the aliased type has structure, return the corresponding element. |
| /// For example it could be [GenericFunctionTypeElement]. |
| /// |
| /// If there is no structure, return `null`. |
| Element2? get aliasedElement2; |
| |
| /// The aliased type. |
| /// |
| /// If non-function type aliases feature is enabled for the enclosing library, |
| /// this type might be just anything. If the feature is disabled, return |
| /// a [FunctionType]. |
| DartType get aliasedType; |
| |
| @override |
| LibraryElement2 get enclosingElement2; |
| |
| /// Returns the type resulting from instantiating this typedef with the given |
| /// [typeArguments] and [nullabilitySuffix]. |
| /// |
| /// Note that this always instantiates the typedef itself, so for a |
| /// [TypeAliasElement2] the returned [DartType] might still be a generic |
| /// type, with type formals. For example, if the typedef is: |
| /// typedef F<T> = void Function<U>(T, U); |
| /// then `F<int>` will produce `void Function<U>(int, U)`. |
| DartType instantiate({ |
| required List<DartType> typeArguments, |
| required NullabilitySuffix nullabilitySuffix, |
| }); |
| } |
| |
| /// The portion of a [TypeAliasElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TypeAliasFragment |
| implements TypeParameterizedFragment, TypeDefiningFragment { |
| @override |
| TypeAliasElement2 get element; |
| |
| @override |
| LibraryFragment? get enclosingFragment; |
| |
| @override |
| TypeAliasFragment? get nextFragment; |
| |
| @override |
| TypeAliasFragment? get previousFragment; |
| } |
| |
| /// An element that defines a type. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TypeDefiningElement2 |
| implements Element2, _Annotatable, _Fragmented { |
| // TODO(brianwilkerson): Evaluate to see whether this type is actually needed |
| // after converting clients to the new API. |
| } |
| |
| /// The portion of a [TypeDefiningElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TypeDefiningFragment implements Fragment, _Annotatable {} |
| |
| /// A type parameter. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TypeParameterElement2 implements TypeDefiningElement2 { |
| @override |
| TypeParameterElement2 get baseElement; |
| |
| /// The type representing the bound associated with this parameter. |
| /// |
| /// Returns `null` if this parameter does not have an explicit bound. Being |
| /// able to distinguish between an implicit and explicit bound is needed by |
| /// the instantiate to bounds algorithm.` |
| DartType? get bound; |
| |
| @override |
| LibraryElement2 get library2; |
| |
| /// Returns the [TypeParameterType] with the given [nullabilitySuffix] for |
| /// this type parameter. |
| TypeParameterType instantiate({ |
| required NullabilitySuffix nullabilitySuffix, |
| }); |
| } |
| |
| /// The portion of a [TypeParameterElement2] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TypeParameterFragment implements TypeDefiningFragment { |
| @override |
| TypeParameterFragment? get nextFragment; |
| |
| @override |
| TypeParameterFragment? get previousFragment; |
| } |
| |
| /// An element that has type parameters, such as a class, typedef, or method. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TypeParameterizedElement2 implements Element2, _Annotatable { |
| /// If the element defines a type, indicates whether the type may safely |
| /// appear without explicit type arguments as the bounds of a type parameter |
| /// declaration. |
| /// |
| /// If the element does not define a type, returns `true`. |
| bool get isSimplyBounded; |
| |
| /// The type parameters declared by this element directly. |
| /// |
| /// This does not include type parameters that are declared by any enclosing |
| /// elements. |
| List<TypeParameterElement2> get typeParameters2; |
| } |
| |
| /// The portion of a [TypeParameterizedElement2] contributed by a single |
| /// declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class TypeParameterizedFragment implements Fragment, _Annotatable { |
| /// The type parameters declared by this fragment directly. |
| /// |
| /// This does not include type parameters that are declared by any enclosing |
| /// fragments. |
| List<TypeParameterFragment> get typeParameters2; |
| } |
| |
| /// A pseudo-element that represents names that are undefined. |
| /// |
| /// This situation is not allowed by the language, so objects implementing this |
| /// interface always represent an error. As a result, most of the normal |
| /// operations on elements do not make sense and will return useless results. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class UndefinedElement2 implements Element2 {} |
| |
| /// A variable. |
| /// |
| /// There are more specific subclasses for more specific kinds of variables. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class VariableElement2 implements Element2 { |
| /// Whether the variable element did not have an explicit type specified |
| /// for it. |
| bool get hasImplicitType; |
| |
| /// Whether the variable was declared with the 'const' modifier. |
| bool get isConst; |
| |
| /// 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. |
| bool get isFinal; |
| |
| /// Whether the variable uses late evaluation semantics. |
| bool get isLate; |
| |
| /// 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. |
| bool get isStatic; |
| |
| /// The declared type of this variable. |
| DartType get type; |
| |
| /// Returns a representation of the value of this variable. |
| /// |
| /// If the value had not previously been computed, it will be computed as a |
| /// result of invoking this method. |
| /// |
| /// Returns `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. |
| DartObject? computeConstantValue(); |
| } |
| |
| /// The portion of a [VariableElement2] contributed by a single declaration. |
| /// |
| /// Clients may not extend, implement or mix-in this class. |
| abstract class VariableFragment implements Fragment { |
| /// Whether the variable was declared with the 'const' modifier. |
| bool get isConst; |
| |
| /// 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. |
| bool get isFinal; |
| } |
| |
| /// An element or fragment that can have either annotations (metadata), a |
| /// documentation comment, or both associated with it. |
| abstract class _Annotatable { |
| /// The content of the documentation comment (including delimiters) for this |
| /// element or fragment. |
| /// |
| /// If the receiver is an element that has fragments, the comment will be a |
| /// concatenation of the comments from all of the fragments. |
| /// |
| /// Returns `null` if the receiver doesn't have documentation. |
| String? get documentationComment; |
| |
| /// Whether the receiver has an annotation of the form `@alwaysThrows`. |
| bool get hasAlwaysThrows; |
| |
| /// Whether the receiver has an annotation of the form `@deprecated` |
| /// or `@Deprecated('..')`. |
| bool get hasDeprecated; |
| |
| /// Whether the receiver has an annotation of the form `@doNotStore`. |
| bool get hasDoNotStore; |
| |
| /// Whether the receiver has an annotation of the form `@doNotSubmit`. |
| bool get hasDoNotSubmit; |
| |
| /// Whether the receiver has an annotation of the form `@factory`. |
| bool get hasFactory; |
| |
| /// Whether the receiver has an annotation of the form `@immutable`. |
| bool get hasImmutable; |
| |
| /// Whether the receiver has an annotation of the form `@internal`. |
| bool get hasInternal; |
| |
| /// Whether the receiver has an annotation of the form `@isTest`. |
| bool get hasIsTest; |
| |
| /// Whether the receiver has an annotation of the form `@isTestGroup`. |
| bool get hasIsTestGroup; |
| |
| /// Whether the receiver has an annotation of the form `@JS(..)`. |
| bool get hasJS; |
| |
| /// Whether the receiver has an annotation of the form `@literal`. |
| bool get hasLiteral; |
| |
| /// Whether the receiver has an annotation of the form `@mustBeConst`. |
| bool get hasMustBeConst; |
| |
| /// Whether the receiver has an annotation of the form `@mustBeOverridden`. |
| bool get hasMustBeOverridden; |
| |
| /// Whether the receiver has an annotation of the form `@mustCallSuper`. |
| bool get hasMustCallSuper; |
| |
| /// Whether the receiver has an annotation of the form `@nonVirtual`. |
| bool get hasNonVirtual; |
| |
| /// Whether the receiver has an annotation of the form `@optionalTypeArgs`. |
| bool get hasOptionalTypeArgs; |
| |
| /// Whether the receiver has an annotation of the form `@override`. |
| bool get hasOverride; |
| |
| /// Whether the receiver has an annotation of the form `@protected`. |
| bool get hasProtected; |
| |
| /// Whether the receiver has an annotation of the form `@redeclare`. |
| bool get hasRedeclare; |
| |
| /// Whether the receiver has an annotation of the form `@reopen`. |
| bool get hasReopen; |
| |
| /// Whether the receiver has an annotation of the form `@required`. |
| bool get hasRequired; |
| |
| /// Whether the receiver has an annotation of the form `@sealed`. |
| bool get hasSealed; |
| |
| /// Whether the receiver has an annotation of the form `@useResult` |
| /// or `@UseResult('..')`. |
| bool get hasUseResult; |
| |
| /// Whether the receiver has an annotation of the form `@visibleForOverriding`. |
| bool get hasVisibleForOverriding; |
| |
| /// Whether the receiver has an annotation of the form `@visibleForTemplate`. |
| bool get hasVisibleForTemplate; |
| |
| /// Whether the receiver has an annotation of the form `@visibleForTesting`. |
| bool get hasVisibleForTesting; |
| |
| /// Whether the receiver has an annotation of the form |
| /// `@visibleOutsideTemplate`. |
| bool get hasVisibleOutsideTemplate; |
| |
| /// The metadata associated with the element or fragment. |
| /// |
| /// If the receiver is an element that has fragments, the list will include |
| /// all of the metadata from all of the fragments. |
| /// |
| /// The list will be empty if the receiver does not have any metadata or if |
| /// the library containing this element has not yet been fully resolved. |
| List<ElementAnnotation> get metadata; |
| |
| /// 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 the SDK, or doesn't have |
| /// a `@Since()` annotation applied to it. |
| Version? get sinceSdkVersion; |
| } |
| |
| /// An element that can be defined by multiple fragments. |
| abstract class _Fragmented { |
| /// The first fragment in the chain of fragments that are merged to make this |
| /// element. |
| /// |
| /// The other fragments in the chain can be accessed using |
| /// [Fragment.nextFragment]. |
| Fragment get firstFragment; |
| } |