// 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 '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 context messages associated with the error.
  @Id(5)
  List<DiagnosticMessage> get contextMessages;

  /// 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(2)
  List<String> get definedClassMemberNames;

  /// List of top-level names defined by the unit.
  @Id(1)
  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(3)
  List<String> get subtypedNames;

  /// Unlinked information for the unit.
  @Id(4)
  UnlinkedUnit2 get unit2;
}

/// Information about a single declaration.
abstract class AvailableDeclaration extends base.SummaryClass {
  @Id(0)
  List<AvailableDeclaration> get children;

  @Id(1)
  int get codeLength;

  @Id(2)
  int get codeOffset;

  @Id(3)
  String get defaultArgumentListString;

  @Id(4)
  List<int> get defaultArgumentListTextRanges;

  @Id(5)
  String get docComplete;

  @Id(6)
  String get docSummary;

  @Id(7)
  int get fieldMask;

  @Id(8)
  bool get isAbstract;

  @Id(9)
  bool get isConst;

  @Id(10)
  bool get isDeprecated;

  @Id(11)
  bool get isFinal;

  @Id(12)
  bool get isStatic;

  /// The kind of the declaration.
  @Id(13)
  AvailableDeclarationKind get kind;

  @Id(14)
  int get locationOffset;

  @Id(15)
  int get locationStartColumn;

  @Id(16)
  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(17)
  String get name;

  @Id(18)
  List<String> get parameterNames;

  @Id(19)
  String get parameters;

  @Id(20)
  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(21)
  List<String> get relevanceTags;

  @Id(22)
  int get requiredParameterCount;

  @Id(23)
  String get returnType;

  @Id(24)
  String get typeParameters;
}

/// Enum of declaration kinds in available files.
enum AvailableDeclarationKind {
  CLASS,
  CLASS_TYPE_ALIAS,
  CONSTRUCTOR,
  ENUM,
  ENUM_CONSTANT,
  EXTENSION,
  FIELD,
  FUNCTION,
  FUNCTION_TYPE_ALIAS,
  GETTER,
  METHOD,
  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(1)
  DirectiveInfo get directiveInfo;

  /// Exports directives of the file.
  @Id(2)
  List<AvailableFileExport> get exports;

  /// Is `true` if this file is a library.
  @Id(3)
  bool get isLibrary;

  /// Is `true` if this file is a library, and it is deprecated.
  @Id(4)
  bool get isLibraryDeprecated;

  /// Offsets of the first character of each line in the source code.
  @informative
  @Id(5)
  List<int> get lineStarts;

  /// URIs of `part` directives.
  @Id(6)
  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 linked libraries, a group of libraries that form
/// a library cycle.
@TopLevel('CLNB')
abstract class CiderLinkedLibraryCycle extends base.SummaryClass {
  factory CiderLinkedLibraryCycle.fromBuffer(List<int> buffer) =>
      generated.readCiderLinkedLibraryCycle(buffer);

  @Id(1)
  LinkedNodeBundle get bundle;

  /// The hash signature for this linked cycle. It depends of API signatures
  /// of all files in the cycle, and on the signatures of the transitive
  /// closure of the cycle dependencies.
  @Id(0)
  List<int> get signature;
}

/// Errors for a single unit.
@TopLevel('CUEr')
abstract class CiderUnitErrors extends base.SummaryClass {
  factory CiderUnitErrors.fromBuffer(List<int> buffer) =>
      generated.readCiderUnitErrors(buffer);

  @Id(1)
  List<AnalysisDriverUnitError> get errors;

  /// The hash signature of this data.
  @Id(0)
  List<int> get signature;
}

/// Information about a compilation unit, contains the content hash
/// and unlinked summary.
@TopLevel('CUUN')
abstract class CiderUnlinkedUnit extends base.SummaryClass {
  factory CiderUnlinkedUnit.fromBuffer(List<int> buffer) =>
      generated.readCiderUnlinkedUnit(buffer);

  /// The hash signature of the contents of the file.
  @Id(0)
  List<int> get contentDigest;

  /// Unlinked summary of the compilation unit.
  @Id(1)
  UnlinkedUnit2 get unlinkedUnit;
}

abstract class DiagnosticMessage extends base.SummaryClass {
  /// The absolute and normalized path of the file associated with this message.
  @Id(0)
  String get filePath;

  /// The length of the source range associated with this message.
  @Id(1)
  int get length;

  /// The text of the message.
  @Id(2)
  String get message;

  /// The zero-based offset from the start of the file to the beginning of the
  /// source range associated with this message.
  @Id(3)
  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;
}

/// 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 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
}

abstract class LinkedLanguageVersion extends base.SummaryClass {
  @Id(0)
  int get major;

  @Id(1)
  int get minor;
}

abstract class LinkedLibraryLanguageVersion extends base.SummaryClass {
  @Id(1)
  LinkedLanguageVersion get override2;

  @Id(0)
  LinkedLanguageVersion get package;
}

/// 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(4, variantList: [
    LinkedNodeKind.classDeclaration,
    LinkedNodeKind.classTypeAlias,
    LinkedNodeKind.constructorDeclaration,
    LinkedNodeKind.declaredIdentifier,
    LinkedNodeKind.enumDeclaration,
    LinkedNodeKind.enumConstantDeclaration,
    LinkedNodeKind.exportDirective,
    LinkedNodeKind.extensionDeclaration,
    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(7, variant: LinkedNodeKind.annotation)
  LinkedNode get annotation_constructorName;

  @VariantId(17, variant: LinkedNodeKind.annotation)
  int get annotation_element;

  @VariantId(8, variant: LinkedNodeKind.annotation)
  LinkedNode get annotation_name;

  @VariantId(38, variant: LinkedNodeKind.annotation)
  LinkedNodeTypeSubstitution get annotation_substitution;

  @VariantId(2, variant: LinkedNodeKind.argumentList)
  List<LinkedNode> get argumentList_arguments;

  @VariantId(6, variant: LinkedNodeKind.asExpression)
  LinkedNode get asExpression_expression;

  @VariantId(7, variant: LinkedNodeKind.asExpression)
  LinkedNode get asExpression_type;

  @VariantId(6, variant: LinkedNodeKind.assertInitializer)
  LinkedNode get assertInitializer_condition;

  @VariantId(7, variant: LinkedNodeKind.assertInitializer)
  LinkedNode get assertInitializer_message;

  @VariantId(6, variant: LinkedNodeKind.assertStatement)
  LinkedNode get assertStatement_condition;

  @VariantId(7, variant: LinkedNodeKind.assertStatement)
  LinkedNode get assertStatement_message;

  @VariantId(15, variant: LinkedNodeKind.assignmentExpression)
  int get assignmentExpression_element;

  @VariantId(6, variant: LinkedNodeKind.assignmentExpression)
  LinkedNode get assignmentExpression_leftHandSide;

  @VariantId(28, variant: LinkedNodeKind.assignmentExpression)
  UnlinkedTokenType get assignmentExpression_operator;

  @VariantId(7, variant: LinkedNodeKind.assignmentExpression)
  LinkedNode get assignmentExpression_rightHandSide;

  @VariantId(38, variant: LinkedNodeKind.assignmentExpression)
  LinkedNodeTypeSubstitution get assignmentExpression_substitution;

  @VariantId(6, variant: LinkedNodeKind.awaitExpression)
  LinkedNode get awaitExpression_expression;

  @VariantId(15, variant: LinkedNodeKind.binaryExpression)
  int get binaryExpression_element;

  @VariantId(24, variant: LinkedNodeKind.binaryExpression)
  LinkedNodeType get binaryExpression_invokeType;

  @VariantId(6, variant: LinkedNodeKind.binaryExpression)
  LinkedNode get binaryExpression_leftOperand;

  @VariantId(28, variant: LinkedNodeKind.binaryExpression)
  UnlinkedTokenType get binaryExpression_operator;

  @VariantId(7, variant: LinkedNodeKind.binaryExpression)
  LinkedNode get binaryExpression_rightOperand;

  @VariantId(38, variant: LinkedNodeKind.binaryExpression)
  LinkedNodeTypeSubstitution get binaryExpression_substitution;

  @VariantId(2, variant: LinkedNodeKind.block)
  List<LinkedNode> get block_statements;

  @VariantId(6, variant: LinkedNodeKind.blockFunctionBody)
  LinkedNode get blockFunctionBody_block;

  @VariantId(27, variant: LinkedNodeKind.booleanLiteral)
  bool get booleanLiteral_value;

  @VariantId(6, variant: LinkedNodeKind.breakStatement)
  LinkedNode get breakStatement_label;

  @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(7, variant: LinkedNodeKind.catchClause)
  LinkedNode get catchClause_exceptionParameter;

  @VariantId(8, variant: LinkedNodeKind.catchClause)
  LinkedNode get catchClause_exceptionType;

  @VariantId(9, variant: LinkedNodeKind.catchClause)
  LinkedNode get catchClause_stackTraceParameter;

  @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(5, variantList: [
    LinkedNodeKind.classDeclaration,
    LinkedNodeKind.mixinDeclaration,
  ])
  List<LinkedNode> get classOrMixinDeclaration_members;

  @VariantId(13, variantList: [
    LinkedNodeKind.classDeclaration,
    LinkedNodeKind.mixinDeclaration,
  ])
  LinkedNode get classOrMixinDeclaration_typeParameters;

  @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(2, variant: LinkedNodeKind.comment)
  List<LinkedNode> get comment_references;

  @VariantId(33, variant: LinkedNodeKind.comment)
  List<String> get comment_tokens;

  @VariantId(29, variant: LinkedNodeKind.comment)
  LinkedNodeCommentType get comment_type;

  @VariantId(6, variant: LinkedNodeKind.commentReference)
  LinkedNode get commentReference_identifier;

  @VariantId(2, variant: LinkedNodeKind.compilationUnit)
  List<LinkedNode> get compilationUnit_declarations;

  @VariantId(3, variant: LinkedNodeKind.compilationUnit)
  List<LinkedNode> get compilationUnit_directives;

  @VariantId(41, variant: LinkedNodeKind.compilationUnit)
  List<int> get compilationUnit_featureSet;

  /// The language version information.
  @VariantId(40, variant: LinkedNodeKind.compilationUnit)
  LinkedLibraryLanguageVersion get compilationUnit_languageVersion;

  @VariantId(6, variant: LinkedNodeKind.compilationUnit)
  LinkedNode get compilationUnit_scriptTag;

  @VariantId(6, variant: LinkedNodeKind.conditionalExpression)
  LinkedNode get conditionalExpression_condition;

  @VariantId(7, variant: LinkedNodeKind.conditionalExpression)
  LinkedNode get conditionalExpression_elseExpression;

  @VariantId(8, variant: LinkedNodeKind.conditionalExpression)
  LinkedNode get conditionalExpression_thenExpression;

  @VariantId(6, variant: LinkedNodeKind.configuration)
  LinkedNode get configuration_name;

  @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(2, variant: LinkedNodeKind.constructorDeclaration)
  List<LinkedNode> get constructorDeclaration_initializers;

  @VariantId(8, variant: LinkedNodeKind.constructorDeclaration)
  LinkedNode get constructorDeclaration_parameters;

  @VariantId(9, variant: LinkedNodeKind.constructorDeclaration)
  LinkedNode get constructorDeclaration_redirectedConstructor;

  @VariantId(10, variant: LinkedNodeKind.constructorDeclaration)
  LinkedNode get constructorDeclaration_returnType;

  @VariantId(6, variant: LinkedNodeKind.constructorFieldInitializer)
  LinkedNode get constructorFieldInitializer_expression;

  @VariantId(7, variant: LinkedNodeKind.constructorFieldInitializer)
  LinkedNode get constructorFieldInitializer_fieldName;

  @VariantId(15, variant: LinkedNodeKind.constructorName)
  int get constructorName_element;

  @VariantId(6, variant: LinkedNodeKind.constructorName)
  LinkedNode get constructorName_name;

  @VariantId(38, variant: LinkedNodeKind.constructorName)
  LinkedNodeTypeSubstitution get constructorName_substitution;

  @VariantId(7, variant: LinkedNodeKind.constructorName)
  LinkedNode get constructorName_type;

  @VariantId(6, variant: LinkedNodeKind.continueStatement)
  LinkedNode get continueStatement_label;

  @VariantId(6, variant: LinkedNodeKind.declaredIdentifier)
  LinkedNode get declaredIdentifier_identifier;

  @VariantId(7, variant: LinkedNodeKind.declaredIdentifier)
  LinkedNode get declaredIdentifier_type;

  @VariantId(6, variant: LinkedNodeKind.defaultFormalParameter)
  LinkedNode get defaultFormalParameter_defaultValue;

  @VariantId(26, variant: LinkedNodeKind.defaultFormalParameter)
  LinkedNodeFormalParameterKind get defaultFormalParameter_kind;

  @VariantId(7, variant: LinkedNodeKind.defaultFormalParameter)
  LinkedNode get defaultFormalParameter_parameter;

  @VariantId(6, variant: LinkedNodeKind.doStatement)
  LinkedNode get doStatement_body;

  @VariantId(7, variant: LinkedNodeKind.doStatement)
  LinkedNode get doStatement_condition;

  @VariantId(2, variant: LinkedNodeKind.dottedName)
  List<LinkedNode> get dottedName_components;

  @VariantId(21, variant: LinkedNodeKind.doubleLiteral)
  double get doubleLiteral_value;

  @VariantId(15, variant: LinkedNodeKind.emptyFunctionBody)
  int get emptyFunctionBody_fake;

  @VariantId(15, variant: LinkedNodeKind.emptyStatement)
  int get emptyStatement_fake;

  @VariantId(2, variant: LinkedNodeKind.enumDeclaration)
  List<LinkedNode> get enumDeclaration_constants;

  @VariantId(25, variantList: [
    LinkedNodeKind.assignmentExpression,
    LinkedNodeKind.asExpression,
    LinkedNodeKind.awaitExpression,
    LinkedNodeKind.binaryExpression,
    LinkedNodeKind.cascadeExpression,
    LinkedNodeKind.conditionalExpression,
    LinkedNodeKind.functionExpressionInvocation,
    LinkedNodeKind.indexExpression,
    LinkedNodeKind.instanceCreationExpression,
    LinkedNodeKind.integerLiteral,
    LinkedNodeKind.listLiteral,
    LinkedNodeKind.methodInvocation,
    LinkedNodeKind.nullLiteral,
    LinkedNodeKind.parenthesizedExpression,
    LinkedNodeKind.prefixExpression,
    LinkedNodeKind.prefixedIdentifier,
    LinkedNodeKind.propertyAccess,
    LinkedNodeKind.postfixExpression,
    LinkedNodeKind.rethrowExpression,
    LinkedNodeKind.setOrMapLiteral,
    LinkedNodeKind.simpleIdentifier,
    LinkedNodeKind.superExpression,
    LinkedNodeKind.symbolLiteral,
    LinkedNodeKind.thisExpression,
    LinkedNodeKind.throwExpression,
  ])
  LinkedNodeType get expression_type;

  @VariantId(6, variant: LinkedNodeKind.expressionFunctionBody)
  LinkedNode get expressionFunctionBody_expression;

  @VariantId(6, variant: LinkedNodeKind.expressionStatement)
  LinkedNode get expressionStatement_expression;

  @VariantId(6, variant: LinkedNodeKind.extendsClause)
  LinkedNode get extendsClause_superclass;

  @VariantId(7, variant: LinkedNodeKind.extensionDeclaration)
  LinkedNode get extensionDeclaration_extendedType;

  @VariantId(5, variant: LinkedNodeKind.extensionDeclaration)
  List<LinkedNode> get extensionDeclaration_members;

  @VariantId(20, variant: LinkedNodeKind.extensionDeclaration)
  String get extensionDeclaration_refName;

  @VariantId(6, variant: LinkedNodeKind.extensionDeclaration)
  LinkedNode get extensionDeclaration_typeParameters;

  @VariantId(2, variant: LinkedNodeKind.extensionOverride)
  List<LinkedNode> get extensionOverride_arguments;

  @VariantId(24, variant: LinkedNodeKind.extensionOverride)
  LinkedNodeType get extensionOverride_extendedType;

  @VariantId(7, variant: LinkedNodeKind.extensionOverride)
  LinkedNode get extensionOverride_extensionName;

  @VariantId(8, variant: LinkedNodeKind.extensionOverride)
  LinkedNode get extensionOverride_typeArguments;

  @VariantId(39, variant: LinkedNodeKind.extensionOverride)
  List<LinkedNodeType> get extensionOverride_typeArgumentTypes;

  @VariantId(6, variant: LinkedNodeKind.fieldDeclaration)
  LinkedNode get fieldDeclaration_fields;

  @VariantId(8, variant: LinkedNodeKind.fieldFormalParameter)
  LinkedNode get fieldFormalParameter_formalParameters;

  @VariantId(6, variant: LinkedNodeKind.fieldFormalParameter)
  LinkedNode get fieldFormalParameter_type;

  @VariantId(7, variant: LinkedNodeKind.fieldFormalParameter)
  LinkedNode get fieldFormalParameter_typeParameters;

  @Id(18)
  int get flags;

  @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(2, variant: LinkedNodeKind.formalParameterList)
  List<LinkedNode> get formalParameterList_parameters;

  @VariantId(6, variantList: [
    LinkedNodeKind.forElement,
    LinkedNodeKind.forStatement,
  ])
  LinkedNode get forMixin_forLoopParts;

  @VariantId(6, variantList: [
    LinkedNodeKind.forPartsWithDeclarations,
    LinkedNodeKind.forPartsWithExpression,
  ])
  LinkedNode get forParts_condition;

  @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(6, variant: LinkedNodeKind.functionDeclaration)
  LinkedNode get functionDeclaration_functionExpression;

  @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(17, variant: LinkedNodeKind.genericFunctionType)
  int get genericFunctionType_id;

  @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(7, variant: LinkedNodeKind.genericTypeAlias)
  LinkedNode get genericTypeAlias_functionType;

  @VariantId(6, variant: LinkedNodeKind.genericTypeAlias)
  LinkedNode get genericTypeAlias_typeParameters;

  @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(7, variant: LinkedNodeKind.ifStatement)
  LinkedNode get ifStatement_elseStatement;

  @VariantId(8, variant: LinkedNodeKind.ifStatement)
  LinkedNode get ifStatement_thenStatement;

  @VariantId(2, variant: LinkedNodeKind.implementsClause)
  List<LinkedNode> get implementsClause_interfaces;

  @VariantId(1, variant: LinkedNodeKind.importDirective)
  String get importDirective_prefix;

  @VariantId(15, variant: LinkedNodeKind.indexExpression)
  int get indexExpression_element;

  @VariantId(6, variant: LinkedNodeKind.indexExpression)
  LinkedNode get indexExpression_index;

  @VariantId(38, variant: LinkedNodeKind.indexExpression)
  LinkedNodeTypeSubstitution get indexExpression_substitution;

  @VariantId(7, variant: LinkedNodeKind.indexExpression)
  LinkedNode get indexExpression_target;

  @VariantId(36, variantList: [
    LinkedNodeKind.classDeclaration,
    LinkedNodeKind.classTypeAlias,
    LinkedNodeKind.compilationUnit,
    LinkedNodeKind.compilationUnit,
    LinkedNodeKind.constructorDeclaration,
    LinkedNodeKind.defaultFormalParameter,
    LinkedNodeKind.enumConstantDeclaration,
    LinkedNodeKind.enumDeclaration,
    LinkedNodeKind.exportDirective,
    LinkedNodeKind.extensionDeclaration,
    LinkedNodeKind.fieldDeclaration,
    LinkedNodeKind.fieldFormalParameter,
    LinkedNodeKind.functionDeclaration,
    LinkedNodeKind.functionTypedFormalParameter,
    LinkedNodeKind.functionTypeAlias,
    LinkedNodeKind.genericTypeAlias,
    LinkedNodeKind.hideCombinator,
    LinkedNodeKind.importDirective,
    LinkedNodeKind.libraryDirective,
    LinkedNodeKind.methodDeclaration,
    LinkedNodeKind.mixinDeclaration,
    LinkedNodeKind.partDirective,
    LinkedNodeKind.partOfDirective,
    LinkedNodeKind.showCombinator,
    LinkedNodeKind.simpleFormalParameter,
    LinkedNodeKind.topLevelVariableDeclaration,
    LinkedNodeKind.typeParameter,
    LinkedNodeKind.variableDeclaration,
    LinkedNodeKind.variableDeclarationList,
  ])
  @informative
  int get informativeId;

  @VariantId(27, variantList: [
    LinkedNodeKind.fieldFormalParameter,
    LinkedNodeKind.functionTypedFormalParameter,
    LinkedNodeKind.simpleFormalParameter,
    LinkedNodeKind.variableDeclaration,
  ])
  bool get inheritsCovariant;

  @VariantId(2, variant: LinkedNodeKind.instanceCreationExpression)
  List<LinkedNode> get instanceCreationExpression_arguments;

  @VariantId(7, variant: LinkedNodeKind.instanceCreationExpression)
  LinkedNode get instanceCreationExpression_constructorName;

  @VariantId(8, variant: LinkedNodeKind.instanceCreationExpression)
  LinkedNode get instanceCreationExpression_typeArguments;

  @VariantId(16, variant: LinkedNodeKind.integerLiteral)
  int get integerLiteral_value;

  @VariantId(6, variant: LinkedNodeKind.interpolationExpression)
  LinkedNode get interpolationExpression_expression;

  @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(7, variant: LinkedNodeKind.isExpression)
  LinkedNode get isExpression_type;

  @Id(0)
  LinkedNodeKind get kind;

  @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(3, variant: LinkedNodeKind.listLiteral)
  List<LinkedNode> get listLiteral_elements;

  @VariantId(6, variant: LinkedNodeKind.mapLiteralEntry)
  LinkedNode get mapLiteralEntry_key;

  @VariantId(7, variant: LinkedNodeKind.mapLiteralEntry)
  LinkedNode get mapLiteralEntry_value;

  @VariantId(6, variant: LinkedNodeKind.methodDeclaration)
  LinkedNode get methodDeclaration_body;

  @VariantId(7, variant: LinkedNodeKind.methodDeclaration)
  LinkedNode get methodDeclaration_formalParameters;

  @VariantId(31, variant: LinkedNodeKind.methodDeclaration)
  bool get methodDeclaration_hasOperatorEqualWithParameterTypeFromObject;

  @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(7, variant: LinkedNodeKind.methodInvocation)
  LinkedNode get methodInvocation_target;

  @VariantId(6, variant: LinkedNodeKind.mixinDeclaration)
  LinkedNode get mixinDeclaration_onClause;

  @VariantId(34, variant: LinkedNodeKind.mixinDeclaration)
  List<String> get mixinDeclaration_superInvokedNames;

  @Id(37)
  String get name;

  @VariantId(6, variant: LinkedNodeKind.namedExpression)
  LinkedNode get namedExpression_expression;

  @VariantId(7, variant: LinkedNodeKind.namedExpression)
  LinkedNode get namedExpression_name;

  @VariantId(34, variantList: [
    LinkedNodeKind.hideCombinator,
    LinkedNodeKind.showCombinator,
    LinkedNodeKind.symbolLiteral,
  ])
  List<String> get names;

  @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(6, variant: LinkedNodeKind.nativeFunctionBody)
  LinkedNode get nativeFunctionBody_stringLiteral;

  @VariantId(4, variantList: [
    LinkedNodeKind.fieldFormalParameter,
    LinkedNodeKind.functionTypedFormalParameter,
    LinkedNodeKind.simpleFormalParameter,
  ])
  List<LinkedNode> get normalFormalParameter_metadata;

  @VariantId(15, variant: LinkedNodeKind.nullLiteral)
  int get nullLiteral_fake;

  @VariantId(2, variant: LinkedNodeKind.onClause)
  List<LinkedNode> get onClause_superclassConstraints;

  @VariantId(6, variant: LinkedNodeKind.parenthesizedExpression)
  LinkedNode get parenthesizedExpression_expression;

  @VariantId(6, variant: LinkedNodeKind.partOfDirective)
  LinkedNode get partOfDirective_libraryName;

  @VariantId(7, variant: LinkedNodeKind.partOfDirective)
  LinkedNode get partOfDirective_uri;

  @VariantId(15, variant: LinkedNodeKind.postfixExpression)
  int get postfixExpression_element;

  @VariantId(6, variant: LinkedNodeKind.postfixExpression)
  LinkedNode get postfixExpression_operand;

  @VariantId(28, variant: LinkedNodeKind.postfixExpression)
  UnlinkedTokenType get postfixExpression_operator;

  @VariantId(38, variant: LinkedNodeKind.postfixExpression)
  LinkedNodeTypeSubstitution get postfixExpression_substitution;

  @VariantId(6, variant: LinkedNodeKind.prefixedIdentifier)
  LinkedNode get prefixedIdentifier_identifier;

  @VariantId(7, variant: LinkedNodeKind.prefixedIdentifier)
  LinkedNode get prefixedIdentifier_prefix;

  @VariantId(15, variant: LinkedNodeKind.prefixExpression)
  int get prefixExpression_element;

  @VariantId(6, variant: LinkedNodeKind.prefixExpression)
  LinkedNode get prefixExpression_operand;

  @VariantId(28, variant: LinkedNodeKind.prefixExpression)
  UnlinkedTokenType get prefixExpression_operator;

  @VariantId(38, variant: LinkedNodeKind.prefixExpression)
  LinkedNodeTypeSubstitution get prefixExpression_substitution;

  @VariantId(28, variant: LinkedNodeKind.propertyAccess)
  UnlinkedTokenType 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(38, variant: LinkedNodeKind.redirectingConstructorInvocation)
  LinkedNodeTypeSubstitution get redirectingConstructorInvocation_substitution;

  @VariantId(6, variant: LinkedNodeKind.returnStatement)
  LinkedNode get returnStatement_expression;

  @VariantId(3, variant: LinkedNodeKind.setOrMapLiteral)
  List<LinkedNode> get setOrMapLiteral_elements;

  @VariantId(6, variant: LinkedNodeKind.simpleFormalParameter)
  LinkedNode get simpleFormalParameter_type;

  @VariantId(15, variant: LinkedNodeKind.simpleIdentifier)
  int get simpleIdentifier_element;

  @VariantId(38, variant: LinkedNodeKind.simpleIdentifier)
  LinkedNodeTypeSubstitution get simpleIdentifier_substitution;

  @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(35, variant: LinkedNodeKind.spreadElement)
  UnlinkedTokenType 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(38, variant: LinkedNodeKind.superConstructorInvocation)
  LinkedNodeTypeSubstitution get superConstructorInvocation_substitution;

  @VariantId(6, variant: LinkedNodeKind.switchCase)
  LinkedNode get switchCase_expression;

  @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(2, variant: LinkedNodeKind.switchStatement)
  List<LinkedNode> get switchStatement_members;

  @VariantId(6, variant: LinkedNodeKind.throwExpression)
  LinkedNode get throwExpression_expression;

  @VariantId(32, variantList: [
    LinkedNodeKind.methodDeclaration,
    LinkedNodeKind.simpleFormalParameter,
    LinkedNodeKind.variableDeclaration,
  ])
  TopLevelInferenceError get topLevelTypeInferenceError;

  @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(27, variantList: [
    LinkedNodeKind.functionTypeAlias,
    LinkedNodeKind.genericTypeAlias,
  ])
  bool get typeAlias_hasSelfReference;

  @VariantId(2, variant: LinkedNodeKind.typeArgumentList)
  List<LinkedNode> get typeArgumentList_arguments;

  @VariantId(2, variantList: [
    LinkedNodeKind.listLiteral,
    LinkedNodeKind.setOrMapLiteral,
  ])
  List<LinkedNode> get typedLiteral_typeArguments;

  @VariantId(6, variant: LinkedNodeKind.typeName)
  LinkedNode get typeName_name;

  @VariantId(23, variant: LinkedNodeKind.typeName)
  LinkedNodeType get typeName_type;

  @VariantId(2, variant: LinkedNodeKind.typeName)
  List<LinkedNode> get typeName_typeArguments;

  @VariantId(6, variant: LinkedNodeKind.typeParameter)
  LinkedNode get typeParameter_bound;

  @VariantId(23, variant: LinkedNodeKind.typeParameter)
  LinkedNodeType get typeParameter_defaultType;

  @VariantId(15, variant: LinkedNodeKind.typeParameter)
  int get typeParameter_variance;

  @VariantId(2, variant: LinkedNodeKind.typeParameterList)
  List<LinkedNode> get typeParameterList_typeParameters;

  @VariantId(11, variantList: [
    LinkedNodeKind.classDeclaration,
  ])
  LinkedNode get unused11;

  @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(6, variant: LinkedNodeKind.variableDeclaration)
  LinkedNode get variableDeclaration_initializer;

  @VariantId(6, variant: LinkedNodeKind.variableDeclarationList)
  LinkedNode get variableDeclarationList_type;

  @VariantId(2, variant: LinkedNodeKind.variableDeclarationList)
  List<LinkedNode> get variableDeclarationList_variables;

  @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(2, variant: LinkedNodeKind.withClause)
  List<LinkedNode> get withClause_mixinTypes;

  @VariantId(6, variant: LinkedNodeKind.yieldStatement)
  LinkedNode get yieldStatement_expression;
}

/// 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,
  commentReference,
  compilationUnit,
  conditionalExpression,
  configuration,
  constructorDeclaration,
  constructorFieldInitializer,
  constructorName,
  continueStatement,
  declaredIdentifier,
  defaultFormalParameter,
  doubleLiteral,
  doStatement,
  dottedName,
  emptyFunctionBody,
  emptyStatement,
  enumConstantDeclaration,
  enumDeclaration,
  exportDirective,
  expressionFunctionBody,
  expressionStatement,
  extendsClause,
  extensionDeclaration,
  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,
  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,
  extensionOverride,
}

/// 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;

  /// The typedef this function type is created for.
  @Id(9)
  int get functionTypedef;

  @Id(10)
  List<LinkedNodeType> get functionTypedefTypeArguments;

  @Id(2)
  List<LinkedNodeTypeTypeParameter> get functionTypeParameters;

  /// Reference to a [LinkedNodeReferences].
  @Id(3)
  int get interfaceClass;

  @Id(4)
  List<LinkedNodeType> get interfaceTypeArguments;

  @Id(5)
  LinkedNodeTypeKind get kind;

  @Id(8)
  EntityRefNullabilitySuffix get nullabilitySuffix;

  @Id(6)
  int get typeParameterElement;

  @Id(7)
  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 {
  dynamic_,
  function,
  interface,
  never,
  typeParameter,
  void_
}

/// Information about a type substitution.
abstract class LinkedNodeTypeSubstitution extends base.SummaryClass {
  @Id(2)
  bool get isLegacy;

  @Id(1)
  List<LinkedNodeType> get typeArguments;

  @Id(0)
  List<int> get typeParameters;
}

/// 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)
  bool get isSynthetic;

  @Id(1)
  LinkedNode get node;

  /// If the unit is a part, the URI specified in the `part` directive.
  /// Otherwise empty.
  @Id(3)
  String get partUriStr;

  /// The absolute URI.
  @Id(0)
  String get uriStr;
}

/// Summary information about a package.
@TopLevel('PBdl')
abstract class PackageBundle extends base.SummaryClass {
  factory PackageBundle.fromBuffer(List<int> buffer) =>
      generated.readPackageBundle(buffer);

  /// The version 2 of the summary.
  @Id(0)
  LinkedNodeBundle get bundle2;

  /// The SDK specific data, if this bundle is for SDK.
  @Id(1)
  PackageBundleSdk get sdk;
}

/// Summary information about a package.
abstract class PackageBundleSdk extends base.SummaryClass {
  /// The content of the `allowed_experiments.json` from SDK.
  @Id(0)
  String get allowedExperimentsJson;

  /// The language version of the SDK.
  @Id(1)
  LinkedLanguageVersion get languageVersion;
}

/// Summary information about a top-level type inference error.
abstract class TopLevelInferenceError extends base.SummaryClass {
  /// The [kind] specific arguments.
  @Id(1)
  List<String> get arguments;

  /// The kind of the error.
  @Id(0)
  TopLevelInferenceErrorKind get kind;
}

/// Enum used to indicate the kind of the error during top-level inference.
enum TopLevelInferenceErrorKind {
  assignment,
  instanceGetter,
  dependencyCycle,
  overrideConflictFieldType,
  overrideNoCombinedSuperSignature,
}

@Variant('kind')
abstract class UnlinkedInformativeData extends base.SummaryClass {
  @VariantId(2, variantList: [
    LinkedNodeKind.classDeclaration,
    LinkedNodeKind.classTypeAlias,
    LinkedNodeKind.compilationUnit,
    LinkedNodeKind.constructorDeclaration,
    LinkedNodeKind.defaultFormalParameter,
    LinkedNodeKind.enumConstantDeclaration,
    LinkedNodeKind.enumDeclaration,
    LinkedNodeKind.extensionDeclaration,
    LinkedNodeKind.fieldFormalParameter,
    LinkedNodeKind.functionDeclaration,
    LinkedNodeKind.functionTypeAlias,
    LinkedNodeKind.functionTypedFormalParameter,
    LinkedNodeKind.genericTypeAlias,
    LinkedNodeKind.methodDeclaration,
    LinkedNodeKind.mixinDeclaration,
    LinkedNodeKind.simpleFormalParameter,
    LinkedNodeKind.typeParameter,
    LinkedNodeKind.variableDeclaration,
  ])
  int get codeLength;

  @VariantId(3, variantList: [
    LinkedNodeKind.classDeclaration,
    LinkedNodeKind.classTypeAlias,
    LinkedNodeKind.compilationUnit,
    LinkedNodeKind.constructorDeclaration,
    LinkedNodeKind.defaultFormalParameter,
    LinkedNodeKind.enumConstantDeclaration,
    LinkedNodeKind.enumDeclaration,
    LinkedNodeKind.extensionDeclaration,
    LinkedNodeKind.fieldFormalParameter,
    LinkedNodeKind.functionDeclaration,
    LinkedNodeKind.functionTypeAlias,
    LinkedNodeKind.functionTypedFormalParameter,
    LinkedNodeKind.genericTypeAlias,
    LinkedNodeKind.methodDeclaration,
    LinkedNodeKind.mixinDeclaration,
    LinkedNodeKind.simpleFormalParameter,
    LinkedNodeKind.typeParameter,
    LinkedNodeKind.variableDeclaration,
  ])
  int get codeOffset;

  @VariantId(9, variantList: [
    LinkedNodeKind.hideCombinator,
    LinkedNodeKind.showCombinator,
  ])
  int get combinatorEnd;

  @VariantId(8, variantList: [
    LinkedNodeKind.hideCombinator,
    LinkedNodeKind.showCombinator,
  ])
  int get combinatorKeywordOffset;

  /// Offsets of the first character of each line in the source code.
  @VariantId(7, variant: LinkedNodeKind.compilationUnit)
  List<int> get compilationUnit_lineStarts;

  @VariantId(6, variant: LinkedNodeKind.constructorDeclaration)
  int get constructorDeclaration_periodOffset;

  @VariantId(5, variant: LinkedNodeKind.constructorDeclaration)
  int get constructorDeclaration_returnTypeOffset;

  /// If the parameter has a default value, the source text of the constant
  /// expression in the default value.  Otherwise the empty string.
  @VariantId(10, variant: LinkedNodeKind.defaultFormalParameter)
  String get defaultFormalParameter_defaultValueCode;

  @VariantId(1, variantList: [
    LinkedNodeKind.exportDirective,
    LinkedNodeKind.importDirective,
    LinkedNodeKind.libraryDirective,
    LinkedNodeKind.partDirective,
    LinkedNodeKind.partOfDirective,
  ])
  int get directiveKeywordOffset;

  @VariantId(4, variantList: [
    LinkedNodeKind.classDeclaration,
    LinkedNodeKind.classTypeAlias,
    LinkedNodeKind.constructorDeclaration,
    LinkedNodeKind.enumDeclaration,
    LinkedNodeKind.enumConstantDeclaration,
    LinkedNodeKind.extensionDeclaration,
    LinkedNodeKind.fieldDeclaration,
    LinkedNodeKind.functionDeclaration,
    LinkedNodeKind.functionTypeAlias,
    LinkedNodeKind.genericTypeAlias,
    LinkedNodeKind.libraryDirective,
    LinkedNodeKind.methodDeclaration,
    LinkedNodeKind.mixinDeclaration,
    LinkedNodeKind.topLevelVariableDeclaration,
  ])
  List<String> get documentationComment_tokens;

  @VariantId(8, variant: LinkedNodeKind.importDirective)
  int get importDirective_prefixOffset;

  /// The kind of the node.
  @Id(0)
  LinkedNodeKind get kind;

  @VariantId(1, variantList: [
    LinkedNodeKind.classDeclaration,
    LinkedNodeKind.classTypeAlias,
    LinkedNodeKind.constructorDeclaration,
    LinkedNodeKind.enumConstantDeclaration,
    LinkedNodeKind.enumDeclaration,
    LinkedNodeKind.extensionDeclaration,
    LinkedNodeKind.fieldFormalParameter,
    LinkedNodeKind.functionDeclaration,
    LinkedNodeKind.functionTypedFormalParameter,
    LinkedNodeKind.functionTypeAlias,
    LinkedNodeKind.genericTypeAlias,
    LinkedNodeKind.methodDeclaration,
    LinkedNodeKind.mixinDeclaration,
    LinkedNodeKind.simpleFormalParameter,
    LinkedNodeKind.typeParameter,
    LinkedNodeKind.variableDeclaration,
  ])
  int get nameOffset;
}

/// Unlinked summary information about a namespace directive.
abstract class UnlinkedNamespaceDirective extends base.SummaryClass {
  /// The configurations that control which library will actually be used.
  @Id(0)
  List<UnlinkedNamespaceDirectiveConfiguration> get configurations;

  /// The URI referenced by this directive, nad used by default when none
  /// of the [configurations] matches.
  @Id(1)
  String get uri;
}

/// Unlinked summary information about a namespace directive configuration.
abstract class UnlinkedNamespaceDirectiveConfiguration
    extends base.SummaryClass {
  /// The name of the declared variable used in the condition.
  @Id(0)
  String get name;

  /// The URI to be used if the condition is true.
  @Id(2)
  String get uri;

  /// The value to which the value of the declared variable will be compared,
  /// or the empty string if the condition does not include an equality test.
  @Id(1)
  String get value;
}

/// Enum of token types, corresponding to AST token types.
enum UnlinkedTokenType {
  NOTHING,
  ABSTRACT,
  AMPERSAND,
  AMPERSAND_AMPERSAND,
  AMPERSAND_EQ,
  AS,
  ASSERT,
  ASYNC,
  AT,
  AWAIT,
  BACKPING,
  BACKSLASH,
  BANG,
  BANG_EQ,
  BANG_EQ_EQ,
  BAR,
  BAR_BAR,
  BAR_EQ,
  BREAK,
  CARET,
  CARET_EQ,
  CASE,
  CATCH,
  CLASS,
  CLOSE_CURLY_BRACKET,
  CLOSE_PAREN,
  CLOSE_SQUARE_BRACKET,
  COLON,
  COMMA,
  CONST,
  CONTINUE,
  COVARIANT,
  DEFAULT,
  DEFERRED,
  DO,
  DOUBLE,
  DYNAMIC,
  ELSE,
  ENUM,
  EOF,
  EQ,
  EQ_EQ,
  EQ_EQ_EQ,
  EXPORT,
  EXTENDS,
  EXTERNAL,
  FACTORY,
  FALSE,
  FINAL,
  FINALLY,
  FOR,
  FUNCTION,
  FUNCTION_KEYWORD,
  GET,
  GT,
  GT_EQ,
  GT_GT,
  GT_GT_EQ,
  GT_GT_GT,
  GT_GT_GT_EQ,
  HASH,
  HEXADECIMAL,
  HIDE,
  IDENTIFIER,
  IF,
  IMPLEMENTS,
  IMPORT,
  IN,
  INDEX,
  INDEX_EQ,
  INT,
  INTERFACE,
  IS,
  LATE,
  LIBRARY,
  LT,
  LT_EQ,
  LT_LT,
  LT_LT_EQ,
  MINUS,
  MINUS_EQ,
  MINUS_MINUS,
  MIXIN,
  MULTI_LINE_COMMENT,
  NATIVE,
  NEW,
  NULL,
  OF,
  ON,
  OPEN_CURLY_BRACKET,
  OPEN_PAREN,
  OPEN_SQUARE_BRACKET,
  OPERATOR,
  PART,
  PATCH,
  PERCENT,
  PERCENT_EQ,
  PERIOD,
  PERIOD_PERIOD,
  PERIOD_PERIOD_PERIOD,
  PERIOD_PERIOD_PERIOD_QUESTION,
  PLUS,
  PLUS_EQ,
  PLUS_PLUS,
  QUESTION,
  QUESTION_PERIOD,
  QUESTION_QUESTION,
  QUESTION_QUESTION_EQ,
  REQUIRED,
  RETHROW,
  RETURN,
  SCRIPT_TAG,
  SEMICOLON,
  SET,
  SHOW,
  SINGLE_LINE_COMMENT,
  SLASH,
  SLASH_EQ,
  SOURCE,
  STAR,
  STAR_EQ,
  STATIC,
  STRING,
  STRING_INTERPOLATION_EXPRESSION,
  STRING_INTERPOLATION_IDENTIFIER,
  SUPER,
  SWITCH,
  SYNC,
  THIS,
  THROW,
  TILDE,
  TILDE_SLASH,
  TILDE_SLASH_EQ,
  TRUE,
  TRY,
  TYPEDEF,
  VAR,
  VOID,
  WHILE,
  WITH,
  YIELD,
  INOUT,
  OUT,
}

/// Unlinked summary information about a compilation unit.
@TopLevel('UUN2')
abstract class UnlinkedUnit2 extends base.SummaryClass {
  factory UnlinkedUnit2.fromBuffer(List<int> buffer) =>
      generated.readUnlinkedUnit2(buffer);

  /// The MD5 hash signature of the API portion of this unit. It depends on all
  /// tokens that might affect APIs of declarations in the unit.
  @Id(0)
  List<int> get apiSignature;

  /// URIs of `export` directives.
  @Id(1)
  List<UnlinkedNamespaceDirective> get exports;

  /// Is `true` if the unit contains a `library` directive.
  @Id(6)
  bool get hasLibraryDirective;

  /// Is `true` if the unit contains a `part of` directive.
  @Id(3)
  bool get hasPartOfDirective;

  /// URIs of `import` directives.
  @Id(2)
  List<UnlinkedNamespaceDirective> get imports;

  @Id(7)
  List<UnlinkedInformativeData> get informativeData;

  /// Offsets of the first character of each line in the source code.
  @informative
  @Id(5)
  List<int> get lineStarts;

  /// URI of the `part of` directive.
  @Id(8)
  String get partOfUri;

  /// URIs of `part` directives.
  @Id(4)
  List<String> get parts;
}