Rename UnlinkedTypeRef to TypeRef.

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 43 matching lines @@
 
 /**
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _LibrarySerializer serializer;
 
   _ConstExprSerializer(this.serializer);
 
-  UnlinkedTypeRefBuilder serializeIdentifier(Identifier identifier) {
+  TypeRefBuilder serializeIdentifier(Identifier identifier) {
     Element element = identifier.staticElement;
     assert(element != null);
     // TODO(scheglov) how to serialize element references?
-    return new UnlinkedTypeRefBuilder(
+    return new TypeRefBuilder(
         reference: serializer._getElementReferenceId(element));
   }
 
   @override
-  UnlinkedTypeRefBuilder serializeType(TypeName typeName) {
+  TypeRefBuilder 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 611 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 an [UnlinkedTypeRef].
+   * Serialize the given [type] into a [TypeRef].
    */
-  UnlinkedTypeRefBuilder serializeTypeRef(DartType type, Element context) {
-    UnlinkedTypeRefBuilder b = new UnlinkedTypeRefBuilder();
+  TypeRefBuilder serializeTypeRef(DartType type, Element context) {
+    TypeRefBuilder b = new TypeRefBuilder();
     if (type is TypeParameterType) {
       b.paramReference = findTypeParameterIndex(type, context);
     } else {
       Element element = type.element;
       LibraryElement dependentLibrary = element.library;
       if (dependentLibrary == null) {
         assert(type.isDynamic);
         if (type is UndefinedTypeImpl) {
           b.reference = serializeUnresolvedReference();
         } else {
           b.reference = serializeDynamicReference();
         }
       } else {
         b.reference = _getElementReferenceId(element);
       }
       List<DartType> typeArguments;
       if (type is InterfaceType) {
         typeArguments = type.typeArguments;
       } else if (type is FunctionType) {
         typeArguments = type.typeArguments;
       }
       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<UnlinkedTypeRefBuilder> serializedArguments =
-              <UnlinkedTypeRefBuilder>[];
+          List<TypeRefBuilder> serializedArguments = <TypeRefBuilder>[];
           for (int i = 0; i < numArgsToSerialize; i++) {
             serializedArguments
                 .add(serializeTypeRef(typeArguments[i], context));
           }
           b.typeArguments = serializedArguments;
         }
       }
     }
     return b;
   }
@@ skipping 86 matching lines @@
     } else if (element is ClassElement) {
       kind = ReferenceKind.classOrEnum;
     } else if (element is FunctionElement) {
       kind = ReferenceKind.topLevelFunction;
     } else {
       throw new Exception('Unexpected element kind: ${element.runtimeType}');
     }
     return kind;
   }
 }