Generate documentation for enumeration values.

pkg/analyzer/lib/src/summary/format.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 has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script "pkg/analyzer/tool/generate_files".
 
 library analyzer.src.summary.format;
 
 import 'base.dart' as base;
 import 'flat_buffers.dart' as fb;
 
 /**
  * Enum used to indicate the kind of entity referred to by a
  * [LinkedReference].
  */
 enum ReferenceKind {
+  /**
+   * The entity is a class or enum.
+   */
   classOrEnum,
+
+  /**
+   * The entity is a typedef.
+   */
   typedef,
+
+  /**
+   * The entity is a top level function.
+   */
   topLevelFunction,
+
+  /**
+   * The entity is a top level getter or setter.
+   */
   topLevelPropertyAccessor,
+
+  /**
+   * The entity is a prefix.
+   */
   prefix,
-  unresolved,
+
+  /**
+   * The entity being referred to does not exist.
+   */
+  unresolved
 }
 
 class _ReferenceKindReader extends fb.Reader<ReferenceKind> {
   const _ReferenceKindReader() : super();
 
   @override
   int get size => 4;
 
   @override
   ReferenceKind read(fb.BufferPointer bp) {
     int index = const fb.Uint32Reader().read(bp);
     return ReferenceKind.values[index];
   }
 }
 
 /**
  * Enum representing the various kinds of operations which may be performed to
  * produce a constant value.  These options are assumed to execute in the
  * context of a stack which is initially empty.
  */
 enum UnlinkedConstOperation {
+  /**
+   * Push the value of the n-th constructor argument (where n is obtained from
+   * [UnlinkedConst.ints]) onto the stack.
+   */
   pushArgument,
+
+  /**
+   * Push the next value from [UnlinkedConst.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 [shiftOr] operation.
+   */
   pushInt,
+
+  /**
+   * Pop the top value off the stack, which should be an integer.  Multiply it
+   * by 2^32, "or" in the next value from [UnlinkedConst.ints] (which is
+   * interpreted as a 32-bit unsigned integer), and push the result back onto
+   * the stack.
+   */
   shiftOr,
+
+  /**
+   * Push the next value from [UnlinkedConst.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.
+   */
   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),
+   * 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,
+
+  /**
+   * Pop the top value from the stack which should be string, convert it to
+   * a symbol, and push it back onto the stack.
+   */
   makeSymbol,
+
+  /**
+   * Push the constant `null` onto the stack.
+   */
   pushNull,
+
+  /**
+   * Evaluate a (potentially qualified) identifier expression and push the
+   * resulting value onto the stack.  The identifier to be evaluated is
+   * obtained from [UnlinkedConst.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 `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
+   * 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
+   * from the end) and use them as positional arguments.  Use the lists of
+   * positional and names arguments to invoke a constant constructor whose name
+   * is obtained from [UnlinkedConst.strings], and whose class is obtained from
+   * [UnlinkedConst.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.  In this case it is presumed that
+   * `a` is a prefix name and `b` is a class name.
+   *
+   * TODO(paulberry): figure out how to resolve this ambiguity in the
+   * "prelinked" part of the summary.
+   */
   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
+   * onto the stack.  The type parameter for the [List] is obtained from
+   * [UnlinkedConst.references].
+   */
   makeList,
+
+  /**
+   * 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
+   * [Map], and push the result back onto the stack.  The two type parameters for
+   * the [Map] are obtained from [UnlinkedConst.references].
+   */
   makeMap,
+
+  /**
+   * Pop the top 2 values from the stack, pass them to the predefined Dart
+   * function `identical`, and push the result back onto the stack.
+   */
   identical,
+
+  /**
+   * Pop the top 2 values from the stack, evaluate `v1 == v2`, and push the
+   * result back onto the stack.
+   *
+   * This is also used to represent `v1 != v2`, by composition with [not].
+   */
   equal,
+
+  /**
+   * Pop the top value from the stack, compute its boolean negation, and push
+   * the result back onto the stack.
+   */
   not,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 && v2`, and push the
+   * result back onto the stack.
+   */
   and,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 || v2`, and push the
+   * result back onto the stack.
+   */
   or,
+
+  /**
+   * Pop the top value from the stack, compute its integer complement, and push
+   * the result back onto the stack.
+   */
   complement,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 ^ v2`, and push the
+   * result back onto the stack.
+   */
   bitXor,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 & v2`, and push the
+   * result back onto the stack.
+   */
   bitAnd,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 | v2`, and push the
+   * result back onto the stack.
+   */
   bitOr,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 >> v2`, and push the
+   * result back onto the stack.
+   */
   bitShiftRight,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 << v2`, and push the
+   * result back onto the stack.
+   */
   bitShiftLeft,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 + v2`, and push the
+   * result back onto the stack.
+   */
   add,
+
+  /**
+   * Pop the top value from the stack, compute its integer negation, and push
+   * the result back onto the stack.
+   */
   negate,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 - v2`, and push the
+   * result back onto the stack.
+   */
   subtract,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 * v2`, and push the
+   * result back onto the stack.
+   */
   multiply,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 / v2`, and push the
+   * result back onto the stack.
+   */
   divide,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 ~/ v2`, and push the
+   * result back onto the stack.
+   */
   floorDivide,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 > v2`, and push the
+   * result back onto the stack.
+   */
   greater,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 < v2`, and push the
+   * result back onto the stack.
+   */
   less,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 >= v2`, and push the
+   * result back onto the stack.
+   */
   greaterEqual,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 <= v2`, and push the
+   * result back onto the stack.
+   */
   lessEqual,
+
+  /**
+   * Pop the top 2 values from the stack, compute `v1 % v2`, and push the
+   * result back onto the stack.
+   */
   modulo,
+
+  /**
+   * Pop the top 3 values from the stack, compute `v1 ? v2 : v3`, and push the
+   * result back onto the stack.
+   */
   conditional,
-  length,
+
+  /**
+   * Pop the top value from the stack, evaluate `v.length`, and push the result
+   * back onto the stack.
+   */
+  length
 }
 
 class _UnlinkedConstOperationReader extends fb.Reader<UnlinkedConstOperation> {
   const _UnlinkedConstOperationReader() : super();
 
   @override
   int get size => 4;
 
   @override
   UnlinkedConstOperation read(fb.BufferPointer bp) {
     int index = const fb.Uint32Reader().read(bp);
     return UnlinkedConstOperation.values[index];
   }
 }
 
 /**
  * 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,
-  constructor,
+
+  /**
+   * Executable is a constructor.
+   */
+  constructor
 }
 
 class _UnlinkedExecutableKindReader extends fb.Reader<UnlinkedExecutableKind> {
   const _UnlinkedExecutableKindReader() : super();
 
   @override
   int get size => 4;
 
   @override
   UnlinkedExecutableKind read(fb.BufferPointer bp) {
     int index = const fb.Uint32Reader().read(bp);
     return UnlinkedExecutableKind.values[index];
   }
 }
 
 /**
  * Enum used to indicate the kind of a parameter.
  */
 enum UnlinkedParamKind {
+  /**
+   * Parameter is required.
+   */
   required,
+
+  /**
+   * Parameter is positional optional (enclosed in `[]`)
+   */
   positional,
-  named,
+
+  /**
+   * Parameter is named optional (enclosed in `{}`)
+   */
+  named
 }
 
 class _UnlinkedParamKindReader extends fb.Reader<UnlinkedParamKind> {
   const _UnlinkedParamKindReader() : super();
 
   @override
   int get size => 4;
 
   @override
   UnlinkedParamKind read(fb.BufferPointer bp) {
@@ skipping 5607 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
     "propagatedTypeSlot": propagatedTypeSlot,
   };
 }