Rename UnlinkedTypeRef to TypeRef.

pkg/analyzer/test/src/summary/summary_test.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 analyzer.test.src.summary.summary_test;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 40 matching lines @@
       analysisContext.typeProvider.objectType.element.library,
       analysisContext.typeProvider.futureType.element.library
     ];
     for (LibraryElement library in libraries) {
       summarize_elements.LibrarySerializationResult serializedLibrary =
           summarize_elements.serializeLibrary(
               library, analysisContext.typeProvider);
       for (int i = 0; i < serializedLibrary.unlinkedUnits.length; i++) {
         uriToNamespace[serializedLibrary.unitUris[i]] =
             new UnlinkedUnit.fromBuffer(
-                    serializedLibrary.unlinkedUnits[i].toBuffer())
-                .publicNamespace;
+                serializedLibrary.unlinkedUnits[i].toBuffer()).publicNamespace;
       }
     }
     return uriToNamespace;
   } catch (_) {
     return null;
   }
 }();
 
 /**
  * Convert a summary object (or a portion of one) into a canonical form that
@@ skipping 40 matching lines @@
       new Scanner(source, reader, AnalysisErrorListener.NULL_LISTENER);
   Parser parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
   parser.parseGenericMethods = true;
   CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
   UnlinkedPublicNamespace namespace = new UnlinkedPublicNamespace.fromBuffer(
       public_namespace.computePublicNamespace(unit).toBuffer());
   return namespace;
 }
 
 /**
- * Type of a function that validates an [UnlinkedTypeRef].
+ * Type of a function that validates an [TypeRef].
  */
-typedef bool _UnlinkedTypeRefValidator(UnlinkedTypeRef unlinkedTypeRef);
+typedef bool _TypeRefValidator(TypeRef unlinkedTypeRef);
 
 /**
  * Override of [SummaryTest] which verifies the correctness of the prelinker by
  * creating summaries from the element model, discarding their prelinked
  * information, and then recreating it using the prelinker.
  */
 @reflectiveTest
 class PrelinkerTest extends SummarizeElementsTest {
   final Map<String, UnlinkedPublicNamespace> uriToPublicNamespace =
       <String, UnlinkedPublicNamespace>{};
@@ skipping 280 matching lines @@
     String expectedCommentText =
         text.substring(commentStart, commentEnd).replaceAll('\r\n', '\n');
     expect(documentationComment.text, expectedCommentText);
     expect(documentationComment.offset, commentStart);
     expect(documentationComment.length, commentEnd - commentStart);
   }
 
   /**
    * Verify that the given [typeRef] represents the type `dynamic`.
    */
-  void checkDynamicTypeRef(UnlinkedTypeRef typeRef) {
+  void checkDynamicTypeRef(TypeRef typeRef) {
     checkTypeRef(typeRef, null, null, null);
   }
 
   /**
    * Verify that the given [exportName] represents a reference to an entity
    * declared in a file reachable via [absoluteUri] and [relativeUri], having
    * name [expectedName].  [expectedKind] is the kind of object referenced.
    * [expectedTargetUnit] is the index of the compilation unit in which the
    * target of the [exportName] is expected to appear; if not specified it is
    * assumed to be the defining compilation unit.
@@ skipping 49 matching lines @@
       if (dep.uri == relativeUri) {
         fail('Unexpected dependency found: $relativeUri');
       }
     }
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type parameter
    * having the given [deBruijnIndex].
    */
-  void checkParamTypeRef(UnlinkedTypeRef typeRef, int deBruijnIndex) {
-    expect(typeRef, new isInstanceOf<UnlinkedTypeRef>());
+  void checkParamTypeRef(TypeRef typeRef, int deBruijnIndex) {
+    expect(typeRef, new isInstanceOf<TypeRef>());
     expect(typeRef.reference, 0);
     expect(typeRef.typeArguments, isEmpty);
     expect(typeRef.paramReference, deBruijnIndex);
   }
 
   /**
    * Verify that [prefixReference] is a valid reference to a prefix having the
    * given [name].
    */
   void checkPrefix(int prefixReference, String name) {
@@ skipping 12 matching lines @@
    * reached via the given prefix.  If [allowTypeParameters] is true, allow the
    * type reference to supply type parameters.  [expectedKind] is the kind of
    * object referenced.  [linkedSourceUnit] and [unlinkedSourceUnit] refer
    * to the compilation unit within which the [typeRef] appears; if not
    * specified they are assumed to refer to the defining compilation unit.
    * [expectedTargetUnit] is the index of the compilation unit in which the
    * target of the [typeRef] is expected to appear; if not specified it is
    * assumed to be the defining compilation unit.  [numTypeParameters] is the
    * number of type parameters of the thing being referred to.
    */
-  void checkTypeRef(UnlinkedTypeRef typeRef, String absoluteUri,
-      String relativeUri, String expectedName,
+  void checkTypeRef(TypeRef typeRef, String absoluteUri, String relativeUri,
+      String expectedName,
       {String expectedPrefix,
       bool allowTypeParameters: false,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     linkedSourceUnit ??= definingUnit;
     unlinkedSourceUnit ??= unlinkedUnits[0];
-    expect(typeRef, new isInstanceOf<UnlinkedTypeRef>());
+    expect(typeRef, new isInstanceOf<TypeRef>());
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
     UnlinkedReference reference = unlinkedSourceUnit.references[index];
     LinkedReference referenceResolution = linkedSourceUnit.references[index];
     if (index == 0) {
       // Index 0 is reserved for "dynamic".
       expect(reference.name, isEmpty);
       expect(reference.prefixReference, 0);
     }
     if (absoluteUri == null) {
@@ skipping 24 matching lines @@
     expect(referenceResolution.kind, expectedKind);
     expect(referenceResolution.unit, expectedTargetUnit);
     expect(referenceResolution.numTypeParameters, numTypeParameters);
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to an unresolved
    * type.
    */
   void checkUnresolvedTypeRef(
-      UnlinkedTypeRef typeRef, String expectedPrefix, String expectedName) {
+      TypeRef typeRef, String expectedPrefix, String expectedName) {
     // When serializing from the element model, unresolved type refs lose their
     // name.
     checkTypeRef(typeRef, null, null, checkAstDerivedData ? expectedName : null,
         expectedPrefix: expectedPrefix, expectedKind: ReferenceKind.unresolved);
   }
 
   fail_constExpr_pushInt_shiftOr() {
     UnlinkedVariable variable =
         serializeVariableText('const v = 0x111222333444555666;');
     //                                     ^^!!!!^^^^!!!!^^^^
@@ skipping 190 matching lines @@
    * with the given [typedefName].
    */
   UnlinkedTypedef serializeTypedefText(String text,
       [String typedefName = 'F']) {
     serializeLibraryText(text);
     return findTypedef(typedefName, failIfAbsent: true);
   }
 
   /**
    * Serialize a type declaration using the given [text] as a type name, and
-   * return a summary of the corresponding [UnlinkedTypeRef].  If the type
+   * return a summary of the corresponding [TypeRef].  If the type
    * declaration needs to refer to types that are not available in core, those
    * types may be declared in [otherDeclarations].
    */
-  UnlinkedTypeRef serializeTypeText(String text,
+  TypeRef serializeTypeText(String text,
       {String otherDeclarations: '', bool allowErrors: false}) {
     return serializeVariableText('$otherDeclarations\n$text v;',
-            allowErrors: allowErrors)
-        .type;
+        allowErrors: allowErrors).type;
   }
 
   /**
    * Serialize the given library [text] and return the summary of the variable
    * with the given [variableName].
    */
   UnlinkedVariable serializeVariableText(String text,
       {String variableName: 'v', bool allowErrors: false}) {
     serializeLibraryText(text, allowErrors: allowErrors);
     return findVariable(variableName, failIfAbsent: true);
@@ skipping 199 matching lines @@
     expect(cls.executables, isEmpty);
   }
 
   test_class_alias_private() {
     serializeClassText('class _C = _D with _E; class _D {} class _E {}',
         className: '_C');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_class_alias_reference_generic() {
-    UnlinkedTypeRef typeRef = serializeTypeText('C',
+    TypeRef typeRef = serializeTypeText('C',
         otherDeclarations: 'class C<D, E> = F with G; class F {} class G {}');
     checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
   }
 
   test_class_alias_reference_generic_imported() {
     addNamedSource(
         '/lib.dart', 'class C<D, E> = F with G; class F {} class G {}');
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
     checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
         numTypeParameters: 2);
   }
 
   test_class_alias_supertype() {
     UnlinkedClass cls =
         serializeClassText('class C = D with E; class D {} class E {}');
     checkTypeRef(cls.supertype, null, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
@@ skipping 115 matching lines @@
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isMixinApplication, false);
   }
 
   test_class_private() {
     serializeClassText('class _C {}', className: '_C');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_class_reference_generic() {
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('C', otherDeclarations: 'class C<D, E> {}');
     checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
   }
 
   test_class_reference_generic_imported() {
     addNamedSource('/lib.dart', 'class C<D, E> {}');
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
     checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
         numTypeParameters: 2);
   }
 
   test_class_superclass() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.supertype, isNull);
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_superclass_explicit() {
     UnlinkedClass cls = serializeClassText('class C extends D {} class D {}');
     expect(cls.supertype, isNotNull);
     checkTypeRef(cls.supertype, null, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_type_param_bound() {
     UnlinkedClass cls = serializeClassText('class C<T extends List> {}');
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
     expect(cls.typeParameters[0].bound, isNotNull);
     checkTypeRef(cls.typeParameters[0].bound, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true, numTypeParameters: 1);
   }
 
   test_class_type_param_f_bound() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<T>> {}');
-    UnlinkedTypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
+    TypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
   test_class_type_param_f_bound_self_ref() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<U>> {}');
-    UnlinkedTypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
+    TypeRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
   test_class_type_param_no_bound() {
     String text = 'class C<T> {}';
     UnlinkedClass cls = serializeClassText(text);
     expect(cls.typeParameters, hasLength(1));
     expect(cls.typeParameters[0].name, 'T');
     expect(cls.typeParameters[0].nameOffset, text.indexOf('T'));
     expect(cls.typeParameters[0].bound, isNull);
@@ skipping 262 matching lines @@
 }
 const v = const C.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0
     ], strings: [
       'named'
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, 'C',
+      (TypeRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported() {
     if (checkAstDerivedData) {
       // TODO(scheglov) at the moment we cannot link class member references
       return;
     }
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0
     ], strings: [
       'named'
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
+      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       0
     ], strings: [
       'named'
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
+      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
           expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'p')
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   const C(int a, String b);
 }
 const v = const C(42, 'sss');
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
       42,
       2
     ], strings: [
       'sss',
       ''
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, 'C',
+      (TypeRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_length() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "abc".length;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushString,
-      UnlinkedConstOperation.length
-    ], strings: [
-      'abc'
-    ]);
+    _assertUnlinkedConst(variable.constExpr,
+        operators:
+            [UnlinkedConstOperation.pushString, UnlinkedConstOperation.length],
+        strings: ['abc']);
   }
 
   test_constExpr_makeList_typed() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const <int>[11, 22, 33];');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.makeList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
+      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeList_untyped() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const [11, 22, 33];');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.makeList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, '',
+      (TypeRef r) => checkTypeRef(r, null, null, '',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeMap_typed() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const <int, String>{11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.makeMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
+      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum),
-      (UnlinkedTypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String',
+      (TypeRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeMap_untyped() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const {11: "aaa", 22: "bbb", 33: "ccc"};');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.makeMap
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, '',
+      (TypeRef r) => checkTypeRef(r, null, null, '',
           expectedKind: ReferenceKind.classOrEnum),
-      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, '',
+      (TypeRef r) => checkTypeRef(r, null, null, '',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeSymbol() {
     UnlinkedVariable variable = serializeVariableText('const v = #a.bb.ccc;');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushString,
       UnlinkedConstOperation.makeSymbol
     ], strings: [
@@ skipping 11 matching lines @@
       UnlinkedConstOperation.multiply,
     ], ints: [
       1,
       2,
       3
     ]);
   }
 
   test_constExpr_prefix_complement() {
     UnlinkedVariable variable = serializeVariableText('const v = ~2;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.complement
-    ], ints: [
-      2
-    ]);
+    _assertUnlinkedConst(variable.constExpr,
+        operators:
+            [UnlinkedConstOperation.pushInt, UnlinkedConstOperation.complement],
+        ints: [2]);
   }
 
   test_constExpr_prefix_negate() {
     UnlinkedVariable variable = serializeVariableText('const v = -(2);');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushInt,
-      UnlinkedConstOperation.negate
-    ], ints: [
-      2
-    ]);
+    _assertUnlinkedConst(variable.constExpr,
+        operators:
+            [UnlinkedConstOperation.pushInt, UnlinkedConstOperation.negate],
+        ints: [2]);
   }
 
   test_constExpr_prefix_not() {
     UnlinkedVariable variable = serializeVariableText('const v = !true;');
-    _assertUnlinkedConst(variable.constExpr, operators: [
-      UnlinkedConstOperation.pushTrue,
-      UnlinkedConstOperation.not
-    ]);
+    _assertUnlinkedConst(variable.constExpr, operators:
+        [UnlinkedConstOperation.pushTrue, UnlinkedConstOperation.not]);
   }
 
   test_constExpr_pushDouble() {
     UnlinkedVariable variable = serializeVariableText('const v = 123.4567;');
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushDouble], doubles: [123.4567]);
   }
 
   test_constExpr_pushFalse() {
     UnlinkedVariable variable = serializeVariableText('const v = false;');
@@ skipping 14 matching lines @@
   }
 
   test_constExpr_pushReference_class() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {}
 const v = C;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, 'C',
+      (TypeRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_pushReference_class_field() {
     // TODO(scheglov) Not sure for to represent a field reference
-    // using UnlinkedTypeRef.
+    // using TypeRef.
 //    UnlinkedVariable variable = serializeVariableText('''
 //class C {
 //  static const int F = 1;
 //}
 //const v = C.F;
 //''');
 //    _assertUnlinkedConst(variable.constExpr, operators: [
 //      UnlinkedConstOperation.pushReference
 //    ], references: [
-//      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, 'F',
+//      (TypeRef r) => checkTypeRef(r, null, null, 'F',
 //          expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'C')
 //    ]);
   }
 
   test_constExpr_pushReference_enum() {
     UnlinkedVariable variable = serializeVariableText('''
 enum C {V1, V2, V3}
 const v = C;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, 'C',
+      (TypeRef r) => checkTypeRef(r, null, null, 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_imported() {
     addNamedSource('/a.dart', 'const int a = 1;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = a;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
+      (TypeRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_imported_withPrefix() {
     addNamedSource('/a.dart', 'const int a = 1;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.a;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (UnlinkedTypeRef r) {
+      (TypeRef r) {
         return checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
             expectedKind: ReferenceKind.topLevelPropertyAccessor,
             expectedPrefix: 'p');
       }
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_local() {
     // TODO(scheglov) use `a + b`
     UnlinkedVariable variable = serializeVariableText('''
 const int a = 1;
 const v = a;
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.pushReference
     ], referenceValidators: [
-      (UnlinkedTypeRef r) => checkTypeRef(r, null, null, 'a',
+      (TypeRef r) => checkTypeRef(r, null, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushString_adjacent() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "aaa" "b" "ccc";');
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushString], strings: ['aaabccc']);
   }
@@ skipping 707 matching lines @@
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'bool');
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_index_set() {
     UnlinkedExecutable executable = serializeClassText(
-            'class C { void operator[]=(int i, bool v) => null; }')
-        .executables[0];
+        'class C { void operator[]=(int i, bool v) => null; }').executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(2));
     expect(executable.returnType, isNull);
     expect(executable.typeParameters, isEmpty);
@@ skipping 174 matching lines @@
 
   test_executable_static() {
     UnlinkedExecutable executable =
         serializeClassText('class C { static f() {} }').executables[0];
     expect(executable.isStatic, isTrue);
   }
 
   test_executable_type_param_f_bound_function() {
     UnlinkedExecutable ex =
         serializeExecutableText('void f<T, U extends List<T>>() {}');
-    UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
   test_executable_type_param_f_bound_method() {
     UnlinkedExecutable ex =
         serializeMethodText('void f<T, U extends List<T>>() {}');
-    UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
   test_executable_type_param_f_bound_self_ref_function() {
     UnlinkedExecutable ex =
         serializeExecutableText('void f<T, U extends List<U>>() {}');
-    UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
   test_executable_type_param_f_bound_self_ref_method() {
     UnlinkedExecutable ex =
         serializeMethodText('void f<T, U extends List<U>>() {}');
-    UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    TypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
   test_executable_type_param_in_parameter_function() {
     UnlinkedExecutable ex = serializeExecutableText('void f<T>(T t) {}');
     checkParamTypeRef(ex.parameters[0].type, 1);
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
   }
 
   test_executable_type_param_in_parameter_method() {
@@ skipping 540 matching lines @@
     checkUnresolvedTypeRef(
         serializeTypeText('dynamic.T', allowErrors: true), 'dynamic', 'T');
   }
 
   test_invalid_prefix_type_parameter() {
     if (checkAstDerivedData) {
       // TODO(paulberry): get this to work properly.
       return;
     }
     checkUnresolvedTypeRef(
-        serializeClassText('class C<T> { T.U x; }', allowErrors: true)
-            .fields[0]
+        serializeClassText('class C<T> { T.U x; }', allowErrors: true).fields[0]
             .type,
         'T',
         'U');
   }
 
   test_invalid_prefix_void() {
     if (checkAstDerivedData) {
       // TODO(paulberry): get this to work properly.
       return;
     }
@@ skipping 113 matching lines @@
 /**
  * Docs
  */
 void set f(value) {}''';
     UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
     expect(executable.documentationComment, isNotNull);
     checkDocumentationComment(executable.documentationComment, text);
   }
 
   test_type_arguments_explicit() {
-    UnlinkedTypeRef typeRef = serializeTypeText('List<int>');
+    TypeRef typeRef = serializeTypeText('List<int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic() {
-    UnlinkedTypeRef typeRef = serializeTypeText('List<dynamic>');
+    TypeRef typeRef = serializeTypeText('List<dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_dynamic_dynamic() {
-    UnlinkedTypeRef typeRef = serializeTypeText('Map<dynamic, dynamic>');
+    TypeRef typeRef = serializeTypeText('Map<dynamic, dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 2);
     // Trailing type arguments of type `dynamic` are omitted.
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_dynamic_int() {
-    UnlinkedTypeRef typeRef = serializeTypeText('Map<dynamic, int>');
+    TypeRef typeRef = serializeTypeText('Map<dynamic, int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 2);
     // Leading type arguments of type `dynamic` are not omitted.
     expect(typeRef.typeArguments.length, 2);
     checkDynamicTypeRef(typeRef.typeArguments[0]);
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic_typedef() {
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('F<dynamic>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_explicit_String_dynamic() {
-    UnlinkedTypeRef typeRef = serializeTypeText('Map<String, dynamic>');
+    TypeRef typeRef = serializeTypeText('Map<String, dynamic>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 2);
     // Trailing type arguments of type `dynamic` are omitted.
     expect(typeRef.typeArguments.length, 1);
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
   }
 
   test_type_arguments_explicit_String_int() {
-    UnlinkedTypeRef typeRef = serializeTypeText('Map<String, int>');
+    TypeRef typeRef = serializeTypeText('Map<String, int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 2);
     expect(typeRef.typeArguments.length, 2);
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_typedef() {
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('F<int>', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
   test_type_arguments_implicit() {
-    UnlinkedTypeRef typeRef = serializeTypeText('List');
+    TypeRef typeRef = serializeTypeText('List');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true, numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_implicit_typedef() {
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef T F<T>();');
     checkTypeRef(typeRef, null, null, 'F',
         allowTypeParameters: true,
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1);
     expect(typeRef.typeArguments, isEmpty);
   }
 
   test_type_arguments_order() {
-    UnlinkedTypeRef typeRef = serializeTypeText('Map<int, Object>');
+    TypeRef typeRef = serializeTypeText('Map<int, Object>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
         allowTypeParameters: true, numTypeParameters: 2);
     expect(typeRef.typeArguments, hasLength(2));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'Object');
   }
 
   test_type_dynamic() {
     checkDynamicTypeRef(serializeTypeText('dynamic'));
   }
@@ skipping 90 matching lines @@
     checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
         absUri('/a.dart'), 'a.dart', 'C',
         expectedPrefix: 'a',
         linkedSourceUnit: linked.units[1],
         unlinkedSourceUnit: unlinkedUnits[1]);
   }
 
   test_type_reference_to_class_argument() {
     UnlinkedClass cls = serializeClassText('class C<T, U> { T t; U u; }');
     {
-      UnlinkedTypeRef typeRef =
+      TypeRef typeRef =
           findVariable('t', variables: cls.fields, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 2);
     }
     {
-      UnlinkedTypeRef typeRef =
+      TypeRef typeRef =
           findVariable('u', variables: cls.fields, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 1);
     }
   }
 
   test_type_reference_to_import_of_export() {
     addNamedSource('/a.dart', 'library a; export "b.dart";');
     addNamedSource('/b.dart', 'library b; class C {}');
     checkTypeRef(serializeTypeText('C', otherDeclarations: 'import "a.dart";'),
         absUri('/b.dart'), 'b.dart', 'C');
@@ skipping 66 matching lines @@
   }
 
   test_type_reference_to_nonexistent_file_via_prefix() {
     if (!checkAstDerivedData) {
       // TODO(paulberry): this test currently fails because there is not enough
       // information in the element model to figure out that the unresolved
       // reference `p.C` uses the prefix `p`.
       return;
     }
     allowMissingFiles = true;
-    UnlinkedTypeRef typeRef = serializeTypeText('p.C',
+    TypeRef typeRef = serializeTypeText('p.C',
         otherDeclarations: 'import "foo.dart" as p;', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, 'p', 'C');
   }
 
   test_type_reference_to_part() {
     addNamedSource('/a.dart', 'part of foo; class C { C(); }');
     serializeLibraryText('library foo; part "a.dart"; C c;');
     checkTypeRef(unlinkedUnits[0].variables.single.type, null, null, 'C',
         expectedKind: ReferenceKind.classOrEnum, expectedTargetUnit: 1);
   }
@@ skipping 32 matching lines @@
   test_type_reference_to_typedef() {
     checkTypeRef(serializeTypeText('F', otherDeclarations: 'typedef void F();'),
         null, null, 'F',
         expectedKind: ReferenceKind.typedef);
   }
 
   test_type_unit_counts_unreferenced_units() {
     addNamedSource('/a.dart', 'library a; part "b.dart"; part "c.dart";');
     addNamedSource('/b.dart', 'part of a;');
     addNamedSource('/c.dart', 'part of a; class C {}');
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "a.dart";');
     // The referenced unit should be 2, since unit 0 is a.dart and unit 1 is
     // b.dart.  a.dart and b.dart are counted even though nothing is imported
     // from them.
     checkTypeRef(typeRef, absUri('/a.dart'), 'a.dart', 'C',
         expectedTargetUnit: 2);
   }
 
   test_type_unresolved() {
-    UnlinkedTypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
+    TypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 typedef F();''';
@@ skipping 25 matching lines @@
     expect(type.parameters[0].name, 'x');
     expect(type.parameters[1].name, 'y');
   }
 
   test_typedef_private() {
     serializeTypedefText('typedef _F();', '_F');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_typedef_reference_generic() {
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef void F<A, B>();');
     checkTypeRef(typeRef, null, null, 'F',
         numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
   }
 
   test_typedef_reference_generic_imported() {
     addNamedSource('/lib.dart', 'typedef void F<A, B>();');
-    UnlinkedTypeRef typeRef =
+    TypeRef typeRef =
         serializeTypeText('F', otherDeclarations: 'import "lib.dart";');
     checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'F',
         numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
   }
 
   test_typedef_return_type_explicit() {
     UnlinkedTypedef type = serializeTypedefText('typedef int F();');
     checkTypeRef(type.returnType, 'dart:core', 'dart:core', 'int');
   }
 
@@ skipping 127 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 
   void _assertUnlinkedConst(UnlinkedConst constExpr,
       {List<UnlinkedConstOperation> operators,
       List<int> ints: const <int>[],
       List<double> doubles: const <double>[],
       List<String> strings: const <String>[],
-      List<_UnlinkedTypeRefValidator> referenceValidators:
-          const <_UnlinkedTypeRefValidator>[]}) {
+      List<_TypeRefValidator> referenceValidators:
+          const <_TypeRefValidator>[]}) {
     expect(constExpr, isNotNull);
     expect(constExpr.operations, operators);
     expect(constExpr.ints, ints);
     expect(constExpr.doubles, doubles);
     expect(constExpr.strings, strings);
     expect(constExpr.references, hasLength(referenceValidators.length));
     for (int i = 0; i < referenceValidators.length; i++) {
       referenceValidators[i](constExpr.references[i]);
     }
   }
@@ skipping 79 matching lines @@
   CompilationUnit _parseText(String text) {
     CharSequenceReader reader = new CharSequenceReader(text);
     Scanner scanner =
         new Scanner(null, reader, AnalysisErrorListener.NULL_LISTENER);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, AnalysisErrorListener.NULL_LISTENER);
     parser.parseGenericMethods = true;
     return parser.parseCompilationUnit(token);
   }
 }