Rename TypeRef to EntityRef.

pkg/analyzer/lib/src/summary/summarize_elements.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.
 
 library serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 27 matching lines @@
   } else if (element is FunctionElement) {
     kind = ReferenceKind.topLevelFunction;
   } else {
     throw new Exception('Unexpected element kind: ${element.runtimeType}');
   }
   return kind;
 }
 
 /**
  * Type of closures used by [_LibrarySerializer] to defer generation of
- * [TypeRefBuilder] objects until the end of serialization of a
+ * [EntityRefBuilder] objects until the end of serialization of a
  * compilation unit.
  */
-typedef TypeRefBuilder _SerializeTypeRef();
+typedef EntityRefBuilder _SerializeTypeRef();
 
 /**
  * Data structure holding the result of serializing a [LibraryElement].
  */
 class LibrarySerializationResult {
   /**
    * Linked information the given library.
    */
   final LinkedLibraryBuilder linked;
 
@@ skipping 511 matching lines @@
       assert(unlinkedReferences.length == linkedReferences.length);
       int index = unlinkedReferences.length;
       unlinkedReferences.add(new UnlinkedReferenceBuilder(name: element.name));
       linkedReferences
           .add(new LinkedReferenceBuilder(kind: ReferenceKind.prefix));
       return index;
     });
   }
 
   /**
-   * Compute the reference index which should be stored in a [TypeRef].
+   * Compute the reference index which should be stored in a [EntityRef].
    *
    * If [linked] is true, and a new reference has to be created, the reference
    * will only be stored in [linkedReferences].
    */
   int serializeReferenceForType(DartType type, bool linked) {
     Element element = type.element;
     LibraryElement dependentLibrary = element.library;
     if (dependentLibrary == null) {
       assert(type.isDynamic);
       if (type is UndefinedTypeImpl) {
@@ skipping 33 matching lines @@
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder();
     b.name = typeParameter.name;
     b.nameOffset = typeParameter.nameOffset;
     if (typeParameter.bound != null) {
       b.bound = serializeTypeRef(typeParameter.bound, typeParameter);
     }
     return b;
   }
 
   /**
-   * Serialize the given [type] into a [TypeRef].  If [slot] is provided,
-   * it should be included in the [TypeRef].  If [linked] is true, any
+   * Serialize the given [type] into a [EntityRef].  If [slot] is provided,
+   * it should be included in the [EntityRef].  If [linked] is true, any
    * references that are created will be populated into [linkedReferences] but
    * [not [unlinkedReferences].
    *
-   * [context] is the element within which the [TypeRef] will be
+   * [context] is the element within which the [EntityRef] will be
    * interpreted; this is used to serialize type parameters.
    */
-  TypeRefBuilder serializeTypeRef(DartType type, Element context,
+  EntityRefBuilder serializeTypeRef(DartType type, Element context,
       {bool linked: false, int slot}) {
-    TypeRefBuilder b = new TypeRefBuilder(slot: slot);
+    EntityRefBuilder b = new EntityRefBuilder(slot: slot);
     if (type is TypeParameterType) {
       b.paramReference = findTypeParameterIndex(type, context);
     } else {
       b.reference = serializeReferenceForType(type, linked);
       List<DartType> typeArguments = getTypeArguments(type);
       if (typeArguments != null) {
         // Trailing type arguments of type 'dynamic' should be omitted.
         int numArgsToSerialize = typeArguments.length;
         while (numArgsToSerialize > 0 &&
             typeArguments[numArgsToSerialize - 1].isDynamic) {
           --numArgsToSerialize;
         }
         if (numArgsToSerialize > 0) {
-          List<TypeRefBuilder> serializedArguments = <TypeRefBuilder>[];
+          List<EntityRefBuilder> serializedArguments = <EntityRefBuilder>[];
           for (int i = 0; i < numArgsToSerialize; i++) {
             serializedArguments.add(
                 serializeTypeRef(typeArguments[i], context, linked: linked));
           }
           b.typeArguments = serializedArguments;
         }
       }
     }
     return b;
   }
@@ skipping 109 matching lines @@
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _CompilationUnitSerializer serializer;
 
   _ConstExprSerializer(this.serializer);
 
-  TypeRefBuilder serializeIdentifier(Identifier identifier) {
+  EntityRefBuilder serializeIdentifier(Identifier identifier) {
     Element element = identifier.staticElement;
     assert(element != null);
     // TODO(scheglov) how to serialize element references?
-    return new TypeRefBuilder(
+    return new EntityRefBuilder(
         reference: serializer._getElementReferenceId(element));
   }
 
   @override
-  TypeRefBuilder serializeType(TypeName typeName) {
+  EntityRefBuilder serializeType(TypeName typeName) {
     DartType type = typeName != null ? typeName.type : DynamicTypeImpl.instance;
     return serializer.serializeTypeRef(type, null);
   }
 }
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single library.
  */
 class _LibrarySerializer {
@@ skipping 169 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }