Rename TypeRef to EntityRef.

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

 // Copyright (c) 2016, 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.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ skipping 10 matching lines @@
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _SummarizeAstVisitor visitor;
 
   _ConstExprSerializer(this.visitor);
 
-  TypeRefBuilder serializeIdentifier(Identifier identifier) {
-    TypeRefBuilder b = new TypeRefBuilder();
+  EntityRefBuilder serializeIdentifier(Identifier identifier) {
+    EntityRefBuilder b = new EntityRefBuilder();
     if (identifier is SimpleIdentifier) {
       b.reference = visitor.serializeReference(null, identifier.name);
     } else if (identifier is PrefixedIdentifier) {
       int prefix = visitor.serializeReference(null, identifier.prefix.name);
       b.reference =
           visitor.serializeReference(prefix, identifier.identifier.name);
     } else {
       throw new StateError(
           'Unexpected identifier type: ${identifier.runtimeType}');
     }
     return b;
   }
 
   @override
-  TypeRefBuilder serializeType(TypeName node) {
+  EntityRefBuilder serializeType(TypeName node) {
     return visitor.serializeTypeName(node);
   }
 }
 
 /**
  * An [_OtherScopedEntity] is a [_ScopedEntity] that does not refer to a type
  * parameter.  Since we don't need to track any special information about these
  * types of scoped entities, it is a singleton class.
  */
 class _OtherScopedEntity extends _ScopedEntity {
@@ skipping 400 matching lines @@
     assert(scopes.length == oldScopesLength);
     return b;
   }
 
   /**
    * Serialize the return type and parameters of a function-typed formal
    * parameter and store them in [b].
    */
   void serializeFunctionTypedParameterDetails(UnlinkedParamBuilder b,
       TypeName returnType, FormalParameterList parameters) {
-    TypeRefBuilder serializedReturnType =
+    EntityRefBuilder serializedReturnType =
         serializeTypeName(returnType, allowVoid: true);
     if (serializedReturnType != null) {
       b.type = serializedReturnType;
     }
     b.parameters = parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
   }
 
   /**
@@ skipping 32 matching lines @@
         assert(name != 'dynamic');
         int index = unlinkedReferences.length;
         unlinkedReferences.add(new UnlinkedReferenceBuilder(
             prefixReference: prefixIndex, name: name));
         return index;
       });
 
   /**
    * Serialize a type name (which might be defined in a nested scope, at top
    * level within this library, or at top level within an imported library) to
-   * a [TypeRef].  Note that this method does the right thing if the
+   * a [EntityRef].  Note that this method does the right thing if the
    * name doesn't refer to an entity other than a type (e.g. a class member).
    */
-  TypeRefBuilder serializeTypeName(TypeName node, {bool allowVoid: false}) {
-    TypeRefBuilder b = new TypeRefBuilder();
+  EntityRefBuilder serializeTypeName(TypeName node, {bool allowVoid: false}) {
+    EntityRefBuilder b = new EntityRefBuilder();
     if (node != null) {
       Identifier identifier = node.name;
       if (identifier is SimpleIdentifier) {
         String name = identifier.name;
         int indexOffset = 0;
         for (int i = scopes.length - 1; i >= 0; i--) {
           _Scope scope = scopes[i];
           _ScopedEntity entity = scope[name];
           if (entity != null) {
             if (entity is _ScopedTypeParameter) {
@@ skipping 27 matching lines @@
       }
       if (node.typeArguments != null) {
         // Trailing type arguments of type 'dynamic' should be omitted.
         NodeList<TypeName> args = node.typeArguments.arguments;
         int numArgsToSerialize = args.length;
         while (
             numArgsToSerialize > 0 && isDynamic(args[numArgsToSerialize - 1])) {
           --numArgsToSerialize;
         }
         if (numArgsToSerialize > 0) {
-          List<TypeRefBuilder> serializedArguments = <TypeRefBuilder>[];
+          List<EntityRefBuilder> serializedArguments = <EntityRefBuilder>[];
           for (int i = 0; i < numArgsToSerialize; i++) {
             serializedArguments.add(serializeTypeName(args[i]));
           }
           b.typeArguments = serializedArguments;
         }
       }
     }
     return b;
   }
 
@@ skipping 171 matching lines @@
   @override
   void visitFunctionTypeAlias(FunctionTypeAlias node) {
     int oldScopesLength = scopes.length;
     _TypeParameterScope typeParameterScope = new _TypeParameterScope();
     scopes.add(typeParameterScope);
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
     b.name = node.name.name;
     b.nameOffset = node.name.offset;
     b.typeParameters =
         serializeTypeParameters(node.typeParameters, typeParameterScope);
-    TypeRefBuilder serializedReturnType =
+    EntityRefBuilder serializedReturnType =
         serializeTypeName(node.returnType, allowVoid: true);
     if (serializedReturnType != null) {
       b.returnType = serializedReturnType;
     }
     b.parameters = node.parameters.parameters
         .map((FormalParameter p) => p.accept(this))
         .toList();
     b.documentationComment = serializeDocumentation(node.documentationComment);
     typedefs.add(b);
     scopes.removeLast();
@@ skipping 99 matching lines @@
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }