Rename UnlinkedConst -> UnlinkedExpr

pkg/analyzer/lib/src/summary/idl.dart

 // 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.
  *
@@ skipping 953 matching lines @@
 }
 
 /**
  * Unlinked summary information about a class declaration.
  */
 abstract class UnlinkedClass extends base.SummaryClass {
   /**
    * Annotations for this class.
    */
   @Id(5)
-  List<UnlinkedConst> get annotations;
+  List<UnlinkedExpr> get annotations;
 
   /**
    * Code range of the class.
    */
   @informative
   @Id(13)
   CodeRange get codeRange;
 
   /**
    * Documentation comment for the class, or `null` if there is no
@@ skipping 127 matching lines @@
 
   /**
    * The value to which the value of the declared variable will be compared,
    * or `true` if the condition does not include an equality test.
    */
   @Id(1)
   String get value;
 }
 
 /**
- * Unlinked summary information about a compile-time constant expression, or a
- * potentially constant expression.
+ * Unlinked summary information about a constructor initializer.
+ */
+abstract class UnlinkedConstructorInitializer extends base.SummaryClass {
+  /**
+   * If there are `m` [arguments] and `n` [argumentNames], then each argument
+   * from [arguments] with index `i` such that `n + i - m >= 0`, should be used
+   * with the name at `n + i - m`.
+   */
+  @Id(4)
+  List<String> get argumentNames;
+
+  /**
+   * If [kind] is `thisInvocation` or `superInvocation`, the arguments of the
+   * invocation.  Otherwise empty.
+   */
+  @Id(3)
+  List<UnlinkedExpr> get arguments;
+
+  /**
+   * If [kind] is `field`, the expression of the field initializer.
+   * Otherwise `null`.
+   */
+  @Id(1)
+  UnlinkedExpr get expression;
+
+  /**
+   * The kind of the constructor initializer (field, redirect, super).
+   */
+  @Id(2)
+  UnlinkedConstructorInitializerKind get kind;
+
+  /**
+   * If [kind] is `field`, the name of the field declared in the class.  If
+   * [kind] is `thisInvocation`, the name of the constructor, declared in this
+   * class, to redirect to.  If [kind] is `superInvocation`, the name of the
+   * constructor, declared in the superclass, to invoke.
+   */
+  @Id(0)
+  String get name;
+}
+
+/**
+ * Enum used to indicate the kind of an constructor initializer.
+ */
+enum UnlinkedConstructorInitializerKind {
+  /**
+   * Initialization of a field.
+   */
+  field,
+
+  /**
+   * Invocation of a constructor in the same class.
+   */
+  thisInvocation,
+
+  /**
+   * Invocation of a superclass' constructor.
+   */
+  superInvocation
+}
+
+/**
+ * Unlinked summary information about a documentation comment.
+ */
+abstract class UnlinkedDocumentationComment extends base.SummaryClass {
+  /**
+   * Length of the documentation comment (prior to replacing '\r\n' with '\n').
+   */
+  @Id(0)
+  @deprecated
+  int get length;
+
+  /**
+   * Offset of the beginning of the documentation comment relative to the
+   * beginning of the file.
+   */
+  @Id(2)
+  @deprecated
+  int get offset;
+
+  /**
+   * Text of the documentation comment, with '\r\n' replaced by '\n'.
+   *
+   * References appearing within the doc comment in square brackets are not
+   * specially encoded.
+   */
+  @Id(1)
+  String get text;
+}
+
+/**
+ * Unlinked summary information about an enum declaration.
+ */
+abstract class UnlinkedEnum extends base.SummaryClass {
+  /**
+   * Annotations for this enum.
+   */
+  @Id(4)
+  List<UnlinkedExpr> get annotations;
+
+  /**
+   * Code range of the enum.
+   */
+  @informative
+  @Id(5)
+  CodeRange get codeRange;
+
+  /**
+   * Documentation comment for the enum, or `null` if there is no documentation
+   * comment.
+   */
+  @informative
+  @Id(3)
+  UnlinkedDocumentationComment get documentationComment;
+
+  /**
+   * Name of the enum type.
+   */
+  @Id(0)
+  String get name;
+
+  /**
+   * Offset of the enum name relative to the beginning of the file.
+   */
+  @informative
+  @Id(1)
+  int get nameOffset;
+
+  /**
+   * Values listed in the enum declaration, in declaration order.
+   */
+  @Id(2)
+  List<UnlinkedEnumValue> get values;
+}
+
+/**
+ * Unlinked summary information about a single enumerated value in an enum
+ * declaration.
+ */
+abstract class UnlinkedEnumValue extends base.SummaryClass {
+  /**
+   * Documentation comment for the enum value, or `null` if there is no
+   * documentation comment.
+   */
+  @informative
+  @Id(2)
+  UnlinkedDocumentationComment get documentationComment;
+
+  /**
+   * Name of the enumerated value.
+   */
+  @Id(0)
+  String get name;
+
+  /**
+   * Offset of the enum value name relative to the beginning of the file.
+   */
+  @informative
+  @Id(1)
+  int get nameOffset;
+}
+
+/**
+ * Unlinked summary information about a function, method, getter, or setter
+ * declaration.
+ */
+abstract class UnlinkedExecutable extends base.SummaryClass {
+  /**
+   * Annotations for this executable.
+   */
+  @Id(6)
+  List<UnlinkedExpr> get annotations;
+
+  /**
+   * If this executable's function body is declared using `=>`, the expression
+   * to the right of the `=>`.  May be omitted if neither type inference nor
+   * constant evaluation depends on the function body.
+   */
+  @Id(29)
+  UnlinkedExpr get bodyExpr;
+
+  /**
+   * Code range of the executable.
+   */
+  @informative
+  @Id(26)
+  CodeRange get codeRange;
+
+  /**
+   * If a constant [UnlinkedExecutableKind.constructor], the constructor
+   * initializers.  Otherwise empty.
+   */
+  @Id(14)
+  List<UnlinkedConstructorInitializer> get constantInitializers;
+
+  /**
+   * If [kind] is [UnlinkedExecutableKind.constructor] and [isConst] is `true`,
+   * a nonzero slot id which is unique within this compilation unit.  If this id
+   * is found in [LinkedUnit.constCycles], then this constructor is part of a
+   * cycle.
+   *
+   * Otherwise, zero.
+   */
+  @Id(25)
+  int get constCycleSlot;
+
+  /**
+   * Documentation comment for the executable, or `null` if there is no
+   * documentation comment.
+   */
+  @informative
+  @Id(7)
+  UnlinkedDocumentationComment get documentationComment;
+
+  /**
+   * If this executable's return type is inferable, nonzero slot id
+   * identifying which entry in [LinkedUnit.types] contains the inferred
+   * return type.  If there is no matching entry in [LinkedUnit.types], then
+   * no return type was inferred for this variable, so its static type is
+   * `dynamic`.
+   */
+  @Id(5)
+  int get inferredReturnTypeSlot;
+
+  /**
+   * Indicates whether the executable is declared using the `abstract` keyword.
+   */
+  @Id(10)
+  bool get isAbstract;
+
+  /**
+   * Indicates whether the executable has body marked as being asynchronous.
+   */
+  @informative
+  @Id(27)
+  bool get isAsynchronous;
+
+  /**
+   * Indicates whether the executable is declared using the `const` keyword.
+   */
+  @Id(12)
+  bool get isConst;
+
+  /**
+   * Indicates whether the executable is declared using the `external` keyword.
+   */
+  @Id(11)
+  bool get isExternal;
+
+  /**
+   * Indicates whether the executable is declared using the `factory` keyword.
+   */
+  @Id(8)
+  bool get isFactory;
+
+  /**
+   * Indicates whether the executable has body marked as being a generator.
+   */
+  @informative
+  @Id(28)
+  bool get isGenerator;
+
+  /**
+   * Indicates whether the executable is a redirected constructor.
+   */
+  @Id(13)
+  bool get isRedirectedConstructor;
+
+  /**
+   * Indicates whether the executable is declared using the `static` keyword.
+   *
+   * Note that for top level executables, this flag is false, since they are
+   * not declared using the `static` keyword (even though they are considered
+   * static for semantic purposes).
+   */
+  @Id(9)
+  bool get isStatic;
+
+  /**
+   * The kind of the executable (function/method, getter, setter, or
+   * constructor).
+   */
+  @Id(4)
+  UnlinkedExecutableKind get kind;
+
+  /**
+   * The list of local functions.
+   */
+  @Id(18)
+  List<UnlinkedExecutable> get localFunctions;
+
+  /**
+   * The list of local labels.
+   */
+  @informative
+  @Id(22)
+  List<UnlinkedLabel> get localLabels;
+
+  /**
+   * The list of local variables.
+   */
+  @informative
+  @Id(19)
+  List<UnlinkedVariable> get localVariables;
+
+  /**
+   * Name of the executable.  For setters, this includes the trailing "=".  For
+   * named constructors, this excludes the class name and excludes the ".".
+   * For unnamed constructors, this is the empty string.
+   */
+  @Id(1)
+  String get name;
+
+  /**
+   * If [kind] is [UnlinkedExecutableKind.constructor] and [name] is not empty,
+   * the offset of the end of the constructor name.  Otherwise zero.
+   */
+  @informative
+  @Id(23)
+  int get nameEnd;
+
+  /**
+   * Offset of the executable name relative to the beginning of the file.  For
+   * named constructors, this excludes the class name and excludes the ".".
+   * For unnamed constructors, this is the offset of the class name (i.e. the
+   * offset of the second "C" in "class C { C(); }").
+   */
+  @informative
+  @Id(0)
+  int get nameOffset;
+
+  /**
+   * Parameters of the executable, if any.  Note that getters have no
+   * parameters (hence this will be the empty list), and setters have a single
+   * parameter.
+   */
+  @Id(2)
+  List<UnlinkedParam> get parameters;
+
+  /**
+   * If [kind] is [UnlinkedExecutableKind.constructor] and [name] is not empty,
+   * the offset of the period before the constructor name.  Otherwise zero.
+   */
+  @informative
+  @Id(24)
+  int get periodOffset;
+
+  /**
+   * If [isRedirectedConstructor] and [isFactory] are both `true`, the
+   * constructor to which this constructor redirects; otherwise empty.
+   */
+  @Id(15)
+  EntityRef get redirectedConstructor;
+
+  /**
+   * If [isRedirectedConstructor] is `true` and [isFactory] is `false`, the
+   * name of the constructor that this constructor redirects to; otherwise
+   * empty.
+   */
+  @Id(17)
+  String get redirectedConstructorName;
+
+  /**
+   * Declared return type of the executable.  Absent if the executable is a
+   * constructor or the return type is implicit.  Absent for executables
+   * associated with variable initializers and closures, since these
+   * executables may have return types that are not accessible via direct
+   * imports.
+   */
+  @Id(3)
+  EntityRef get returnType;
+
+  /**
+   * Type parameters of the executable, if any.  Empty if support for generic
+   * method syntax is disabled.
+   */
+  @Id(16)
+  List<UnlinkedTypeParam> get typeParameters;
+
+  /**
+   * If a local function, the length of the visible range; zero otherwise.
+   */
+  @informative
+  @Id(20)
+  int get visibleLength;
+
+  /**
+   * If a local function, the beginning of the visible range; zero otherwise.
+   */
+  @informative
+  @Id(21)
+  int get visibleOffset;
+}
+
+/**
+ * Enum used to indicate the kind of an executable.
+ */
+enum UnlinkedExecutableKind {
+  /**
+   * Executable is a function or method.
+   */
+  functionOrMethod,
+
+  /**
+   * Executable is a getter.
+   */
+  getter,
+
+  /**
+   * Executable is a setter.
+   */
+  setter,
+
+  /**
+   * Executable is a constructor.
+   */
+  constructor
+}
+
+/**
+ * Unlinked summary information about an export declaration (stored outside
+ * [UnlinkedPublicNamespace]).
+ */
+abstract class UnlinkedExportNonPublic extends base.SummaryClass {
+  /**
+   * Annotations for this export directive.
+   */
+  @Id(3)
+  List<UnlinkedExpr> get annotations;
+
+  /**
+   * Offset of the "export" keyword.
+   */
+  @informative
+  @Id(0)
+  int get offset;
+
+  /**
+   * End of the URI string (including quotes) relative to the beginning of the
+   * file.
+   */
+  @informative
+  @Id(1)
+  int get uriEnd;
+
+  /**
+   * Offset of the URI string (including quotes) relative to the beginning of
+   * the file.
+   */
+  @informative
+  @Id(2)
+  int get uriOffset;
+}
+
+/**
+ * Unlinked summary information about an export declaration (stored inside
+ * [UnlinkedPublicNamespace]).
+ */
+abstract class UnlinkedExportPublic extends base.SummaryClass {
+  /**
+   * Combinators contained in this export declaration.
+   */
+  @Id(1)
+  List<UnlinkedCombinator> get combinators;
+
+  /**
+   * Configurations used to control which library will actually be loaded at
+   * run-time.
+   */
+  @Id(2)
+  List<UnlinkedConfiguration> get configurations;
+
+  /**
+   * URI used in the source code to reference the exported library.
+   */
+  @Id(0)
+  String get uri;
+}
+
+/**
+ * Unlinked summary information about an expression.
  *
- * Constant expressions are represented using a simple stack-based language
+ * Expressions are represented using a simple stack-based language
  * where [operations] is a sequence of operations to execute starting with an
  * empty stack.  Once all operations have been executed, the stack should
  * contain a single value which is the value of the constant.  Note that some
  * operations consume additional data from the other fields of this class.
  */
-abstract class UnlinkedConst extends base.SummaryClass {
+abstract class UnlinkedExpr extends base.SummaryClass {
   /**
    * Sequence of operators used by assignment operations.
    */
   @Id(6)
   List<UnlinkedExprAssignOperator> get assignmentOperators;
 
   /**
    * Sequence of 64-bit doubles consumed by the operation `pushDouble`.
    */
   @Id(4)
@@ skipping 12 matching lines @@
    * expression.
    */
   @Id(5)
   bool get isValidConst;
 
   /**
    * Sequence of operations to execute (starting with an empty stack) to form
    * the constant value.
    */
   @Id(0)
-  List<UnlinkedConstOperation> get operations;
+  List<UnlinkedExprOperation> get operations;
 
   /**
    * Sequence of language constructs consumed by the operations
    * `pushReference`, `invokeConstructor`, `makeList`, and `makeMap`.  Note
    * that in the case of `pushReference` (and sometimes `invokeConstructor` the
    * actual entity being referred to may be something other than a type.
    */
   @Id(2)
   List<EntityRef> get references;
 
   /**
    * Sequence of strings consumed by the operations `pushString` and
    * `invokeConstructor`.
    */
   @Id(3)
   List<String> get strings;
 }
 
 /**
+ * Enum representing the various kinds of assignment operations combined
+ * with:
+ *    [UnlinkedExprOperation.assignToRef],
+ *    [UnlinkedExprOperation.assignToProperty],
+ *    [UnlinkedExprOperation.assignToIndex].
+ */
+enum UnlinkedExprAssignOperator {
+  /**
+   * Perform simple assignment `target = operand`.
+   */
+  assign,
+
+  /**
+   * Perform `target ??= operand`.
+   */
+  ifNull,
+
+  /**
+   * Perform `target *= operand`.
+   */
+  multiply,
+
+  /**
+   * Perform `target /= operand`.
+   */
+  divide,
+
+  /**
+   * Perform `target ~/= operand`.
+   */
+  floorDivide,
+
+  /**
+   * Perform `target %= operand`.
+   */
+  modulo,
+
+  /**
+   * Perform `target += operand`.
+   */
+  plus,
+
+  /**
+   * Perform `target -= operand`.
+   */
+  minus,
+
+  /**
+   * Perform `target <<= operand`.
+   */
+  shiftLeft,
+
+  /**
+   * Perform `target >>= operand`.
+   */
+  shiftRight,
+
+  /**
+   * Perform `target &= operand`.
+   */
+  bitAnd,
+
+  /**
+   * Perform `target ^= operand`.
+   */
+  bitXor,
+
+  /**
+   * Perform `target |= operand`.
+   */
+  bitOr,
+
+  /**
+   * Perform `++target`.
+   */
+  prefixIncrement,
+
+  /**
+   * Perform `--target`.
+   */
+  prefixDecrement,
+
+  /**
+   * Perform `target++`.
+   */
+  postfixIncrement,
+
+  /**
+   * Perform `target++`.
+   */
+  postfixDecrement,
+}
+
+/**
  * Enum representing the various kinds of operations which may be performed to
- * produce a constant value.  These options are assumed to execute in the
+ * in an expression.  These options are assumed to execute in the
  * context of a stack which is initially empty.
  */
-enum UnlinkedConstOperation {
-  /**
-   * Push the next value from [UnlinkedConst.ints] (a 32-bit unsigned integer)
+enum UnlinkedExprOperation {
+  /**
+   * Push the next value from [UnlinkedExpr.ints] (a 32-bit unsigned integer)
    * onto the stack.
    *
    * Note that Dart supports integers larger than 32 bits; these are
    * represented by composing 32-bit values using the [pushLongInt] operation.
    */
   pushInt,
 
   /**
-   * Get the number of components from [UnlinkedConst.ints], then do this number
+   * Get the number of components from [UnlinkedExpr.ints], then do this number
    * of times the following operations: multiple the current value by 2^32, "or"
-   * it with the next value in [UnlinkedConst.ints]. The initial value is zero.
+   * it with the next value in [UnlinkedExpr.ints]. The initial value is zero.
    * Push the result into the stack.
    */
   pushLongInt,
 
   /**
-   * Push the next value from [UnlinkedConst.doubles] (a double precision
+   * Push the next value from [UnlinkedExpr.doubles] (a double precision
    * floating point value) onto the stack.
    */
   pushDouble,
 
   /**
    * Push the constant `true` onto the stack.
    */
   pushTrue,
 
   /**
    * Push the constant `false` onto the stack.
    */
   pushFalse,
 
   /**
-   * Push the next value from [UnlinkedConst.strings] onto the stack.
+   * Push the next value from [UnlinkedExpr.strings] onto the stack.
    */
   pushString,
 
   /**
    * Pop the top n values from the stack (where n is obtained from
-   * [UnlinkedConst.ints]), convert them to strings (if they aren't already),
+   * [UnlinkedExpr.ints]), convert them to strings (if they aren't already),
    * concatenate them into a single string, and push it back onto the stack.
    *
    * This operation is used to represent constants whose value is a literal
    * string containing string interpolations.
    */
   concatenate,
 
   /**
-   * Get the next value from [UnlinkedConst.strings], convert it to a symbol,
+   * Get the next value from [UnlinkedExpr.strings], convert it to a symbol,
    * and push it onto the stack.
    */
   makeSymbol,
 
   /**
    * Push the constant `null` onto the stack.
    */
   pushNull,
 
   /**
    * Push the value of the function parameter with the name obtained from
-   * [UnlinkedConst.strings].
+   * [UnlinkedExpr.strings].
    */
   pushParameter,
 
   /**
    * Evaluate a (potentially qualified) identifier expression and push the
    * resulting value onto the stack.  The identifier to be evaluated is
-   * obtained from [UnlinkedConst.references].
+   * obtained from [UnlinkedExpr.references].
    *
    * This operation is used to represent the following kinds of constants
    * (which are indistinguishable from an unresolved AST alone):
    *
    * - A qualified reference to a static constant variable (e.g. `C.v`, where
    *   C is a class and `v` is a constant static variable in `C`).
    * - An identifier expression referring to a constant variable.
    * - A simple or qualified identifier denoting a class or type alias.
    * - A simple or qualified identifier denoting a top-level function or a
    *   static method.
    */
   pushReference,
 
   /**
    * Pop the top value from the stack, extract the value of the property with
-   * the name obtained from [UnlinkedConst.strings], and push the result back
+   * the name obtained from [UnlinkedExpr.strings], and push the result back
    * onto the stack.
    */
   extractProperty,
 
   /**
    * Pop the top `n` values from the stack (where `n` is obtained from
-   * [UnlinkedConst.ints]) into a list (filled from the end) and take the next
-   * `n` values from [UnlinkedConst.strings] and use the lists of names and
+   * [UnlinkedExpr.ints]) into a list (filled from the end) and take the next
+   * `n` values from [UnlinkedExpr.strings] and use the lists of names and
    * values to create named arguments.  Then pop the top `m` values from the
-   * stack (where `m` is obtained from [UnlinkedConst.ints]) into a list (filled
+   * stack (where `m` is obtained from [UnlinkedExpr.ints]) into a list (filled
    * from the end) and use them as positional arguments.  Use the lists of
    * positional and names arguments to invoke a constant constructor obtained
-   * from [UnlinkedConst.references], and push the resulting value back onto the
+   * from [UnlinkedExpr.references], and push the resulting value back onto the
    * stack.
    *
    * Note that for an invocation of the form `const a.b(...)` (where no type
    * arguments are specified), it is impossible to tell from the unresolved AST
    * alone whether `a` is a class name and `b` is a constructor name, or `a` is
    * a prefix name and `b` is a class name.  For consistency between AST based
    * and elements based summaries, references to default constructors are always
    * recorded as references to corresponding classes.
    */
   invokeConstructor,
 
   /**
    * Pop the top n values from the stack (where n is obtained from
-   * [UnlinkedConst.ints]), place them in a [List], and push the result back
+   * [UnlinkedExpr.ints]), place them in a [List], and push the result back
    * onto the stack.  The type parameter for the [List] is implicitly `dynamic`.
    */
   makeUntypedList,
 
   /**
    * Pop the top 2*n values from the stack (where n is obtained from
-   * [UnlinkedConst.ints]), interpret them as key/value pairs, place them in a
+   * [UnlinkedExpr.ints]), interpret them as key/value pairs, place them in a
    * [Map], and push the result back onto the stack.  The two type parameters
    * for the [Map] are implicitly `dynamic`.
    */
   makeUntypedMap,
 
   /**
    * Pop the top n values from the stack (where n is obtained from
-   * [UnlinkedConst.ints]), place them in a [List], and push the result back
+   * [UnlinkedExpr.ints]), place them in a [List], and push the result back
    * onto the stack.  The type parameter for the [List] is obtained from
-   * [UnlinkedConst.references].
+   * [UnlinkedExpr.references].
    */
   makeTypedList,
 
   /**
    * Pop the top 2*n values from the stack (where n is obtained from
-   * [UnlinkedConst.ints]), interpret them as key/value pairs, place them in a
+   * [UnlinkedExpr.ints]), interpret them as key/value pairs, place them in a
    * [Map], and push the result back onto the stack.  The two type parameters for
-   * the [Map] are obtained from [UnlinkedConst.references].
+   * the [Map] are obtained from [UnlinkedExpr.references].
    */
   makeTypedMap,
 
   /**
    * Pop the top 2 values from the stack, evaluate `v1 == v2`, and push the
    * result back onto the stack.
    */
   equal,
 
   /**
@@ skipping 123 matching lines @@
   modulo,
 
   /**
    * Pop the top 3 values from the stack, compute `v1 ? v2 : v3`, and push the
    * result back onto the stack.
    */
   conditional,
 
   /**
    * Pop from the stack `value` and get the next `target` reference from
-   * [UnlinkedConst.references] - a top-level variable (prefixed or not), an
+   * [UnlinkedExpr.references] - a top-level variable (prefixed or not), an
    * assignable field of a class (prefixed or not), or a sequence of getters
    * ending with an assignable property `a.b.b.c.d.e`.  In general `a.b` cannot
    * not be distinguished between: `a` is a prefix and `b` is a top-level
    * variable; or `a` is an object and `b` is the name of a property.  Perform
    * `reference op= value` where `op` is the next assignment operator from
-   * [UnlinkedConst.assignmentOperators].  Push `value` back into the stack.
+   * [UnlinkedExpr.assignmentOperators].  Push `value` back into the stack.
    *
    * If the assignment operator is a prefix/postfix increment/decrement, then
    * `value` is not present in the stack, so it should not be popped and the
    * corresponding value of the `target` after/before update is pushed into the
    * stack instead.
    */
   assignToRef,
 
   /**
    * Pop from the stack `target` and `value`.  Get the name of the property from
    * `UnlinkedConst.strings` and assign the `value` to the named property of the
    * `target`.  This operation is used when we know that the `target` is an
    * object reference expression, e.g. `new Foo().a.b.c` or `a.b[0].c.d`.
    * Perform `target.property op= value` where `op` is the next assignment
-   * operator from [UnlinkedConst.assignmentOperators].  Push `value` back into
+   * operator from [UnlinkedExpr.assignmentOperators].  Push `value` back into
    * the stack.
    *
    * If the assignment operator is a prefix/postfix increment/decrement, then
    * `value` is not present in the stack, so it should not be popped and the
    * corresponding value of the `target` after/before update is pushed into the
    * stack instead.
    */
   assignToProperty,
 
   /**
    * Pop from the stack `index`, `target` and `value`.  Perform
    * `target[index] op= value`  where `op` is the next assignment operator from
-   * [UnlinkedConst.assignmentOperators].  Push `value` back into the stack.
+   * [UnlinkedExpr.assignmentOperators].  Push `value` back into the stack.
    *
    * If the assignment operator is a prefix/postfix increment/decrement, then
    * `value` is not present in the stack, so it should not be popped and the
    * corresponding value of the `target` after/before update is pushed into the
    * stack instead.
    */
   assignToIndex,
 
   /**
    * Pop from the stack `index` and `target`.  Push into the stack the result
    * of evaluation of `target[index]`.
    */
   extractIndex,
 
   /**
    * Pop the top `n` values from the stack (where `n` is obtained from
-   * [UnlinkedConst.ints]) into a list (filled from the end) and take the next
-   * `n` values from [UnlinkedConst.strings] and use the lists of names and
+   * [UnlinkedExpr.ints]) into a list (filled from the end) and take the next
+   * `n` values from [UnlinkedExpr.strings] and use the lists of names and
    * values to create named arguments.  Then pop the top `m` values from the
-   * stack (where `m` is obtained from [UnlinkedConst.ints]) into a list (filled
+   * stack (where `m` is obtained from [UnlinkedExpr.ints]) into a list (filled
    * from the end) and use them as positional arguments.  Use the lists of
    * positional and names arguments to invoke a method (or a function) with
-   * the reference from [UnlinkedConst.references].  If `k` is nonzero (where
-   * `k` is obtained from [UnlinkedConst.ints]), obtain `k` type arguments from
-   * [UnlinkedConst.references] and use them as generic type arguments for the
+   * the reference from [UnlinkedExpr.references].  If `k` is nonzero (where
+   * `k` is obtained from [UnlinkedExpr.ints]), obtain `k` type arguments from
+   * [UnlinkedExpr.references] and use them as generic type arguments for the
    * aforementioned method or function.  Push the result of the invocation onto
    * the stack.
    *
    * In general `a.b` cannot not be distinguished between: `a` is a prefix and
    * `b` is a top-level function; or `a` is an object and `b` is the name of a
    * method.  This operation should be used for a sequence of identifiers
    * `a.b.b.c.d.e` ending with an invokable result.
    */
   invokeMethodRef,
 
   /**
    * Pop the top `n` values from the stack (where `n` is obtained from
-   * [UnlinkedConst.ints]) into a list (filled from the end) and take the next
-   * `n` values from [UnlinkedConst.strings] and use the lists of names and
+   * [UnlinkedExpr.ints]) into a list (filled from the end) and take the next
+   * `n` values from [UnlinkedExpr.strings] and use the lists of names and
    * values to create named arguments.  Then pop the top `m` values from the
-   * stack (where `m` is obtained from [UnlinkedConst.ints]) into a list (filled
+   * stack (where `m` is obtained from [UnlinkedExpr.ints]) into a list (filled
    * from the end) and use them as positional arguments.  Use the lists of
    * positional and names arguments to invoke the method with the name from
-   * [UnlinkedConst.strings] of the target popped from the stack.  If `k` is
-   * nonzero (where `k` is obtained from [UnlinkedConst.ints]), obtain `k` type
-   * arguments from [UnlinkedConst.references] and use them as generic type
+   * [UnlinkedExpr.strings] of the target popped from the stack.  If `k` is
+   * nonzero (where `k` is obtained from [UnlinkedExpr.ints]), obtain `k` type
+   * arguments from [UnlinkedExpr.references] and use them as generic type
    * arguments for the aforementioned method.  Push the result of the
    * invocation onto the stack.
    *
    * This operation should be used for invocation of a method invocation
    * where `target` is known to be an object instance.
    */
   invokeMethod,
 
   /**
    * Begin a new cascade section.  Duplicate the top value of the stack.
    */
   cascadeSectionBegin,
 
   /**
    * End a new cascade section.  Pop the top value from the stack and throw it
    * away.
    */
   cascadeSectionEnd,
 
   /**
    * Pop the top value from the stack and cast it to the type with reference
-   * from [UnlinkedConst.references], push the result into the stack.
+   * from [UnlinkedExpr.references], push the result into the stack.
    */
   typeCast,
 
   /**
    * Pop the top value from the stack and check whether it is a subclass of the
-   * type with reference from [UnlinkedConst.references], push the result into
+   * type with reference from [UnlinkedExpr.references], push the result into
    * the stack.
    */
   typeCheck,
 
   /**
    * Pop the top value from the stack and raise an exception with this value.
    */
   throwException,
 
   /**
-   * Obtain two values `n` and `m` from [UnlinkedConst.ints].  Then, starting at
+   * Obtain two values `n` and `m` from [UnlinkedExpr.ints].  Then, starting at
    * the executable element for the expression being evaluated, if n > 0, pop to
    * the nth enclosing function element.  Then, push the mth local function of
    * that element onto the stack.
    */
   pushLocalFunctionReference,
 }
 
 /**
- * Unlinked summary information about a constructor initializer.
- */
-abstract class UnlinkedConstructorInitializer extends base.SummaryClass {
-  /**
-   * If there are `m` [arguments] and `n` [argumentNames], then each argument
-   * from [arguments] with index `i` such that `n + i - m >= 0`, should be used
-   * with the name at `n + i - m`.
-   */
-  @Id(4)
-  List<String> get argumentNames;
-
-  /**
-   * If [kind] is `thisInvocation` or `superInvocation`, the arguments of the
-   * invocation.  Otherwise empty.
-   */
-  @Id(3)
-  List<UnlinkedConst> get arguments;
-
-  /**
-   * If [kind] is `field`, the expression of the field initializer.
-   * Otherwise `null`.
-   */
-  @Id(1)
-  UnlinkedConst get expression;
-
-  /**
-   * The kind of the constructor initializer (field, redirect, super).
-   */
-  @Id(2)
-  UnlinkedConstructorInitializerKind get kind;
-
-  /**
-   * If [kind] is `field`, the name of the field declared in the class.  If
-   * [kind] is `thisInvocation`, the name of the constructor, declared in this
-   * class, to redirect to.  If [kind] is `superInvocation`, the name of the
-   * constructor, declared in the superclass, to invoke.
-   */
-  @Id(0)
-  String get name;
-}
-
-/**
- * Enum used to indicate the kind of an constructor initializer.
- */
-enum UnlinkedConstructorInitializerKind {
-  /**
-   * Initialization of a field.
-   */
-  field,
-
-  /**
-   * Invocation of a constructor in the same class.
-   */
-  thisInvocation,
-
-  /**
-   * Invocation of a superclass' constructor.
-   */
-  superInvocation
-}
-
-/**
- * Unlinked summary information about a documentation comment.
- */
-abstract class UnlinkedDocumentationComment extends base.SummaryClass {
-  /**
-   * Length of the documentation comment (prior to replacing '\r\n' with '\n').
-   */
-  @Id(0)
-  @deprecated
-  int get length;
-
-  /**
-   * Offset of the beginning of the documentation comment relative to the
-   * beginning of the file.
-   */
-  @Id(2)
-  @deprecated
-  int get offset;
-
-  /**
-   * Text of the documentation comment, with '\r\n' replaced by '\n'.
-   *
-   * References appearing within the doc comment in square brackets are not
-   * specially encoded.
-   */
-  @Id(1)
-  String get text;
-}
-
-/**
- * Unlinked summary information about an enum declaration.
- */
-abstract class UnlinkedEnum extends base.SummaryClass {
-  /**
-   * Annotations for this enum.
-   */
-  @Id(4)
-  List<UnlinkedConst> get annotations;
-
-  /**
-   * Code range of the enum.
-   */
-  @informative
-  @Id(5)
-  CodeRange get codeRange;
-
-  /**
-   * Documentation comment for the enum, or `null` if there is no documentation
-   * comment.
-   */
-  @informative
-  @Id(3)
-  UnlinkedDocumentationComment get documentationComment;
-
-  /**
-   * Name of the enum type.
-   */
-  @Id(0)
-  String get name;
-
-  /**
-   * Offset of the enum name relative to the beginning of the file.
-   */
-  @informative
-  @Id(1)
-  int get nameOffset;
-
-  /**
-   * Values listed in the enum declaration, in declaration order.
-   */
-  @Id(2)
-  List<UnlinkedEnumValue> get values;
-}
-
-/**
- * Unlinked summary information about a single enumerated value in an enum
- * declaration.
- */
-abstract class UnlinkedEnumValue extends base.SummaryClass {
-  /**
-   * Documentation comment for the enum value, or `null` if there is no
-   * documentation comment.
-   */
-  @informative
-  @Id(2)
-  UnlinkedDocumentationComment get documentationComment;
-
-  /**
-   * Name of the enumerated value.
-   */
-  @Id(0)
-  String get name;
-
-  /**
-   * Offset of the enum value name relative to the beginning of the file.
-   */
-  @informative
-  @Id(1)
-  int get nameOffset;
-}
-
-/**
- * Unlinked summary information about a function, method, getter, or setter
- * declaration.
- */
-abstract class UnlinkedExecutable extends base.SummaryClass {
-  /**
-   * Annotations for this executable.
-   */
-  @Id(6)
-  List<UnlinkedConst> get annotations;
-
-  /**
-   * If this executable's function body is declared using `=>`, the expression
-   * to the right of the `=>`.  May be omitted if neither type inference nor
-   * constant evaluation depends on the function body.
-   */
-  @Id(29)
-  UnlinkedConst get bodyExpr;
-
-  /**
-   * Code range of the executable.
-   */
-  @informative
-  @Id(26)
-  CodeRange get codeRange;
-
-  /**
-   * If a constant [UnlinkedExecutableKind.constructor], the constructor
-   * initializers.  Otherwise empty.
-   */
-  @Id(14)
-  List<UnlinkedConstructorInitializer> get constantInitializers;
-
-  /**
-   * If [kind] is [UnlinkedExecutableKind.constructor] and [isConst] is `true`,
-   * a nonzero slot id which is unique within this compilation unit.  If this id
-   * is found in [LinkedUnit.constCycles], then this constructor is part of a
-   * cycle.
-   *
-   * Otherwise, zero.
-   */
-  @Id(25)
-  int get constCycleSlot;
-
-  /**
-   * Documentation comment for the executable, or `null` if there is no
-   * documentation comment.
-   */
-  @informative
-  @Id(7)
-  UnlinkedDocumentationComment get documentationComment;
-
-  /**
-   * If this executable's return type is inferable, nonzero slot id
-   * identifying which entry in [LinkedUnit.types] contains the inferred
-   * return type.  If there is no matching entry in [LinkedUnit.types], then
-   * no return type was inferred for this variable, so its static type is
-   * `dynamic`.
-   */
-  @Id(5)
-  int get inferredReturnTypeSlot;
-
-  /**
-   * Indicates whether the executable is declared using the `abstract` keyword.
-   */
-  @Id(10)
-  bool get isAbstract;
-
-  /**
-   * Indicates whether the executable has body marked as being asynchronous.
-   */
-  @informative
-  @Id(27)
-  bool get isAsynchronous;
-
-  /**
-   * Indicates whether the executable is declared using the `const` keyword.
-   */
-  @Id(12)
-  bool get isConst;
-
-  /**
-   * Indicates whether the executable is declared using the `external` keyword.
-   */
-  @Id(11)
-  bool get isExternal;
-
-  /**
-   * Indicates whether the executable is declared using the `factory` keyword.
-   */
-  @Id(8)
-  bool get isFactory;
-
-  /**
-   * Indicates whether the executable has body marked as being a generator.
-   */
-  @informative
-  @Id(28)
-  bool get isGenerator;
-
-  /**
-   * Indicates whether the executable is a redirected constructor.
-   */
-  @Id(13)
-  bool get isRedirectedConstructor;
-
-  /**
-   * Indicates whether the executable is declared using the `static` keyword.
-   *
-   * Note that for top level executables, this flag is false, since they are
-   * not declared using the `static` keyword (even though they are considered
-   * static for semantic purposes).
-   */
-  @Id(9)
-  bool get isStatic;
-
-  /**
-   * The kind of the executable (function/method, getter, setter, or
-   * constructor).
-   */
-  @Id(4)
-  UnlinkedExecutableKind get kind;
-
-  /**
-   * The list of local functions.
-   */
-  @Id(18)
-  List<UnlinkedExecutable> get localFunctions;
-
-  /**
-   * The list of local labels.
-   */
-  @informative
-  @Id(22)
-  List<UnlinkedLabel> get localLabels;
-
-  /**
-   * The list of local variables.
-   */
-  @informative
-  @Id(19)
-  List<UnlinkedVariable> get localVariables;
-
-  /**
-   * Name of the executable.  For setters, this includes the trailing "=".  For
-   * named constructors, this excludes the class name and excludes the ".".
-   * For unnamed constructors, this is the empty string.
-   */
-  @Id(1)
-  String get name;
-
-  /**
-   * If [kind] is [UnlinkedExecutableKind.constructor] and [name] is not empty,
-   * the offset of the end of the constructor name.  Otherwise zero.
-   */
-  @informative
-  @Id(23)
-  int get nameEnd;
-
-  /**
-   * Offset of the executable name relative to the beginning of the file.  For
-   * named constructors, this excludes the class name and excludes the ".".
-   * For unnamed constructors, this is the offset of the class name (i.e. the
-   * offset of the second "C" in "class C { C(); }").
-   */
-  @informative
-  @Id(0)
-  int get nameOffset;
-
-  /**
-   * Parameters of the executable, if any.  Note that getters have no
-   * parameters (hence this will be the empty list), and setters have a single
-   * parameter.
-   */
-  @Id(2)
-  List<UnlinkedParam> get parameters;
-
-  /**
-   * If [kind] is [UnlinkedExecutableKind.constructor] and [name] is not empty,
-   * the offset of the period before the constructor name.  Otherwise zero.
-   */
-  @informative
-  @Id(24)
-  int get periodOffset;
-
-  /**
-   * If [isRedirectedConstructor] and [isFactory] are both `true`, the
-   * constructor to which this constructor redirects; otherwise empty.
-   */
-  @Id(15)
-  EntityRef get redirectedConstructor;
-
-  /**
-   * If [isRedirectedConstructor] is `true` and [isFactory] is `false`, the
-   * name of the constructor that this constructor redirects to; otherwise
-   * empty.
-   */
-  @Id(17)
-  String get redirectedConstructorName;
-
-  /**
-   * Declared return type of the executable.  Absent if the executable is a
-   * constructor or the return type is implicit.  Absent for executables
-   * associated with variable initializers and closures, since these
-   * executables may have return types that are not accessible via direct
-   * imports.
-   */
-  @Id(3)
-  EntityRef get returnType;
-
-  /**
-   * Type parameters of the executable, if any.  Empty if support for generic
-   * method syntax is disabled.
-   */
-  @Id(16)
-  List<UnlinkedTypeParam> get typeParameters;
-
-  /**
-   * If a local function, the length of the visible range; zero otherwise.
-   */
-  @informative
-  @Id(20)
-  int get visibleLength;
-
-  /**
-   * If a local function, the beginning of the visible range; zero otherwise.
-   */
-  @informative
-  @Id(21)
-  int get visibleOffset;
-}
-
-/**
- * Enum used to indicate the kind of an executable.
- */
-enum UnlinkedExecutableKind {
-  /**
-   * Executable is a function or method.
-   */
-  functionOrMethod,
-
-  /**
-   * Executable is a getter.
-   */
-  getter,
-
-  /**
-   * Executable is a setter.
-   */
-  setter,
-
-  /**
-   * Executable is a constructor.
-   */
-  constructor
-}
-
-/**
- * Unlinked summary information about an export declaration (stored outside
- * [UnlinkedPublicNamespace]).
- */
-abstract class UnlinkedExportNonPublic extends base.SummaryClass {
-  /**
-   * Annotations for this export directive.
-   */
-  @Id(3)
-  List<UnlinkedConst> get annotations;
-
-  /**
-   * Offset of the "export" keyword.
-   */
-  @informative
-  @Id(0)
-  int get offset;
-
-  /**
-   * End of the URI string (including quotes) relative to the beginning of the
-   * file.
-   */
-  @informative
-  @Id(1)
-  int get uriEnd;
-
-  /**
-   * Offset of the URI string (including quotes) relative to the beginning of
-   * the file.
-   */
-  @informative
-  @Id(2)
-  int get uriOffset;
-}
-
-/**
- * Unlinked summary information about an export declaration (stored inside
- * [UnlinkedPublicNamespace]).
- */
-abstract class UnlinkedExportPublic extends base.SummaryClass {
-  /**
-   * Combinators contained in this export declaration.
-   */
-  @Id(1)
-  List<UnlinkedCombinator> get combinators;
-
-  /**
-   * Configurations used to control which library will actually be loaded at
-   * run-time.
-   */
-  @Id(2)
-  List<UnlinkedConfiguration> get configurations;
-
-  /**
-   * URI used in the source code to reference the exported library.
-   */
-  @Id(0)
-  String get uri;
-}
-
-/**
- * Enum representing the various kinds of assignment operations combined
- * with:
- *    [UnlinkedConstOperation.assignToRef],
- *    [UnlinkedConstOperation.assignToProperty],
- *    [UnlinkedConstOperation.assignToIndex].
- */
-enum UnlinkedExprAssignOperator {
-  /**
-   * Perform simple assignment `target = operand`.
-   */
-  assign,
-
-  /**
-   * Perform `target ??= operand`.
-   */
-  ifNull,
-
-  /**
-   * Perform `target *= operand`.
-   */
-  multiply,
-
-  /**
-   * Perform `target /= operand`.
-   */
-  divide,
-
-  /**
-   * Perform `target ~/= operand`.
-   */
-  floorDivide,
-
-  /**
-   * Perform `target %= operand`.
-   */
-  modulo,
-
-  /**
-   * Perform `target += operand`.
-   */
-  plus,
-
-  /**
-   * Perform `target -= operand`.
-   */
-  minus,
-
-  /**
-   * Perform `target <<= operand`.
-   */
-  shiftLeft,
-
-  /**
-   * Perform `target >>= operand`.
-   */
-  shiftRight,
-
-  /**
-   * Perform `target &= operand`.
-   */
-  bitAnd,
-
-  /**
-   * Perform `target ^= operand`.
-   */
-  bitXor,
-
-  /**
-   * Perform `target |= operand`.
-   */
-  bitOr,
-
-  /**
-   * Perform `++target`.
-   */
-  prefixIncrement,
-
-  /**
-   * Perform `--target`.
-   */
-  prefixDecrement,
-
-  /**
-   * Perform `target++`.
-   */
-  postfixIncrement,
-
-  /**
-   * Perform `target++`.
-   */
-  postfixDecrement,
-}
-
-/**
  * Unlinked summary information about an import declaration.
  */
 abstract class UnlinkedImport extends base.SummaryClass {
   /**
    * Annotations for this import declaration.
    */
   @Id(8)
-  List<UnlinkedConst> get annotations;
+  List<UnlinkedExpr> get annotations;
 
   /**
    * Combinators contained in this import declaration.
    */
   @Id(4)
   List<UnlinkedCombinator> get combinators;
 
   /**
    * Configurations used to control which library will actually be loaded at
    * run-time.
@@ skipping 93 matching lines @@
 }
 
 /**
  * Unlinked summary information about a function parameter.
  */
 abstract class UnlinkedParam extends base.SummaryClass {
   /**
    * Annotations for this parameter.
    */
   @Id(9)
-  List<UnlinkedConst> get annotations;
+  List<UnlinkedExpr> get annotations;
 
   /**
    * Code range of the parameter.
    */
   @informative
   @Id(7)
   CodeRange get codeRange;
 
   /**
    * If the parameter has a default value, the source text of the constant
@@ skipping 117 matching lines @@
 }
 
 /**
  * Unlinked summary information about a part declaration.
  */
 abstract class UnlinkedPart extends base.SummaryClass {
   /**
    * Annotations for this part declaration.
    */
   @Id(2)
-  List<UnlinkedConst> get annotations;
+  List<UnlinkedExpr> get annotations;
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.
    */
   @informative
   @Id(0)
   int get uriEnd;
 
   /**
@@ skipping 103 matching lines @@
 }
 
 /**
  * Unlinked summary information about a typedef declaration.
  */
 abstract class UnlinkedTypedef extends base.SummaryClass {
   /**
    * Annotations for this typedef.
    */
   @Id(4)
-  List<UnlinkedConst> get annotations;
+  List<UnlinkedExpr> get annotations;
 
   /**
    * Code range of the typedef.
    */
   @informative
   @Id(7)
   CodeRange get codeRange;
 
   /**
    * Documentation comment for the typedef, or `null` if there is no
@@ skipping 36 matching lines @@
 }
 
 /**
  * Unlinked summary information about a type parameter declaration.
  */
 abstract class UnlinkedTypeParam extends base.SummaryClass {
   /**
    * Annotations for this type parameter.
    */
   @Id(3)
-  List<UnlinkedConst> get annotations;
+  List<UnlinkedExpr> get annotations;
 
   /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
   @Id(2)
   EntityRef get bound;
 
   /**
    * Code range of the type parameter.
@@ skipping 84 matching lines @@
    * Indicates whether the unit contains a "part of" declaration.
    */
   @Id(18)
   bool get isPartOf;
 
   /**
    * Annotations for the library declaration, or the empty list if there is no
    * library declaration.
    */
   @Id(14)
-  List<UnlinkedConst> get libraryAnnotations;
+  List<UnlinkedExpr> get libraryAnnotations;
 
   /**
    * Documentation comment for the library, or `null` if there is no
    * documentation comment.
    */
   @informative
   @Id(9)
   UnlinkedDocumentationComment get libraryDocumentationComment;
 
   /**
@@ skipping 62 matching lines @@
 
 /**
  * Unlinked summary information about a top level variable, local variable, or
  * a field.
  */
 abstract class UnlinkedVariable extends base.SummaryClass {
   /**
    * Annotations for this variable.
    */
   @Id(8)
-  List<UnlinkedConst> get annotations;
+  List<UnlinkedExpr> get annotations;
 
   /**
    * Code range of the variable.
    */
   @informative
   @Id(5)
   CodeRange get codeRange;
 
   /**
    * Documentation comment for the variable, or `null` if there is no
@@ skipping 78 matching lines @@
   @Id(11)
   int get visibleLength;
 
   /**
    * If a local variable, the beginning of the visible range; zero otherwise.
    */
   @informative
   @Id(12)
   int get visibleOffset;
 }