Rename TypeRef to EntityRef.

pkg/analyzer/tool/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 is not
  * executed directly; instead it is parsed and transformed into code that
  * implements the summary format.
  *
  * The code generation process introduces the following non-typical semantics:
@@ skipping 49 matching lines @@
  */
 const private = null;
 
 /**
  * Annotation describing a class which can be the top level object in an
  * encoded summary.
  */
 const topLevel = null;
 
 /**
+ * Summary information about a reference to a an entity such as a type, top
+ * level executable, or executable within a class.
+ */
+class EntityRef {
+  /**
+   * If this [EntityRef] is contained within [LinkedUnit.types], slot id (which
+   * is unique within the compilation unit) identifying the target of type
+   * propagation or type inference with which this [EntityRef] is associated.
+   *
+   * Otherwise zero.
+   */
+  int slot;
+
+  /**
+   * Index into [UnlinkedUnit.references] for the entity being referred to, or
+   * zero if this is a reference to a type parameter.
+   *
+   * Note that since zero is also a valid index into
+   * [UnlinkedUnit.references], we cannot distinguish between references to
+   * type parameters and references to other entities by checking [reference]
+   * against zero.  To distinguish between references to type parameters and
+   * references to other entities, check whether [paramReference] is zero.
+   */
+  int reference;
+
+  /**
+   * If this is a reference to a type parameter, one-based index into the list
+   * of [UnlinkedTypeParam]s currently in effect.  Indexing is done using De
+   * Bruijn index conventions; that is, innermost parameters come first, and
+   * if a class or method has multiple parameters, they are indexed from right
+   * to left.  So for instance, if the enclosing declaration is
+   *
+   *     class C<T,U> {
+   *       m<V,W> {
+   *         ...
+   *       }
+   *     }
+   *
+   * Then [paramReference] values of 1, 2, 3, and 4 represent W, V, U, and T,
+   * respectively.
+   *
+   * If the type being referred to is not a type parameter, [paramReference] is
+   * zero.
+   */
+  int paramReference;
+
+  /**
+   * If this is an instantiation of a generic type or generic executable, the
+   * type arguments used to instantiate it.  Trailing type arguments of type
+   * `dynamic` are omitted.
+   */
+  List<EntityRef> typeArguments;
+}
+
+/**
  * Information about a dependency that exists between one library and another
  * due to an "import" declaration.
  */
 class LinkedDependency {
   /**
    * The relative URI of the dependent library.  This URI is relative to the
    * importing library, even if there are intervening `export` declarations.
    * So, for example, if `a.dart` imports `b/c.dart` and `b/c.dart` exports
    * `d/e.dart`, the URI listed for `a.dart`'s dependency on `e.dart` will be
    * `b/d/e.dart`.
@@ skipping 140 matching lines @@
    * elements beyond the number of elements in [UnlinkedUnit.references], those
    * additional elements are references that are only referred to implicitly
    * (e.g. elements involved in inferred or propagated types).
    */
   List<LinkedReference> references;
 
   /**
    * List associating slot ids found inside the unlinked summary for the
    * compilation unit with propagated and inferred types.
    */
-  List<TypeRef> types;
+  List<EntityRef> types;
 }
 
 /**
  * Enum used to indicate the kind of entity referred to by a
  * [LinkedReference].
  */
 enum ReferenceKind {
   /**
    * The entity is a class or enum.
    */
@@ skipping 45 matching lines @@
    */
   List<String> unlinkedUnitUris;
 
   /**
    * Unlinked information for the compilation units constituting the SDK.
    */
   List<UnlinkedUnit> unlinkedUnits;
 }
 
 /**
- * Summary information about a reference to a type.
- */
-class TypeRef {
-  /**
-   * If this [TypeRef] is contained within [LinkedUnit.types], slot id (which
-   * is unique within the compilation unit) identifying the target of type
-   * propagation or type inference with which this [TypeRef] is associated.
-   *
-   * Otherwise zero.
-   */
-  int slot;
-
-  /**
-   * Index into [UnlinkedUnit.references] for the type being referred to, or
-   * zero if this is a reference to a type parameter.
-   *
-   * Note that since zero is also a valid index into
-   * [UnlinkedUnit.references], we cannot distinguish between references to
-   * type parameters and references to types by checking [reference] against
-   * zero.  To distinguish between references to type parameters and references
-   * to types, check whether [paramReference] is zero.
-   */
-  int reference;
-
-  /**
-   * If this is a reference to a type parameter, one-based index into the list
-   * of [UnlinkedTypeParam]s currently in effect.  Indexing is done using De
-   * Bruijn index conventions; that is, innermost parameters come first, and
-   * if a class or method has multiple parameters, they are indexed from right
-   * to left.  So for instance, if the enclosing declaration is
-   *
-   *     class C<T,U> {
-   *       m<V,W> {
-   *         ...
-   *       }
-   *     }
-   *
-   * Then [paramReference] values of 1, 2, 3, and 4 represent W, V, U, and T,
-   * respectively.
-   *
-   * If the type being referred to is not a type parameter, [paramReference] is
-   * zero.
-   */
-  int paramReference;
-
-  /**
-   * If this is an instantiation of a generic type, the type arguments used to
-   * instantiate it.  Trailing type arguments of type `dynamic` are omitted.
-   */
-  List<TypeRef> typeArguments;
-}
-
-/**
  * Unlinked summary information about a class declaration.
  */
 class UnlinkedClass {
   /**
    * Name of the class.
    */
   String name;
 
   /**
    * Offset of the class name relative to the beginning of the file.
@@ skipping 11 matching lines @@
   /**
    * Type parameters of the class, if any.
    */
   List<UnlinkedTypeParam> typeParameters;
 
   /**
    * Supertype of the class, or `null` if either (a) the class doesn't
    * explicitly declare a supertype (and hence has supertype `Object`), or (b)
    * the class *is* `Object` (and hence has no supertype).
    */
-  TypeRef supertype;
+  EntityRef supertype;
 
   /**
    * Mixins appearing in a `with` clause, if any.
    */
-  List<TypeRef> mixins;
+  List<EntityRef> mixins;
 
   /**
    * Interfaces appearing in an `implements` clause, if any.
    */
-  List<TypeRef> interfaces;
+  List<EntityRef> interfaces;
 
   /**
    * Field declarations contained in the class.
    */
   List<UnlinkedVariable> fields;
 
   /**
    * Executable objects (methods, getters, and setters) contained in the class.
    */
   List<UnlinkedExecutable> executables;
@@ skipping 65 matching lines @@
    * `invokeConstructor`.
    */
   List<String> strings;
 
   /**
    * 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.
    */
-  List<TypeRef> references;
+  List<EntityRef> references;
 }
 
 /**
  * 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
@@ skipping 371 matching lines @@
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   List<UnlinkedTypeParam> typeParameters;
 
   /**
    * Declared return type of the executable.  Absent if the return type is
    * `void` or the executable is a constructor.  Note that when strong mode is
    * enabled, the actual return type may be different due to type inference.
    */
-  TypeRef returnType;
+  EntityRef returnType;
 
   /**
    * 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.
    */
   List<UnlinkedParam> parameters;
 
   /**
    * The kind of the executable (function/method, getter, setter, or
@@ skipping 180 matching lines @@
   @informative
   int nameOffset;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
    * [isFunctionTyped] is `false`, the declared type.  Absent if
    * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
    * that when strong mode is enabled, the actual type may be different due to
    * type inference.
    */
-  TypeRef type;
+  EntityRef type;
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   List<UnlinkedParam> parameters;
 
   /**
    * Kind of the parameter.
    */
   UnlinkedParamKind kind;
@@ skipping 158 matching lines @@
   UnlinkedDocumentationComment documentationComment;
 
   /**
    * Type parameters of the typedef, if any.
    */
   List<UnlinkedTypeParam> typeParameters;
 
   /**
    * Return type of the typedef.  Absent if the return type is `void`.
    */
-  TypeRef returnType;
+  EntityRef returnType;
 
   /**
    * Parameters of the executable, if any.
    */
   List<UnlinkedParam> parameters;
 }
 
 /**
  * Unlinked summary information about a type parameter declaration.
  */
 class UnlinkedTypeParam {
   /**
    * Name of the type parameter.
    */
   String name;
 
   /**
    * Offset of the type parameter name relative to the beginning of the file.
    */
   @informative
   int nameOffset;
 
   /**
    * Bound of the type parameter, if a bound is explicitly declared.  Otherwise
    * null.
    */
-  TypeRef bound;
+  EntityRef bound;
 }
 
 /**
  * Unlinked summary information about a compilation unit ("part file").
  */
 @topLevel
 class UnlinkedUnit {
   /**
    * Name of the library (from a "library" declaration, if present).
    */
@@ skipping 94 matching lines @@
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
   @informative
   UnlinkedDocumentationComment documentationComment;
 
   /**
    * Declared type of the variable.  Note that when strong mode is enabled, the
    * actual type of the variable may be different due to type inference.
    */
-  TypeRef type;
+  EntityRef type;
 
   /**
    * If [isConst] is true, and the variable has an initializer, the constant
    * expression in the initializer.
    */
   UnlinkedConst constExpr;
 
   /**
    * Indicates whether the variable is declared using the `static` keyword.
    *
@@ skipping 21 matching lines @@
   /**
    * If this variable is propagable, nonzero slot id identifying which entry in
    * [LinkedLibrary.types] contains the propagated type for this variable.  If
    * there is no matching entry in [LinkedLibrary.types], then this variable's
    * propagated type is the same as its declared type.
    *
    * Non-propagable variables have a [propagatedTypeSlot] of zero.
    */
   int propagatedTypeSlot;
 }