// 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 has been automatically generated.  Please do not edit it manually.
// To regenerate the file, use the SDK script
// "pkg/analyzer/tool/summary/generate.dart $IDL_FILE_PATH",
// or "pkg/analyzer/tool/generate_files" for the analyzer package IDL/sources.


/// Enum of declaration kinds in available files.
enum AvailableDeclarationKind : byte {
  CLASS,

  CLASS_TYPE_ALIAS,

  CONSTRUCTOR,

  ENUM,

  ENUM_CONSTANT,

  EXTENSION,

  FIELD,

  FUNCTION,

  FUNCTION_TYPE_ALIAS,

  GETTER,

  METHOD,

  MIXIN,

  SETTER,

  VARIABLE
}

/// 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 : byte {
  /// 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 : byte {
  /// 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 : byte {
  /// 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
}

/// Types of comments.
enum LinkedNodeCommentType : byte {
  block,

  documentation,

  endOfLine
}

/// Kinds of formal parameters.
enum LinkedNodeFormalParameterKind : byte {
  requiredPositional,

  optionalPositional,

  optionalNamed,

  requiredNamed
}

/// Kinds of [LinkedNode].
enum LinkedNodeKind : byte {
  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
}

/// Kinds of [LinkedNodeType]s.
enum LinkedNodeTypeKind : byte {
  bottom,

  dynamic_,

  function,

  interface,

  typeParameter,

  void_
}

/// Enum used to indicate the kind of the error during top-level inference.
enum TopLevelInferenceErrorKind : byte {
  assignment,

  instanceGetter,

  dependencyCycle,

  overrideConflictFieldType,

  overrideConflictReturnType,

  overrideConflictParameterType
}

/// TODO(scheglov) document
enum UnlinkedTokenType : byte {
  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
}

/// Information about the context of an exception in analysis driver.
table AnalysisDriverExceptionContext {
  /// The exception string.
  exception:string (id: 1);

  /// The state of files when the exception happened.
  files:[AnalysisDriverExceptionFile] (id: 3);

  /// The path of the file being analyzed when the exception happened.
  path:string (id: 0);

  /// The exception stack trace string.
  stackTrace:string (id: 2);
}

/// Information about a single file in [AnalysisDriverExceptionContext].
table AnalysisDriverExceptionFile {
  /// The content of the file.
  content:string (id: 1);

  /// The path of the file.
  path:string (id: 0);
}

/// Information about a resolved unit.
table AnalysisDriverResolvedUnit {
  /// The full list of analysis errors, both syntactic and semantic.
  errors:[AnalysisDriverUnitError] (id: 0);

  /// The index of the unit.
  index:AnalysisDriverUnitIndex (id: 1);
}

/// Information about a subtype of one or more classes.
table AnalysisDriverSubtype {
  /// The names of defined instance members.
  /// They are indexes into [AnalysisDriverUnitError.strings] list.
  /// The list is sorted in ascending order.
  members:[uint] (id: 1);

  /// The name of the class.
  /// It is an index into [AnalysisDriverUnitError.strings] list.
  name:uint (id: 0);
}

/// Information about an error in a resolved unit.
table AnalysisDriverUnitError {
  /// The context messages associated with the error.
  contextMessages:[DiagnosticMessage] (id: 5);

  /// The optional correction hint for the error.
  correction:string (id: 4);

  /// The length of the error in the file.
  length:uint (id: 1);

  /// The message of the error.
  message:string (id: 3);

  /// The offset from the beginning of the file.
  offset:uint (id: 0);

  /// The unique name of the error code.
  uniqueName:string (id: 2);
}

/// Information about a resolved unit.
table AnalysisDriverUnitIndex {
  /// Each item of this list corresponds to a unique referenced element.  It is
  /// the kind of the synthetic element.
  elementKinds:[IndexSyntheticElementKind] (id: 4);

  /// 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.
  elementNameClassMemberIds:[uint] (id: 7);

  /// 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.
  elementNameParameterIds:[uint] (id: 8);

  /// 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.
  elementNameUnitMemberIds:[uint] (id: 6);

  /// 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.
  elementUnits:[uint] (id: 5);

  /// Identifier of the null string in [strings].
  nullStringId:uint (id: 1);

  /// 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.
  strings:[string] (id: 0);

  /// The list of classes declared in the unit.
  subtypes:[AnalysisDriverSubtype] (id: 19);

  /// 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.
  supertypes:[uint] (id: 18);

  /// 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.
  unitLibraryUris:[uint] (id: 2);

  /// 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.
  unitUnitUris:[uint] (id: 3);

  /// Each item of this list is the `true` if the corresponding element usage
  /// is qualified with some prefix.
  usedElementIsQualifiedFlags:[ubyte] (id: 13);

  /// Each item of this list is the kind of the element usage.
  usedElementKinds:[IndexRelationKind] (id: 10);

  /// Each item of this list is the length of the element usage.
  usedElementLengths:[uint] (id: 12);

  /// Each item of this list is the offset of the element usage relative to the
  /// beginning of the file.
  usedElementOffsets:[uint] (id: 11);

  /// 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.
  usedElements:[uint] (id: 9);

  /// Each item of this list is the `true` if the corresponding name usage
  /// is qualified with some prefix.
  usedNameIsQualifiedFlags:[ubyte] (id: 17);

  /// Each item of this list is the kind of the name usage.
  usedNameKinds:[IndexRelationKind] (id: 15);

  /// Each item of this list is the offset of the name usage relative to the
  /// beginning of the file.
  usedNameOffsets:[uint] (id: 16);

  /// 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.
  usedNames:[uint] (id: 14);
}

/// Information about an unlinked unit.
table AnalysisDriverUnlinkedUnit {
  /// List of class member names defined by the unit.
  definedClassMemberNames:[string] (id: 3);

  /// List of top-level names defined by the unit.
  definedTopLevelNames:[string] (id: 2);

  /// List of external names referenced by the unit.
  referencedNames:[string] (id: 0);

  /// List of names which are used in `extends`, `with` or `implements` clauses
  /// in the file. Import prefixes and type arguments are not included.
  subtypedNames:[string] (id: 4);

  /// Unlinked information for the unit.
  unit:UnlinkedUnit (id: 1);

  /// Unlinked information for the unit.
  unit2:UnlinkedUnit2 (id: 5);
}

/// Information about a single declaration.
table AvailableDeclaration {
  children:[AvailableDeclaration] (id: 0);

  codeLength:uint (id: 1);

  codeOffset:uint (id: 2);

  defaultArgumentListString:string (id: 3);

  defaultArgumentListTextRanges:[uint] (id: 4);

  docComplete:string (id: 5);

  docSummary:string (id: 6);

  fieldMask:uint (id: 7);

  isAbstract:bool (id: 8);

  isConst:bool (id: 9);

  isDeprecated:bool (id: 10);

  isFinal:bool (id: 11);

  /// The kind of the declaration.
  kind:AvailableDeclarationKind (id: 12);

  locationOffset:uint (id: 13);

  locationStartColumn:uint (id: 14);

  locationStartLine:uint (id: 15);

  /// 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`.
  name:string (id: 16);

  parameterNames:[string] (id: 17);

  parameters:string (id: 18);

  parameterTypes:[string] (id: 19);

  /// 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).
  relevanceTags:[string] (id: 20);

  requiredParameterCount:uint (id: 21);

  returnType:string (id: 22);

  typeParameters:string (id: 23);
}

/// Information about an available, even if not yet imported file.
table AvailableFile {
  /// Declarations of the file.
  declarations:[AvailableDeclaration] (id: 0);

  /// The Dartdoc directives in the file.
  directiveInfo:DirectiveInfo (id: 1);

  /// Exports directives of the file.
  exports:[AvailableFileExport] (id: 2);

  /// Is `true` if this file is a library.
  isLibrary:bool (id: 3);

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

  /// Offsets of the first character of each line in the source code.
  lineStarts:[uint] (id: 5);

  /// URIs of `part` directives.
  parts:[string] (id: 6);
}

/// Information about an export directive.
table AvailableFileExport {
  /// Combinators contained in this export directive.
  combinators:[AvailableFileExportCombinator] (id: 1);

  /// URI of the exported library.
  uri:string (id: 0);
}

/// Information about a `show` or `hide` combinator in an export directive.
table AvailableFileExportCombinator {
  /// List of names which are hidden.  Empty if this is a `show` combinator.
  hides:[string] (id: 1);

  /// List of names which are shown.  Empty if this is a `hide` combinator.
  shows:[string] (id: 0);
}

table DiagnosticMessage {
  /// The absolute and normalized path of the file associated with this message.
  filePath:string (id: 0);

  /// The length of the source range associated with this message.
  length:uint (id: 1);

  /// The text of the message.
  message:string (id: 2);

  /// The zero-based offset from the start of the file to the beginning of the
  /// source range associated with this message.
  offset:uint (id: 3);
}

/// Information about the Dartdoc directives in an [AvailableFile].
table DirectiveInfo {
  /// The names of the defined templates.
  templateNames:[string] (id: 0);

  /// The values of the defined templates.
  templateValues:[string] (id: 1);
}

/// TODO(scheglov) Remove it.
table LinkedLibrary {
  placeholder:uint (id: 0);
}

/// Information about a linked AST node.
table LinkedNode {
  /// The explicit or inferred return type of a function typed node.
  variantField_24:LinkedNodeType (id: 24);

  variantField_2:[LinkedNode] (id: 2);

  variantField_4:[LinkedNode] (id: 4);

  variantField_6:LinkedNode (id: 6);

  variantField_7:LinkedNode (id: 7);

  variantField_17:uint (id: 17);

  variantField_8:LinkedNode (id: 8);

  variantField_38:LinkedNodeTypeSubstitution (id: 38);

  variantField_15:uint (id: 15);

  variantField_28:UnlinkedTokenType (id: 28);

  variantField_27:bool (id: 27);

  variantField_9:LinkedNode (id: 9);

  variantField_12:LinkedNode (id: 12);

  variantField_5:[LinkedNode] (id: 5);

  variantField_13:LinkedNode (id: 13);

  variantField_33:[string] (id: 33);

  variantField_29:LinkedNodeCommentType (id: 29);

  variantField_3:[LinkedNode] (id: 3);

  variantField_10:LinkedNode (id: 10);

  variantField_26:LinkedNodeFormalParameterKind (id: 26);

  variantField_21:double (id: 21);

  variantField_25:LinkedNodeType (id: 25);

  variantField_20:string (id: 20);

  variantField_39:[LinkedNodeType] (id: 39);

  flags:uint (id: 18);

  variantField_1:string (id: 1);

  variantField_36:uint (id: 36);

  variantField_16:uint (id: 16);

  variantField_30:string (id: 30);

  variantField_14:LinkedNode (id: 14);

  kind:LinkedNodeKind (id: 0);

  variantField_34:[string] (id: 34);

  name:string (id: 37);

  variantField_31:bool (id: 31);

  variantField_35:UnlinkedTokenType (id: 35);

  variantField_32:TopLevelInferenceError (id: 32);

  variantField_23:LinkedNodeType (id: 23);

  variantField_11:LinkedNode (id: 11);

  variantField_22:string (id: 22);

  variantField_19:uint (id: 19);
}

/// Information about a group of libraries linked together, for example because
/// they form a single cycle, or because they represent a single build artifact.
table LinkedNodeBundle {
  libraries:[LinkedNodeLibrary] (id: 1);

  /// The shared list of references used in the [libraries].
  references:LinkedNodeReferences (id: 0);
}

/// Information about a single library in a [LinkedNodeBundle].
table LinkedNodeLibrary {
  exports:[uint] (id: 2);

  name:string (id: 3);

  nameLength:uint (id: 5);

  nameOffset:uint (id: 4);

  units:[LinkedNodeUnit] (id: 1);

  uriStr:string (id: 0);
}

/// Flattened tree of declarations referenced from [LinkedNode]s.
table LinkedNodeReferences {
  name:[string] (id: 1);

  parent:[uint] (id: 0);
}

/// Information about a Dart type.
table LinkedNodeType {
  functionFormalParameters:[LinkedNodeTypeFormalParameter] (id: 0);

  functionReturnType:LinkedNodeType (id: 1);

  /// The typedef this function type is created for.
  functionTypedef:uint (id: 9);

  functionTypedefTypeArguments:[LinkedNodeType] (id: 10);

  functionTypeParameters:[LinkedNodeTypeTypeParameter] (id: 2);

  /// Reference to a [LinkedNodeReferences].
  interfaceClass:uint (id: 3);

  interfaceTypeArguments:[LinkedNodeType] (id: 4);

  kind:LinkedNodeTypeKind (id: 5);

  nullabilitySuffix:EntityRefNullabilitySuffix (id: 8);

  typeParameterElement:uint (id: 6);

  typeParameterId:uint (id: 7);
}

/// Information about a formal parameter in a function type.
table LinkedNodeTypeFormalParameter {
  kind:LinkedNodeFormalParameterKind (id: 0);

  name:string (id: 1);

  type:LinkedNodeType (id: 2);
}

/// Information about a type substitution.
table LinkedNodeTypeSubstitution {
  typeArguments:[LinkedNodeType] (id: 1);

  typeParameters:[uint] (id: 0);
}

/// Information about a type parameter in a function type.
table LinkedNodeTypeTypeParameter {
  bound:LinkedNodeType (id: 1);

  name:string (id: 0);
}

/// Information about a single library in a [LinkedNodeLibrary].
table LinkedNodeUnit {
  isNNBD:bool (id: 4);

  isSynthetic:bool (id: 3);

  node:LinkedNode (id: 2);

  /// If the unit is a part, the URI specified in the `part` directive.
  /// Otherwise empty.
  partUriStr:string (id: 5);

  tokens:UnlinkedTokens (id: 1);

  /// The absolute URI.
  uriStr:string (id: 0);
}

/// Summary information about a package.
table PackageBundle {
  /// 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.
  apiSignature:string (id: 7, deprecated);

  /// The version 2 of the summary.
  bundle2:LinkedNodeBundle (id: 9);

  /// Information about the packages this package depends on, if known.
  dependencies:[PackageDependencyInfo] (id: 8, deprecated);

  /// Linked libraries.
  linkedLibraries:[LinkedLibrary] (id: 0, deprecated);

  /// The list of URIs of items in [linkedLibraries], e.g. `dart:core` or
  /// `package:foo/bar.dart`.
  linkedLibraryUris:[string] (id: 1, deprecated);

  /// Major version of the summary format.  See
  /// [PackageBundleAssembler.currentMajorVersion].
  majorVersion:uint (id: 5);

  /// Minor version of the summary format.  See
  /// [PackageBundleAssembler.currentMinorVersion].
  minorVersion:uint (id: 6);

  /// List of MD5 hashes of the files listed in [unlinkedUnitUris].  Each hash
  /// is encoded as a hexadecimal string using lower case letters.
  unlinkedUnitHashes:[string] (id: 4, deprecated);

  /// Unlinked information for the compilation units constituting the package.
  unlinkedUnits:[UnlinkedUnit] (id: 2, deprecated);

  /// The list of URIs of items in [unlinkedUnits], e.g. `dart:core/bool.dart`.
  unlinkedUnitUris:[string] (id: 3, deprecated);
}

/// TODO(scheglov) Remove it.
table PackageDependencyInfo {
  placeholder:uint (id: 0);
}

/// Summary information about a top-level type inference error.
table TopLevelInferenceError {
  /// The [kind] specific arguments.
  arguments:[string] (id: 2);

  /// The kind of the error.
  kind:TopLevelInferenceErrorKind (id: 1);

  /// The slot id (which is unique within the compilation unit) identifying the
  /// target of type inference with which this [TopLevelInferenceError] is
  /// associated.
  slot:uint (id: 0);
}

table UnlinkedInformativeData {
  variantField_2:uint (id: 2);

  variantField_3:uint (id: 3);

  variantField_9:uint (id: 9);

  variantField_8:uint (id: 8);

  /// Offsets of the first character of each line in the source code.
  variantField_7:[uint] (id: 7);

  variantField_6:uint (id: 6);

  variantField_5:uint (id: 5);

  /// If the parameter has a default value, the source text of the constant
  /// expression in the default value.  Otherwise the empty string.
  variantField_10:string (id: 10);

  variantField_1:uint (id: 1);

  variantField_4:[string] (id: 4);

  /// The kind of the node.
  kind:LinkedNodeKind (id: 0);
}

/// TODO(scheglov) Remove it.
table UnlinkedTokens {
  placeholder:uint (id: 0);
}

/// TODO(scheglov) Remove it.
table UnlinkedUnit {
  placeholder:uint (id: 0);
}

/// Unlinked summary information about a compilation unit.
table UnlinkedUnit2 {
  /// 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.
  apiSignature:[uint] (id: 0);

  /// URIs of `export` directives.
  exports:[string] (id: 1);

  /// Is `true` if the unit contains a `library` directive.
  hasLibraryDirective:bool (id: 6);

  /// Is `true` if the unit contains a `part of` directive.
  hasPartOfDirective:bool (id: 3);

  /// URIs of `import` directives.
  imports:[string] (id: 2);

  informativeData:[UnlinkedInformativeData] (id: 7);

  /// Offsets of the first character of each line in the source code.
  lineStarts:[uint] (id: 5);

  /// URIs of `part` directives.
  parts:[string] (id: 4);
}

root_type PackageBundle;

file_identifier "PBdl";