blob: 067b214c9a4903c92e2d0e62cc4194afa991d7f4 [file] [log] [blame]
// This code was auto-generated, is not intended to be edited, and is subject to
// significant change. Please see the README file for more information.
library engine.element;
import 'dart:collection';
import 'java_core.dart';
import 'java_engine.dart';
import 'utilities_collection.dart';
import 'source.dart';
import 'scanner.dart' show Keyword;
import 'ast.dart' show Identifier, LibraryIdentifier;
import 'sdk.dart' show DartSdk;
import 'html.dart' show XmlTagNode;
import 'engine.dart' show AnalysisContext;
import 'constant.dart' show EvaluationResultImpl;
import 'utilities_dart.dart';
/**
* The interface `ClassElement` defines the behavior of elements that represent a class.
*
* @coverage dart.engine.element
*/
abstract class ClassElement implements Element {
/**
* Return an array containing all of the accessors (getters and setters) declared in this class.
*
* @return the accessors declared in this class
*/
List<PropertyAccessorElement> get accessors;
/**
* Return an array containing all the supertypes defined for this class and its supertypes. This
* includes superclasses, mixins and interfaces.
*
* @return all the supertypes of this class, including mixins
*/
List<InterfaceType> get allSupertypes;
/**
* Return an array containing all of the constructors declared in this class.
*
* @return the constructors declared in this class
*/
List<ConstructorElement> get constructors;
/**
* Return an array containing all of the fields declared in this class.
*
* @return the fields declared in this class
*/
List<FieldElement> get fields;
/**
* Return the element representing the getter with the given name that is declared in this class,
* or `null` if this class does not declare a getter with the given name.
*
* @param getterName the name of the getter to be returned
* @return the getter declared in this class with the given name
*/
PropertyAccessorElement getGetter(String getterName);
/**
* Return an array containing all of 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.
*
* @return the interfaces that are implemented by this class
*/
List<InterfaceType> get interfaces;
/**
* Return the element representing the method with the given name that is declared in this class,
* or `null` if this class does not declare a method with the given name.
*
* @param methodName the name of the method to be returned
* @return the method declared in this class with the given name
*/
MethodElement getMethod(String methodName);
/**
* Return an array containing all of the methods declared in this class.
*
* @return the methods declared in this class
*/
List<MethodElement> get methods;
/**
* Return an array containing all of the mixins that are applied to the class being extended in
* order to derive the superclass of 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.
*
* @return the mixins that are applied to derive the superclass of this class
*/
List<InterfaceType> get mixins;
/**
* Return the named constructor declared in this class with the given name, or `null` if
* this class does not declare a named constructor with the given name.
*
* @param name the name of the constructor to be returned
* @return the element representing the specified constructor
*/
ConstructorElement getNamedConstructor(String name);
/**
* Return the element representing the setter with the given name that is declared in this class,
* or `null` if this class does not declare a setter with the given name.
*
* @param setterName the name of the getter to be returned
* @return the setter declared in this class with the given name
*/
PropertyAccessorElement getSetter(String setterName);
/**
* Return the superclass of this class, or `null` if the class represents the class
* 'Object'. All other classes will have a non-`null` superclass. If the superclass was not
* explicitly declared then the implicit superclass 'Object' will be 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.
*
* @return the superclass of this class
*/
InterfaceType get supertype;
/**
* Return the type defined by the class.
*
* @return the type defined by the class
*/
InterfaceType get type;
/**
* Return an array containing all of the type parameters declared for this class.
*
* @return the type parameters declared for this class
*/
List<TypeParameterElement> get typeParameters;
/**
* Return the unnamed constructor declared in this class, or `null` if this class does not
* declare an unnamed constructor but does declare named constructors. The returned constructor
* will be synthetic if this class does not declare any constructors, in which case it will
* represent the default constructor for the class.
*
* @return the unnamed constructor defined in this class
*/
ConstructorElement get unnamedConstructor;
/**
* Return `true` if this class or its superclass declares a non-final instance field.
*
* @return `true` if this class or its superclass declares a non-final instance field
*/
bool hasNonFinalField();
/**
* Return `true` if this class has reference to super (so, for example, cannot be used as a
* mixin).
*
* @return `true` if this class has reference to super
*/
bool hasReferenceToSuper();
/**
* Return `true` if this 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>.
*
* @return `true` if this class is abstract
*/
bool get isAbstract;
/**
* Return `true` if this class is defined by a typedef construct.
*
* @return `true` if this class is defined by a typedef construct
*/
bool get isTypedef;
/**
* Return `true` if this class can validly be used as a mixin when defining another class.
* 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>
*
* @return `true` if this class can validly be used as a mixin
*/
bool get isValidMixin;
/**
* Return the element representing the getter that results from looking up the given getter in
* this class with respect to the given library, or `null` if the look up fails. The
* behavior of this method is defined by the Dart Language Specification in section 12.15.1:
* <blockquote>The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
* with respect to library <i>L</i> is:
*
* * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
* accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
* Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
* of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
* Otherwise, we say that the lookup has failed.
*
* </blockquote>
*
* @param getterName the name of the getter being looked up
* @param library the library with respect to which the lookup is being performed
* @return the result of looking up the given getter in this class with respect to the given
* library
*/
PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library);
/**
* Return the element representing the method that results from looking up the given method in
* this class with respect to the given library, or `null` if the look up fails. The
* behavior of this method is defined by the Dart Language Specification in section 12.15.1:
* <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with respect to library
* <i>L</i> is:
*
* * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
* that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
* the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
* to <i>L</i>. Otherwise, we say that the lookup has failed.
*
* </blockquote>
*
* @param methodName the name of the method being looked up
* @param library the library with respect to which the lookup is being performed
* @return the result of looking up the given method in this class with respect to the given
* library
*/
MethodElement lookUpMethod(String methodName, LibraryElement library);
/**
* Return the element representing the setter that results from looking up the given setter in
* this class with respect to the given library, or `null` if the look up fails. The
* behavior of this method is defined by the Dart Language Specification in section 12.16:
* <blockquote> The result of looking up getter (respectively setter) <i>m</i> in class <i>C</i>
* with respect to library <i>L</i> is:
*
* * If <i>C</i> declares an instance getter (respectively setter) named <i>m</i> that is
* accessible to <i>L</i>, then that getter (respectively setter) is the result of the lookup.
* Otherwise, if <i>C</i> has a superclass <i>S</i>, then the result of the lookup is the result
* of looking up getter (respectively setter) <i>m</i> in <i>S</i> with respect to <i>L</i>.
* Otherwise, we say that the lookup has failed.
*
* </blockquote>
*
* @param setterName the name of the setter being looked up
* @param library the library with respect to which the lookup is being performed
* @return the result of looking up the given setter in this class with respect to the given
* library
*/
PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library);
}
/**
* The interface `ClassMemberElement` defines the behavior of elements that are contained
* within a [ClassElement].
*/
abstract class ClassMemberElement implements Element {
/**
* Return the type in which this member is defined.
*
* @return the type in which this member is defined
*/
ClassElement get enclosingElement;
/**
* Return `true` if this 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.
*
* @return `true` if this executable element is a static element
*/
bool get isStatic;
}
/**
* The interface `CompilationUnitElement` defines the behavior of elements representing a
* compilation unit.
*
* @coverage dart.engine.element
*/
abstract class CompilationUnitElement implements Element, UriReferencedElement {
/**
* Return an array containing all of the top-level accessors (getters and setters) contained in
* this compilation unit.
*
* @return the top-level accessors contained in this compilation unit
*/
List<PropertyAccessorElement> get accessors;
/**
* Return the library in which this compilation unit is defined.
*
* @return the library in which this compilation unit is defined
*/
LibraryElement get enclosingElement;
/**
* Return an array containing all of the top-level functions contained in this compilation unit.
*
* @return the top-level functions contained in this compilation unit
*/
List<FunctionElement> get functions;
/**
* Return an array containing all of the function type aliases contained in this compilation unit.
*
* @return the function type aliases contained in this compilation unit
*/
List<FunctionTypeAliasElement> get functionTypeAliases;
/**
* Return an array containing all of the top-level variables contained in this compilation unit.
*
* @return the top-level variables contained in this compilation unit
*/
List<TopLevelVariableElement> get topLevelVariables;
/**
* Return the class defined in this compilation unit that has the given name, or `null` if
* this compilation unit does not define a class with the given name.
*
* @param className the name of the class to be returned
* @return the class with the given name that is defined in this compilation unit
*/
ClassElement getType(String className);
/**
* Return an array containing all of the classes contained in this compilation unit.
*
* @return the classes contained in this compilation unit
*/
List<ClassElement> get types;
}
/**
* The interface `ConstructorElement` defines the behavior of elements representing a
* constructor or a factory method defined within a type.
*
* @coverage dart.engine.element
*/
abstract class ConstructorElement implements ClassMemberElement, ExecutableElement {
/**
* Return the constructor to which this constructor is redirecting.
*
* @return the constructor to which this constructor is redirecting
*/
ConstructorElement get redirectedConstructor;
/**
* Return `true` if this constructor is a const constructor.
*
* @return `true` if this constructor is a const constructor
*/
bool get isConst;
/**
* Return `true` if this constructor can be used as a default constructor - unnamed and has
* no required parameters.
*
* @return `true` if this constructor can be used as a default constructor.
*/
bool get isDefaultConstructor;
/**
* Return `true` if this constructor represents a factory constructor.
*
* @return `true` if this constructor represents a factory constructor
*/
bool get isFactory;
}
/**
* The interface `Element` defines the behavior common to 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 do not 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 do not 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 do not have a name. These correspond to
* unnamed functions and exist in order to more accurately represent the semantic structure of the
* program.
*
* @coverage dart.engine.element
*/
abstract class Element {
/**
* A comparator that can be used to sort elements by their name offset. Elements with a smaller
* offset will be sorted to be before elements with a larger name offset.
*/
static final Comparator<Element> SORT_BY_OFFSET = (Element firstElement, Element secondElement) => firstElement.nameOffset - secondElement.nameOffset;
/**
* Use the given visitor to visit this element.
*
* @param visitor the visitor that will visit this element
* @return the value returned by the visitor as a result of visiting this element
*/
accept(ElementVisitor visitor);
/**
* Return the documentation comment for this element as it appears in the original source
* (complete with the beginning and ending delimiters), or `null` if this element does not
* have a documentation comment associated with it. This can be a long-running operation if the
* information needed to access the comment is not cached.
*
* @return this element's documentation comment
* @throws AnalysisException if the documentation comment could not be determined because the
* analysis could not be performed
*/
String computeDocumentationComment();
/**
* Return the element of the given class that most immediately encloses this element, or
* `null` if there is no enclosing element of the given class.
*
* @param elementClass the class of the element to be returned
* @return the element that encloses this element
*/
Element getAncestor(Type elementClass);
/**
* Return the analysis context in which this element is defined.
*
* @return the analysis context in which this element is defined
*/
AnalysisContext get context;
/**
* Return the display name of this element, or `null` if this 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`.
*
* @return the display name of this element
*/
String get displayName;
/**
* Return the element that either physically or logically encloses this element. This will be
* `null` if this element is a library because libraries are the top-level elements in the
* model.
*
* @return the element that encloses this element
*/
Element get enclosingElement;
/**
* Return the kind of element that this is.
*
* @return the kind of this element
*/
ElementKind get kind;
/**
* Return the library that contains this element. This will be the element itself if it is a
* library element. This will be `null` if this element is an HTML file because HTML files
* are not contained in libraries.
*
* @return the library that contains this element
*/
LibraryElement get library;
/**
* Return an object representing the location of this element in the element model. The object can
* be used to locate this element at a later time.
*
* @return the location of this element in the element model
*/
ElementLocation get location;
/**
* Return an array containing all of the metadata associated with this element.
*
* @return the metadata associated with this element
*/
List<ElementAnnotation> get metadata;
/**
* Return the name of this element, or `null` if this element does not have a name.
*
* @return the name of this element
*/
String get name;
/**
* Return the offset of the name of this element in the file that contains the declaration of this
* element, or `-1` if this element is synthetic, does not have a name, or otherwise does
* not have an offset.
*
* @return the offset of the name of this element
*/
int get nameOffset;
/**
* Return the source that contains this element, or `null` if this element is not contained
* in a source.
*
* @return the source that contains this element
*/
Source get source;
/**
* Return `true` if this 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 3.2:
* <blockquote> A declaration <i>m</i> is accessible to library <i>L</i> if <i>m</i> is declared
* in <i>L</i> or if <i>m</i> is public. </blockquote>
*
* @param library the library in which a possible reference to this element would occur
* @return `true` if this element is accessible to code in the given library
*/
bool isAccessibleIn(LibraryElement library);
/**
* Return `true` if 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.
*
* @return `true` if this element is synthetic
*/
bool get isSynthetic;
/**
* 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.
*
* @param visitor the visitor that will be used to visit the children of this element
*/
void visitChildren(ElementVisitor visitor);
}
/**
* The interface `ElementAnnotation` defines the behavior of objects representing a single
* annotation associated with an element.
*
* @coverage dart.engine.element
*/
abstract class ElementAnnotation {
/**
* Return the element representing the field, variable, or const constructor being used as an
* annotation.
*
* @return the field, variable, or constructor being used as an annotation
*/
Element get element;
}
/**
* The enumeration `ElementKind` defines the various kinds of elements in the element model.
*
* @coverage dart.engine.element
*/
class ElementKind extends Enum<ElementKind> {
static final ElementKind CLASS = new ElementKind('CLASS', 0, "class");
static final ElementKind COMPILATION_UNIT = new ElementKind('COMPILATION_UNIT', 1, "compilation unit");
static final ElementKind CONSTRUCTOR = new ElementKind('CONSTRUCTOR', 2, "constructor");
static final ElementKind DYNAMIC = new ElementKind('DYNAMIC', 3, "<dynamic>");
static final ElementKind EMBEDDED_HTML_SCRIPT = new ElementKind('EMBEDDED_HTML_SCRIPT', 4, "embedded html script");
static final ElementKind ERROR = new ElementKind('ERROR', 5, "<error>");
static final ElementKind EXPORT = new ElementKind('EXPORT', 6, "export directive");
static final ElementKind EXTERNAL_HTML_SCRIPT = new ElementKind('EXTERNAL_HTML_SCRIPT', 7, "external html script");
static final ElementKind FIELD = new ElementKind('FIELD', 8, "field");
static final ElementKind FUNCTION = new ElementKind('FUNCTION', 9, "function");
static final ElementKind GETTER = new ElementKind('GETTER', 10, "getter");
static final ElementKind HTML = new ElementKind('HTML', 11, "html");
static final ElementKind IMPORT = new ElementKind('IMPORT', 12, "import directive");
static final ElementKind LABEL = new ElementKind('LABEL', 13, "label");
static final ElementKind LIBRARY = new ElementKind('LIBRARY', 14, "library");
static final ElementKind LOCAL_VARIABLE = new ElementKind('LOCAL_VARIABLE', 15, "local variable");
static final ElementKind METHOD = new ElementKind('METHOD', 16, "method");
static final ElementKind NAME = new ElementKind('NAME', 17, "<name>");
static final ElementKind PARAMETER = new ElementKind('PARAMETER', 18, "parameter");
static final ElementKind PREFIX = new ElementKind('PREFIX', 19, "import prefix");
static final ElementKind SETTER = new ElementKind('SETTER', 20, "setter");
static final ElementKind TOP_LEVEL_VARIABLE = new ElementKind('TOP_LEVEL_VARIABLE', 21, "top level variable");
static final ElementKind FUNCTION_TYPE_ALIAS = new ElementKind('FUNCTION_TYPE_ALIAS', 22, "function type alias");
static final ElementKind TYPE_PARAMETER = new ElementKind('TYPE_PARAMETER', 23, "type parameter");
static final ElementKind UNIVERSE = new ElementKind('UNIVERSE', 24, "<universe>");
static final List<ElementKind> values = [
CLASS,
COMPILATION_UNIT,
CONSTRUCTOR,
DYNAMIC,
EMBEDDED_HTML_SCRIPT,
ERROR,
EXPORT,
EXTERNAL_HTML_SCRIPT,
FIELD,
FUNCTION,
GETTER,
HTML,
IMPORT,
LABEL,
LIBRARY,
LOCAL_VARIABLE,
METHOD,
NAME,
PARAMETER,
PREFIX,
SETTER,
TOP_LEVEL_VARIABLE,
FUNCTION_TYPE_ALIAS,
TYPE_PARAMETER,
UNIVERSE];
/**
* Return the kind of the given element, or [ERROR] if the element is `null`. This is
* a utility method that can reduce the need for null checks in other places.
*
* @param element the element whose kind is to be returned
* @return the kind of the given element
*/
static ElementKind of(Element element) {
if (element == null) {
return ERROR;
}
return element.kind;
}
/**
* The name displayed in the UI for this kind of element.
*/
String displayName;
/**
* Initialize a newly created element kind to have the given display name.
*
* @param displayName the name displayed in the UI for this kind of element
*/
ElementKind(String name, int ordinal, String displayName) : super(name, ordinal) {
this.displayName = displayName;
}
}
/**
* The interface `ElementLocation` defines the behavior of objects that represent the location
* of an element within the element model.
*
* @coverage dart.engine.element
*/
abstract class ElementLocation {
/**
* Return an encoded representation of this location that can be used to create a location that is
* equal to this location.
*
* @return an encoded representation of this location
*/
String get encoding;
}
/**
* The interface `ElementVisitor` defines the behavior of objects that can be used to visit an
* element structure.
*
* @coverage dart.engine.element
*/
abstract class ElementVisitor<R> {
R visitClassElement(ClassElement element);
R visitCompilationUnitElement(CompilationUnitElement element);
R visitConstructorElement(ConstructorElement element);
R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element);
R visitExportElement(ExportElement element);
R visitExternalHtmlScriptElement(ExternalHtmlScriptElement element);
R visitFieldElement(FieldElement element);
R visitFieldFormalParameterElement(FieldFormalParameterElement element);
R visitFunctionElement(FunctionElement element);
R visitFunctionTypeAliasElement(FunctionTypeAliasElement element);
R visitHtmlElement(HtmlElement element);
R visitImportElement(ImportElement element);
R visitLabelElement(LabelElement element);
R visitLibraryElement(LibraryElement element);
R visitLocalVariableElement(LocalVariableElement element);
R visitMethodElement(MethodElement element);
R visitMultiplyDefinedElement(MultiplyDefinedElement element);
R visitParameterElement(ParameterElement element);
R visitPrefixElement(PrefixElement element);
R visitPropertyAccessorElement(PropertyAccessorElement element);
R visitTopLevelVariableElement(TopLevelVariableElement element);
R visitTypeParameterElement(TypeParameterElement element);
}
/**
* The interface `EmbeddedHtmlScriptElement` defines the behavior of elements representing a
* script tag in an HTML file having content that defines a Dart library.
*
* @coverage dart.engine.element
*/
abstract class EmbeddedHtmlScriptElement implements HtmlScriptElement {
/**
* Return the library element defined by the content of the script tag.
*
* @return the library element (not `null`)
*/
LibraryElement get scriptLibrary;
}
/**
* The interface `ExecutableElement` defines the behavior of elements representing an
* executable object, including functions, methods, constructors, getters, and setters.
*
* @coverage dart.engine.element
*/
abstract class ExecutableElement implements Element {
/**
* Return an array containing all of the functions defined within this executable element.
*
* @return the functions defined within this executable element
*/
List<FunctionElement> get functions;
/**
* Return an array containing all of the labels defined within this executable element.
*
* @return the labels defined within this executable element
*/
List<LabelElement> get labels;
/**
* Return an array containing all of the local variables defined within this executable element.
*
* @return the local variables defined within this executable element
*/
List<LocalVariableElement> get localVariables;
/**
* Return an array containing all of the parameters defined by this executable element.
*
* @return the parameters defined by this executable element
*/
List<ParameterElement> get parameters;
/**
* Return the return type defined by this executable element.
*
* @return the return type defined by this executable element
*/
Type2 get returnType;
/**
* Return the type of function defined by this executable element.
*
* @return the type of function defined by this executable element
*/
FunctionType get type;
/**
* Return `true` if this 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.
*
* @return `true` if this executable element is an operator
*/
bool get isOperator;
/**
* Return `true` if this 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.
*
* @return `true` if this executable element is a static element
*/
bool get isStatic;
}
/**
* The interface `ExportElement` defines the behavior of objects representing information
* about a single export directive within a library.
*
* @coverage dart.engine.element
*/
abstract class ExportElement implements Element, UriReferencedElement {
/**
* An empty array of export elements.
*/
static final List<ExportElement> EMPTY_ARRAY = new List<ExportElement>(0);
/**
* Return an array containing the combinators that were specified as part of the export directive
* in the order in which they were specified.
*
* @return the combinators specified in the export directive
*/
List<NamespaceCombinator> get combinators;
/**
* Return the library that is exported from this library by this export directive.
*
* @return the library that is exported from this library
*/
LibraryElement get exportedLibrary;
}
/**
* The interface `ExternalHtmlScriptElement` defines the behavior of elements representing a
* script tag in an HTML file having a `source` attribute that references a Dart library
* source file.
*
* @coverage dart.engine.element
*/
abstract class ExternalHtmlScriptElement implements HtmlScriptElement {
/**
* Return the source referenced by this element, or `null` if this element does not
* reference a Dart library source file.
*
* @return the source for the external Dart library
*/
Source get scriptSource;
}
/**
* The interface `FieldElement` defines the behavior of elements representing a field defined
* within a type.
*
* @coverage dart.engine.element
*/
abstract class FieldElement implements ClassMemberElement, PropertyInducingElement {
}
/**
* The interface `FieldFormalParameterElement` defines the behavior of elements representing a
* field formal parameter defined within a constructor element.
*/
abstract class FieldFormalParameterElement implements ParameterElement {
/**
* Return the field element associated with this field formal parameter, or `null` if the
* parameter references a field that doesn't exist.
*
* @return the field element associated with this field formal parameter
*/
FieldElement get field;
}
/**
* The interface `FunctionElement` defines the behavior of elements representing a function.
*
* @coverage dart.engine.element
*/
abstract class FunctionElement implements ExecutableElement, LocalElement {
}
/**
* The interface `FunctionTypeAliasElement` defines the behavior of elements representing a
* function type alias (`typedef`).
*
* @coverage dart.engine.element
*/
abstract class FunctionTypeAliasElement implements Element {
/**
* Return the compilation unit in which this type alias is defined.
*
* @return the compilation unit in which this type alias is defined
*/
CompilationUnitElement get enclosingElement;
/**
* Return an array containing all of the parameters defined by this type alias.
*
* @return the parameters defined by this type alias
*/
List<ParameterElement> get parameters;
/**
* Return the return type defined by this type alias.
*
* @return the return type defined by this type alias
*/
Type2 get returnType;
/**
* Return the type of function defined by this type alias.
*
* @return the type of function defined by this type alias
*/
FunctionType get type;
/**
* Return an array containing all of the type parameters defined for this type.
*
* @return the type parameters defined for this type
*/
List<TypeParameterElement> get typeParameters;
}
/**
* The interface `HideElementCombinator` defines the behavior of combinators that cause some
* of the names in a namespace to be hidden when being imported.
*
* @coverage dart.engine.element
*/
abstract class HideElementCombinator implements NamespaceCombinator {
/**
* Return an array containing the names that are not to be made visible in the importing library
* even if they are defined in the imported library.
*
* @return the names from the imported library that are hidden from the importing library
*/
List<String> get hiddenNames;
}
/**
* The interface `HtmlElement` defines the behavior of elements representing an HTML file.
*
* @coverage dart.engine.element
*/
abstract class HtmlElement implements Element {
/**
* Return an array containing all of the script elements contained in the HTML file. This includes
* scripts with libraries that are defined by the content of a script tag as well as libraries
* that are referenced in the {@core source} attribute of a script tag.
*
* @return the script elements in the HTML file (not `null`, contains no `null`s)
*/
List<HtmlScriptElement> get scripts;
}
/**
* The interface `HtmlScriptElement` defines the behavior of elements representing a script
* tag in an HTML file.
*
* @see EmbeddedHtmlScriptElement
* @see ExternalHtmlScriptElement
* @coverage dart.engine.element
*/
abstract class HtmlScriptElement implements Element {
}
/**
* The interface `ImportElement` defines the behavior of objects representing information
* about a single import directive within a library.
*
* @coverage dart.engine.element
*/
abstract class ImportElement implements Element, UriReferencedElement {
/**
* An empty array of import elements.
*/
static final List<ImportElement> EMPTY_ARRAY = new List<ImportElement>(0);
/**
* Return an array containing the combinators that were specified as part of the import directive
* in the order in which they were specified.
*
* @return the combinators specified in the import directive
*/
List<NamespaceCombinator> get combinators;
/**
* Return the library that is imported into this library by this import directive.
*
* @return the library that is imported into this library
*/
LibraryElement get importedLibrary;
/**
* Return the prefix that was specified as part of the import directive, or `null` if there
* was no prefix specified.
*
* @return the prefix that was specified as part of the import directive
*/
PrefixElement get prefix;
/**
* Return the offset of the prefix of this import in the file that contains this import directive,
* or `-1` if this import is synthetic, does not have a prefix, or otherwise does not have
* an offset.
*
* @return the offset of the prefix of this import
*/
int get prefixOffset;
/**
* Return the offset of the character immediately following the last character of this node's URI,
* or `-1` for synthetic import.
*
* @return the offset of the character just past the node's URI
*/
int get uriEnd;
}
/**
* The interface `LabelElement` defines the behavior of elements representing a label
* associated with a statement.
*
* @coverage dart.engine.element
*/
abstract class LabelElement implements Element {
/**
* Return the executable element in which this label is defined.
*
* @return the executable element in which this label is defined
*/
ExecutableElement get enclosingElement;
}
/**
* The interface `LibraryElement` defines the behavior of elements representing a library.
*
* @coverage dart.engine.element
*/
abstract class LibraryElement implements Element {
/**
* Return the compilation unit that defines this library.
*
* @return the compilation unit that defines this library
*/
CompilationUnitElement get definingCompilationUnit;
/**
* Return the entry point for this library, or `null` if this library does not have an entry
* point. The entry point is defined to be a zero argument top-level function whose name is
* `main`.
*
* @return the entry point for this library
*/
FunctionElement get entryPoint;
/**
* Return an array containing all of the libraries that are exported from this library.
*
* @return an array containing all of the libraries that are exported from this library
*/
List<LibraryElement> get exportedLibraries;
/**
* Return an array containing all of the exports defined in this library.
*
* @return the exports defined in this library
*/
List<ExportElement> get exports;
/**
* Return an array containing all of the libraries that are imported into this library. This
* includes all of the libraries that are imported using a prefix (also available through the
* prefixes returned by [getPrefixes]) and those that are imported without a prefix.
*
* @return an array containing all of the libraries that are imported into this library
*/
List<LibraryElement> get importedLibraries;
/**
* Return an array containing all of the imports defined in this library.
*
* @return the imports defined in this library
*/
List<ImportElement> get imports;
/**
* Return an array containing all of the compilation units that are included in this library using
* a `part` directive. This does not include the defining compilation unit that contains the
* `part` directives.
*
* @return the compilation units that are included in this library
*/
List<CompilationUnitElement> get parts;
/**
* Return an array containing elements for each of the prefixes used to `import` libraries
* into this library. Each prefix can be used in more than one `import` directive.
*
* @return the prefixes used to `import` libraries into this library
*/
List<PrefixElement> get prefixes;
/**
* Return the class defined in this library that has the given name, or `null` if this
* library does not define a class with the given name.
*
* @param className the name of the class to be returned
* @return the class with the given name that is defined in this library
*/
ClassElement getType(String className);
/**
* Answer `true` if this library is an application that can be run in the browser.
*
* @return `true` if this library is an application that can be run in the browser
*/
bool get isBrowserApplication;
/**
* Return `true` if this library is the dart:core library.
*
* @return `true` if this library is the dart:core library
*/
bool get isDartCore;
/**
* Return `true` if this library is the dart:core library.
*
* @return `true` if this library is the dart:core library
*/
bool get isInSdk;
/**
* Return `true` if this library is up to date with respect to the given time stamp. If any
* transitively referenced Source is newer than the time stamp, this method returns false.
*
* @param timeStamp the time stamp to compare against
* @return `true` if this library is up to date with respect to the given time stamp
*/
bool isUpToDate2(int timeStamp);
}
/**
* The interface `LocalElement` defines the behavior of elements that can be (but are not
* required to be) defined within a method or function (an [ExecutableElement]).
*
* @coverage dart.engine.element
*/
abstract class LocalElement implements Element {
/**
* Return a source range that covers the approximate portion of the source in which the name of
* this element is visible, or `null` if there is no single range of characters within which
* the element name is visible.
*
* * For a local variable, this includes everything from the end of the variable's initializer
* to the end of the block that encloses the variable declaration.
* * For a parameter, this includes the body of the method or function that declares the
* parameter.
* * For a local function, this includes everything from the beginning of the function's body to
* the end of the block that encloses the function declaration.
* * For top-level functions, `null` will be returned because they are potentially visible
* in multiple sources.
*
*
* @return the range of characters in which the name of this element is visible
*/
SourceRange get visibleRange;
}
/**
* The interface `LocalVariableElement` defines the behavior common to elements that represent
* a local variable.
*
* @coverage dart.engine.element
*/
abstract class LocalVariableElement implements LocalElement, VariableElement {
}
/**
* The interface `MethodElement` defines the behavior of elements that represent a method
* defined within a type.
*
* @coverage dart.engine.element
*/
abstract class MethodElement implements ClassMemberElement, ExecutableElement {
/**
* Return `true` if this method is abstract. Methods are abstract if they are not external
* and have no body.
*
* @return `true` if this method is abstract
*/
bool get isAbstract;
}
/**
* The interface `MultiplyDefinedElement` defines the behavior of pseudo-elements that
* represent 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.
*
* @coverage dart.engine.element
*/
abstract class MultiplyDefinedElement implements Element {
/**
* Return an array containing all of the elements that were defined within the scope to have the
* same name.
*
* @return the elements that were defined with the same name
*/
List<Element> get conflictingElements;
/**
* Return the type of this element as the dynamic type.
*
* @return the type of this element as the dynamic type
*/
Type2 get type;
}
/**
* The interface `NamespaceCombinator` defines the behavior common to objects that control how
* namespaces are combined.
*
* @coverage dart.engine.element
*/
abstract class NamespaceCombinator {
/**
* An empty array of namespace combinators.
*/
static final List<NamespaceCombinator> EMPTY_ARRAY = new List<NamespaceCombinator>(0);
}
/**
* The interface `ParameterElement` defines the behavior of elements representing a parameter
* defined within an executable element.
*
* @coverage dart.engine.element
*/
abstract class ParameterElement implements LocalElement, VariableElement {
/**
* Return a source range that covers the portion of the source in which the default value for this
* parameter is specified, or `null` if there is no default value.
*
* @return the range of characters in which the default value of this parameter is specified
*/
SourceRange get defaultValueRange;
/**
* Return the kind of this parameter.
*
* @return the kind of this parameter
*/
ParameterKind get parameterKind;
/**
* Return an array containing all of the parameters defined by this parameter. A parameter will
* only define other parameters if it is a function typed parameter.
*
* @return the parameters defined by this parameter element
*/
List<ParameterElement> get parameters;
/**
* Return `true` if this parameter is an initializing formal parameter.
*
* @return `true` if this parameter is an initializing formal parameter
*/
bool get isInitializingFormal;
}
/**
* The interface `PrefixElement` defines the behavior common to elements that represent a
* prefix used to import one or more libraries into another library.
*
* @coverage dart.engine.element
*/
abstract class PrefixElement implements Element {
/**
* Return the library into which other libraries are imported using this prefix.
*
* @return the library into which other libraries are imported using this prefix
*/
LibraryElement get enclosingElement;
/**
* Return an array containing all of the libraries that are imported using this prefix.
*
* @return the libraries that are imported using this prefix
*/
List<LibraryElement> get importedLibraries;
}
/**
* The interface `PropertyAccessorElement` defines the behavior of elements representing a
* getter or a setter. Note that explicitly defined property accessors implicitly define a synthetic
* field. Symmetrically, synthetic accessors are implicitly created for explicitly defined fields.
* The following rules apply:
*
* * Every explicit field is represented by a non-synthetic [FieldElement].
* * Every explicit field 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 field
* that is represented by a synthetic [FieldElement].
*
*
* @coverage dart.engine.element
*/
abstract class PropertyAccessorElement implements ExecutableElement {
/**
* Return the accessor representing the getter that corresponds to (has the same name as) this
* setter, or `null` if this accessor is not a setter or if there is no corresponding
* getter.
*
* @return the getter that corresponds to this setter
*/
PropertyAccessorElement get correspondingGetter;
/**
* Return the accessor representing the setter that corresponds to (has the same name as) this
* getter, or `null` if this accessor is not a getter or if there is no corresponding
* setter.
*
* @return the setter that corresponds to this getter
*/
PropertyAccessorElement get correspondingSetter;
/**
* Return the field or top-level variable associated with this accessor. If this accessor was
* explicitly defined (is not synthetic) then the variable associated with it will be synthetic.
*
* @return the variable associated with this accessor
*/
PropertyInducingElement get variable;
/**
* Return `true` if this accessor is abstract. Accessors are abstract if they are not
* external and have no body.
*
* @return `true` if this accessor is abstract
*/
bool get isAbstract;
/**
* Return `true` if this accessor represents a getter.
*
* @return `true` if this accessor represents a getter
*/
bool get isGetter;
/**
* Return `true` if this accessor represents a setter.
*
* @return `true` if this accessor represents a setter
*/
bool get isSetter;
}
/**
* The interface `PropertyInducingElement` defines the behavior of elements representing 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].
*
*
* @coverage dart.engine.element
*/
abstract class PropertyInducingElement implements VariableElement {
/**
* Return the getter associated with this variable. If this variable was explicitly defined (is
* not synthetic) then the getter associated with it will be synthetic.
*
* @return the getter associated with this variable
*/
PropertyAccessorElement get getter;
/**
* Return the setter associated with this variable, or `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.
*
* @return the setter associated with this variable
*/
PropertyAccessorElement get setter;
/**
* Return `true` if this 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.
*
* @return `true` if this executable element is a static element
*/
bool get isStatic;
}
/**
* The interface `ShowElementCombinator` defines the behavior of combinators that cause some
* of the names in a namespace to be visible (and the rest hidden) when being imported.
*
* @coverage dart.engine.element
*/
abstract class ShowElementCombinator implements NamespaceCombinator {
/**
* Return an array containing the names that are to be made visible in the importing library if
* they are defined in the imported library.
*
* @return the names from the imported library that are visible in the importing library
*/
List<String> get shownNames;
}
/**
* The interface `TopLevelVariableElement` defines the behavior of elements representing a
* top-level variable.
*
* @coverage dart.engine.element
*/
abstract class TopLevelVariableElement implements PropertyInducingElement {
}
/**
* The interface `TypeParameterElement` defines the behavior of elements representing a type
* parameter.
*
* @coverage dart.engine.element
*/
abstract class TypeParameterElement implements Element {
/**
* Return the type representing the bound associated with this parameter, or `null` if this
* parameter does not have an explicit bound.
*
* @return the type representing the bound associated with this parameter
*/
Type2 get bound;
/**
* Return the type defined by this type parameter.
*
* @return the type defined by this type parameter
*/
TypeParameterType get type;
}
/**
* The interface `UndefinedElement` defines the behavior of pseudo-elements that represent
* 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.
*
* @coverage dart.engine.element
*/
abstract class UndefinedElement implements Element {
}
/**
* The interface `UriReferencedElement` defines the behavior of objects included into a
* library using some URI.
*
* @coverage dart.engine.element
*/
abstract class UriReferencedElement implements Element {
/**
* Return the URI that is used to include this element into the enclosing library, or `null`
* if this is the defining compilation unit of a library.
*
* @return the URI that is used to include this element into the enclosing library
*/
String get uri;
}
/**
* The interface `VariableElement` defines the behavior common to elements that represent a
* variable.
*
* @coverage dart.engine.element
*/
abstract class VariableElement implements Element {
/**
* Return a synthetic function representing this variable's initializer, or `null` if this
* variable does not have an initializer. The function will have no parameters. The return type of
* the function will be the compile-time type of the initialization expression.
*
* @return a synthetic function representing this variable's initializer
*/
FunctionElement get initializer;
/**
* Return the declared type of this variable, or `null` if the variable did not have a
* declared type (such as if it was declared using the keyword 'var').
*
* @return the declared type of this variable
*/
Type2 get type;
/**
* Return `true` if this variable was declared with the 'const' modifier.
*
* @return `true` if this variable was declared with the 'const' modifier
*/
bool get isConst;
/**
* Return `true` if this variable was declared with the 'final' modifier. Variables that are
* declared with the 'const' modifier will return `false` even though they are implicitly
* final.
*
* @return `true` if this variable was declared with the 'final' modifier
*/
bool get isFinal;
}
/**
* Instances of the class `GeneralizingElementVisitor` implement an element visitor that will
* recursively visit all of the elements in an element model (like instances of the class
* [RecursiveElementVisitor]). In addition, when an element of a specific type is visited not
* only will the visit method for that specific type of element be invoked, but additional methods
* for the supertypes of that element will also be invoked. For example, using an instance of this
* class to visit a [MethodElement] will cause the method
* [visitMethodElement] to be invoked but will also cause the methods
* [visitExecutableElement] and [visitElement] to be
* subsequently invoked. This allows visitors to be written that visit all executable elements
* without needing to override the visit method for each of the specific subclasses of
* [ExecutableElement].
*
* Note, however, that unlike many visitors, element visitors visit objects based on the interfaces
* implemented by those elements. Because interfaces form a graph structure rather than a tree
* structure the way classes do, and because it is generally undesirable for an object to be visited
* more than once, this class flattens the interface graph into a pseudo-tree. In particular, this
* class treats elements as if the element types were structured in the following way:
*
*
* <pre>
* Element
* ClassElement
* CompilationUnitElement
* ExecutableElement
* ConstructorElement
* LocalElement
* FunctionElement
* MethodElement
* PropertyAccessorElement
* ExportElement
* HtmlElement
* ImportElement
* LabelElement
* LibraryElement
* MultiplyDefinedElement
* PrefixElement
* TypeAliasElement
* TypeParameterElement
* UndefinedElement
* VariableElement
* PropertyInducingElement
* FieldElement
* TopLevelVariableElement
* LocalElement
* LocalVariableElement
* ParameterElement
* FieldFormalParameterElement
* </pre>
*
* Subclasses that override a visit method must either invoke the overridden visit method or
* explicitly invoke the more general visit method. Failure to do so will cause the visit methods
* for superclasses of the element to not be invoked and will cause the children of the visited node
* to not be visited.
*
* @coverage dart.engine.element
*/
class GeneralizingElementVisitor<R> implements ElementVisitor<R> {
R visitClassElement(ClassElement element) => visitElement(element);
R visitCompilationUnitElement(CompilationUnitElement element) => visitElement(element);
R visitConstructorElement(ConstructorElement element) => visitExecutableElement(element);
R visitElement(Element element) {
element.visitChildren(this);
return null;
}
R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element) => visitHtmlScriptElement(element);
R visitExecutableElement(ExecutableElement element) => visitElement(element);
R visitExportElement(ExportElement element) => visitElement(element);
R visitExternalHtmlScriptElement(ExternalHtmlScriptElement element) => visitHtmlScriptElement(element);
R visitFieldElement(FieldElement element) => visitPropertyInducingElement(element);
R visitFieldFormalParameterElement(FieldFormalParameterElement element) => visitParameterElement(element);
R visitFunctionElement(FunctionElement element) => visitLocalElement(element);
R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) => visitElement(element);
R visitHtmlElement(HtmlElement element) => visitElement(element);
R visitHtmlScriptElement(HtmlScriptElement element) => visitElement(element);
R visitImportElement(ImportElement element) => visitElement(element);
R visitLabelElement(LabelElement element) => visitElement(element);
R visitLibraryElement(LibraryElement element) => visitElement(element);
R visitLocalElement(LocalElement element) {
if (element is LocalVariableElement) {
return visitVariableElement(element as LocalVariableElement);
} else if (element is ParameterElement) {
return visitVariableElement(element as ParameterElement);
} else if (element is FunctionElement) {
return visitExecutableElement(element as FunctionElement);
}
return null;
}
R visitLocalVariableElement(LocalVariableElement element) => visitLocalElement(element);
R visitMethodElement(MethodElement element) => visitExecutableElement(element);
R visitMultiplyDefinedElement(MultiplyDefinedElement element) => visitElement(element);
R visitParameterElement(ParameterElement element) => visitLocalElement(element);
R visitPrefixElement(PrefixElement element) => visitElement(element);
R visitPropertyAccessorElement(PropertyAccessorElement element) => visitExecutableElement(element);
R visitPropertyInducingElement(PropertyInducingElement element) => visitVariableElement(element);
R visitTopLevelVariableElement(TopLevelVariableElement element) => visitPropertyInducingElement(element);
R visitTypeParameterElement(TypeParameterElement element) => visitElement(element);
R visitVariableElement(VariableElement element) => visitElement(element);
}
/**
* Instances of the class `RecursiveElementVisitor` implement an element visitor that will
* recursively visit all of the element in an element model. For example, using an instance of this
* class to visit a [CompilationUnitElement] will also cause all of the types in the
* compilation unit to be visited.
*
* Subclasses that override a visit method must either invoke the overridden visit method or must
* explicitly ask the visited element to visit its children. Failure to do so will cause the
* children of the visited element to not be visited.
*
* @coverage dart.engine.element
*/
class RecursiveElementVisitor<R> implements ElementVisitor<R> {
R visitClassElement(ClassElement element) {
element.visitChildren(this);
return null;
}
R visitCompilationUnitElement(CompilationUnitElement element) {
element.visitChildren(this);
return null;
}
R visitConstructorElement(ConstructorElement element) {
element.visitChildren(this);
return null;
}
R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element) {
element.visitChildren(this);
return null;
}
R visitExportElement(ExportElement element) {
element.visitChildren(this);
return null;
}
R visitExternalHtmlScriptElement(ExternalHtmlScriptElement element) {
element.visitChildren(this);
return null;
}
R visitFieldElement(FieldElement element) {
element.visitChildren(this);
return null;
}
R visitFieldFormalParameterElement(FieldFormalParameterElement element) {
element.visitChildren(this);
return null;
}
R visitFunctionElement(FunctionElement element) {
element.visitChildren(this);
return null;
}
R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
element.visitChildren(this);
return null;
}
R visitHtmlElement(HtmlElement element) {
element.visitChildren(this);
return null;
}
R visitImportElement(ImportElement element) {
element.visitChildren(this);
return null;
}
R visitLabelElement(LabelElement element) {
element.visitChildren(this);
return null;
}
R visitLibraryElement(LibraryElement element) {
element.visitChildren(this);
return null;
}
R visitLocalVariableElement(LocalVariableElement element) {
element.visitChildren(this);
return null;
}
R visitMethodElement(MethodElement element) {
element.visitChildren(this);
return null;
}
R visitMultiplyDefinedElement(MultiplyDefinedElement element) {
element.visitChildren(this);
return null;
}
R visitParameterElement(ParameterElement element) {
element.visitChildren(this);
return null;
}
R visitPrefixElement(PrefixElement element) {
element.visitChildren(this);
return null;
}
R visitPropertyAccessorElement(PropertyAccessorElement element) {
element.visitChildren(this);
return null;
}
R visitTopLevelVariableElement(TopLevelVariableElement element) {
element.visitChildren(this);
return null;
}
R visitTypeParameterElement(TypeParameterElement element) {
element.visitChildren(this);
return null;
}
}
/**
* Instances of the class `SimpleElementVisitor` implement an element visitor that will do
* nothing when visiting an element. It is intended to be a superclass for classes that use the
* visitor pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a
* whole structure) and that only need to visit a small number of element types.
*
* @coverage dart.engine.element
*/
class SimpleElementVisitor<R> implements ElementVisitor<R> {
R visitClassElement(ClassElement element) => null;
R visitCompilationUnitElement(CompilationUnitElement element) => null;
R visitConstructorElement(ConstructorElement element) => null;
R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element) => null;
R visitExportElement(ExportElement element) => null;
R visitExternalHtmlScriptElement(ExternalHtmlScriptElement element) => null;
R visitFieldElement(FieldElement element) => null;
R visitFieldFormalParameterElement(FieldFormalParameterElement element) => null;
R visitFunctionElement(FunctionElement element) => null;
R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) => null;
R visitHtmlElement(HtmlElement element) => null;
R visitImportElement(ImportElement element) => null;
R visitLabelElement(LabelElement element) => null;
R visitLibraryElement(LibraryElement element) => null;
R visitLocalVariableElement(LocalVariableElement element) => null;
R visitMethodElement(MethodElement element) => null;
R visitMultiplyDefinedElement(MultiplyDefinedElement element) => null;
R visitParameterElement(ParameterElement element) => null;
R visitPrefixElement(PrefixElement element) => null;
R visitPropertyAccessorElement(PropertyAccessorElement element) => null;
R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
R visitTypeParameterElement(TypeParameterElement element) => null;
}
/**
* For AST nodes that could be in both the getter and setter contexts ([IndexExpression]s and
* [SimpleIdentifier]s), the additional resolved elements are stored in the AST node, in an
* [AuxiliaryElements]. Since resolved elements are either statically resolved or resolved
* using propagated type information, this class is a wrapper for a pair of
* [ExecutableElement]s, not just a single [ExecutableElement].
*/
class AuxiliaryElements {
/**
* The element based on propagated type information, or `null` if the AST structure has not
* been resolved or if this identifier could not be resolved.
*/
ExecutableElement propagatedElement;
/**
* The element associated with this identifier based on static type information, or `null`
* if the AST structure has not been resolved or if this identifier could not be resolved.
*/
ExecutableElement staticElement;
/**
* Create the [AuxiliaryElements] with a static and propagated [ExecutableElement].
*
* @param staticElement the static element
* @param propagatedElement the propagated element
*/
AuxiliaryElements(ExecutableElement staticElement, ExecutableElement propagatedElement) {
this.staticElement = staticElement;
this.propagatedElement = propagatedElement;
}
}
/**
* Instances of the class `ClassElementImpl` implement a `ClassElement`.
*
* @coverage dart.engine.element
*/
class ClassElementImpl extends ElementImpl implements ClassElement {
/**
* An array containing all of the accessors (getters and setters) contained in this class.
*/
List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the constructors contained in this class.
*/
List<ConstructorElement> _constructors = ConstructorElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the fields contained in this class.
*/
List<FieldElement> _fields = FieldElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the mixins that are applied to the class being extended in order to
* derive the superclass of this class.
*/
List<InterfaceType> _mixins = InterfaceTypeImpl.EMPTY_ARRAY;
/**
* An array containing all of the interfaces that are implemented by this class.
*/
List<InterfaceType> _interfaces = InterfaceTypeImpl.EMPTY_ARRAY;
/**
* An array containing all of the methods contained in this class.
*/
List<MethodElement> _methods = MethodElementImpl.EMPTY_ARRAY;
/**
* The superclass of the class, or `null` if the class does not have an explicit superclass.
*/
InterfaceType _supertype;
/**
* The type defined by the class.
*/
InterfaceType _type;
/**
* An array containing all of the type parameters defined for this class.
*/
List<TypeParameterElement> _typeParameters = TypeParameterElementImpl.EMPTY_ARRAY;
/**
* An empty array of type elements.
*/
static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
/**
* Initialize a newly created class element to have the given name.
*
* @param name the name of this element
*/
ClassElementImpl(Identifier name) : super.con1(name);
accept(ElementVisitor visitor) => visitor.visitClassElement(this);
List<PropertyAccessorElement> get accessors => _accessors;
List<InterfaceType> get allSupertypes {
List<InterfaceType> list = new List<InterfaceType>();
collectAllSupertypes(list);
return new List.from(list);
}
ElementImpl getChild(String identifier) {
for (PropertyAccessorElement accessor in _accessors) {
if (((accessor as PropertyAccessorElementImpl)).identifier == identifier) {
return accessor as PropertyAccessorElementImpl;
}
}
for (ConstructorElement constructor in _constructors) {
if (((constructor as ConstructorElementImpl)).identifier == identifier) {
return constructor as ConstructorElementImpl;
}
}
for (FieldElement field in _fields) {
if (((field as FieldElementImpl)).identifier == identifier) {
return field as FieldElementImpl;
}
}
for (MethodElement method in _methods) {
if (((method as MethodElementImpl)).identifier == identifier) {
return method as MethodElementImpl;
}
}
for (TypeParameterElement typeParameter in _typeParameters) {
if (((typeParameter as TypeParameterElementImpl)).identifier == identifier) {
return typeParameter as TypeParameterElementImpl;
}
}
return null;
}
List<ConstructorElement> get constructors => _constructors;
/**
* Given some name, this returns the [FieldElement] with the matching name, if there is no
* such field, then `null` is returned.
*
* @param name some name to lookup a field element with
* @return the matching field element, or `null` if no such element was found
*/
FieldElement getField(String name) {
for (FieldElement fieldElement in _fields) {
if (name == fieldElement.name) {
return fieldElement;
}
}
return null;
}
List<FieldElement> get fields => _fields;
PropertyAccessorElement getGetter(String getterName) {
for (PropertyAccessorElement accessor in _accessors) {
if (accessor.isGetter && accessor.name == getterName) {
return accessor;
}
}
return null;
}
List<InterfaceType> get interfaces => _interfaces;
ElementKind get kind => ElementKind.CLASS;
MethodElement getMethod(String methodName) {
for (MethodElement method in _methods) {
if (method.name == methodName) {
return method;
}
}
return null;
}
List<MethodElement> get methods => _methods;
List<InterfaceType> get mixins => _mixins;
ConstructorElement getNamedConstructor(String name) {
for (ConstructorElement element in constructors) {
String elementName = element.name;
if (elementName != null && elementName == name) {
return element;
}
}
return null;
}
PropertyAccessorElement getSetter(String setterName) {
if (!setterName.endsWith("=")) {
setterName += '=';
}
for (PropertyAccessorElement accessor in _accessors) {
if (accessor.isSetter && accessor.name == setterName) {
return accessor;
}
}
return null;
}
InterfaceType get supertype => _supertype;
InterfaceType get type => _type;
List<TypeParameterElement> get typeParameters => _typeParameters;
ConstructorElement get unnamedConstructor {
for (ConstructorElement element in constructors) {
String name = element.displayName;
if (name == null || name.isEmpty) {
return element;
}
}
return null;
}
bool hasNonFinalField() {
List<ClassElement> classesToVisit = new List<ClassElement>();
Set<ClassElement> visitedClasses = new Set<ClassElement>();
classesToVisit.add(this);
while (!classesToVisit.isEmpty) {
ClassElement currentElement = classesToVisit.removeAt(0);
if (javaSetAdd(visitedClasses, currentElement)) {
for (FieldElement field in currentElement.fields) {
if (!field.isFinal && !field.isConst && !field.isStatic && !field.isSynthetic) {
return true;
}
}
for (InterfaceType mixinType in currentElement.mixins) {
ClassElement mixinElement = mixinType.element;
classesToVisit.add(mixinElement);
}
InterfaceType supertype = currentElement.supertype;
if (supertype != null) {
ClassElement superElement = supertype.element;
if (superElement != null) {
classesToVisit.add(superElement);
}
}
}
}
return false;
}
bool hasReferenceToSuper() => hasModifier(Modifier.REFERENCES_SUPER);
bool get isAbstract => hasModifier(Modifier.ABSTRACT);
bool get isTypedef => hasModifier(Modifier.TYPEDEF);
bool get isValidMixin => hasModifier(Modifier.MIXIN);
PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) {
Set<ClassElement> visitedClasses = new Set<ClassElement>();
ClassElement currentElement = this;
while (currentElement != null && !visitedClasses.contains(currentElement)) {
javaSetAdd(visitedClasses, currentElement);
PropertyAccessorElement element = currentElement.getGetter(getterName);
if (element != null && element.isAccessibleIn(library)) {
return element;
}
for (InterfaceType mixin in currentElement.mixins) {
ClassElement mixinElement = mixin.element;
if (mixinElement != null) {
element = mixinElement.getGetter(getterName);
if (element != null && element.isAccessibleIn(library)) {
return element;
}
}
}
InterfaceType supertype = currentElement.supertype;
if (supertype == null) {
return null;
}
currentElement = supertype.element;
}
return null;
}
MethodElement lookUpMethod(String methodName, LibraryElement library) {
Set<ClassElement> visitedClasses = new Set<ClassElement>();
ClassElement currentElement = this;
while (currentElement != null && !visitedClasses.contains(currentElement)) {
javaSetAdd(visitedClasses, currentElement);
MethodElement element = currentElement.getMethod(methodName);
if (element != null && element.isAccessibleIn(library)) {
return element;
}
for (InterfaceType mixin in currentElement.mixins) {
ClassElement mixinElement = mixin.element;
if (mixinElement != null) {
element = mixinElement.getMethod(methodName);
if (element != null && element.isAccessibleIn(library)) {
return element;
}
}
}
InterfaceType supertype = currentElement.supertype;
if (supertype == null) {
return null;
}
currentElement = supertype.element;
}
return null;
}
PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) {
Set<ClassElement> visitedClasses = new Set<ClassElement>();
ClassElement currentElement = this;
while (currentElement != null && !visitedClasses.contains(currentElement)) {
javaSetAdd(visitedClasses, currentElement);
PropertyAccessorElement element = currentElement.getSetter(setterName);
if (element != null && element.isAccessibleIn(library)) {
return element;
}
for (InterfaceType mixin in currentElement.mixins) {
ClassElement mixinElement = mixin.element;
if (mixinElement != null) {
element = mixinElement.getSetter(setterName);
if (element != null && element.isAccessibleIn(library)) {
return element;
}
}
}
InterfaceType supertype = currentElement.supertype;
if (supertype == null) {
return null;
}
currentElement = supertype.element;
}
return null;
}
/**
* Set whether this class is abstract to correspond to the given value.
*
* @param isAbstract `true` if the class is abstract
*/
void set abstract(bool isAbstract) {
setModifier(Modifier.ABSTRACT, isAbstract);
}
/**
* Set the accessors contained in this class to the given accessors.
*
* @param accessors the accessors contained in this class
*/
void set accessors(List<PropertyAccessorElement> accessors) {
for (PropertyAccessorElement accessor in accessors) {
((accessor as PropertyAccessorElementImpl)).enclosingElement = this;
}
this._accessors = accessors;
}
/**
* Set the constructors contained in this class to the given constructors.
*
* @param constructors the constructors contained in this class
*/
void set constructors(List<ConstructorElement> constructors) {
for (ConstructorElement constructor in constructors) {
((constructor as ConstructorElementImpl)).enclosingElement = this;
}
this._constructors = constructors;
}
/**
* Set the fields contained in this class to the given fields.
*
* @param fields the fields contained in this class
*/
void set fields(List<FieldElement> fields) {
for (FieldElement field in fields) {
((field as FieldElementImpl)).enclosingElement = this;
}
this._fields = fields;
}
/**
* Set whether this class references 'super' to the given value.
*
* @param isReferencedSuper `true` references 'super'
*/
void set hasReferenceToSuper2(bool isReferencedSuper) {
setModifier(Modifier.REFERENCES_SUPER, isReferencedSuper);
}
/**
* Set the interfaces that are implemented by this class to the given types.
*
* @param the interfaces that are implemented by this class
*/
void set interfaces(List<InterfaceType> interfaces) {
this._interfaces = interfaces;
}
/**
* Set the methods contained in this class to the given methods.
*
* @param methods the methods contained in this class
*/
void set methods(List<MethodElement> methods) {
for (MethodElement method in methods) {
((method as MethodElementImpl)).enclosingElement = this;
}
this._methods = methods;
}
/**
* Set the mixins that are applied to the class being extended in order to derive the superclass
* of this class to the given types.
*
* @param mixins the mixins that are applied to derive the superclass of this class
*/
void set mixins(List<InterfaceType> mixins) {
this._mixins = mixins;
}
/**
* Set the superclass of the class to the given type.
*
* @param supertype the superclass of the class
*/
void set supertype(InterfaceType supertype) {
this._supertype = supertype;
}
/**
* Set the type defined by the class to the given type.
*
* @param type the type defined by the class
*/
void set type(InterfaceType type) {
this._type = type;
}
/**
* Set whether this class is defined by a typedef construct to correspond to the given value.
*
* @param isTypedef `true` if the class is defined by a typedef construct
*/
void set typedef(bool isTypedef) {
setModifier(Modifier.TYPEDEF, isTypedef);
}
/**
* Set the type parameters defined for this class to the given type parameters.
*
* @param typeParameters the type parameters defined for this class
*/
void set typeParameters(List<TypeParameterElement> typeParameters) {
for (TypeParameterElement typeParameter in typeParameters) {
((typeParameter as TypeParameterElementImpl)).enclosingElement = this;
}
this._typeParameters = typeParameters;
}
/**
* Set whether this class is a valid mixin to correspond to the given value.
*
* @param isValidMixin `true` if this class can be used as a mixin
*/
void set validMixin(bool isValidMixin) {
setModifier(Modifier.MIXIN, isValidMixin);
}
void visitChildren(ElementVisitor visitor) {
super.visitChildren(visitor);
safelyVisitChildren(_accessors, visitor);
safelyVisitChildren(_constructors, visitor);
safelyVisitChildren(_fields, visitor);
safelyVisitChildren(_methods, visitor);
safelyVisitChildren(_typeParameters, visitor);
}
void appendTo(JavaStringBuilder builder) {
String name = displayName;
if (name == null) {
builder.append("{unnamed class}");
} else {
builder.append(name);
}
int variableCount = _typeParameters.length;
if (variableCount > 0) {
builder.append("<");
for (int i = 0; i < variableCount; i++) {
if (i > 0) {
builder.append(", ");
}
((_typeParameters[i] as TypeParameterElementImpl)).appendTo(builder);
}
builder.append(">");
}
}
void collectAllSupertypes(List<InterfaceType> supertypes) {
List<InterfaceType> typesToVisit = new List<InterfaceType>();
List<ClassElement> visitedClasses = new List<ClassElement>();
typesToVisit.add(this.type);
while (!typesToVisit.isEmpty) {
InterfaceType currentType = typesToVisit.removeAt(0);
ClassElement currentElement = currentType.element;
if (!visitedClasses.contains(currentElement)) {
visitedClasses.add(currentElement);
if (currentType != this.type) {
supertypes.add(currentType);
}
InterfaceType supertype = currentType.superclass;
if (supertype != null) {
typesToVisit.add(supertype);
}
for (InterfaceType type in currentElement.interfaces) {
typesToVisit.add(type);
}
for (InterfaceType type in currentElement.mixins) {
ClassElement element = type.element;
if (!visitedClasses.contains(element)) {
supertypes.add(type);
}
}
}
}
}
}
/**
* Instances of the class `CompilationUnitElementImpl` implement a
* [CompilationUnitElement].
*
* @coverage dart.engine.element
*/
class CompilationUnitElementImpl extends ElementImpl implements CompilationUnitElement {
/**
* An empty array of compilation unit elements.
*/
static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>(0);
/**
* An array containing all of the top-level accessors (getters and setters) contained in this
* compilation unit.
*/
List<PropertyAccessorElement> _accessors = PropertyAccessorElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the top-level functions contained in this compilation unit.
*/
List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the variables contained in this compilation unit.
*/
List<TopLevelVariableElement> _variables = TopLevelVariableElementImpl.EMPTY_ARRAY;
/**
* The source that corresponds to this compilation unit.
*/
Source _source;
/**
* An array containing all of the function type aliases contained in this compilation unit.
*/
List<FunctionTypeAliasElement> _typeAliases = FunctionTypeAliasElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the types contained in this compilation unit.
*/
List<ClassElement> _types = ClassElementImpl.EMPTY_ARRAY;
/**
* The URI that is specified by the "part" directive in the enclosing library, or `null` if
* this is the defining compilation unit of a library.
*/
String _uri;
/**
* Initialize a newly created compilation unit element to have the given name.
*
* @param name the name of this element
*/
CompilationUnitElementImpl(String name) : super.con2(name, -1);
accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _source == ((object as CompilationUnitElementImpl)).source;
List<PropertyAccessorElement> get accessors => _accessors;
ElementImpl getChild(String identifier) {
for (PropertyAccessorElement accessor in _accessors) {
if (((accessor as PropertyAccessorElementImpl)).identifier == identifier) {
return accessor as PropertyAccessorElementImpl;
}
}
for (VariableElement variable in _variables) {
if (((variable as VariableElementImpl)).identifier == identifier) {
return variable as VariableElementImpl;
}
}
for (ExecutableElement function in _functions) {
if (((function as ExecutableElementImpl)).identifier == identifier) {
return function as ExecutableElementImpl;
}
}
for (FunctionTypeAliasElement typeAlias in _typeAliases) {
if (((typeAlias as FunctionTypeAliasElementImpl)).identifier == identifier) {
return typeAlias as FunctionTypeAliasElementImpl;
}
}
for (ClassElement type in _types) {
if (((type as ClassElementImpl)).identifier == identifier) {
return type as ClassElementImpl;
}
}
return null;
}
LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
List<FunctionElement> get functions => _functions;
List<FunctionTypeAliasElement> get functionTypeAliases => _typeAliases;
String get identifier => source.encoding;
ElementKind get kind => ElementKind.COMPILATION_UNIT;
Source get source => _source;
List<TopLevelVariableElement> get topLevelVariables => _variables;
ClassElement getType(String className) {
for (ClassElement type in _types) {
if (type.name == className) {
return type;
}
}
return null;
}
List<ClassElement> get types => _types;
String get uri => _uri;
int get hashCode => _source.hashCode;
/**
* Set the top-level accessors (getters and setters) contained in this compilation unit to the
* given accessors.
*
* @param the top-level accessors (getters and setters) contained in this compilation unit
*/
void set accessors(List<PropertyAccessorElement> accessors) {
for (PropertyAccessorElement accessor in accessors) {
((accessor as PropertyAccessorElementImpl)).enclosingElement = this;
}
this._accessors = accessors;
}
/**
* Set the top-level functions contained in this compilation unit to the given functions.
*
* @param functions the top-level functions contained in this compilation unit
*/
void set functions(List<FunctionElement> functions) {
for (FunctionElement function in functions) {
((function as FunctionElementImpl)).enclosingElement = this;
}
this._functions = functions;
}
/**
* Set the source that corresponds to this compilation unit to the given source.
*
* @param source the source that corresponds to this compilation unit
*/
void set source(Source source) {
this._source = source;
}
/**
* Set the top-level variables contained in this compilation unit to the given variables.
*
* @param variables the top-level variables contained in this compilation unit
*/
void set topLevelVariables(List<TopLevelVariableElement> variables) {
for (TopLevelVariableElement field in variables) {
((field as TopLevelVariableElementImpl)).enclosingElement = this;
}
this._variables = variables;
}
/**
* Set the function type aliases contained in this compilation unit to the given type aliases.
*
* @param typeAliases the function type aliases contained in this compilation unit
*/
void set typeAliases(List<FunctionTypeAliasElement> typeAliases) {
for (FunctionTypeAliasElement typeAlias in typeAliases) {
((typeAlias as FunctionTypeAliasElementImpl)).enclosingElement = this;
}
this._typeAliases = typeAliases;
}
/**
* Set the types contained in this compilation unit to the given types.
*
* @param types types contained in this compilation unit
*/
void set types(List<ClassElement> types) {
for (ClassElement type in types) {
((type as ClassElementImpl)).enclosingElement = this;
}
this._types = types;
}
/**
* Set the URI that is specified by the "part" directive in the enclosing library.
*
* @param uri the URI that is specified by the "part" directive in the enclosing library.
*/
void set uri(String uri) {
this._uri = uri;
}
void visitChildren(ElementVisitor visitor) {
super.visitChildren(visitor);
safelyVisitChildren(_accessors, visitor);
safelyVisitChildren(_functions, visitor);
safelyVisitChildren(_typeAliases, visitor);
safelyVisitChildren(_types, visitor);
safelyVisitChildren(_variables, visitor);
}
void appendTo(JavaStringBuilder builder) {
if (_source == null) {
builder.append("{compilation unit}");
} else {
builder.append(_source.fullName);
}
}
}
/**
* Instances of the class `ConstFieldElementImpl` implement a `FieldElement` for a
* 'const' field that has an initializer.
*/
class ConstFieldElementImpl extends FieldElementImpl {
/**
* The result of evaluating this variable's initializer.
*/
EvaluationResultImpl _result;
/**
* Initialize a newly created field element to have the given name.
*
* @param name the name of this element
*/
ConstFieldElementImpl(Identifier name) : super.con1(name);
EvaluationResultImpl get evaluationResult => _result;
void set evaluationResult(EvaluationResultImpl result) {
this._result = result;
}
}
/**
* Instances of the class `ConstLocalVariableElementImpl` implement a
* `LocalVariableElement` for a local 'const' variable that has an initializer.
*
* @coverage dart.engine.element
*/
class ConstLocalVariableElementImpl extends LocalVariableElementImpl {
/**
* The result of evaluating this variable's initializer.
*/
EvaluationResultImpl _result;
/**
* Initialize a newly created local variable element to have the given name.
*
* @param name the name of this element
*/
ConstLocalVariableElementImpl(Identifier name) : super(name);
EvaluationResultImpl get evaluationResult => _result;
void set evaluationResult(EvaluationResultImpl result) {
this._result = result;
}
}
/**
* Instances of the class `ConstTopLevelVariableElementImpl` implement a
* `TopLevelVariableElement` for a top-level 'const' variable that has an initializer.
*/
class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl {
/**
* The result of evaluating this variable's initializer.
*/
EvaluationResultImpl _result;
/**
* Initialize a newly created top-level variable element to have the given name.
*
* @param name the name of this element
*/
ConstTopLevelVariableElementImpl(Identifier name) : super.con1(name);
EvaluationResultImpl get evaluationResult => _result;
void set evaluationResult(EvaluationResultImpl result) {
this._result = result;
}
}
/**
* Instances of the class `ConstructorElementImpl` implement a `ConstructorElement`.
*
* @coverage dart.engine.element
*/
class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
/**
* An empty array of constructor elements.
*/
static List<ConstructorElement> EMPTY_ARRAY = new List<ConstructorElement>(0);
/**
* The constructor to which this constructor is redirecting.
*/
ConstructorElement _redirectedConstructor;
/**
* Initialize a newly created constructor element to have the given name.
*
* @param name the name of this element
*/
ConstructorElementImpl(Identifier name) : super.con1(name);
accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
ClassElement get enclosingElement => super.enclosingElement as ClassElement;
ElementKind get kind => ElementKind.CONSTRUCTOR;
ConstructorElement get redirectedConstructor => _redirectedConstructor;
bool get isConst => hasModifier(Modifier.CONST);
bool get isDefaultConstructor {
String name = this.name;
if (name != null && name.length != 0) {
return false;
}
for (ParameterElement parameter in parameters) {
if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
return false;
}
}
return true;
}
bool get isFactory => hasModifier(Modifier.FACTORY);
bool get isStatic => false;
/**
* Set whether this constructor represents a 'const' constructor to the given value.
*
* @param isConst `true` if this constructor represents a 'const' constructor
*/
void set const2(bool isConst) {
setModifier(Modifier.CONST, isConst);
}
/**
* Set whether this constructor represents a factory method to the given value.
*
* @param isFactory `true` if this constructor represents a factory method
*/
void set factory(bool isFactory) {
setModifier(Modifier.FACTORY, isFactory);
}
/**
* Sets the constructor to which this constructor is redirecting.
*
* @param redirectedConstructor the constructor to which this constructor is redirecting
*/
void set redirectedConstructor(ConstructorElement redirectedConstructor) {
this._redirectedConstructor = redirectedConstructor;
}
void appendTo(JavaStringBuilder builder) {
builder.append(enclosingElement.displayName);
String name = displayName;
if (name != null && !name.isEmpty) {
builder.append(".");
builder.append(name);
}
super.appendTo(builder);
}
}
/**
* Instances of the class `DefaultFieldFormalParameterElementImpl` implement a
* `FieldFormalParameterElementImpl` for parameters that have an initializer.
*
* @coverage dart.engine.element
*/
class DefaultFieldFormalParameterElementImpl extends FieldFormalParameterElementImpl {
/**
* The result of evaluating this variable's initializer.
*/
EvaluationResultImpl _result;
/**
* Initialize a newly created parameter element to have the given name.
*
* @param name the name of this element
*/
DefaultFieldFormalParameterElementImpl(Identifier name) : super(name);
EvaluationResultImpl get evaluationResult => _result;
void set evaluationResult(EvaluationResultImpl result) {
this._result = result;
}
}
/**
* Instances of the class `DefaultParameterElementImpl` implement a `ParameterElement`
* for parameters that have an initializer.
*
* @coverage dart.engine.element
*/
class DefaultParameterElementImpl extends ParameterElementImpl {
/**
* The result of evaluating this variable's initializer.
*/
EvaluationResultImpl _result;
/**
* Initialize a newly created parameter element to have the given name.
*
* @param name the name of this element
*/
DefaultParameterElementImpl(Identifier name) : super.con1(name);
EvaluationResultImpl get evaluationResult => _result;
void set evaluationResult(EvaluationResultImpl result) {
this._result = result;
}
}
/**
* Instances of the class `DynamicElementImpl` represent the synthetic element representing
* the declaration of the type `dynamic`.
*
* @coverage dart.engine.element
*/
class DynamicElementImpl extends ElementImpl {
/**
* Return the unique instance of this class.
*
* @return the unique instance of this class
*/
static DynamicElementImpl get instance => DynamicTypeImpl.instance.element as DynamicElementImpl;
/**
* The type defined by this element.
*/
DynamicTypeImpl type;
/**
* 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 [getInstance].
*/
DynamicElementImpl() : super.con2(Keyword.DYNAMIC.syntax, -1) {
setModifier(Modifier.SYNTHETIC, true);
}
accept(ElementVisitor visitor) => null;
ElementKind get kind => ElementKind.DYNAMIC;
}
/**
* Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
*
* @coverage dart.engine.element
*/
class ElementAnnotationImpl implements ElementAnnotation {
/**
* The element representing the field, variable, or constructor being used as an annotation.
*/
Element _element;
/**
* An empty array of annotations.
*/
static List<ElementAnnotationImpl> EMPTY_ARRAY = new List<ElementAnnotationImpl>(0);
/**
* Initialize a newly created annotation.
*
* @param element the element representing the field, variable, or constructor being used as an
* annotation
*/
ElementAnnotationImpl(Element element) {
this._element = element;
}
Element get element => _element;
String toString() => "@${_element.toString()}";
}
/**
* The abstract class `ElementImpl` implements the behavior common to objects that implement
* an [Element].
*
* @coverage dart.engine.element
*/
abstract class ElementImpl implements Element {
/**
* The enclosing element of this element, or `null` if this element is at the root of the
* element structure.
*/
ElementImpl _enclosingElement;
/**
* The name of this element.
*/
String _name;
/**
* The offset of the name of this element in the file that contains the declaration of this
* element.
*/
int _nameOffset = 0;
/**
* A bit-encoded form of the modifiers associated with this element.
*/
int _modifiers = 0;
/**
* An array containing all of the metadata associated with this element.
*/
List<ElementAnnotation> _metadata = ElementAnnotationImpl.EMPTY_ARRAY;
/**
* A cached copy of the calculated hashCode for this element.
*/
int _cachedHashCode = 0;
/**
* Initialize a newly created element to have the given name.
*
* @param name the name of this element
*/
ElementImpl.con1(Identifier name) : this.con2(name == null ? "" : name.name, name == null ? -1 : name.offset);
/**
* Initialize a newly created element to have the given name.
*
* @param name the name of this element
* @param nameOffset the offset of the name of this element in the file that contains the
* declaration of this element
*/
ElementImpl.con2(String name, int nameOffset) {
this._name = StringUtilities.intern(name);
this._nameOffset = nameOffset;
}
String computeDocumentationComment() {
AnalysisContext context = this.context;
if (context == null) {
return null;
}
return context.computeDocumentationComment(this);
}
bool operator ==(Object object) => object != null && object.runtimeType == runtimeType && ((object as Element)).location == location;
Element getAncestor(Type elementClass) {
Element ancestor = _enclosingElement;
while (ancestor != null && !isInstanceOf(ancestor, elementClass)) {
ancestor = ancestor.enclosingElement;
}
return ancestor as Element;
}
/**
* Return the child of this element that is uniquely identified by the given identifier, or
* `null` if there is no such child.
*
* @param identifier the identifier used to select a child
* @return the child of this element with the given identifier
*/
ElementImpl getChild(String identifier) => null;
AnalysisContext get context {
if (_enclosingElement == null) {
return null;
}
return _enclosingElement.context;
}
String get displayName => _name;
Element get enclosingElement => _enclosingElement;
LibraryElement get library => getAncestor(LibraryElement);
ElementLocation get location => new ElementLocationImpl.con1(this);
List<ElementAnnotation> get metadata => _metadata;
String get name => _name;
int get nameOffset => _nameOffset;
Source get source {
if (_enclosingElement == null) {
return null;
}
return _enclosingElement.source;
}
int get hashCode {
if (_cachedHashCode == 0) {
_cachedHashCode = location.hashCode;
}
return _cachedHashCode;
}
bool isAccessibleIn(LibraryElement library) {
if (Identifier.isPrivateName(_name)) {
return library == this.library;
}
return true;
}
bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
/**
* Set the metadata associate with this element to the given array of annotations.
*
* @param metadata the metadata to be associated with this element
*/
void set metadata(List<ElementAnnotation> metadata) {
this._metadata = metadata;
}
/**
* Set the offset of the name of this element in the file that contains the declaration of this
* element to the given value. This is normally done via the constructor, but this method is
* provided to support unnamed constructors.
*
* @param nameOffset the offset to the beginning of the name
*/
void set nameOffset(int nameOffset) {
this._nameOffset = nameOffset;
}
/**
* Set whether this element is synthetic to correspond to the given value.
*
* @param isSynthetic `true` if the element is synthetic
*/
void set synthetic(bool isSynthetic) {
setModifier(Modifier.SYNTHETIC, isSynthetic);
}
String toString() {
JavaStringBuilder builder = new JavaStringBuilder();
appendTo(builder);
return builder.toString();
}
void visitChildren(ElementVisitor visitor) {
}
/**
* Append a textual representation of this type to the given builder.
*
* @param builder the builder to which the text is to be appended
*/
void appendTo(JavaStringBuilder builder) {
if (_name == null) {
builder.append("<unnamed ");
builder.append(runtimeType.toString());
builder.append(">");
} else {
builder.append(_name);
}
}
/**
* Return an identifier that uniquely identifies this element among the children of this element's
* parent.
*
* @return an identifier that uniquely identifies this element relative to its parent
*/
String get identifier => name;
/**
* Return `true` if this element has the given modifier associated with it.
*
* @param modifier the modifier being tested for
* @return `true` if this element has the given modifier associated with it
*/
bool hasModifier(Modifier modifier) => BooleanArray.get(_modifiers, modifier);
/**
* If the given child is not `null`, use the given visitor to visit it.
*
* @param child the child to be visited
* @param visitor the visitor to be used to visit the child
*/
void safelyVisitChild(Element child, ElementVisitor visitor) {
if (child != null) {
child.accept(visitor);
}
}
/**
* Use the given visitor to visit all of the children in the given array.
*
* @param children the children to be visited
* @param visitor the visitor being used to visit the children
*/
void safelyVisitChildren(List<Element> children, ElementVisitor visitor) {
if (children != null) {
for (Element child in children) {
child.accept(visitor);
}
}
}
/**
* Set the enclosing element of this element to the given element.
*
* @param element the enclosing element of this element
*/
void set enclosingElement(ElementImpl element) {
_enclosingElement = element;
}
/**
* Set whether the given modifier is associated with this element to correspond to the given
* value.
*
* @param modifier the modifier to be set
* @param value `true` if the modifier is to be associated with this element
*/
void setModifier(Modifier modifier, bool value) {
_modifiers = BooleanArray.set(_modifiers, modifier, value);
}
}
/**
* Instances of the class `ElementLocationImpl` implement an [ElementLocation].
*
* @coverage dart.engine.element
*/
class ElementLocationImpl implements ElementLocation {
/**
* The path to the element whose location is represented by this object.
*/
List<String> components;
/**
* The character used to separate components in the encoded form.
*/
static int _SEPARATOR_CHAR = 0x3B;
/**
* Initialize a newly created location to represent the given element.
*
* @param element the element whose location is being represented
*/
ElementLocationImpl.con1(Element element) {
List<String> components = new List<String>();
Element ancestor = element;
while (ancestor != null) {
components.insert(0, ((ancestor as ElementImpl)).identifier);
ancestor = ancestor.enclosingElement;
}
this.components = new List.from(components);
}
/**
* Initialize a newly created location from the given encoded form.
*
* @param encoding the encoded form of a location
*/
ElementLocationImpl.con2(String encoding) {
this.components = decode(encoding);
}
bool operator ==(Object object) {
if (object is! ElementLocationImpl) {
return false;
}
ElementLocationImpl location = object as ElementLocationImpl;
List<String> otherComponents = location.components;
int length = components.length;
if (otherComponents.length != length) {
return false;
}
if (length > 0 && !equalSourceComponents(components[0], otherComponents[0])) {
return false;
}
if (length > 1 && !equalSourceComponents(components[1], otherComponents[1])) {
return false;
}
for (int i = 2; i < length; i++) {
if (components[i] != otherComponents[i]) {
return false;
}
}
return true;
}
String get encoding {
JavaStringBuilder builder = new JavaStringBuilder();
int length = components.length;
for (int i = 0; i < length; i++) {
if (i > 0) {
builder.appendChar(_SEPARATOR_CHAR);
}
encode(builder, components[i]);
}
return builder.toString();
}
int get hashCode {
int result = 1;
for (int i = 0; i < components.length; i++) {
String component = components[i];
int componentHash;
if (i <= 1) {
componentHash = hashSourceComponent(component);
} else {
componentHash = component.hashCode;
}
result = 31 * result + componentHash;
}
return result;
}
String toString() => encoding;
/**
* Decode the encoded form of a location into an array of components.
*
* @param encoding the encoded form of a location
* @return the components that were encoded
*/
List<String> decode(String encoding) {
List<String> components = new List<String>();
JavaStringBuilder builder = new JavaStringBuilder();
int index = 0;
int length = encoding.length;
while (index < length) {
int currentChar = encoding.codeUnitAt(index);
if (currentChar == _SEPARATOR_CHAR) {
if (index + 1 < length && encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
builder.appendChar(_SEPARATOR_CHAR);
index += 2;
} else {
components.add(builder.toString());
builder.length = 0;
index++;
}
} else {
builder.appendChar(currentChar);
index++;
}
}
if (builder.length > 0) {
components.add(builder.toString());
}
return new List.from(components);
}
/**
* Append an encoded form of the given component to the given builder.
*
* @param builder the builder to which the encoded component is to be appended
* @param component the component to be appended to the builder
*/
void encode(JavaStringBuilder builder, String component) {
int length = component.length;
for (int i = 0; i < length; i++) {
int currentChar = component.codeUnitAt(i);
if (currentChar == _SEPARATOR_CHAR) {
builder.appendChar(_SEPARATOR_CHAR);
}
builder.appendChar(currentChar);
}
}
/**
* Return `true` if the given components, when interpreted to be encoded sources with a
* leading source type indicator, are equal when the source type's are ignored.
*
* @param left the left component being compared
* @param right the right component being compared
* @return `true` if the given components are equal when the source type's are ignored
*/
bool equalSourceComponents(String left, String right) {
if (left == null) {
return right == null;
} else if (right == null) {
return false;
}
if (left.length <= 1 || right.length <= 1) {
return left == right;
}
return left.substring(1) == right.substring(1);
}
/**
* Return the hash code of the given encoded source component, ignoring the source type indicator.
*
* @param sourceComponent the component to compute a hash code
* @return the hash code of the given encoded source component
*/
int hashSourceComponent(String sourceComponent) {
if (sourceComponent.length <= 1) {
return sourceComponent.hashCode;
}
return sourceComponent.substring(1).hashCode;
}
}
/**
* Instances of the class `EmbeddedHtmlScriptElementImpl` implement an
* [EmbeddedHtmlScriptElement].
*
* @coverage dart.engine.element
*/
class EmbeddedHtmlScriptElementImpl extends HtmlScriptElementImpl implements EmbeddedHtmlScriptElement {
/**
* The library defined by the script tag's content.
*/
LibraryElement _scriptLibrary;
/**
* Initialize a newly created script element to have the specified tag name and offset.
*
* @param node the XML node from which this element is derived (not `null`)
*/
EmbeddedHtmlScriptElementImpl(XmlTagNode node) : super(node);
accept(ElementVisitor visitor) => visitor.visitEmbeddedHtmlScriptElement(this);
ElementKind get kind => ElementKind.EMBEDDED_HTML_SCRIPT;
LibraryElement get scriptLibrary => _scriptLibrary;
/**
* Set the script library defined by the script tag's content.
*
* @param scriptLibrary the library or `null` if none
*/
void set scriptLibrary(LibraryElementImpl scriptLibrary) {
scriptLibrary.enclosingElement = this;
this._scriptLibrary = scriptLibrary;
}
void visitChildren(ElementVisitor visitor) {
safelyVisitChild(_scriptLibrary, visitor);
}
}
/**
* The abstract class `ExecutableElementImpl` implements the behavior common to
* `ExecutableElement`s.
*
* @coverage dart.engine.element
*/
abstract class ExecutableElementImpl extends ElementImpl implements ExecutableElement {
/**
* An array containing all of the functions defined within this executable element.
*/
List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the labels defined within this executable element.
*/
List<LabelElement> _labels = LabelElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the local variables defined within this executable element.
*/
List<LocalVariableElement> _localVariables = LocalVariableElementImpl.EMPTY_ARRAY;
/**
* An array containing all of the parameters defined by this executable element.
*/
List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
/**
* The return type defined by this executable element.
*/
Type2 _returnType;
/**
* The type of function defined by this executable element.
*/
FunctionType _type;
/**
* An empty array of executable elements.
*/
static List<ExecutableElement> EMPTY_ARRAY = new List<ExecutableElement>(0);
/**
* Initialize a newly created executable element to have the given name.
*
* @param name the name of this element
*/
ExecutableElementImpl.con1(Identifier name) : super.con1(name);
/**
* Initialize a newly created executable element to have the given name.
*
* @param name the name of this element
* @param nameOffset the offset of the name of this element in the file that contains the
* declaration of this element
*/
ExecutableElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
ElementImpl getChild(String identifier) {
for (ExecutableElement function in _functions) {
if (((function as ExecutableElementImpl)).identifier == identifier) {
return function as ExecutableElementImpl;
}
}
for (LabelElement label in _labels) {
if (((label as LabelElementImpl)).identifier == identifier) {
return label as LabelElementImpl;
}
}
for (VariableElement variable in _localVariables) {
if (((variable as VariableElementImpl)).identifier == identifier) {
return variable as VariableElementImpl;
}
}
for (ParameterElement parameter in _parameters) {
if (((parameter as ParameterElementImpl)).identifier == identifier) {
return parameter as ParameterElementImpl;
}
}
return null;
}
List<FunctionElement> get functions => _functions;
List<LabelElement> get labels => _labels;
List<LocalVariableElement> get localVariables => _localVariables;
List<ParameterElement> get parameters => _parameters;
Type2 get returnType => _returnType;
FunctionType get type => _type;
bool get isOperator => false;
/**
* Set the functions defined within this executable element to the given functions.
*
* @param functions the functions defined within this executable element
*/
void set functions(List<FunctionElement> functions) {
for (FunctionElement function in functions) {
((function as FunctionElementImpl)).enclosingElement = this;
}
this._functions = functions;
}
/**
* Set the labels defined within this executable element to the given labels.
*
* @param labels the labels defined within this executable element
*/
void set labels(List<LabelElement> labels) {
for (LabelElement label in labels) {
((label as LabelElementImpl)).enclosingElement = this;
}
this._labels = labels;
}
/**
* Set the local variables defined within this executable element to the given variables.
*
* @param localVariables the local variables defined within this executable element
*/
void set localVariables(List<LocalVariableElement> localVariables) {
for (LocalVariableElement variable in localVariables) {
((variable as LocalVariableElementImpl)).enclosingElement = this;
}
this._localVariables = localVariables;
}
/**
* Set the parameters defined by this executable element to the given parameters.
*
* @param parameters the parameters defined by this executable element
*/
void set parameters(List<ParameterElement> parameters) {
for (ParameterElement parameter in parameters) {
((parameter as ParameterElementImpl)).enclosingElement = this;
}
this._parameters = parameters;
}
/**
* Set the return type defined by this executable element.
*
* @param returnType the return type defined by this executable element
*/
void set returnType(Type2 returnType) {
this._returnType = returnType;
}
/**
* Set the type of function defined by this executable element to the given type.
*
* @param type the type of function defined by this executable element
*/
void set type(FunctionType type) {
this._type = type;
}
void visitChildren(ElementVisitor visitor) {
super.visitChildren(visitor);
safelyVisitChildren(_functions, visitor);
safelyVisitChildren(_labels, visitor);
safelyVisitChildren(_localVariables, visitor);
safelyVisitChildren(_parameters, visitor);
}
void appendTo(JavaStringBuilder builder) {
builder.append("(");
int parameterCount = _parameters.length;
for (int i = 0; i < parameterCount; i++) {
if (i > 0) {
builder.append(", ");
}
((_parameters[i] as ParameterElementImpl)).appendTo(builder);
}
builder.append(")");
if (_type != null) {
builder.append(" -> ");
builder.append(_type.returnType);
}
}
}
/**
* Instances of the class `ExportElementImpl` implement an [ExportElement].
*
* @coverage dart.engine.element
*/
class ExportElementImpl extends ElementImpl implements ExportElement {
/**
* The URI that is specified by this directive.
*/
String _uri;
/**
* The library that is exported from this library by this export directive.
*/
LibraryElement _exportedLibrary;
/**
* The combinators that were specified as part of the export directive in the order in which they
* were specified.
*/
List<NamespaceCombinator> _combinators = NamespaceCombinator.EMPTY_ARRAY;
/**
* Initialize a newly created export element.
*/
ExportElementImpl() : super.con1(null);
accept(ElementVisitor visitor) => visitor.visitExportElement(this);
List<NamespaceCombinator> get combinators => _combinators;
LibraryElement get exportedLibrary => _exportedLibrary;
ElementKind get kind => ElementKind.EXPORT;
String get uri => _uri;
/**
* Set the combinators that were specified as part of the export directive to the given array of
* combinators.
*
* @param combinators the combinators that were specified as part of the export directive
*/
void set combinators(List<NamespaceCombinator> combinators) {
this._combinators = combinators;
}
/**
* Set the library that is exported from this library by this import directive to the given
* library.
*
* @param exportedLibrary the library that is exported from this library
*/
void set exportedLibrary(LibraryElement exportedLibrary) {
this._exportedLibrary = exportedLibrary;
}
/**
* Set the URI that is specified by this directive.
*
* @param uri the URI that is specified by this directive.
*/
void set uri(String uri) {
this._uri = uri;
}
void appendTo(JavaStringBuilder builder) {
builder.append("export ");
((_exportedLibrary as LibraryElementImpl)).appendTo(builder);
}
String get identifier => _exportedLibrary.name;
}
/**
* Instances of the class `ExternalHtmlScriptElementImpl` implement an
* [ExternalHtmlScriptElement].
*
* @coverage dart.engine.element
*/
class ExternalHtmlScriptElementImpl extends HtmlScriptElementImpl implements ExternalHtmlScriptElement {
/**
* The source specified in the `source` attribute or `null` if unspecified.
*/
Source _scriptSource;
/**
* Initialize a newly created script element to have the specified tag name and offset.
*
* @param node the XML node from which this element is derived (not `null`)
*/
ExternalHtmlScriptElementImpl(XmlTagNode node) : super(node);
accept(ElementVisitor visitor) => visitor.visitExternalHtmlScriptElement(this);
ElementKind get kind => ElementKind.EXTERNAL_HTML_SCRIPT;
Source get scriptSource => _scriptSource;
/**
* Set the source specified in the `source` attribute.
*
* @param scriptSource the script source or `null` if unspecified
*/
void set scriptSource(Source scriptSource) {
this._scriptSource = scriptSource;
}
}
/**
* Instances of the class `FieldElementImpl` implement a `FieldElement`.
*
* @coverage dart.engine.element
*/
class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
/**
* An empty array of field elements.
*/
static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>(0);