blob: 1f1860404e9d1b6aafc842a2fea7fe2edb4662af [file] [log] [blame]
// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
/// This file is an "idl" style description of the summary format. It
/// contains abstract classes which declare the interface for reading data from
/// summaries. It is parsed and transformed into code that implements the
/// summary format.
///
/// The code generation process introduces the following semantics:
/// - Getters of type List never return null, and have a default value of the
/// empty list.
/// - Getters of type int return unsigned 32-bit integers, never null, and have
/// a default value of zero.
/// - Getters of type String never return null, and have a default value of ''.
/// - Getters of type bool never return null, and have a default value of false.
/// - Getters of type double never return null, and have a default value of
/// `0.0`.
/// - Getters whose type is an enum never return null, and have a default value
/// of the first value declared in the enum.
///
/// Terminology used in this document:
/// - "Unlinked" refers to information that can be determined from reading a
/// single .dart file in isolation.
/// - "Prelinked" refers to information that can be determined from the defining
/// compilation unit of a library, plus direct imports, plus the transitive
/// closure of exports reachable from those libraries, plus all part files
/// constituting those libraries.
/// - "Linked" refers to all other information; in theory, this information may
/// depend on all files in the transitive import/export closure. However, in
/// practice we expect that the number of additional dependencies will usually
/// be small, since the additional dependencies only need to be consulted for
/// type propagation, type inference, and constant evaluation, which typically
/// have short dependency chains.
///
/// Since we expect "linked" and "prelinked" dependencies to be similar, we only
/// rarely distinguish between them; most information is that is not "unlinked"
/// is typically considered "linked" for simplicity.
///
/// Except as otherwise noted, synthetic elements are not stored in the summary;
/// they are re-synthesized at the time the summary is read.
import 'package:analyzer/dart/element/element.dart';
import 'base.dart' as base;
import 'base.dart' show Id, TopLevel, Variant, VariantId;
import 'format.dart' as generated;
/// Annotation describing information which is not part of Dart semantics; in
/// other words, if this information (or any information it refers to) changes,
/// static analysis and runtime behavior of the library are unaffected.
///
/// Information that has purely local effect (in other words, it does not affect
/// the API of the code being analyzed) is also marked as `informative`.
const informative = null;
/// Information about the context of an exception in analysis driver.
@TopLevel('ADEC')
abstract class AnalysisDriverExceptionContext extends base.SummaryClass {
factory AnalysisDriverExceptionContext.fromBuffer(List<int> buffer) =>
generated.readAnalysisDriverExceptionContext(buffer);
/// The exception string.
@Id(1)
String get exception;
/// The state of files when the exception happened.
@Id(3)
List<AnalysisDriverExceptionFile> get files;
/// The path of the file being analyzed when the exception happened.
@Id(0)
String get path;
/// The exception stack trace string.
@Id(2)
String get stackTrace;
}
/// Information about a single file in [AnalysisDriverExceptionContext].
abstract class AnalysisDriverExceptionFile extends base.SummaryClass {
/// The content of the file.
@Id(1)
String get content;
/// The path of the file.
@Id(0)
String get path;
}
/// Information about a resolved unit.
@TopLevel('ADRU')
abstract class AnalysisDriverResolvedUnit extends base.SummaryClass {
factory AnalysisDriverResolvedUnit.fromBuffer(List<int> buffer) =>
generated.readAnalysisDriverResolvedUnit(buffer);
/// The full list of analysis errors, both syntactic and semantic.
@Id(0)
List<AnalysisDriverUnitError> get errors;
/// The index of the unit.
@Id(1)
AnalysisDriverUnitIndex get index;
}
/// Information about a subtype of one or more classes.
abstract class AnalysisDriverSubtype extends base.SummaryClass {
/// The names of defined instance members.
/// They are indexes into [AnalysisDriverUnitError.strings] list.
/// The list is sorted in ascending order.
@Id(1)
List<int> get members;
/// The name of the class.
/// It is an index into [AnalysisDriverUnitError.strings] list.
@Id(0)
int get name;
}
/// Information about an error in a resolved unit.
abstract class AnalysisDriverUnitError extends base.SummaryClass {
/// The optional correction hint for the error.
@Id(4)
String get correction;
/// The length of the error in the file.
@Id(1)
int get length;
/// The message of the error.
@Id(3)
String get message;
/// The offset from the beginning of the file.
@Id(0)
int get offset;
/// The unique name of the error code.
@Id(2)
String get uniqueName;
}
/// Information about a resolved unit.
@TopLevel('ADUI')
abstract class AnalysisDriverUnitIndex extends base.SummaryClass {
factory AnalysisDriverUnitIndex.fromBuffer(List<int> buffer) =>
generated.readAnalysisDriverUnitIndex(buffer);
/// Each item of this list corresponds to a unique referenced element. It is
/// the kind of the synthetic element.
@Id(4)
List<IndexSyntheticElementKind> get elementKinds;
/// Each item of this list corresponds to a unique referenced element. It is
/// the identifier of the class member element name, or `null` if the element
/// is a top-level element. The list is sorted in ascending order, so that
/// the client can quickly check whether an element is referenced in this
/// index.
@Id(7)
List<int> get elementNameClassMemberIds;
/// Each item of this list corresponds to a unique referenced element. It is
/// the identifier of the named parameter name, or `null` if the element is
/// not a named parameter. The list is sorted in ascending order, so that the
/// client can quickly check whether an element is referenced in this index.
@Id(8)
List<int> get elementNameParameterIds;
/// Each item of this list corresponds to a unique referenced element. It is
/// the identifier of the top-level element name, or `null` if the element is
/// the unit. The list is sorted in ascending order, so that the client can
/// quickly check whether an element is referenced in this index.
@Id(6)
List<int> get elementNameUnitMemberIds;
/// Each item of this list corresponds to a unique referenced element. It is
/// the index into [unitLibraryUris] and [unitUnitUris] for the library
/// specific unit where the element is declared.
@Id(5)
List<int> get elementUnits;
/// Identifier of the null string in [strings].
@Id(1)
int get nullStringId;
/// List of unique element strings used in this index. The list is sorted in
/// ascending order, so that the client can quickly check the presence of a
/// string in this index.
@Id(0)
List<String> get strings;
/// The list of classes declared in the unit.
@Id(19)
List<AnalysisDriverSubtype> get subtypes;
/// The identifiers of supertypes of elements at corresponding indexes
/// in [subtypes]. They are indexes into [strings] list. The list is sorted
/// in ascending order. There might be more than one element with the same
/// value if there is more than one subtype of this supertype.
@Id(18)
List<int> get supertypes;
/// Each item of this list corresponds to the library URI of a unique library
/// specific unit referenced in the index. It is an index into [strings]
/// list.
@Id(2)
List<int> get unitLibraryUris;
/// Each item of this list corresponds to the unit URI of a unique library
/// specific unit referenced in the index. It is an index into [strings]
/// list.
@Id(3)
List<int> get unitUnitUris;
/// Each item of this list is the `true` if the corresponding element usage
/// is qualified with some prefix.
@Id(13)
List<bool> get usedElementIsQualifiedFlags;
/// Each item of this list is the kind of the element usage.
@Id(10)
List<IndexRelationKind> get usedElementKinds;
/// Each item of this list is the length of the element usage.
@Id(12)
List<int> get usedElementLengths;
/// Each item of this list is the offset of the element usage relative to the
/// beginning of the file.
@Id(11)
List<int> get usedElementOffsets;
/// Each item of this list is the index into [elementUnits],
/// [elementNameUnitMemberIds], [elementNameClassMemberIds] and
/// [elementNameParameterIds]. The list is sorted in ascending order, so
/// that the client can quickly find element references in this index.
@Id(9)
List<int> get usedElements;
/// Each item of this list is the `true` if the corresponding name usage
/// is qualified with some prefix.
@Id(17)
List<bool> get usedNameIsQualifiedFlags;
/// Each item of this list is the kind of the name usage.
@Id(15)
List<IndexRelationKind> get usedNameKinds;
/// Each item of this list is the offset of the name usage relative to the
/// beginning of the file.
@Id(16)
List<int> get usedNameOffsets;
/// Each item of this list is the index into [strings] for a used name. The
/// list is sorted in ascending order, so that the client can quickly find
/// whether a name is used in this index.
@Id(14)
List<int> get usedNames;
}
/// Information about an unlinked unit.
@TopLevel('ADUU')
abstract class AnalysisDriverUnlinkedUnit extends base.SummaryClass {
factory AnalysisDriverUnlinkedUnit.fromBuffer(List<int> buffer) =>
generated.readAnalysisDriverUnlinkedUnit(buffer);
/// List of class member names defined by the unit.
@Id(3)
List<String> get definedClassMemberNames;
/// List of top-level names defined by the unit.
@Id(2)
List<String> get definedTopLevelNames;
/// List of external names referenced by the unit.
@Id(0)
List<String> get referencedNames;
/// List of names which are used in `extends`, `with` or `implements` clauses
/// in the file. Import prefixes and type arguments are not included.
@Id(4)
List<String> get subtypedNames;
/// Unlinked information for the unit.
@Id(1)
UnlinkedUnit get unit;
/// Unlinked information for the unit.
@Id(5)
UnlinkedUnit2 get unit2;
}
/// Information about a single declaration.
abstract class AvailableDeclaration extends base.SummaryClass {
@Id(0)
List<AvailableDeclaration> get children;
@Id(1)
String get defaultArgumentListString;
@Id(2)
List<int> get defaultArgumentListTextRanges;
@Id(3)
String get docComplete;
@Id(4)
String get docSummary;
@Id(5)
int get fieldMask;
@Id(6)
bool get isAbstract;
@Id(7)
bool get isConst;
@Id(8)
bool get isDeprecated;
@Id(9)
bool get isFinal;
/// The kind of the declaration.
@Id(10)
AvailableDeclarationKind get kind;
@Id(11)
int get locationOffset;
@Id(12)
int get locationStartColumn;
@Id(13)
int get locationStartLine;
/// The first part of the declaration name, usually the only one, for example
/// the name of a class like `MyClass`, or a function like `myFunction`.
@Id(14)
String get name;
@Id(15)
List<String> get parameterNames;
@Id(16)
String get parameters;
@Id(17)
List<String> get parameterTypes;
/// The partial list of relevance tags. Not every declaration has one (for
/// example, function do not currently), and not every declaration has to
/// store one (for classes it can be computed when we know the library that
/// includes this file).
@Id(18)
List<String> get relevanceTags;
@Id(19)
int get requiredParameterCount;
@Id(20)
String get returnType;
@Id(21)
String get typeParameters;
}
/// Enum of declaration kinds in available files.
enum AvailableDeclarationKind {
CLASS,
CLASS_TYPE_ALIAS,
CONSTRUCTOR,
ENUM,
ENUM_CONSTANT,
FUNCTION,
FUNCTION_TYPE_ALIAS,
GETTER,
MIXIN,
SETTER,
VARIABLE
}
/// Information about an available, even if not yet imported file.
@TopLevel('UICF')
abstract class AvailableFile extends base.SummaryClass {
factory AvailableFile.fromBuffer(List<int> buffer) =>
generated.readAvailableFile(buffer);
/// Declarations of the file.
@Id(0)
List<AvailableDeclaration> get declarations;
/// The Dartdoc directives in the file.
@Id(5)
DirectiveInfo get directiveInfo;
/// Exports directives of the file.
@Id(1)
List<AvailableFileExport> get exports;
/// Is `true` if this file is a library.
@Id(2)
bool get isLibrary;
/// Is `true` if this file is a library, and it is deprecated.
@Id(3)
bool get isLibraryDeprecated;
/// URIs of `part` directives.
@Id(4)
List<String> get parts;
}
/// Information about an export directive.
abstract class AvailableFileExport extends base.SummaryClass {
/// Combinators contained in this export directive.
@Id(1)
List<AvailableFileExportCombinator> get combinators;
/// URI of the exported library.
@Id(0)
String get uri;
}
/// Information about a `show` or `hide` combinator in an export directive.
abstract class AvailableFileExportCombinator extends base.SummaryClass {
/// List of names which are hidden. Empty if this is a `show` combinator.
@Id(1)
List<String> get hides;
/// List of names which are shown. Empty if this is a `hide` combinator.
@Id(0)
List<String> get shows;
}
/// Information about an element code range.
abstract class CodeRange extends base.SummaryClass {
/// Length of the element code.
@Id(1)
int get length;
/// Offset of the element code relative to the beginning of the file.
@Id(0)
int get offset;
}
/// Information about the Dartdoc directives in an [AvailableFile].
abstract class DirectiveInfo extends base.SummaryClass {
/// The names of the defined templates.
@Id(0)
List<String> get templateNames;
/// The values of the defined templates.
@Id(1)
List<String> get templateValues;
}
/// Summary information about a reference to an entity such as a type, top level
/// executable, or executable within a class.
abstract class EntityRef extends base.SummaryClass {
/// The kind of entity being represented.
@Id(8)
EntityRefKind get entityKind;
/// Notice: This will be deprecated. However, its not deprecated yet, as we're
/// keeping it for backwards compatibilty, and marking it deprecated makes it
/// unreadable.
///
/// TODO(mfairhurst) mark this deprecated, and remove its logic.
///
/// If this is a reference to a function type implicitly defined by a
/// function-typed parameter, a list of zero-based indices indicating the path
/// from the entity referred to by [reference] to the appropriate type
/// parameter. Otherwise the empty list.
///
/// If there are N indices in this list, then the entity being referred to is
/// the function type implicitly defined by a function-typed parameter of a
/// function-typed parameter, to N levels of nesting. The first index in the
/// list refers to the outermost level of nesting; for example if [reference]
/// refers to the entity defined by:
///
/// void f(x, void g(y, z, int h(String w))) { ... }
///
/// Then to refer to the function type implicitly defined by parameter `h`
/// (which is parameter 2 of parameter 1 of `f`), then
/// [implicitFunctionTypeIndices] should be [1, 2].
///
/// Note that if the entity being referred to is a generic method inside a
/// generic class, then the type arguments in [typeArguments] are applied
/// first to the class and then to the method.
@Id(4)
List<int> get implicitFunctionTypeIndices;
/// If the reference represents a type, the nullability of the type.
@Id(10)
EntityRefNullabilitySuffix get nullabilitySuffix;
/// If this is a reference to a type parameter, one-based index into the list
/// of [UnlinkedTypeParam]s currently in effect. Indexing is done using De
/// Bruijn index conventions; that is, innermost parameters come first, and
/// if a class or method has multiple parameters, they are indexed from right
/// to left. So for instance, if the enclosing declaration is
///
/// class C<T,U> {
/// m<V,W> {
/// ...
/// }
/// }
///
/// Then [paramReference] values of 1, 2, 3, and 4 represent W, V, U, and T,
/// respectively.
///
/// If the type being referred to is not a type parameter, [paramReference] is
/// zero.
@Id(3)
int get paramReference;
/// Index into [UnlinkedUnit.references] for the entity being referred to, or
/// zero if this is a reference to a type parameter.
@Id(0)
int get reference;
/// If this [EntityRef] appears in a syntactic context where its type
/// arguments might need to be inferred by a method other than
/// instantiate-to-bounds, and [typeArguments] is empty, a slot id (which is
/// unique within the compilation unit). If an entry appears in
/// [LinkedUnit.types] whose [slot] matches this value, that entry will
/// contain the complete inferred type.
///
/// This is called `refinedSlot` to clarify that if it points to an inferred
/// type, it points to a type that is a "refinement" of this one (one in which
/// some type arguments have been inferred).
@Id(9)
int get refinedSlot;
/// If this [EntityRef] is contained within [LinkedUnit.types], slot id (which
/// is unique within the compilation unit) identifying the target of type
/// propagation or type inference with which this [EntityRef] is associated.
///
/// Otherwise zero.
@Id(2)
int get slot;
/// If this [EntityRef] is a reference to a function type whose
/// [FunctionElement] is not in any library (e.g. a function type that was
/// synthesized by a LUB computation), the function parameters. Otherwise
/// empty.
@Id(6)
List<UnlinkedParam> get syntheticParams;
/// If this [EntityRef] is a reference to a function type whose
/// [FunctionElement] is not in any library (e.g. a function type that was
/// synthesized by a LUB computation), the return type of the function.
/// Otherwise `null`.
@Id(5)
EntityRef get syntheticReturnType;
/// If this is an instantiation of a generic type or generic executable, the
/// type arguments used to instantiate it (if any).
@Id(1)
List<EntityRef> get typeArguments;
/// If this is a function type, the type parameters defined for the function
/// type (if any).
@Id(7)
List<UnlinkedTypeParam> get typeParameters;
}
/// Enum used to indicate the kind of an entity reference.
enum EntityRefKind {
/// The entity represents a named type.
named,
/// The entity represents a generic function type.
genericFunctionType,
/// The entity represents a function type that was synthesized by a LUB
/// computation.
syntheticFunction
}
/// Enum representing nullability suffixes in summaries.
///
/// This enum is similar to [NullabilitySuffix], but the order is different so
/// that [EntityRefNullabilitySuffix.starOrIrrelevant] can be the default.
enum EntityRefNullabilitySuffix {
/// An indication that the canonical representation of the type under
/// consideration ends with `*`. Types having this nullability suffix are
/// called "legacy types"; it has not yet been determined whether they should
/// be unioned with the Null type.
///
/// Also used in circumstances where no nullability suffix information is
/// needed.
starOrIrrelevant,
/// An indication that the canonical representation of the type under
/// consideration ends with `?`. Types having this nullability suffix should
/// be interpreted as being unioned with the Null type.
question,
/// An indication that the canonical representation of the type under
/// consideration does not end with either `?` or `*`.
none,
}
/// Enum used to indicate the kind of a name in index.
enum IndexNameKind {
/// A top-level element.
topLevel,
/// A class member.
classMember
}
/// Enum used to indicate the kind of an index relation.
enum IndexRelationKind {
/// Left: class.
/// Is ancestor of (is extended or implemented, directly or indirectly).
/// Right: other class declaration.
IS_ANCESTOR_OF,
/// Left: class.
/// Is extended by.
/// Right: other class declaration.
IS_EXTENDED_BY,
/// Left: class.
/// Is implemented by.
/// Right: other class declaration.
IS_IMPLEMENTED_BY,
/// Left: class.
/// Is mixed into.
/// Right: other class declaration.
IS_MIXED_IN_BY,
/// Left: method, property accessor, function, variable.
/// Is invoked at.
/// Right: location.
IS_INVOKED_BY,
/// Left: any element.
/// Is referenced (and not invoked, read/written) at.
/// Right: location.
IS_REFERENCED_BY,
/// Left: unresolved member name.
/// Is read at.
/// Right: location.
IS_READ_BY,
/// Left: unresolved member name.
/// Is both read and written at.
/// Right: location.
IS_READ_WRITTEN_BY,
/// Left: unresolved member name.
/// Is written at.
/// Right: location.
IS_WRITTEN_BY
}
/// When we need to reference a synthetic element in [PackageIndex] we use a
/// value of this enum to specify which kind of the synthetic element we
/// actually reference.
enum IndexSyntheticElementKind {
/// Not a synthetic element.
notSynthetic,
/// The unnamed synthetic constructor a class element.
constructor,
/// The synthetic field element.
field,
/// The synthetic getter of a property introducing element.
getter,
/// The synthetic setter of a property introducing element.
setter,
/// The synthetic top-level variable element.
topLevelVariable,
/// The synthetic `loadLibrary` element.
loadLibrary,
/// The synthetic `index` getter of an enum.
enumIndex,
/// The synthetic `values` getter of an enum.
enumValues,
/// The synthetic `toString` method of an enum.
enumToString,
/// The containing unit itself.
unit
}
/// Information about a dependency that exists between one library and another
/// due to an "import" declaration.
abstract class LinkedDependency extends base.SummaryClass {
/// Absolute URI for the compilation units listed in the library's `part`
/// declarations, empty string for invalid URI.
@Id(1)
List<String> get parts;
/// The absolute URI of the dependent library, e.g. `package:foo/bar.dart`.
@Id(0)
String get uri;
}
/// Information about a single name in the export namespace of the library that
/// is not in the public namespace.
abstract class LinkedExportName extends base.SummaryClass {
/// Index into [LinkedLibrary.dependencies] for the library in which the
/// entity is defined.
@Id(0)
int get dependency;
/// The kind of the entity being referred to.
@Id(3)
ReferenceKind get kind;
/// Name of the exported entity. For an exported setter, this name includes
/// the trailing '='.
@Id(1)
String get name;
/// Integer index indicating which unit in the exported library contains the
/// definition of the entity. As with indices into [LinkedLibrary.units],
/// zero represents the defining compilation unit, and nonzero values
/// represent parts in the order of the corresponding `part` declarations.
@Id(2)
int get unit;
}
/// Linked summary of a library.
@TopLevel('LLib')
abstract class LinkedLibrary extends base.SummaryClass {
factory LinkedLibrary.fromBuffer(List<int> buffer) =>
generated.readLinkedLibrary(buffer);
/// The libraries that this library depends on (either via an explicit import
/// statement or via the implicit dependencies on `dart:core` and
/// `dart:async`). The first element of this array is a pseudo-dependency
/// representing the library itself (it is also used for `dynamic` and
/// `void`). This is followed by elements representing "prelinked"
/// dependencies (direct imports and the transitive closure of exports).
/// After the prelinked dependencies are elements representing "linked"
/// dependencies.
///
/// A library is only included as a "linked" dependency if it is a true
/// dependency (e.g. a propagated or inferred type or constant value
/// implicitly refers to an element declared in the library) or
/// anti-dependency (e.g. the result of type propagation or type inference
/// depends on the lack of a certain declaration in the library).
@Id(0)
List<LinkedDependency> get dependencies;
/// For each export in [UnlinkedUnit.exports], an index into [dependencies]
/// of the library being exported.
@Id(6)
List<int> get exportDependencies;
/// Information about entities in the export namespace of the library that are
/// not in the public namespace of the library (that is, entities that are
/// brought into the namespace via `export` directives).
///
/// Sorted by name.
@Id(4)
List<LinkedExportName> get exportNames;
/// Indicates whether this library was summarized in "fallback mode". If
/// true, all other fields in the data structure have their default values.
@deprecated
@Id(5)
bool get fallbackMode;
/// For each import in [UnlinkedUnit.imports], an index into [dependencies]
/// of the library being imported.
@Id(1)
List<int> get importDependencies;
/// The number of elements in [dependencies] which are not "linked"
/// dependencies (that is, the number of libraries in the direct imports plus
/// the transitive closure of exports, plus the library itself).
@Id(2)
int get numPrelinkedDependencies;
/// The linked summary of all the compilation units constituting the
/// library. The summary of the defining compilation unit is listed first,
/// followed by the summary of each part, in the order of the `part`
/// declarations in the defining compilation unit.
@Id(3)
List<LinkedUnit> get units;
}
/// Information about a linked AST node.
@Variant('kind')
abstract class LinkedNode extends base.SummaryClass {
/// The explicit or inferred return type of a function typed node.
@VariantId(24, variantList: [
LinkedNodeKind.functionDeclaration,
LinkedNodeKind.functionExpression,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.genericFunctionType,
LinkedNodeKind.methodDeclaration,
])
LinkedNodeType get actualReturnType;
/// The explicit or inferred type of a variable.
@VariantId(24, variantList: [
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.simpleFormalParameter,
LinkedNodeKind.variableDeclaration,
])
LinkedNodeType get actualType;
@VariantId(2, variant: LinkedNodeKind.adjacentStrings)
List<LinkedNode> get adjacentStrings_strings;
@VariantId(11, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.classTypeAlias,
LinkedNodeKind.constructorDeclaration,
LinkedNodeKind.declaredIdentifier,
LinkedNodeKind.enumDeclaration,
LinkedNodeKind.enumConstantDeclaration,
LinkedNodeKind.exportDirective,
LinkedNodeKind.fieldDeclaration,
LinkedNodeKind.functionDeclaration,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.genericTypeAlias,
LinkedNodeKind.importDirective,
LinkedNodeKind.libraryDirective,
LinkedNodeKind.methodDeclaration,
LinkedNodeKind.mixinDeclaration,
LinkedNodeKind.partDirective,
LinkedNodeKind.partOfDirective,
LinkedNodeKind.topLevelVariableDeclaration,
LinkedNodeKind.typeParameter,
LinkedNodeKind.variableDeclaration,
LinkedNodeKind.variableDeclarationList,
])
LinkedNode get annotatedNode_comment;
@VariantId(4, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.classTypeAlias,
LinkedNodeKind.constructorDeclaration,
LinkedNodeKind.declaredIdentifier,
LinkedNodeKind.enumDeclaration,
LinkedNodeKind.enumConstantDeclaration,
LinkedNodeKind.exportDirective,
LinkedNodeKind.fieldDeclaration,
LinkedNodeKind.functionDeclaration,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.genericTypeAlias,
LinkedNodeKind.importDirective,
LinkedNodeKind.libraryDirective,
LinkedNodeKind.methodDeclaration,
LinkedNodeKind.mixinDeclaration,
LinkedNodeKind.partDirective,
LinkedNodeKind.partOfDirective,
LinkedNodeKind.topLevelVariableDeclaration,
LinkedNodeKind.typeParameter,
LinkedNodeKind.variableDeclaration,
LinkedNodeKind.variableDeclarationList,
])
List<LinkedNode> get annotatedNode_metadata;
@VariantId(6, variant: LinkedNodeKind.annotation)
LinkedNode get annotation_arguments;
@VariantId(15, variant: LinkedNodeKind.annotation)
int get annotation_atSign;
@VariantId(7, variant: LinkedNodeKind.annotation)
LinkedNode get annotation_constructorName;
@VariantId(17, variant: LinkedNodeKind.annotation)
int get annotation_element;
@VariantId(23, variant: LinkedNodeKind.annotation)
LinkedNodeType get annotation_elementType;
@VariantId(8, variant: LinkedNodeKind.annotation)
LinkedNode get annotation_name;
@VariantId(16, variant: LinkedNodeKind.annotation)
int get annotation_period;
@VariantId(2, variant: LinkedNodeKind.argumentList)
List<LinkedNode> get argumentList_arguments;
@VariantId(15, variant: LinkedNodeKind.argumentList)
int get argumentList_leftParenthesis;
@VariantId(16, variant: LinkedNodeKind.argumentList)
int get argumentList_rightParenthesis;
@VariantId(15, variant: LinkedNodeKind.asExpression)
int get asExpression_asOperator;
@VariantId(6, variant: LinkedNodeKind.asExpression)
LinkedNode get asExpression_expression;
@VariantId(7, variant: LinkedNodeKind.asExpression)
LinkedNode get asExpression_type;
@VariantId(15, variant: LinkedNodeKind.assertInitializer)
int get assertInitializer_assertKeyword;
@VariantId(16, variant: LinkedNodeKind.assertInitializer)
int get assertInitializer_comma;
@VariantId(6, variant: LinkedNodeKind.assertInitializer)
LinkedNode get assertInitializer_condition;
@VariantId(17, variant: LinkedNodeKind.assertInitializer)
int get assertInitializer_leftParenthesis;
@VariantId(7, variant: LinkedNodeKind.assertInitializer)
LinkedNode get assertInitializer_message;
@VariantId(18, variant: LinkedNodeKind.assertInitializer)
int get assertInitializer_rightParenthesis;
@VariantId(15, variant: LinkedNodeKind.assertStatement)
int get assertStatement_assertKeyword;
@VariantId(16, variant: LinkedNodeKind.assertStatement)
int get assertStatement_comma;
@VariantId(6, variant: LinkedNodeKind.assertStatement)
LinkedNode get assertStatement_condition;
@VariantId(17, variant: LinkedNodeKind.assertStatement)
int get assertStatement_leftParenthesis;
@VariantId(7, variant: LinkedNodeKind.assertStatement)
LinkedNode get assertStatement_message;
@VariantId(18, variant: LinkedNodeKind.assertStatement)
int get assertStatement_rightParenthesis;
@VariantId(19, variant: LinkedNodeKind.assertStatement)
int get assertStatement_semicolon;
@VariantId(15, variant: LinkedNodeKind.assignmentExpression)
int get assignmentExpression_element;
@VariantId(23, variant: LinkedNodeKind.assignmentExpression)
LinkedNodeType get assignmentExpression_elementType;
@VariantId(6, variant: LinkedNodeKind.assignmentExpression)
LinkedNode get assignmentExpression_leftHandSide;
@VariantId(16, variant: LinkedNodeKind.assignmentExpression)
int get assignmentExpression_operator;
@VariantId(7, variant: LinkedNodeKind.assignmentExpression)
LinkedNode get assignmentExpression_rightHandSide;
@VariantId(15, variant: LinkedNodeKind.awaitExpression)
int get awaitExpression_awaitKeyword;
@VariantId(6, variant: LinkedNodeKind.awaitExpression)
LinkedNode get awaitExpression_expression;
@VariantId(15, variant: LinkedNodeKind.binaryExpression)
int get binaryExpression_element;
@VariantId(23, variant: LinkedNodeKind.binaryExpression)
LinkedNodeType get binaryExpression_elementType;
@VariantId(24, variant: LinkedNodeKind.binaryExpression)
LinkedNodeType get binaryExpression_invokeType;
@VariantId(6, variant: LinkedNodeKind.binaryExpression)
LinkedNode get binaryExpression_leftOperand;
@VariantId(16, variant: LinkedNodeKind.binaryExpression)
int get binaryExpression_operator;
@VariantId(7, variant: LinkedNodeKind.binaryExpression)
LinkedNode get binaryExpression_rightOperand;
@VariantId(15, variant: LinkedNodeKind.block)
int get block_leftBracket;
@VariantId(16, variant: LinkedNodeKind.block)
int get block_rightBracket;
@VariantId(2, variant: LinkedNodeKind.block)
List<LinkedNode> get block_statements;
@VariantId(6, variant: LinkedNodeKind.blockFunctionBody)
LinkedNode get blockFunctionBody_block;
@VariantId(15, variant: LinkedNodeKind.blockFunctionBody)
int get blockFunctionBody_keyword;
@VariantId(16, variant: LinkedNodeKind.blockFunctionBody)
int get blockFunctionBody_star;
@VariantId(15, variant: LinkedNodeKind.booleanLiteral)
int get booleanLiteral_literal;
@VariantId(27, variant: LinkedNodeKind.booleanLiteral)
bool get booleanLiteral_value;
@VariantId(15, variant: LinkedNodeKind.breakStatement)
int get breakStatement_breakKeyword;
@VariantId(6, variant: LinkedNodeKind.breakStatement)
LinkedNode get breakStatement_label;
@VariantId(16, variant: LinkedNodeKind.breakStatement)
int get breakStatement_semicolon;
@VariantId(2, variant: LinkedNodeKind.cascadeExpression)
List<LinkedNode> get cascadeExpression_sections;
@VariantId(6, variant: LinkedNodeKind.cascadeExpression)
LinkedNode get cascadeExpression_target;
@VariantId(6, variant: LinkedNodeKind.catchClause)
LinkedNode get catchClause_body;
@VariantId(15, variant: LinkedNodeKind.catchClause)
int get catchClause_catchKeyword;
@VariantId(16, variant: LinkedNodeKind.catchClause)
int get catchClause_comma;
@VariantId(7, variant: LinkedNodeKind.catchClause)
LinkedNode get catchClause_exceptionParameter;
@VariantId(8, variant: LinkedNodeKind.catchClause)
LinkedNode get catchClause_exceptionType;
@VariantId(17, variant: LinkedNodeKind.catchClause)
int get catchClause_leftParenthesis;
@VariantId(18, variant: LinkedNodeKind.catchClause)
int get catchClause_onKeyword;
@VariantId(19, variant: LinkedNodeKind.catchClause)
int get catchClause_rightParenthesis;
@VariantId(9, variant: LinkedNodeKind.catchClause)
LinkedNode get catchClause_stackTraceParameter;
@VariantId(15, variant: LinkedNodeKind.classDeclaration)
int get classDeclaration_abstractKeyword;
@VariantId(16, variant: LinkedNodeKind.classDeclaration)
int get classDeclaration_classKeyword;
@VariantId(6, variant: LinkedNodeKind.classDeclaration)
LinkedNode get classDeclaration_extendsClause;
@VariantId(27, variant: LinkedNodeKind.classDeclaration)
bool get classDeclaration_isDartObject;
@VariantId(8, variant: LinkedNodeKind.classDeclaration)
LinkedNode get classDeclaration_nativeClause;
@VariantId(7, variant: LinkedNodeKind.classDeclaration)
LinkedNode get classDeclaration_withClause;
@VariantId(12, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.mixinDeclaration,
])
LinkedNode get classOrMixinDeclaration_implementsClause;
@VariantId(19, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.mixinDeclaration,
])
int get classOrMixinDeclaration_leftBracket;
@VariantId(5, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.mixinDeclaration,
])
List<LinkedNode> get classOrMixinDeclaration_members;
@VariantId(18, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.mixinDeclaration,
])
int get classOrMixinDeclaration_rightBracket;
@VariantId(13, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.mixinDeclaration,
])
LinkedNode get classOrMixinDeclaration_typeParameters;
@VariantId(15, variant: LinkedNodeKind.classTypeAlias)
int get classTypeAlias_abstractKeyword;
@VariantId(16, variant: LinkedNodeKind.classTypeAlias)
int get classTypeAlias_equals;
@VariantId(9, variant: LinkedNodeKind.classTypeAlias)
LinkedNode get classTypeAlias_implementsClause;
@VariantId(7, variant: LinkedNodeKind.classTypeAlias)
LinkedNode get classTypeAlias_superclass;
@VariantId(6, variant: LinkedNodeKind.classTypeAlias)
LinkedNode get classTypeAlias_typeParameters;
@VariantId(8, variant: LinkedNodeKind.classTypeAlias)
LinkedNode get classTypeAlias_withClause;
@VariantId(34, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.classTypeAlias,
LinkedNodeKind.constructorDeclaration,
LinkedNodeKind.defaultFormalParameter,
LinkedNodeKind.enumDeclaration,
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionDeclaration,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.genericTypeAlias,
LinkedNodeKind.methodDeclaration,
LinkedNodeKind.mixinDeclaration,
LinkedNodeKind.simpleFormalParameter,
LinkedNodeKind.typeParameter,
LinkedNodeKind.variableDeclaration,
])
int get codeLength;
@VariantId(33, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.classTypeAlias,
LinkedNodeKind.constructorDeclaration,
LinkedNodeKind.defaultFormalParameter,
LinkedNodeKind.enumDeclaration,
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionDeclaration,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.genericTypeAlias,
LinkedNodeKind.methodDeclaration,
LinkedNodeKind.mixinDeclaration,
LinkedNodeKind.simpleFormalParameter,
LinkedNodeKind.typeParameter,
LinkedNodeKind.variableDeclaration,
])
int get codeOffset;
@VariantId(19, variantList: [
LinkedNodeKind.hideCombinator,
LinkedNodeKind.showCombinator,
])
int get combinator_keyword;
@VariantId(28, variant: LinkedNodeKind.comment)
List<int> get comment_tokens;
@VariantId(29, variant: LinkedNodeKind.comment)
LinkedNodeCommentType get comment_type;
@VariantId(15, variant: LinkedNodeKind.compilationUnit)
int get compilationUnit_beginToken;
@VariantId(2, variant: LinkedNodeKind.compilationUnit)
List<LinkedNode> get compilationUnit_declarations;
@VariantId(3, variant: LinkedNodeKind.compilationUnit)
List<LinkedNode> get compilationUnit_directives;
@VariantId(16, variant: LinkedNodeKind.compilationUnit)
int get compilationUnit_endToken;
@VariantId(6, variant: LinkedNodeKind.compilationUnit)
LinkedNode get compilationUnit_scriptTag;
@VariantId(15, variant: LinkedNodeKind.conditionalExpression)
int get conditionalExpression_colon;
@VariantId(6, variant: LinkedNodeKind.conditionalExpression)
LinkedNode get conditionalExpression_condition;
@VariantId(7, variant: LinkedNodeKind.conditionalExpression)
LinkedNode get conditionalExpression_elseExpression;
@VariantId(16, variant: LinkedNodeKind.conditionalExpression)
int get conditionalExpression_question;
@VariantId(8, variant: LinkedNodeKind.conditionalExpression)
LinkedNode get conditionalExpression_thenExpression;
@VariantId(18, variant: LinkedNodeKind.configuration)
int get configuration_equalToken;
@VariantId(15, variant: LinkedNodeKind.configuration)
int get configuration_ifKeyword;
@VariantId(16, variant: LinkedNodeKind.configuration)
int get configuration_leftParenthesis;
@VariantId(6, variant: LinkedNodeKind.configuration)
LinkedNode get configuration_name;
@VariantId(17, variant: LinkedNodeKind.configuration)
int get configuration_rightParenthesis;
@VariantId(8, variant: LinkedNodeKind.configuration)
LinkedNode get configuration_uri;
@VariantId(7, variant: LinkedNodeKind.configuration)
LinkedNode get configuration_value;
@VariantId(6, variant: LinkedNodeKind.constructorDeclaration)
LinkedNode get constructorDeclaration_body;
@VariantId(15, variant: LinkedNodeKind.constructorDeclaration)
int get constructorDeclaration_constKeyword;
@VariantId(16, variant: LinkedNodeKind.constructorDeclaration)
int get constructorDeclaration_externalKeyword;
@VariantId(17, variant: LinkedNodeKind.constructorDeclaration)
int get constructorDeclaration_factoryKeyword;
@VariantId(2, variant: LinkedNodeKind.constructorDeclaration)
List<LinkedNode> get constructorDeclaration_initializers;
@VariantId(7, variant: LinkedNodeKind.constructorDeclaration)
LinkedNode get constructorDeclaration_name;
@VariantId(8, variant: LinkedNodeKind.constructorDeclaration)
LinkedNode get constructorDeclaration_parameters;
@VariantId(18, variant: LinkedNodeKind.constructorDeclaration)
int get constructorDeclaration_period;
@VariantId(9, variant: LinkedNodeKind.constructorDeclaration)
LinkedNode get constructorDeclaration_redirectedConstructor;
@VariantId(10, variant: LinkedNodeKind.constructorDeclaration)
LinkedNode get constructorDeclaration_returnType;
@VariantId(19, variant: LinkedNodeKind.constructorDeclaration)
int get constructorDeclaration_separator;
@VariantId(15, variant: LinkedNodeKind.constructorFieldInitializer)
int get constructorFieldInitializer_equals;
@VariantId(6, variant: LinkedNodeKind.constructorFieldInitializer)
LinkedNode get constructorFieldInitializer_expression;
@VariantId(7, variant: LinkedNodeKind.constructorFieldInitializer)
LinkedNode get constructorFieldInitializer_fieldName;
@VariantId(16, variant: LinkedNodeKind.constructorFieldInitializer)
int get constructorFieldInitializer_period;
@VariantId(17, variant: LinkedNodeKind.constructorFieldInitializer)
int get constructorFieldInitializer_thisKeyword;
@VariantId(15, variant: LinkedNodeKind.constructorName)
int get constructorName_element;
@VariantId(23, variant: LinkedNodeKind.constructorName)
LinkedNodeType get constructorName_elementType;
@VariantId(6, variant: LinkedNodeKind.constructorName)
LinkedNode get constructorName_name;
@VariantId(16, variant: LinkedNodeKind.constructorName)
int get constructorName_period;
@VariantId(7, variant: LinkedNodeKind.constructorName)
LinkedNode get constructorName_type;
@VariantId(15, variant: LinkedNodeKind.continueStatement)
int get continueStatement_continueKeyword;
@VariantId(6, variant: LinkedNodeKind.continueStatement)
LinkedNode get continueStatement_label;
@VariantId(16, variant: LinkedNodeKind.continueStatement)
int get continueStatement_semicolon;
@VariantId(6, variant: LinkedNodeKind.declaredIdentifier)
LinkedNode get declaredIdentifier_identifier;
@VariantId(15, variant: LinkedNodeKind.declaredIdentifier)
int get declaredIdentifier_keyword;
@VariantId(7, variant: LinkedNodeKind.declaredIdentifier)
LinkedNode get declaredIdentifier_type;
@VariantId(6, variant: LinkedNodeKind.defaultFormalParameter)
LinkedNode get defaultFormalParameter_defaultValue;
@VariantId(27, variant: LinkedNodeKind.defaultFormalParameter)
bool get defaultFormalParameter_isNamed;
@VariantId(7, variant: LinkedNodeKind.defaultFormalParameter)
LinkedNode get defaultFormalParameter_parameter;
@VariantId(15, variant: LinkedNodeKind.defaultFormalParameter)
int get defaultFormalParameter_separator;
@VariantId(18, variantList: [
LinkedNodeKind.exportDirective,
LinkedNodeKind.importDirective,
LinkedNodeKind.libraryDirective,
LinkedNodeKind.partDirective,
LinkedNodeKind.partOfDirective,
])
int get directive_keyword;
@VariantId(33, variantList: [
LinkedNodeKind.exportDirective,
LinkedNodeKind.importDirective,
LinkedNodeKind.libraryDirective,
LinkedNodeKind.partDirective,
LinkedNodeKind.partOfDirective,
])
int get directive_semicolon;
@VariantId(6, variant: LinkedNodeKind.doStatement)
LinkedNode get doStatement_body;
@VariantId(7, variant: LinkedNodeKind.doStatement)
LinkedNode get doStatement_condition;
@VariantId(17, variant: LinkedNodeKind.doStatement)
int get doStatement_doKeyword;
@VariantId(15, variant: LinkedNodeKind.doStatement)
int get doStatement_leftParenthesis;
@VariantId(16, variant: LinkedNodeKind.doStatement)
int get doStatement_rightParenthesis;
@VariantId(18, variant: LinkedNodeKind.doStatement)
int get doStatement_semicolon;
@VariantId(19, variant: LinkedNodeKind.doStatement)
int get doStatement_whileKeyword;
@VariantId(2, variant: LinkedNodeKind.dottedName)
List<LinkedNode> get dottedName_components;
@VariantId(15, variant: LinkedNodeKind.doubleLiteral)
int get doubleLiteral_literal;
@VariantId(21, variant: LinkedNodeKind.doubleLiteral)
double get doubleLiteral_value;
@VariantId(15, variant: LinkedNodeKind.emptyFunctionBody)
int get emptyFunctionBody_semicolon;
@VariantId(15, variant: LinkedNodeKind.emptyStatement)
int get emptyStatement_semicolon;
@VariantId(6, variant: LinkedNodeKind.enumConstantDeclaration)
LinkedNode get enumConstantDeclaration_name;
@VariantId(2, variant: LinkedNodeKind.enumDeclaration)
List<LinkedNode> get enumDeclaration_constants;
@VariantId(15, variant: LinkedNodeKind.enumDeclaration)
int get enumDeclaration_enumKeyword;
@VariantId(16, variant: LinkedNodeKind.enumDeclaration)
int get enumDeclaration_leftBracket;
@VariantId(17, variant: LinkedNodeKind.enumDeclaration)
int get enumDeclaration_rightBracket;
@VariantId(25, variantList: [
LinkedNodeKind.adjacentStrings,
LinkedNodeKind.assignmentExpression,
LinkedNodeKind.asExpression,
LinkedNodeKind.awaitExpression,
LinkedNodeKind.binaryExpression,
LinkedNodeKind.booleanLiteral,
LinkedNodeKind.cascadeExpression,
LinkedNodeKind.conditionalExpression,
LinkedNodeKind.doubleLiteral,
LinkedNodeKind.functionExpressionInvocation,
LinkedNodeKind.indexExpression,
LinkedNodeKind.instanceCreationExpression,
LinkedNodeKind.integerLiteral,
LinkedNodeKind.isExpression,
LinkedNodeKind.listLiteral,
LinkedNodeKind.methodInvocation,
LinkedNodeKind.namedExpression,
LinkedNodeKind.nullLiteral,
LinkedNodeKind.parenthesizedExpression,
LinkedNodeKind.prefixExpression,
LinkedNodeKind.prefixedIdentifier,
LinkedNodeKind.propertyAccess,
LinkedNodeKind.postfixExpression,
LinkedNodeKind.rethrowExpression,
LinkedNodeKind.setOrMapLiteral,
LinkedNodeKind.simpleIdentifier,
LinkedNodeKind.simpleStringLiteral,
LinkedNodeKind.stringInterpolation,
LinkedNodeKind.superExpression,
LinkedNodeKind.symbolLiteral,
LinkedNodeKind.thisExpression,
LinkedNodeKind.throwExpression,
])
LinkedNodeType get expression_type;
@VariantId(15, variant: LinkedNodeKind.expressionFunctionBody)
int get expressionFunctionBody_arrow;
@VariantId(6, variant: LinkedNodeKind.expressionFunctionBody)
LinkedNode get expressionFunctionBody_expression;
@VariantId(16, variant: LinkedNodeKind.expressionFunctionBody)
int get expressionFunctionBody_keyword;
@VariantId(17, variant: LinkedNodeKind.expressionFunctionBody)
int get expressionFunctionBody_semicolon;
@VariantId(6, variant: LinkedNodeKind.expressionStatement)
LinkedNode get expressionStatement_expression;
@VariantId(15, variant: LinkedNodeKind.expressionStatement)
int get expressionStatement_semicolon;
@VariantId(15, variant: LinkedNodeKind.extendsClause)
int get extendsClause_extendsKeyword;
@VariantId(6, variant: LinkedNodeKind.extendsClause)
LinkedNode get extendsClause_superclass;
@VariantId(15, variant: LinkedNodeKind.fieldDeclaration)
int get fieldDeclaration_covariantKeyword;
@VariantId(6, variant: LinkedNodeKind.fieldDeclaration)
LinkedNode get fieldDeclaration_fields;
@VariantId(16, variant: LinkedNodeKind.fieldDeclaration)
int get fieldDeclaration_semicolon;
@VariantId(17, variant: LinkedNodeKind.fieldDeclaration)
int get fieldDeclaration_staticKeyword;
@VariantId(8, variant: LinkedNodeKind.fieldFormalParameter)
LinkedNode get fieldFormalParameter_formalParameters;
@VariantId(15, variant: LinkedNodeKind.fieldFormalParameter)
int get fieldFormalParameter_keyword;
@VariantId(16, variant: LinkedNodeKind.fieldFormalParameter)
int get fieldFormalParameter_period;
@VariantId(17, variant: LinkedNodeKind.fieldFormalParameter)
int get fieldFormalParameter_thisKeyword;
@VariantId(6, variant: LinkedNodeKind.fieldFormalParameter)
LinkedNode get fieldFormalParameter_type;
@VariantId(7, variant: LinkedNodeKind.fieldFormalParameter)
LinkedNode get fieldFormalParameter_typeParameters;
@VariantId(15, variantList: [
LinkedNodeKind.forEachPartsWithDeclaration,
LinkedNodeKind.forEachPartsWithIdentifier,
])
int get forEachParts_inKeyword;
@VariantId(6, variantList: [
LinkedNodeKind.forEachPartsWithDeclaration,
LinkedNodeKind.forEachPartsWithIdentifier,
])
LinkedNode get forEachParts_iterable;
@VariantId(7, variant: LinkedNodeKind.forEachPartsWithDeclaration)
LinkedNode get forEachPartsWithDeclaration_loopVariable;
@VariantId(7, variant: LinkedNodeKind.forEachPartsWithIdentifier)
LinkedNode get forEachPartsWithIdentifier_identifier;
@VariantId(7, variant: LinkedNodeKind.forElement)
LinkedNode get forElement_body;
@VariantId(26, variantList: [
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.simpleFormalParameter,
])
LinkedNodeFormalParameterKind get formalParameter_kind;
@VariantId(15, variant: LinkedNodeKind.formalParameterList)
int get formalParameterList_leftDelimiter;
@VariantId(16, variant: LinkedNodeKind.formalParameterList)
int get formalParameterList_leftParenthesis;
@VariantId(2, variant: LinkedNodeKind.formalParameterList)
List<LinkedNode> get formalParameterList_parameters;
@VariantId(17, variant: LinkedNodeKind.formalParameterList)
int get formalParameterList_rightDelimiter;
@VariantId(18, variant: LinkedNodeKind.formalParameterList)
int get formalParameterList_rightParenthesis;
@VariantId(15, variantList: [
LinkedNodeKind.forElement,
LinkedNodeKind.forStatement,
])
int get forMixin_awaitKeyword;
@VariantId(16, variantList: [
LinkedNodeKind.forElement,
LinkedNodeKind.forStatement,
])
int get forMixin_forKeyword;
@VariantId(6, variantList: [
LinkedNodeKind.forElement,
LinkedNodeKind.forStatement,
])
LinkedNode get forMixin_forLoopParts;
@VariantId(17, variantList: [
LinkedNodeKind.forElement,
LinkedNodeKind.forStatement,
])
int get forMixin_leftParenthesis;
@VariantId(19, variantList: [
LinkedNodeKind.forElement,
LinkedNodeKind.forStatement,
])
int get forMixin_rightParenthesis;
@VariantId(6, variantList: [
LinkedNodeKind.forPartsWithDeclarations,
LinkedNodeKind.forPartsWithExpression,
])
LinkedNode get forParts_condition;
@VariantId(15, variantList: [
LinkedNodeKind.forPartsWithDeclarations,
LinkedNodeKind.forPartsWithExpression,
])
int get forParts_leftSeparator;
@VariantId(16, variantList: [
LinkedNodeKind.forPartsWithDeclarations,
LinkedNodeKind.forPartsWithExpression,
])
int get forParts_rightSeparator;
@VariantId(5, variantList: [
LinkedNodeKind.forPartsWithDeclarations,
LinkedNodeKind.forPartsWithExpression,
])
List<LinkedNode> get forParts_updaters;
@VariantId(7, variant: LinkedNodeKind.forPartsWithDeclarations)
LinkedNode get forPartsWithDeclarations_variables;
@VariantId(7, variant: LinkedNodeKind.forPartsWithExpression)
LinkedNode get forPartsWithExpression_initialization;
@VariantId(7, variant: LinkedNodeKind.forStatement)
LinkedNode get forStatement_body;
@VariantId(15, variant: LinkedNodeKind.functionDeclaration)
int get functionDeclaration_externalKeyword;
@VariantId(6, variant: LinkedNodeKind.functionDeclaration)
LinkedNode get functionDeclaration_functionExpression;
@VariantId(16, variant: LinkedNodeKind.functionDeclaration)
int get functionDeclaration_propertyKeyword;
@VariantId(7, variant: LinkedNodeKind.functionDeclaration)
LinkedNode get functionDeclaration_returnType;
@VariantId(6, variant: LinkedNodeKind.functionDeclarationStatement)
LinkedNode get functionDeclarationStatement_functionDeclaration;
@VariantId(6, variant: LinkedNodeKind.functionExpression)
LinkedNode get functionExpression_body;
@VariantId(7, variant: LinkedNodeKind.functionExpression)
LinkedNode get functionExpression_formalParameters;
@VariantId(8, variant: LinkedNodeKind.functionExpression)
LinkedNode get functionExpression_typeParameters;
@VariantId(6, variant: LinkedNodeKind.functionExpressionInvocation)
LinkedNode get functionExpressionInvocation_function;
@VariantId(6, variant: LinkedNodeKind.functionTypeAlias)
LinkedNode get functionTypeAlias_formalParameters;
@VariantId(7, variant: LinkedNodeKind.functionTypeAlias)
LinkedNode get functionTypeAlias_returnType;
@VariantId(8, variant: LinkedNodeKind.functionTypeAlias)
LinkedNode get functionTypeAlias_typeParameters;
@VariantId(6, variant: LinkedNodeKind.functionTypedFormalParameter)
LinkedNode get functionTypedFormalParameter_formalParameters;
@VariantId(7, variant: LinkedNodeKind.functionTypedFormalParameter)
LinkedNode get functionTypedFormalParameter_returnType;
@VariantId(8, variant: LinkedNodeKind.functionTypedFormalParameter)
LinkedNode get functionTypedFormalParameter_typeParameters;
@VariantId(8, variant: LinkedNodeKind.genericFunctionType)
LinkedNode get genericFunctionType_formalParameters;
@VariantId(15, variant: LinkedNodeKind.genericFunctionType)
int get genericFunctionType_functionKeyword;
@VariantId(16, variant: LinkedNodeKind.genericFunctionType)
int get genericFunctionType_question;
@VariantId(7, variant: LinkedNodeKind.genericFunctionType)
LinkedNode get genericFunctionType_returnType;
@VariantId(25, variant: LinkedNodeKind.genericFunctionType)
LinkedNodeType get genericFunctionType_type;
@VariantId(6, variant: LinkedNodeKind.genericFunctionType)
LinkedNode get genericFunctionType_typeParameters;
@VariantId(16, variant: LinkedNodeKind.genericTypeAlias)
int get genericTypeAlias_equals;
@VariantId(7, variant: LinkedNodeKind.genericTypeAlias)
LinkedNode get genericTypeAlias_functionType;
@VariantId(6, variant: LinkedNodeKind.genericTypeAlias)
LinkedNode get genericTypeAlias_typeParameters;
@VariantId(2, variant: LinkedNodeKind.hideCombinator)
List<LinkedNode> get hideCombinator_hiddenNames;
@VariantId(9, variant: LinkedNodeKind.ifElement)
LinkedNode get ifElement_elseElement;
@VariantId(8, variant: LinkedNodeKind.ifElement)
LinkedNode get ifElement_thenElement;
@VariantId(6, variantList: [
LinkedNodeKind.ifElement,
LinkedNodeKind.ifStatement,
])
LinkedNode get ifMixin_condition;
@VariantId(15, variantList: [
LinkedNodeKind.ifElement,
LinkedNodeKind.ifStatement,
])
int get ifMixin_elseKeyword;
@VariantId(16, variantList: [
LinkedNodeKind.ifElement,
LinkedNodeKind.ifStatement,
])
int get ifMixin_ifKeyword;
@VariantId(17, variantList: [
LinkedNodeKind.ifElement,
LinkedNodeKind.ifStatement,
])
int get ifMixin_leftParenthesis;
@VariantId(18, variantList: [
LinkedNodeKind.ifElement,
LinkedNodeKind.ifStatement,
])
int get ifMixin_rightParenthesis;
@VariantId(7, variant: LinkedNodeKind.ifStatement)
LinkedNode get ifStatement_elseStatement;
@VariantId(8, variant: LinkedNodeKind.ifStatement)
LinkedNode get ifStatement_thenStatement;
@VariantId(15, variant: LinkedNodeKind.implementsClause)
int get implementsClause_implementsKeyword;
@VariantId(2, variant: LinkedNodeKind.implementsClause)
List<LinkedNode> get implementsClause_interfaces;
@VariantId(15, variant: LinkedNodeKind.importDirective)
int get importDirective_asKeyword;
@VariantId(16, variant: LinkedNodeKind.importDirective)
int get importDirective_deferredKeyword;
@VariantId(6, variant: LinkedNodeKind.importDirective)
LinkedNode get importDirective_prefix;
@VariantId(15, variant: LinkedNodeKind.indexExpression)
int get indexExpression_element;
@VariantId(23, variant: LinkedNodeKind.indexExpression)
LinkedNodeType get indexExpression_elementType;
@VariantId(6, variant: LinkedNodeKind.indexExpression)
LinkedNode get indexExpression_index;
@VariantId(17, variant: LinkedNodeKind.indexExpression)
int get indexExpression_leftBracket;
@VariantId(16, variant: LinkedNodeKind.indexExpression)
int get indexExpression_period;
@VariantId(18, variant: LinkedNodeKind.indexExpression)
int get indexExpression_rightBracket;
@VariantId(7, variant: LinkedNodeKind.indexExpression)
LinkedNode get indexExpression_target;
@VariantId(6, variant: LinkedNodeKind.instanceCreationExpression)
LinkedNode get instanceCreationExpression_arguments;
@VariantId(7, variant: LinkedNodeKind.instanceCreationExpression)
LinkedNode get instanceCreationExpression_constructorName;
@VariantId(15, variant: LinkedNodeKind.instanceCreationExpression)
int get instanceCreationExpression_keyword;
@VariantId(8, variant: LinkedNodeKind.instanceCreationExpression)
LinkedNode get instanceCreationExpression_typeArguments;
@VariantId(15, variant: LinkedNodeKind.integerLiteral)
int get integerLiteral_literal;
@VariantId(16, variant: LinkedNodeKind.integerLiteral)
int get integerLiteral_value;
@VariantId(6, variant: LinkedNodeKind.interpolationExpression)
LinkedNode get interpolationExpression_expression;
@VariantId(15, variant: LinkedNodeKind.interpolationExpression)
int get interpolationExpression_leftBracket;
@VariantId(16, variant: LinkedNodeKind.interpolationExpression)
int get interpolationExpression_rightBracket;
@VariantId(15, variant: LinkedNodeKind.interpolationString)
int get interpolationString_token;
@VariantId(30, variant: LinkedNodeKind.interpolationString)
String get interpolationString_value;
@VariantId(14, variantList: [
LinkedNodeKind.functionExpressionInvocation,
LinkedNodeKind.methodInvocation,
])
LinkedNode get invocationExpression_arguments;
@VariantId(24, variantList: [
LinkedNodeKind.functionExpressionInvocation,
LinkedNodeKind.methodInvocation,
])
LinkedNodeType get invocationExpression_invokeType;
@VariantId(12, variantList: [
LinkedNodeKind.functionExpressionInvocation,
LinkedNodeKind.methodInvocation,
])
LinkedNode get invocationExpression_typeArguments;
@VariantId(6, variant: LinkedNodeKind.isExpression)
LinkedNode get isExpression_expression;
@VariantId(15, variant: LinkedNodeKind.isExpression)
int get isExpression_isOperator;
@VariantId(16, variant: LinkedNodeKind.isExpression)
int get isExpression_notOperator;
@VariantId(7, variant: LinkedNodeKind.isExpression)
LinkedNode get isExpression_type;
@Id(1)
bool get isSynthetic;
@Id(0)
LinkedNodeKind get kind;
@VariantId(15, variant: LinkedNodeKind.label)
int get label_colon;
@VariantId(6, variant: LinkedNodeKind.label)
LinkedNode get label_label;
@VariantId(2, variant: LinkedNodeKind.labeledStatement)
List<LinkedNode> get labeledStatement_labels;
@VariantId(6, variant: LinkedNodeKind.labeledStatement)
LinkedNode get labeledStatement_statement;
@VariantId(6, variant: LinkedNodeKind.libraryDirective)
LinkedNode get libraryDirective_name;
@VariantId(2, variant: LinkedNodeKind.libraryIdentifier)
List<LinkedNode> get libraryIdentifier_components;
@VariantId(2, variant: LinkedNodeKind.listLiteral)
List<LinkedNode> get listLiteral_elements;
@VariantId(15, variant: LinkedNodeKind.listLiteral)
int get listLiteral_leftBracket;
@VariantId(16, variant: LinkedNodeKind.listLiteral)
int get listLiteral_rightBracket;
@VariantId(6, variant: LinkedNodeKind.mapLiteralEntry)
LinkedNode get mapLiteralEntry_key;
@VariantId(15, variant: LinkedNodeKind.mapLiteralEntry)
int get mapLiteralEntry_separator;
@VariantId(7, variant: LinkedNodeKind.mapLiteralEntry)
LinkedNode get mapLiteralEntry_value;
@VariantId(19, variant: LinkedNodeKind.methodDeclaration)
int get methodDeclaration_actualProperty;
@VariantId(6, variant: LinkedNodeKind.methodDeclaration)
LinkedNode get methodDeclaration_body;
@VariantId(15, variant: LinkedNodeKind.methodDeclaration)
int get methodDeclaration_externalKeyword;
@VariantId(7, variant: LinkedNodeKind.methodDeclaration)
LinkedNode get methodDeclaration_formalParameters;
@VariantId(16, variant: LinkedNodeKind.methodDeclaration)
int get methodDeclaration_modifierKeyword;
@VariantId(10, variant: LinkedNodeKind.methodDeclaration)
LinkedNode get methodDeclaration_name;
@VariantId(17, variant: LinkedNodeKind.methodDeclaration)
int get methodDeclaration_operatorKeyword;
@VariantId(18, variant: LinkedNodeKind.methodDeclaration)
int get methodDeclaration_propertyKeyword;
@VariantId(8, variant: LinkedNodeKind.methodDeclaration)
LinkedNode get methodDeclaration_returnType;
@VariantId(9, variant: LinkedNodeKind.methodDeclaration)
LinkedNode get methodDeclaration_typeParameters;
@VariantId(6, variant: LinkedNodeKind.methodInvocation)
LinkedNode get methodInvocation_methodName;
@VariantId(15, variant: LinkedNodeKind.methodInvocation)
int get methodInvocation_operator;
@VariantId(7, variant: LinkedNodeKind.methodInvocation)
LinkedNode get methodInvocation_target;
@VariantId(15, variant: LinkedNodeKind.mixinDeclaration)
int get mixinDeclaration_mixinKeyword;
@VariantId(6, variant: LinkedNodeKind.mixinDeclaration)
LinkedNode get mixinDeclaration_onClause;
@VariantId(14, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.classTypeAlias,
LinkedNodeKind.enumDeclaration,
LinkedNodeKind.functionDeclaration,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.genericTypeAlias,
LinkedNodeKind.mixinDeclaration,
])
LinkedNode get namedCompilationUnitMember_name;
@VariantId(6, variant: LinkedNodeKind.namedExpression)
LinkedNode get namedExpression_expression;
@VariantId(7, variant: LinkedNodeKind.namedExpression)
LinkedNode get namedExpression_name;
@VariantId(2, variantList: [
LinkedNodeKind.exportDirective,
LinkedNodeKind.importDirective,
])
List<LinkedNode> get namespaceDirective_combinators;
@VariantId(3, variantList: [
LinkedNodeKind.exportDirective,
LinkedNodeKind.importDirective,
])
List<LinkedNode> get namespaceDirective_configurations;
@VariantId(20, variantList: [
LinkedNodeKind.exportDirective,
LinkedNodeKind.importDirective,
])
String get namespaceDirective_selectedUri;
@VariantId(6, variant: LinkedNodeKind.nativeClause)
LinkedNode get nativeClause_name;
@VariantId(15, variant: LinkedNodeKind.nativeClause)
int get nativeClause_nativeKeyword;
@VariantId(15, variant: LinkedNodeKind.nativeFunctionBody)
int get nativeFunctionBody_nativeKeyword;
@VariantId(16, variant: LinkedNodeKind.nativeFunctionBody)
int get nativeFunctionBody_semicolon;
@VariantId(6, variant: LinkedNodeKind.nativeFunctionBody)
LinkedNode get nativeFunctionBody_stringLiteral;
@VariantId(14, variantList: [
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.simpleFormalParameter,
])
LinkedNode get normalFormalParameter_comment;
@VariantId(19, variantList: [
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.simpleFormalParameter,
])
int get normalFormalParameter_covariantKeyword;
@VariantId(12, variantList: [
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.simpleFormalParameter,
])
LinkedNode get normalFormalParameter_identifier;
@VariantId(27, variantList: [
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.simpleFormalParameter,
])
bool get normalFormalParameter_isCovariant;
@VariantId(4, variantList: [
LinkedNodeKind.fieldFormalParameter,
LinkedNodeKind.functionTypedFormalParameter,
LinkedNodeKind.simpleFormalParameter,
])
List<LinkedNode> get normalFormalParameter_metadata;
@VariantId(15, variant: LinkedNodeKind.nullLiteral)
int get nullLiteral_literal;
@VariantId(15, variant: LinkedNodeKind.onClause)
int get onClause_onKeyword;
@VariantId(2, variant: LinkedNodeKind.onClause)
List<LinkedNode> get onClause_superclassConstraints;
@VariantId(6, variant: LinkedNodeKind.parenthesizedExpression)
LinkedNode get parenthesizedExpression_expression;
@VariantId(15, variant: LinkedNodeKind.parenthesizedExpression)
int get parenthesizedExpression_leftParenthesis;
@VariantId(16, variant: LinkedNodeKind.parenthesizedExpression)
int get parenthesizedExpression_rightParenthesis;
@VariantId(6, variant: LinkedNodeKind.partOfDirective)
LinkedNode get partOfDirective_libraryName;
@VariantId(16, variant: LinkedNodeKind.partOfDirective)
int get partOfDirective_ofKeyword;
@VariantId(7, variant: LinkedNodeKind.partOfDirective)
LinkedNode get partOfDirective_uri;
@VariantId(15, variant: LinkedNodeKind.postfixExpression)
int get postfixExpression_element;
@VariantId(23, variant: LinkedNodeKind.postfixExpression)
LinkedNodeType get postfixExpression_elementType;
@VariantId(6, variant: LinkedNodeKind.postfixExpression)
LinkedNode get postfixExpression_operand;
@VariantId(16, variant: LinkedNodeKind.postfixExpression)
int get postfixExpression_operator;
@VariantId(6, variant: LinkedNodeKind.prefixedIdentifier)
LinkedNode get prefixedIdentifier_identifier;
@VariantId(15, variant: LinkedNodeKind.prefixedIdentifier)
int get prefixedIdentifier_period;
@VariantId(7, variant: LinkedNodeKind.prefixedIdentifier)
LinkedNode get prefixedIdentifier_prefix;
@VariantId(15, variant: LinkedNodeKind.prefixExpression)
int get prefixExpression_element;
@VariantId(23, variant: LinkedNodeKind.prefixExpression)
LinkedNodeType get prefixExpression_elementType;
@VariantId(6, variant: LinkedNodeKind.prefixExpression)
LinkedNode get prefixExpression_operand;
@VariantId(16, variant: LinkedNodeKind.prefixExpression)
int get prefixExpression_operator;
@VariantId(15, variant: LinkedNodeKind.propertyAccess)
int get propertyAccess_operator;
@VariantId(6, variant: LinkedNodeKind.propertyAccess)
LinkedNode get propertyAccess_propertyName;
@VariantId(7, variant: LinkedNodeKind.propertyAccess)
LinkedNode get propertyAccess_target;
@VariantId(6, variant: LinkedNodeKind.redirectingConstructorInvocation)
LinkedNode get redirectingConstructorInvocation_arguments;
@VariantId(7, variant: LinkedNodeKind.redirectingConstructorInvocation)
LinkedNode get redirectingConstructorInvocation_constructorName;
@VariantId(15, variant: LinkedNodeKind.redirectingConstructorInvocation)
int get redirectingConstructorInvocation_element;
@VariantId(23, variant: LinkedNodeKind.redirectingConstructorInvocation)
LinkedNodeType get redirectingConstructorInvocation_elementType;
@VariantId(16, variant: LinkedNodeKind.redirectingConstructorInvocation)
int get redirectingConstructorInvocation_period;
@VariantId(17, variant: LinkedNodeKind.redirectingConstructorInvocation)
int get redirectingConstructorInvocation_thisKeyword;
@VariantId(15, variant: LinkedNodeKind.rethrowExpression)
int get rethrowExpression_rethrowKeyword;
@VariantId(6, variant: LinkedNodeKind.returnStatement)
LinkedNode get returnStatement_expression;
@VariantId(15, variant: LinkedNodeKind.returnStatement)
int get returnStatement_returnKeyword;
@VariantId(16, variant: LinkedNodeKind.returnStatement)
int get returnStatement_semicolon;
@VariantId(15, variant: LinkedNodeKind.scriptTag)
int get scriptTag_scriptTag;
@VariantId(2, variant: LinkedNodeKind.setOrMapLiteral)
List<LinkedNode> get setOrMapLiteral_elements;
@VariantId(27, variant: LinkedNodeKind.setOrMapLiteral)
bool get setOrMapLiteral_isMap;
@VariantId(31, variant: LinkedNodeKind.setOrMapLiteral)
bool get setOrMapLiteral_isSet;
@VariantId(15, variant: LinkedNodeKind.setOrMapLiteral)
int get setOrMapLiteral_leftBracket;
@VariantId(16, variant: LinkedNodeKind.setOrMapLiteral)
int get setOrMapLiteral_rightBracket;
@VariantId(2, variant: LinkedNodeKind.showCombinator)
List<LinkedNode> get showCombinator_shownNames;
@VariantId(15, variant: LinkedNodeKind.simpleFormalParameter)
int get simpleFormalParameter_keyword;
@VariantId(6, variant: LinkedNodeKind.simpleFormalParameter)
LinkedNode get simpleFormalParameter_type;
@VariantId(15, variant: LinkedNodeKind.simpleIdentifier)
int get simpleIdentifier_element;
@VariantId(23, variant: LinkedNodeKind.simpleIdentifier)
LinkedNodeType get simpleIdentifier_elementType;
@VariantId(16, variant: LinkedNodeKind.simpleIdentifier)
int get simpleIdentifier_token;
@VariantId(15, variant: LinkedNodeKind.simpleStringLiteral)
int get simpleStringLiteral_token;
@VariantId(20, variant: LinkedNodeKind.simpleStringLiteral)
String get simpleStringLiteral_value;
@VariantId(31, variantList: [
LinkedNodeKind.classDeclaration,
LinkedNodeKind.classTypeAlias,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.genericTypeAlias,
LinkedNodeKind.mixinDeclaration,
])
bool get simplyBoundable_isSimplyBounded;
@VariantId(6, variant: LinkedNodeKind.spreadElement)
LinkedNode get spreadElement_expression;
@VariantId(15, variant: LinkedNodeKind.spreadElement)
int get spreadElement_spreadOperator;
@VariantId(2, variant: LinkedNodeKind.stringInterpolation)
List<LinkedNode> get stringInterpolation_elements;
@VariantId(6, variant: LinkedNodeKind.superConstructorInvocation)
LinkedNode get superConstructorInvocation_arguments;
@VariantId(7, variant: LinkedNodeKind.superConstructorInvocation)
LinkedNode get superConstructorInvocation_constructorName;
@VariantId(15, variant: LinkedNodeKind.superConstructorInvocation)
int get superConstructorInvocation_element;
@VariantId(23, variant: LinkedNodeKind.superConstructorInvocation)
LinkedNodeType get superConstructorInvocation_elementType;
@VariantId(16, variant: LinkedNodeKind.superConstructorInvocation)
int get superConstructorInvocation_period;
@VariantId(17, variant: LinkedNodeKind.superConstructorInvocation)
int get superConstructorInvocation_superKeyword;
@VariantId(15, variant: LinkedNodeKind.superExpression)
int get superExpression_superKeyword;
@VariantId(6, variant: LinkedNodeKind.switchCase)
LinkedNode get switchCase_expression;
@VariantId(16, variantList: [
LinkedNodeKind.switchCase,
LinkedNodeKind.switchDefault,
])
int get switchMember_colon;
@VariantId(15, variantList: [
LinkedNodeKind.switchCase,
LinkedNodeKind.switchDefault,
])
int get switchMember_keyword;
@VariantId(3, variantList: [
LinkedNodeKind.switchCase,
LinkedNodeKind.switchDefault,
])
List<LinkedNode> get switchMember_labels;
@VariantId(4, variantList: [
LinkedNodeKind.switchCase,
LinkedNodeKind.switchDefault,
])
List<LinkedNode> get switchMember_statements;
@VariantId(7, variant: LinkedNodeKind.switchStatement)
LinkedNode get switchStatement_expression;
@VariantId(18, variant: LinkedNodeKind.switchStatement)
int get switchStatement_leftBracket;
@VariantId(15, variant: LinkedNodeKind.switchStatement)
int get switchStatement_leftParenthesis;
@VariantId(2, variant: LinkedNodeKind.switchStatement)
List<LinkedNode> get switchStatement_members;
@VariantId(19, variant: LinkedNodeKind.switchStatement)
int get switchStatement_rightBracket;
@VariantId(16, variant: LinkedNodeKind.switchStatement)
int get switchStatement_rightParenthesis;
@VariantId(17, variant: LinkedNodeKind.switchStatement)
int get switchStatement_switchKeyword;
@VariantId(28, variant: LinkedNodeKind.symbolLiteral)
List<int> get symbolLiteral_components;
@VariantId(15, variant: LinkedNodeKind.symbolLiteral)
int get symbolLiteral_poundSign;
@VariantId(15, variant: LinkedNodeKind.thisExpression)
int get thisExpression_thisKeyword;
@VariantId(6, variant: LinkedNodeKind.throwExpression)
LinkedNode get throwExpression_expression;
@VariantId(15, variant: LinkedNodeKind.throwExpression)
int get throwExpression_throwKeyword;
@VariantId(35, variantList: [
LinkedNodeKind.variableDeclaration,
])
TopLevelInferenceError get topLevelTypeInferenceError;
@VariantId(15, variant: LinkedNodeKind.topLevelVariableDeclaration)
int get topLevelVariableDeclaration_semicolon;
@VariantId(6, variant: LinkedNodeKind.topLevelVariableDeclaration)
LinkedNode get topLevelVariableDeclaration_variableList;
@VariantId(6, variant: LinkedNodeKind.tryStatement)
LinkedNode get tryStatement_body;
@VariantId(2, variant: LinkedNodeKind.tryStatement)
List<LinkedNode> get tryStatement_catchClauses;
@VariantId(7, variant: LinkedNodeKind.tryStatement)
LinkedNode get tryStatement_finallyBlock;
@VariantId(15, variant: LinkedNodeKind.tryStatement)
int get tryStatement_finallyKeyword;
@VariantId(16, variant: LinkedNodeKind.tryStatement)
int get tryStatement_tryKeyword;
@VariantId(19, variantList: [
LinkedNodeKind.classTypeAlias,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.genericTypeAlias,
])
int get typeAlias_semicolon;
@VariantId(18, variantList: [
LinkedNodeKind.classTypeAlias,
LinkedNodeKind.functionTypeAlias,
LinkedNodeKind.genericTypeAlias,
])
int get typeAlias_typedefKeyword;
@VariantId(2, variant: LinkedNodeKind.typeArgumentList)
List<LinkedNode> get typeArgumentList_arguments;
@VariantId(15, variant: LinkedNodeKind.typeArgumentList)
int get typeArgumentList_leftBracket;
@VariantId(16, variant: LinkedNodeKind.typeArgumentList)
int get typeArgumentList_rightBracket;
@VariantId(19, variantList: [
LinkedNodeKind.listLiteral,
LinkedNodeKind.setOrMapLiteral,
])
int get typedLiteral_constKeyword;
@VariantId(14, variantList: [
LinkedNodeKind.listLiteral,
LinkedNodeKind.setOrMapLiteral,
])
LinkedNode get typedLiteral_typeArguments;
@VariantId(6, variant: LinkedNodeKind.typeName)
LinkedNode get typeName_name;
@VariantId(15, variant: LinkedNodeKind.typeName)
int get typeName_question;
@VariantId(23, variant: LinkedNodeKind.typeName)
LinkedNodeType get typeName_type;
@VariantId(7, variant: LinkedNodeKind.typeName)
LinkedNode get typeName_typeArguments;
@VariantId(6, variant: LinkedNodeKind.typeParameter)
LinkedNode get typeParameter_bound;
@VariantId(15, variant: LinkedNodeKind.typeParameter)
int get typeParameter_extendsKeyword;
@VariantId(16, variant: LinkedNodeKind.typeParameter)
int get typeParameter_id;
@VariantId(7, variant: LinkedNodeKind.typeParameter)
LinkedNode get typeParameter_name;
@VariantId(15, variant: LinkedNodeKind.typeParameterList)
int get typeParameterList_leftBracket;
@VariantId(16, variant: LinkedNodeKind.typeParameterList)
int get typeParameterList_rightBracket;
@VariantId(2, variant: LinkedNodeKind.typeParameterList)
List<LinkedNode> get typeParameterList_typeParameters;
@VariantId(14, variantList: [
LinkedNodeKind.exportDirective,
LinkedNodeKind.importDirective,
LinkedNodeKind.partDirective,
])
LinkedNode get uriBasedDirective_uri;
@VariantId(22, variantList: [
LinkedNodeKind.exportDirective,
LinkedNodeKind.importDirective,
LinkedNodeKind.partDirective,
])
String get uriBasedDirective_uriContent;
@VariantId(19, variantList: [
LinkedNodeKind.exportDirective,
LinkedNodeKind.importDirective,
LinkedNodeKind.partDirective,
])
int get uriBasedDirective_uriElement;
@VariantId(32, variant: LinkedNodeKind.variableDeclaration)
LinkedNodeVariablesDeclaration get variableDeclaration_declaration;
@VariantId(15, variant: LinkedNodeKind.variableDeclaration)
int get variableDeclaration_equals;
@VariantId(6, variant: LinkedNodeKind.variableDeclaration)
LinkedNode get variableDeclaration_initializer;
@VariantId(7, variant: LinkedNodeKind.variableDeclaration)
LinkedNode get variableDeclaration_name;
@VariantId(15, variant: LinkedNodeKind.variableDeclarationList)
int get variableDeclarationList_keyword;
@VariantId(6, variant: LinkedNodeKind.variableDeclarationList)
LinkedNode get variableDeclarationList_type;
@VariantId(2, variant: LinkedNodeKind.variableDeclarationList)
List<LinkedNode> get variableDeclarationList_variables;
@VariantId(15, variant: LinkedNodeKind.variableDeclarationStatement)
int get variableDeclarationStatement_semicolon;
@VariantId(6, variant: LinkedNodeKind.variableDeclarationStatement)
LinkedNode get variableDeclarationStatement_variables;
@VariantId(6, variant: LinkedNodeKind.whileStatement)
LinkedNode get whileStatement_body;
@VariantId(7, variant: LinkedNodeKind.whileStatement)
LinkedNode get whileStatement_condition;
@VariantId(15, variant: LinkedNodeKind.whileStatement)
int get whileStatement_leftParenthesis;
@VariantId(16, variant: LinkedNodeKind.whileStatement)
int get whileStatement_rightParenthesis;
@VariantId(17, variant: LinkedNodeKind.whileStatement)
int get whileStatement_whileKeyword;
@VariantId(2, variant: LinkedNodeKind.withClause)
List<LinkedNode> get withClause_mixinTypes;
@VariantId(15, variant: LinkedNodeKind.withClause)
int get withClause_withKeyword;
@VariantId(6, variant: LinkedNodeKind.yieldStatement)
LinkedNode get yieldStatement_expression;
@VariantId(17, variant: LinkedNodeKind.yieldStatement)
int get yieldStatement_semicolon;
@VariantId(16, variant: LinkedNodeKind.yieldStatement)
int get yieldStatement_star;
@VariantId(15, variant: LinkedNodeKind.yieldStatement)
int get yieldStatement_yieldKeyword;
}
/// Information about a group of libraries linked together, for example because
/// they form a single cycle, or because they represent a single build artifact.
@TopLevel('LNBn')
abstract class LinkedNodeBundle extends base.SummaryClass {
factory LinkedNodeBundle.fromBuffer(List<int> buffer) =>
generated.readLinkedNodeBundle(buffer);
@Id(1)
List<LinkedNodeLibrary> get libraries;
/// The shared list of references used in the [libraries].
@Id(0)
LinkedNodeReferences get references;
}
/// Types of comments.
enum LinkedNodeCommentType { block, documentation, endOfLine }
/// Kinds of formal parameters.
enum LinkedNodeFormalParameterKind {
requiredPositional,
optionalPositional,
optionalNamed,
requiredNamed
}
/// Kinds of [LinkedNode].
enum LinkedNodeKind {
adjacentStrings,
annotation,
argumentList,
asExpression,
assertInitializer,
assertStatement,
assignmentExpression,
awaitExpression,
binaryExpression,
block,
blockFunctionBody,
booleanLiteral,
breakStatement,
cascadeExpression,
catchClause,
classDeclaration,
classTypeAlias,
comment,
compilationUnit,
conditionalExpression,
configuration,
constructorDeclaration,
constructorFieldInitializer,
constructorName,
continueStatement,
declaredIdentifier,
defaultFormalParameter,
doubleLiteral,
doStatement,
dottedName,
emptyFunctionBody,
emptyStatement,
enumConstantDeclaration,
enumDeclaration,
exportDirective,
expressionFunctionBody,
expressionStatement,
extendsClause,
fieldDeclaration,
fieldFormalParameter,
formalParameterList,
forEachPartsWithDeclaration,
forEachPartsWithIdentifier,
forElement,
forPartsWithDeclarations,
forPartsWithExpression,
forStatement,
functionDeclaration,
functionDeclarationStatement,
functionExpression,
functionExpressionInvocation,
functionTypeAlias,
functionTypedFormalParameter,
genericFunctionType,
genericTypeAlias,
hideCombinator,
ifElement,
ifStatement,
implementsClause,
importDirective,
instanceCreationExpression,
indexExpression,
integerLiteral,
interpolationExpression,
interpolationString,
isExpression,
label,
labeledStatement,
libraryDirective,
libraryIdentifier,
listLiteral,
mapLiteralEntry,
methodDeclaration,
methodInvocation,
mixinDeclaration,
namedExpression,
nativeClause,
nativeFunctionBody,
nullLiteral,
onClause,
parenthesizedExpression,
partDirective,
partOfDirective,
postfixExpression,
prefixExpression,
prefixedIdentifier,
propertyAccess,
redirectingConstructorInvocation,
rethrowExpression,
returnStatement,
scriptTag,
setOrMapLiteral,
showCombinator,
simpleFormalParameter,
simpleIdentifier,
simpleStringLiteral,
spreadElement,
stringInterpolation,
superConstructorInvocation,
superExpression,
switchCase,
switchDefault,
switchStatement,
symbolLiteral,
thisExpression,
throwExpression,
topLevelVariableDeclaration,
tryStatement,
typeArgumentList,
typeName,
typeParameter,
typeParameterList,
variableDeclaration,
variableDeclarationList,
variableDeclarationStatement,
whileStatement,
withClause,
yieldStatement,
}
/// Information about a single library in a [LinkedNodeBundle].
abstract class LinkedNodeLibrary extends base.SummaryClass {
@Id(2)
List<int> get exports;
@Id(3)
String get name;
@Id(5)
int get nameLength;
@Id(4)
int get nameOffset;
@Id(1)
List<LinkedNodeUnit> get units;
@Id(0)
String get uriStr;
}
/// Flattened tree of declarations referenced from [LinkedNode]s.
abstract class LinkedNodeReferences extends base.SummaryClass {
@Id(1)
List<String> get name;
@Id(0)
List<int> get parent;
}
/// Information about a Dart type.
abstract class LinkedNodeType extends base.SummaryClass {
@Id(0)
List<LinkedNodeTypeFormalParameter> get functionFormalParameters;
@Id(1)
LinkedNodeType get functionReturnType;
@Id(2)
List<LinkedNodeTypeTypeParameter> get functionTypeParameters;
@Id(7)
int get genericTypeAliasReference;
@Id(8)
List<LinkedNodeType> get genericTypeAliasTypeArguments;
/// Reference to a [LinkedNodeReferences].
@Id(3)
int get interfaceClass;
@Id(4)
List<LinkedNodeType> get interfaceTypeArguments;
@Id(5)
LinkedNodeTypeKind get kind;
@Id(6)
int get typeParameterId;
}
/// Information about a formal parameter in a function type.
abstract class LinkedNodeTypeFormalParameter extends base.SummaryClass {
@Id(0)
LinkedNodeFormalParameterKind get kind;
@Id(1)
String get name;
@Id(2)
LinkedNodeType get type;
}
/// Kinds of [LinkedNodeType]s.
enum LinkedNodeTypeKind {
bottom,
dynamic_,
function,
interface,
typeParameter,
void_
}
/// Information about a type parameter in a function type.
abstract class LinkedNodeTypeTypeParameter extends base.SummaryClass {
@Id(1)
LinkedNodeType get bound;
@Id(0)
String get name;
}
/// Information about a single library in a [LinkedNodeLibrary].
abstract class LinkedNodeUnit extends base.SummaryClass {
@Id(2)
LinkedNode get node;
@Id(1)
UnlinkedTokens get tokens;
@Id(0)
String get uriStr;
}
/// Information about a top-level declaration, or a field declaration that
/// contributes information to [LinkedNodeKind.variableDeclaration].
abstract class LinkedNodeVariablesDeclaration extends base.SummaryClass {
@Id(0)
LinkedNode get comment;
@Id(1)
bool get isConst;
@Id(2)
bool get isCovariant;
@Id(3)
bool get isFinal;
@Id(4)
bool get isStatic;
}
/// Information about the resolution of an [UnlinkedReference].
abstract class LinkedReference extends base.SummaryClass {
/// If this [LinkedReference] doesn't have an associated [UnlinkedReference],
/// and the entity being referred to is contained within another entity, index
/// of the containing entity. This behaves similarly to
/// [UnlinkedReference.prefixReference], however it is only used for class
/// members, not for prefixed imports.
///
/// Containing references must always point backward; that is, for all i, if
/// LinkedUnit.references[i].containingReference != 0, then
/// LinkedUnit.references[i].containingReference < i.
@Id(5)
int get containingReference;
/// Index into [LinkedLibrary.dependencies] indicating which imported library
/// declares the entity being referred to.
///
/// Zero if this entity is contained within another entity (e.g. a class
/// member), or if [kind] is [ReferenceKind.prefix].
@Id(1)
int get dependency;
/// The kind of the entity being referred to. For the pseudo-types `dynamic`
/// and `void`, the kind is [ReferenceKind.classOrEnum].
@Id(2)
ReferenceKind get kind;
/// If [kind] is [ReferenceKind.function] (that is, the entity being referred
/// to is a local function), the index of the function within
/// [UnlinkedExecutable.localFunctions]. Otherwise zero.
@deprecated
@Id(6)
int get localIndex;
/// If this [LinkedReference] doesn't have an associated [UnlinkedReference],
/// name of the entity being referred to. For the pseudo-type `dynamic`, the
/// string is "dynamic". For the pseudo-type `void`, the string is "void".
@Id(3)
String get name;
/// If the entity being referred to is generic, the number of type parameters
/// it declares (does not include type parameters of enclosing entities).
/// Otherwise zero.
@Id(4)
int get numTypeParameters;
/// Integer index indicating which unit in the imported library contains the
/// definition of the entity. As with indices into [LinkedLibrary.units],
/// zero represents the defining compilation unit, and nonzero values
/// represent parts in the order of the corresponding `part` declarations.
///
/// Zero if this entity is contained within another entity (e.g. a class
/// member).
@Id(0)
int get unit;
}
/// Linked summary of a compilation unit.
abstract class LinkedUnit extends base.SummaryClass {
/// List of slot ids (referring to [UnlinkedExecutable.constCycleSlot])
/// corresponding to const constructors that are part of cycles.
@Id(2)
List<int> get constCycles;
/// List of slot ids (referring to [UnlinkedClass.notSimplyBoundedSlot] or
/// [UnlinkedTypedef.notSimplyBoundedSlot]) corresponding to classes and
/// typedefs that are not simply bounded.
@Id(5)
List<int> get notSimplyBounded;
/// List of slot ids (referring to [UnlinkedParam.inheritsCovariantSlot] or
/// [UnlinkedVariable.inheritsCovariantSlot]) corresponding to parameters
/// that inherit `@covariant` behavior from a base class.
@Id(3)
List<int> get parametersInheritingCovariant;
/// Information about the resolution of references within the compilation
/// unit. Each element of [UnlinkedUnit.references] has a corresponding
/// element in this list (at the same index). If this list has additional
/// elements beyond the number of elements in [UnlinkedUnit.references], those
/// additional elements are references that are only referred to implicitly
/// (e.g. elements involved in inferred or propagated types).
@Id(0)
List<LinkedReference> get references;
/// The list of type inference errors.
@Id(4)
List<TopLevelInferenceError> get topLevelInferenceErrors;
/// List associating slot ids found inside the unlinked summary for the
/// compilation unit with propagated and inferred types.
@Id(1)
List<EntityRef> get types;
}
/// Summary information about a package.
@TopLevel('PBdl')
abstract class PackageBundle extends base.SummaryClass {
factory PackageBundle.fromBuffer(List<int> buffer) =>
generated.readPackageBundle(buffer);
/// MD5 hash of the non-informative fields of the [PackageBundle] (not
/// including this one). This can be used to identify when the API of a
/// package may have changed.
@Id(7)
@deprecated
String get apiSignature;
/// Information about the packages this package depends on, if known.
@Id(8)
@informative
@deprecated
List<PackageDependencyInfo> get dependencies;
/// Linked libraries.
@Id(0)
List<LinkedLibrary> get linkedLibraries;
/// The list of URIs of items in [linkedLibraries], e.g. `dart:core` or
/// `package:foo/bar.dart`.
@Id(1)
List<String> get linkedLibraryUris;
/// Major version of the summary format. See
/// [PackageBundleAssembler.currentMajorVersion].
@Id(5)
int get majorVersion;
/// Minor version of the summary format. See
/// [PackageBundleAssembler.currentMinorVersion].
@Id(6)
int get minorVersion;
/// List of MD5 hashes of the files listed in [unlinkedUnitUris]. Each hash
/// is encoded as a hexadecimal string using lower case letters.
@Id(4)
@deprecated
@informative
List<String> get unlinkedUnitHashes;
/// Unlinked information for the compilation units constituting the package.
@Id(2)
List<UnlinkedUnit> get unlinkedUnits;
/// The list of URIs of items in [unlinkedUnits], e.g. `dart:core/bool.dart`.
@Id(3)
List<String> get unlinkedUnitUris;
}
/// Information about a single dependency of a summary package.
@deprecated
abstract class PackageDependencyInfo extends base.SummaryClass {
/// API signature of this dependency.
@Id(0)
String get apiSignature;
/// If this dependency summarizes any files whose URI takes the form
/// "package:<package_name>/...", a list of all such package names, sorted
/// lexicographically. Otherwise empty.
@Id(2)
List<String> get includedPackageNames;
/// Indicates whether this dependency summarizes any files whose URI takes the
/// form "dart:...".
@Id(4)
bool get includesDartUris;
/// Indicates whether this dependency summarizes any files whose URI takes the
/// form "file:...".
@Id(3)
bool get includesFileUris;
/// Relative path to the summary file for this dependency. This is intended
/// as a hint to help the analysis server locate summaries of dependencies.
/// We don't specify precisely what this path is relative to, but we expect
/// it to be relative to a directory the analysis server can find (e.g. for
/// projects built using Bazel, it would be relative to the "bazel-bin"
/// directory).
///
/// Absent if the path is not known.
@Id(1)
String get summaryPath;
}
/// Index information about a package.
@TopLevel('Indx')
abstract class PackageIndex extends base.SummaryClass {
factory PackageIndex.fromBuffer(List<int> buffer) =>
generated.readPackageIndex(buffer);
/// Each item of this list corresponds to a unique referenced element. It is
/// the kind of the synthetic element.
@Id(5)
List<IndexSyntheticElementKind> get elementKinds;
/// Each item of this list corresponds to a unique referenced element. It is
/// the identifier of the class member element name, or `null` if the element
/// is a top-level element. The list is sorted in ascending order, so that
/// the client can quickly check whether an element is referenced in this
/// [PackageIndex].
@Id(7)
List<int> get elementNameClassMemberIds;
/// Each item of this list corresponds to a unique referenced element. It is
/// the identifier of the named parameter name, or `null` if the element is
/// not a named parameter. The list is sorted in ascending order, so that the
/// client can quickly check whether an element is referenced in this
/// [PackageIndex].
@Id(8)
List<int> get elementNameParameterIds;
/// Each item of this list corresponds to a unique referenced element. It is
/// the identifier of the top-level element name, or `null` if the element is
/// the unit. The list is sorted in ascending order, so that the client can
/// quickly check whether an element is referenced in this [PackageIndex].
@Id(1)
List<int> get elementNameUnitMemberIds;
/// Each item of this list corresponds to a unique referenced element. It is
/// the index into [unitLibraryUris] and [unitUnitUris] for the library
/// specific unit where the element is declared.
@Id(0)
List<int> get elementUnits;
/// List of unique element strings used in this [PackageIndex]. The list is
/// sorted in ascending order, so that the client can quickly check the
/// presence of a string in this [PackageIndex].
@Id(6)
List<String> get strings;
/// Each item of this list corresponds to the library URI of a unique library
/// specific unit referenced in the [PackageIndex]. It is an index into
/// [strings] list.
@Id(2)
List<int> get unitLibraryUris;
/// List of indexes of each unit in this [PackageIndex].
@Id(4)
List<UnitIndex> get units;
/// Each item of this list corresponds to the unit URI of a unique library
/// specific unit referenced in the [PackageIndex]. It is an index into
/// [strings] list.
@Id(3)
List<int> get unitUnitUris;
}
/// Enum used to indicate the kind of entity referred to by a
/// [LinkedReference].
enum ReferenceKind {
/// The entity is a class or enum.
classOrEnum,
/// The entity is a constructor.
constructor,
/// The entity is a getter or setter inside a class. Note: this is used in
/// the case where a constant refers to a static const declared inside a
/// class.
propertyAccessor,
/// The entity is a method.
method,
/// The entity is a typedef.
typedef,
/// The entity is a local function.
function,
/// The entity is a local variable.
variable,
/// The entity is a top level function.
topLevelFunction,
/// The entity is a top level getter or setter.
topLevelPropertyAccessor,
/// The entity is a prefix.
prefix,
/// The entity being referred to does not exist.
unresolved,
/// The entity is a typedef expressed using generic function type syntax.
genericFunctionTypedef
}
/// Summary information about a top-level type inference error.
abstract class TopLevelInferenceError extends base.SummaryClass {
/// The [kind] specific arguments.
@Id(2)
List<String> get arguments;
/// The kind of the error.
@Id(1)
TopLevelInferenceErrorKind get kind;
/// The slot id (which is unique within the compilation unit) identifying the
/// target of type inference with which this [TopLevelInferenceError] is
/// associated.
@Id(0)