Rename UnlinkedConst -> UnlinkedExpr

pkg/analyzer/lib/src/summary/format.fbs

 // 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 script "pkg/analyzer/tool/generate_files".
 
 
 /**
  * Enum used to indicate the kind of a name in index.
@@ skipping 192 matching lines @@
    */
   prefix,
 
   /**
    * The entity being referred to does not exist.
    */
   unresolved
 }
 
 /**
+ * Enum used to indicate the kind of an constructor initializer.
+ */
+enum UnlinkedConstructorInitializerKind : byte {
+  /**
+   * Initialization of a field.
+   */
+  field,
+
+  /**
+   * Invocation of a constructor in the same class.
+   */
+  thisInvocation,
+
+  /**
+   * Invocation of a superclass' constructor.
+   */
+  superInvocation
+}
+
+/**
+ * Enum used to indicate the kind of an executable.
+ */
+enum UnlinkedExecutableKind : byte {
+  /**
+   * Executable is a function or method.
+   */
+  functionOrMethod,
+
+  /**
+   * Executable is a getter.
+   */
+  getter,
+
+  /**
+   * Executable is a setter.
+   */
+  setter,
+
+  /**
+   * Executable is a constructor.
+   */
+  constructor
+}
+
+/**
+ * Enum representing the various kinds of assignment operations combined
+ * with:
+ *    [UnlinkedExprOperation.assignToRef],
+ *    [UnlinkedExprOperation.assignToProperty],
+ *    [UnlinkedExprOperation.assignToIndex].
+ */
+enum UnlinkedExprAssignOperator : byte {
+  /**
+   * 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 : byte {
+enum UnlinkedExprOperation : byte {
   /**
-   * Push the next value from [UnlinkedConst.ints] (a 32-bit unsigned integer)
+   * 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
 }
 
 /**
- * Enum used to indicate the kind of an constructor initializer.
- */
-enum UnlinkedConstructorInitializerKind : byte {
-  /**
-   * Initialization of a field.
-   */
-  field,
-
-  /**
-   * Invocation of a constructor in the same class.
-   */
-  thisInvocation,
-
-  /**
-   * Invocation of a superclass' constructor.
-   */
-  superInvocation
-}
-
-/**
- * Enum used to indicate the kind of an executable.
- */
-enum UnlinkedExecutableKind : byte {
-  /**
-   * Executable is a function or method.
-   */
-  functionOrMethod,
-
-  /**
-   * Executable is a getter.
-   */
-  getter,
-
-  /**
-   * Executable is a setter.
-   */
-  setter,
-
-  /**
-   * Executable is a constructor.
-   */
-  constructor
-}
-
-/**
- * Enum representing the various kinds of assignment operations combined
- * with:
- *    [UnlinkedConstOperation.assignToRef],
- *    [UnlinkedConstOperation.assignToProperty],
- *    [UnlinkedConstOperation.assignToIndex].
- */
-enum UnlinkedExprAssignOperator : byte {
-  /**
-   * 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 used to indicate the kind of a parameter.
  */
 enum UnlinkedParamKind : byte {
   /**
    * Parameter is required.
    */
   required,
 
   /**
    * Parameter is positional optional (enclosed in `[]`)
@@ skipping 616 matching lines @@
   usedNames:[uint] (id: 8);
 }
 
 /**
  * Unlinked summary information about a class declaration.
  */
 table UnlinkedClass {
   /**
    * Annotations for this class.
    */
-  annotations:[UnlinkedConst] (id: 5);
+  annotations:[UnlinkedExpr] (id: 5);
 
   /**
    * Code range of the class.
    */
   codeRange:CodeRange (id: 13);
 
   /**
    * Documentation comment for the class, or `null` if there is no
    * documentation comment.
    */
@@ skipping 102 matching lines @@
   uri:string (id: 2);
 
   /**
    * The value to which the value of the declared variable will be compared,
    * or `true` if the condition does not include an equality test.
    */
   value:string (id: 1);
 }
 
 /**
- * Unlinked summary information about a compile-time constant expression, or a
- * potentially constant expression.
- *
- * Constant 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.
- */
-table UnlinkedConst {
-  /**
-   * Sequence of operators used by assignment operations.
-   */
-  assignmentOperators:[UnlinkedExprAssignOperator] (id: 6);
-
-  /**
-   * Sequence of 64-bit doubles consumed by the operation `pushDouble`.
-   */
-  doubles:[double] (id: 4);
-
-  /**
-   * Sequence of unsigned 32-bit integers consumed by the operations
-   * `pushArgument`, `pushInt`, `shiftOr`, `concatenate`, `invokeConstructor`,
-   * `makeList`, and `makeMap`.
-   */
-  ints:[uint] (id: 1);
-
-  /**
-   * Indicates whether the expression is a valid potentially constant
-   * expression.
-   */
-  isValidConst:bool (id: 5);
-
-  /**
-   * Sequence of operations to execute (starting with an empty stack) to form
-   * the constant value.
-   */
-  operations:[UnlinkedConstOperation] (id: 0);
-
-  /**
-   * 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.
-   */
-  references:[EntityRef] (id: 2);
-
-  /**
-   * Sequence of strings consumed by the operations `pushString` and
-   * `invokeConstructor`.
-   */
-  strings:[string] (id: 3);
-}
-
-/**
  * Unlinked summary information about a constructor initializer.
  */
 table UnlinkedConstructorInitializer {
   /**
    * 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`.
    */
   argumentNames:[string] (id: 4);
 
   /**
    * If [kind] is `thisInvocation` or `superInvocation`, the arguments of the
    * invocation.  Otherwise empty.
    */
-  arguments:[UnlinkedConst] (id: 3);
+  arguments:[UnlinkedExpr] (id: 3);
 
   /**
    * If [kind] is `field`, the expression of the field initializer.
    * Otherwise `null`.
    */
-  expression:UnlinkedConst (id: 1);
+  expression:UnlinkedExpr (id: 1);
 
   /**
    * The kind of the constructor initializer (field, redirect, super).
    */
   kind:UnlinkedConstructorInitializerKind (id: 2);
 
   /**
    * 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
@@ skipping 26 matching lines @@
   text:string (id: 1);
 }
 
 /**
  * Unlinked summary information about an enum declaration.
  */
 table UnlinkedEnum {
   /**
    * Annotations for this enum.
    */
-  annotations:[UnlinkedConst] (id: 4);
+  annotations:[UnlinkedExpr] (id: 4);
 
   /**
    * Code range of the enum.
    */
   codeRange:CodeRange (id: 5);
 
   /**
    * Documentation comment for the enum, or `null` if there is no documentation
    * comment.
    */
@@ skipping 38 matching lines @@
 }
 
 /**
  * Unlinked summary information about a function, method, getter, or setter
  * declaration.
  */
 table UnlinkedExecutable {
   /**
    * Annotations for this executable.
    */
-  annotations:[UnlinkedConst] (id: 6);
+  annotations:[UnlinkedExpr] (id: 6);
 
   /**
    * 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.
    */
-  bodyExpr:UnlinkedConst (id: 29);
+  bodyExpr:UnlinkedExpr (id: 29);
 
   /**
    * Code range of the executable.
    */
   codeRange:CodeRange (id: 26);
 
   /**
    * If a constant [UnlinkedExecutableKind.constructor], the constructor
    * initializers.  Otherwise empty.
    */
@@ skipping 163 matching lines @@
 }
 
 /**
  * Unlinked summary information about an export declaration (stored outside
  * [UnlinkedPublicNamespace]).
  */
 table UnlinkedExportNonPublic {
   /**
    * Annotations for this export directive.
    */
-  annotations:[UnlinkedConst] (id: 3);
+  annotations:[UnlinkedExpr] (id: 3);
 
   /**
    * Offset of the "export" keyword.
    */
   offset:uint (id: 0);
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.
    */
@@ skipping 22 matching lines @@
    */
   configurations:[UnlinkedConfiguration] (id: 2);
 
   /**
    * URI used in the source code to reference the exported library.
    */
   uri:string (id: 0);
 }
 
 /**
+ * Unlinked summary information about an expression.
+ *
+ * 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.
+ */
+table UnlinkedExpr {
+  /**
+   * Sequence of operators used by assignment operations.
+   */
+  assignmentOperators:[UnlinkedExprAssignOperator] (id: 6);
+
+  /**
+   * Sequence of 64-bit doubles consumed by the operation `pushDouble`.
+   */
+  doubles:[double] (id: 4);
+
+  /**
+   * Sequence of unsigned 32-bit integers consumed by the operations
+   * `pushArgument`, `pushInt`, `shiftOr`, `concatenate`, `invokeConstructor`,
+   * `makeList`, and `makeMap`.
+   */
+  ints:[uint] (id: 1);
+
+  /**
+   * Indicates whether the expression is a valid potentially constant
+   * expression.
+   */
+  isValidConst:bool (id: 5);
+
+  /**
+   * Sequence of operations to execute (starting with an empty stack) to form
+   * the constant value.
+   */
+  operations:[UnlinkedExprOperation] (id: 0);
+
+  /**
+   * 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.
+   */
+  references:[EntityRef] (id: 2);
+
+  /**
+   * Sequence of strings consumed by the operations `pushString` and
+   * `invokeConstructor`.
+   */
+  strings:[string] (id: 3);
+}
+
+/**
  * Unlinked summary information about an import declaration.
  */
 table UnlinkedImport {
   /**
    * Annotations for this import declaration.
    */
-  annotations:[UnlinkedConst] (id: 8);
+  annotations:[UnlinkedExpr] (id: 8);
 
   /**
    * Combinators contained in this import declaration.
    */
   combinators:[UnlinkedCombinator] (id: 4);
 
   /**
    * Configurations used to control which library will actually be loaded at
    * run-time.
    */
@@ skipping 73 matching lines @@
   nameOffset:uint (id: 1);
 }
 
 /**
  * Unlinked summary information about a function parameter.
  */
 table UnlinkedParam {
   /**
    * Annotations for this parameter.
    */
-  annotations:[UnlinkedConst] (id: 9);
+  annotations:[UnlinkedExpr] (id: 9);
 
   /**
    * Code range of the parameter.
    */
   codeRange:CodeRange (id: 7);
 
   /**
    * If the parameter has a default value, the source text of the constant
    * expression in the default value.  Otherwise the empty string.
    */
@@ skipping 77 matching lines @@
   visibleOffset:uint (id: 11);
 }
 
 /**
  * Unlinked summary information about a part declaration.
  */
 table UnlinkedPart {
   /**
    * Annotations for this part declaration.
    */
-  annotations:[UnlinkedConst] (id: 2);
+  annotations:[UnlinkedExpr] (id: 2);
 
   /**
    * End of the URI string (including quotes) relative to the beginning of the
    * file.
    */
   uriEnd:uint (id: 0);
 
   /**
    * Offset of the URI string (including quotes) relative to the beginning of
    * the file.
@@ skipping 85 matching lines @@
   prefixReference:uint (id: 1);
 }
 
 /**
  * Unlinked summary information about a typedef declaration.
  */
 table UnlinkedTypedef {
   /**
    * Annotations for this typedef.
    */
-  annotations:[UnlinkedConst] (id: 4);
+  annotations:[UnlinkedExpr] (id: 4);
 
   /**
    * Code range of the typedef.
    */
   codeRange:CodeRange (id: 7);
 
   /**
    * Documentation comment for the typedef, or `null` if there is no
    * documentation comment.
    */
@@ skipping 25 matching lines @@
   typeParameters:[UnlinkedTypeParam] (id: 5);
 }
 
 /**
  * Unlinked summary information about a type parameter declaration.
  */
 table UnlinkedTypeParam {
   /**
    * Annotations for this type parameter.
    */
-  annotations:[UnlinkedConst] (id: 3);
+  annotations:[UnlinkedExpr] (id: 3);
 
   /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
   bound:EntityRef (id: 2);
 
   /**
    * Code range of the type parameter.
    */
@@ skipping 63 matching lines @@
 
   /**
    * Indicates whether the unit contains a "part of" declaration.
    */
   isPartOf:bool (id: 18);
 
   /**
    * Annotations for the library declaration, or the empty list if there is no
    * library declaration.
    */
-  libraryAnnotations:[UnlinkedConst] (id: 14);
+  libraryAnnotations:[UnlinkedExpr] (id: 14);
 
   /**
    * Documentation comment for the library, or `null` if there is no
    * documentation comment.
    */
   libraryDocumentationComment:UnlinkedDocumentationComment (id: 9);
 
   /**
    * Name of the library (from a "library" declaration, if present).
    */
@@ skipping 47 matching lines @@
 }
 
 /**
  * Unlinked summary information about a top level variable, local variable, or
  * a field.
  */
 table UnlinkedVariable {
   /**
    * Annotations for this variable.
    */
-  annotations:[UnlinkedConst] (id: 8);
+  annotations:[UnlinkedExpr] (id: 8);
 
   /**
    * Code range of the variable.
    */
   codeRange:CodeRange (id: 5);
 
   /**
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
@@ skipping 64 matching lines @@
 
   /**
    * If a local variable, the beginning of the visible range; zero otherwise.
    */
   visibleOffset:uint (id: 12);
 }
 
 root_type PackageBundle;
 
 file_identifier "PBdl";