Use absolute URIs for LinkedDependency.uri/parts.

pkg/analyzer/test/src/summary/summary_common.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_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 198 matching lines @@
 
   /**
    * Check that [annotations] contains a single entry which is a reference to
    * a top level variable called `a` in the current library.
    */
   void checkAnnotationA(List<UnlinkedExpr> annotations) {
     expect(annotations, hasLength(1));
     assertUnlinkedConst(annotations[0], operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
+      (EntityRef r) => checkTypeRef(r, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   void checkConstCycle(String className,
       {String name: '', bool hasCycle: true}) {
     UnlinkedClass cls = findClass(className);
     int constCycleSlot =
         findExecutable(name, executables: cls.executables).constCycleSlot;
     expect(constCycleSlot, isNot(0));
     if (!skipFullyLinkedData) {
       expect(
           definingUnit.constCycles,
           hasCycle
               ? contains(constCycleSlot)
               : isNot(contains(constCycleSlot)));
     }
   }
 
   /**
    * Verify that the [dependency]th element of the dependency table represents
-   * a file reachable via the given [absoluteUri] and [relativeUri].
+   * a file reachable via the given [absoluteUri].
    */
-  void checkDependency(int dependency, String absoluteUri, String relativeUri) {
+  void checkDependency(int dependency, String absoluteUri) {
     expect(dependency, new isInstanceOf<int>());
-    if (dependency >= linked.numPrelinkedDependencies) {
-      // Fully-linked dependencies are always absolute URIs.
-      expect(linked.dependencies[dependency].uri, absoluteUri);
-    } else {
-      expect(linked.dependencies[dependency].uri, relativeUri);
-    }
+    expect(linked.dependencies[dependency].uri, absoluteUri);
   }
 
   /**
    * Verify that the given [dependency] lists the given
    * [relativeUris] as its parts.
    */
   void checkDependencyParts(
       LinkedDependency dependency, List<String> relativeUris) {
     expect(dependency.parts, relativeUris);
   }
@@ skipping 16 matching lines @@
     commentEnd += 2;
     String expectedCommentText =
         text.substring(commentStart, commentEnd).replaceAll('\r\n', '\n');
     expect(documentationComment.text, expectedCommentText);
   }
 
   /**
    * Verify that the given [typeRef] represents the type `dynamic`.
    */
   void checkDynamicTypeRef(EntityRef typeRef) {
-    checkTypeRef(typeRef, null, null, 'dynamic');
+    checkTypeRef(typeRef, null, 'dynamic');
   }
 
   /**
    * 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.
+   * declared in a file reachable via [absoluteUri], 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.
    */
   void checkExportName(LinkedExportName exportName, String absoluteUri,
-      String relativeUri, String expectedName, ReferenceKind expectedKind,
+      String expectedName, ReferenceKind expectedKind,
       {int expectedTargetUnit: 0}) {
     expect(exportName, new isInstanceOf<LinkedExportName>());
     // Exported names must come from other libraries.
     expect(exportName.dependency, isNot(0));
-    checkDependency(exportName.dependency, absoluteUri, relativeUri);
+    checkDependency(exportName.dependency, absoluteUri);
     expect(exportName.name, expectedName);
     expect(exportName.kind, expectedKind);
     expect(exportName.unit, expectedTargetUnit);
   }
 
   /**
    * Verify that the dependency table contains an entry for a file reachable
    * via the given [relativeUri].  If [fullyLinked] is
    * `true`, then the dependency should be a fully-linked dependency; otherwise
    * it should be a prelinked dependency.
@@ skipping 17 matching lines @@
     fail('Did not find dependency $relativeUri.  Found: $found');
     return null;
   }
 
   /**
    * Test an inferred type.  If [onlyInStrongMode] is `true` (the default) and
    * strong mode is disabled, verify that the given [slotId] exists and has no
    * associated type.  Otherwise, behave as in [checkLinkedTypeSlot].
    */
   void checkInferredTypeSlot(
-      int slotId, String absoluteUri, String relativeUri, String expectedName,
+      int slotId, String absoluteUri, String expectedName,
       {int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0,
       bool onlyInStrongMode: true}) {
     if (strongMode || !onlyInStrongMode) {
-      checkLinkedTypeSlot(slotId, absoluteUri, relativeUri, expectedName,
+      checkLinkedTypeSlot(slotId, absoluteUri, expectedName,
           numTypeArguments: numTypeArguments,
           expectedKind: expectedKind,
           expectedTargetUnit: expectedTargetUnit,
           linkedSourceUnit: linkedSourceUnit,
           unlinkedSourceUnit: unlinkedSourceUnit,
           numTypeParameters: numTypeParameters);
     } else {
       // A slot id should have been assigned but it should not be associated
       // with any type.
       expect(slotId, isNot(0));
@@ skipping 11 matching lines @@
       if (dep.uri == relativeUri) {
         fail('Unexpected dependency found: $relativeUri');
       }
     }
   }
 
   /**
    * Verify that the given [typeRef] represents the type `dynamic`.
    */
   void checkLinkedDynamicTypeRef(EntityRef typeRef) {
-    checkLinkedTypeRef(typeRef, null, null, 'dynamic');
+    checkLinkedTypeRef(typeRef, null, 'dynamic');
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type declared
-   * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  Verify that the number of type arguments
-   * is equal to [numTypeArguments].  [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.
+   * in a file reachable via [absoluteUri], having name [expectedName].  Verify
+   * that the number of type arguments is equal to [numTypeArguments].
+   * [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 checkLinkedTypeRef(EntityRef typeRef, String absoluteUri,
-      String relativeUri, String expectedName,
+  void checkLinkedTypeRef(
+      EntityRef typeRef, String absoluteUri, String expectedName,
       {int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     linkedSourceUnit ??= definingUnit;
     expect(typeRef, isNotNull,
         reason: 'No entry in linkedSourceUnit.types matching slotId');
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
     expect(typeRef.typeArguments, hasLength(numTypeArguments));
-    checkReferenceIndex(index, absoluteUri, relativeUri, expectedName,
+    checkReferenceIndex(index, absoluteUri, expectedName,
         expectedKind: expectedKind,
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters);
   }
 
   /**
    * Verify that the given [slotId] represents a reference to a type declared
-   * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  Verify that the number of type arguments
-   * is equal to [numTypeArguments].  [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.
+   * in a file reachable via [absoluteUri], having name [expectedName].  Verify
+   * that the number of type arguments is equal to [numTypeArguments].
+   * [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 checkLinkedTypeSlot(
-      int slotId, String absoluteUri, String relativeUri, String expectedName,
+  void checkLinkedTypeSlot(int slotId, String absoluteUri, String expectedName,
       {int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0}) {
     // Slot ids should be nonzero, since zero means "no associated slot".
     expect(slotId, isNot(0));
     if (skipFullyLinkedData) {
       return;
     }
     linkedSourceUnit ??= definingUnit;
     checkLinkedTypeRef(
         getTypeRefForSlot(slotId, linkedSourceUnit: linkedSourceUnit),
         absoluteUri,
-        relativeUri,
         expectedName,
         numTypeArguments: numTypeArguments,
         expectedKind: expectedKind,
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters);
   }
 
   /**
@@ skipping 15 matching lines @@
     expect(prefixReference, isNot(0));
     expect(unlinkedUnits[0].references[prefixReference].prefixReference, 0);
     expect(unlinkedUnits[0].references[prefixReference].name, name);
     expect(definingUnit.references[prefixReference].dependency, 0);
     expect(definingUnit.references[prefixReference].kind, ReferenceKind.prefix);
     expect(definingUnit.references[prefixReference].unit, 0);
   }
 
   /**
    * Check the data structures that are reachable from an index in the
-   * references table..  If the reference in question is an explicit
+   * references table.  If the reference in question is an explicit
    * reference, return the [UnlinkedReference] that is used to make the
    * explicit reference.  If the type reference in question is an implicit
    * reference, return `null`.
    */
-  UnlinkedReference checkReferenceIndex(int referenceIndex, String absoluteUri,
-      String relativeUri, String expectedName,
+  UnlinkedReference checkReferenceIndex(
+      int referenceIndex, String absoluteUri, String expectedName,
       {ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0,
       int localIndex: 0,
       bool unresolvedHasName: false}) {
     linkedSourceUnit ??= definingUnit;
     unlinkedSourceUnit ??= unlinkedUnits[0];
     LinkedReference referenceResolution =
@@ skipping 14 matching lines @@
     } else {
       // This is an implicit reference, so its name should be in
       // [LinkedUnit.references].
       name = referenceResolution.name;
     }
     // Index 0 is reserved.
     expect(referenceIndex, isNot(0));
     if (absoluteUri == null) {
       expect(referenceResolution.dependency, 0);
     } else {
-      checkDependency(referenceResolution.dependency, absoluteUri, relativeUri);
+      checkDependency(referenceResolution.dependency, absoluteUri);
     }
     if (expectedName == null) {
       expect(name, isEmpty);
     } else {
       expect(name, expectedName);
     }
     expect(referenceResolution.kind, expectedKind);
     expect(referenceResolution.unit, expectedTargetUnit);
     expect(referenceResolution.numTypeParameters, numTypeParameters);
     expect(referenceResolution.localIndex, localIndex);
     return reference;
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to a type declared
-   * in a file reachable via [absoluteUri] and [relativeUri], having name
-   * [expectedName].  If [expectedPrefix] is supplied, verify that the type is
-   * reached via the given prefix.  Verify that the number of type arguments
-   * is equal to [numTypeArguments].  [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.
+   * in a file reachable via [absoluteUri], having name [expectedName].
+   * If [expectedPrefix] is supplied, verify that the type is reached via the
+   * given prefix.  Verify that the number of type arguments is equal to
+   * [numTypeArguments].  [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(EntityRef typeRef, String absoluteUri, String relativeUri,
-      String expectedName,
+  void checkTypeRef(EntityRef typeRef, String absoluteUri, String expectedName,
       {String expectedPrefix,
       List<_PrefixExpectation> prefixExpectations,
       int numTypeArguments: 0,
       ReferenceKind expectedKind: ReferenceKind.classOrEnum,
       int expectedTargetUnit: 0,
       LinkedUnit linkedSourceUnit,
       UnlinkedUnit unlinkedSourceUnit,
       int numTypeParameters: 0,
       bool unresolvedHasName: false}) {
     linkedSourceUnit ??= definingUnit;
     expect(typeRef, new isInstanceOf<EntityRef>());
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
     expect(typeRef.typeArguments, hasLength(numTypeArguments));
     UnlinkedReference reference = checkReferenceIndex(
-        index, absoluteUri, relativeUri, expectedName,
+        index, absoluteUri, expectedName,
         expectedKind: expectedKind,
         expectedTargetUnit: expectedTargetUnit,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit,
         numTypeParameters: numTypeParameters,
         unresolvedHasName: unresolvedHasName);
     expect(reference, isNotNull,
         reason: 'Unlinked type refs must refer to an explicit reference');
     if (expectedPrefix != null) {
       checkPrefix(reference.prefixReference, expectedPrefix);
     } else if (prefixExpectations != null) {
       for (_PrefixExpectation expectation in prefixExpectations) {
         expect(reference.prefixReference, isNot(0));
         reference = checkReferenceIndex(reference.prefixReference,
-            expectation.absoluteUri, expectation.relativeUri, expectation.name,
+            expectation.absoluteUri, expectation.name,
             expectedKind: expectation.kind,
             expectedTargetUnit: expectedTargetUnit,
             linkedSourceUnit: linkedSourceUnit,
             unlinkedSourceUnit: unlinkedSourceUnit,
             numTypeParameters: expectation.numTypeParameters);
       }
       expect(reference.prefixReference, 0);
     } else {
       expect(reference.prefixReference, 0);
     }
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to an unresolved
    * type.
    */
   void checkUnresolvedTypeRef(
       EntityRef typeRef, String expectedPrefix, String expectedName,
       {LinkedUnit linkedSourceUnit, UnlinkedUnit unlinkedSourceUnit}) {
     // When serializing from the element model, unresolved type refs lose their
     // name.
-    checkTypeRef(typeRef, null, null, expectedName,
+    checkTypeRef(typeRef, null, expectedName,
         expectedPrefix: expectedPrefix,
         expectedKind: ReferenceKind.unresolved,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit);
   }
 
   /**
    * Verify that the given [typeRef] represents the type `void`.
    */
   void checkVoidTypeRef(EntityRef typeRef) {
-    checkTypeRef(typeRef, null, null, 'void');
+    checkTypeRef(typeRef, null, 'void');
   }
 
   fail_invalid_prefix_dynamic() {
 //    if (checkAstDerivedData) {
 //      // TODO(paulberry): get this to work properly.
 //      return;
 //    }
     var t = serializeTypeText('dynamic.T', allowErrors: true);
     checkUnresolvedTypeRef(t, 'dynamic', 'T');
   }
@@ skipping 370 matching lines @@
     addNamedSource('/lib1.dart', 'export "lib2.dart" hide C hide B, C;');
     addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
     serializeLibraryText(
         '''
 import 'lib1.dart';
 A a;
 B b;
 C c;
     ''',
         allowErrors: true);
-    checkTypeRef(
-        findVariable('a').type, absUri('/lib2.dart'), 'lib2.dart', 'A');
+    checkTypeRef(findVariable('a').type, absUri('/lib2.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_export_hide_show() {
     addNamedSource('/lib1.dart', 'export "lib2.dart" hide C show A, C;');
     addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
     serializeLibraryText(
         '''
 import 'lib1.dart';
 A a;
 B b;
 C c;
     ''',
         allowErrors: true);
-    checkTypeRef(
-        findVariable('a').type, absUri('/lib2.dart'), 'lib2.dart', 'A');
+    checkTypeRef(findVariable('a').type, absUri('/lib2.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_export_show_hide() {
     addNamedSource('/lib1.dart', 'export "lib2.dart" show A, B hide B, C;');
     addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
     serializeLibraryText(
         '''
 import 'lib1.dart';
 A a;
 B b;
 C c;
     ''',
         allowErrors: true);
-    checkTypeRef(
-        findVariable('a').type, absUri('/lib2.dart'), 'lib2.dart', 'A');
+    checkTypeRef(findVariable('a').type, absUri('/lib2.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_export_show_show() {
     addNamedSource('/lib1.dart', 'export "lib2.dart" show A, B show A, C;');
     addNamedSource('/lib2.dart', 'class A {} class B {} class C {}');
     serializeLibraryText(
         '''
 import 'lib1.dart';
 A a;
 B b;
 C c;
     ''',
         allowErrors: true);
-    checkTypeRef(
-        findVariable('a').type, absUri('/lib2.dart'), 'lib2.dart', 'A');
+    checkTypeRef(findVariable('a').type, absUri('/lib2.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_import_hide_hide() {
     addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
     serializeLibraryText(
         '''
 import 'lib.dart' hide C hide B, C;
 A a;
 B b;
 C c;
     ''',
         allowErrors: true);
-    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'lib.dart', 'A');
+    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_import_hide_show() {
     addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
     serializeLibraryText(
         '''
 import 'lib.dart' hide C show A, C;
 A a;
 B b;
 C c;
     ''',
         allowErrors: true);
-    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'lib.dart', 'A');
+    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_import_show_hide() {
     addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
     serializeLibraryText(
         '''
 import 'lib.dart' show A, B hide B, C;
 A a;
 B b;
 C c;
     ''',
         allowErrors: true);
-    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'lib.dart', 'A');
+    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_cascaded_import_show_show() {
     addNamedSource('/lib.dart', 'class A {} class B {} class C {}');
     serializeLibraryText(
         '''
 import 'lib.dart' show A, B show A, C;
 A a;
 B b;
 C c;
     ''',
         allowErrors: true);
-    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'lib.dart', 'A');
+    checkTypeRef(findVariable('a').type, absUri('/lib.dart'), 'A');
     checkUnresolvedTypeRef(findVariable('b').type, null, 'B');
     checkUnresolvedTypeRef(findVariable('c').type, null, 'C');
   }
 
   test_class_abstract() {
     UnlinkedClass cls = serializeClassText('abstract class C {}');
     expect(cls.isAbstract, true);
   }
 
   test_class_alias_abstract() {
@@ skipping 41 matching lines @@
   }
 
   test_class_alias_mixin_order() {
     UnlinkedClass cls = serializeClassText('''
 class C = D with E, F;
 class D {}
 class E {}
 class F {}
 ''');
     expect(cls.mixins, hasLength(2));
-    checkTypeRef(cls.mixins[0], null, null, 'E');
-    checkTypeRef(cls.mixins[1], null, null, 'F');
+    checkTypeRef(cls.mixins[0], null, 'E');
+    checkTypeRef(cls.mixins[1], null, 'F');
   }
 
   test_class_alias_no_implicit_constructors() {
     UnlinkedClass cls = serializeClassText('''
 class C = D with E;
 class D {
   D.foo();
   D.bar();
 }
 class E {}
 ''');
     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() {
     EntityRef typeRef = serializeTypeText('C',
         otherDeclarations: 'class C<D, E> = F with G; class F {} class G {}');
-    checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
+    checkTypeRef(typeRef, null, 'C', numTypeParameters: 2);
   }
 
   test_class_alias_reference_generic_imported() {
     addNamedSource(
         '/lib.dart', 'class C<D, E> = F with G; class F {} class G {}');
     EntityRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
-    checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
-        numTypeParameters: 2);
+    checkTypeRef(typeRef, absUri('/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');
+    checkTypeRef(cls.supertype, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_codeRange() {
     if (!includeInformative) return;
     UnlinkedClass cls = serializeClassText(' class C {}');
     _assertCodeRange(cls.codeRange, 1, 10);
   }
 
   test_class_concrete() {
@@ skipping 128 matching lines @@
     expect(cls.documentationComment, isNotNull);
     checkDocumentationComment(cls.documentationComment, text);
   }
 
   test_class_interface() {
     UnlinkedClass cls = serializeClassText('''
 class C implements D {}
 class D {}
 ''');
     expect(cls.interfaces, hasLength(1));
-    checkTypeRef(cls.interfaces[0], null, null, 'D');
+    checkTypeRef(cls.interfaces[0], null, 'D');
   }
 
   test_class_interface_order() {
     UnlinkedClass cls = serializeClassText('''
 class C implements D, E {}
 class D {}
 class E {}
 ''');
     expect(cls.interfaces, hasLength(2));
-    checkTypeRef(cls.interfaces[0], null, null, 'D');
-    checkTypeRef(cls.interfaces[1], null, null, 'E');
+    checkTypeRef(cls.interfaces[0], null, 'D');
+    checkTypeRef(cls.interfaces[1], null, 'E');
   }
 
   test_class_mixin() {
     UnlinkedClass cls = serializeClassText('''
 class C extends Object with D {}
 class D {}
 ''');
     expect(cls.mixins, hasLength(1));
-    checkTypeRef(cls.mixins[0], null, null, 'D');
+    checkTypeRef(cls.mixins[0], null, 'D');
   }
 
   test_class_mixin_order() {
     UnlinkedClass cls = serializeClassText('''
 class C extends Object with D, E {}
 class D {}
 class E {}
 ''');
     expect(cls.mixins, hasLength(2));
-    checkTypeRef(cls.mixins[0], null, null, 'D');
-    checkTypeRef(cls.mixins[1], null, null, 'E');
+    checkTypeRef(cls.mixins[0], null, 'D');
+    checkTypeRef(cls.mixins[1], null, 'E');
   }
 
   test_class_name() {
     var classText = 'class C {}';
     UnlinkedClass cls = serializeClassText(classText);
     expect(cls.name, 'C');
     if (includeInformative) {
       expect(cls.nameOffset, classText.indexOf('C'));
     }
   }
@@ skipping 25 matching lines @@
   }
 
   test_class_private() {
     serializeClassText('class _C {}', className: '_C');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_class_reference_generic() {
     EntityRef typeRef =
         serializeTypeText('C', otherDeclarations: 'class C<D, E> {}');
-    checkTypeRef(typeRef, null, null, 'C', numTypeParameters: 2);
+    checkTypeRef(typeRef, null, 'C', numTypeParameters: 2);
   }
 
   test_class_reference_generic_imported() {
     addNamedSource('/lib.dart', 'class C<D, E> {}');
     EntityRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "lib.dart";');
-    checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'C',
-        numTypeParameters: 2);
+    checkTypeRef(typeRef, absUri('/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');
+    checkTypeRef(cls.supertype, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_type_param_bound() {
     UnlinkedClass cls = serializeClassText('class C<T extends List> {}');
     expect(cls.typeParameters, hasLength(1));
     {
       UnlinkedTypeParam typeParameter = cls.typeParameters[0];
       expect(typeParameter.name, 'T');
       expect(typeParameter.bound, isNotNull);
-      checkTypeRef(typeParameter.bound, 'dart:core', 'dart:core', 'List',
+      checkTypeRef(typeParameter.bound, 'dart:core', 'List',
           numTypeParameters: 1);
     }
   }
 
   test_class_type_param_f_bound() {
     UnlinkedClass cls = serializeClassText('class C<T, U extends List<T>> {}');
     EntityRef typeArgument = cls.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
@@ skipping 23 matching lines @@
       expect(executable.localFunctions, hasLength(1));
       expect(executable.localFunctions[0].returnType, isNull);
       closure = executable.localFunctions[0];
     }
     if (strongMode) {
       // Strong mode infers a type for the closure of `() => dynamic`, so the
       // inferred return type slot should be empty.
       expect(getTypeRefForSlot(closure.inferredReturnTypeSlot), isNull);
     } else {
       // Spec mode infers a type for the closure of `() => Bottom`.
-      checkInferredTypeSlot(
-          closure.inferredReturnTypeSlot, null, null, '*bottom*',
+      checkInferredTypeSlot(closure.inferredReturnTypeSlot, null, '*bottom*',
           onlyInStrongMode: false);
     }
   }
 
   test_closure_executable_with_imported_return_type() {
     addNamedSource('/a.dart', 'class C { D d; } class D {}');
     // The closure has type `() => D`; `D` is defined in a library that is
     // imported.
     UnlinkedExecutable executable = serializeVariableText(r'''
 import "a.dart";
 var v = (() {
   print((() => new C().d)());
 });
 ''').initializer.localFunctions[0];
     expect(executable.localFunctions, hasLength(1));
     expect(executable.localFunctions[0].returnType, isNull);
     checkInferredTypeSlot(executable.localFunctions[0].inferredReturnTypeSlot,
-        absUri('/a.dart'), 'a.dart', 'D',
+        absUri('/a.dart'), 'D',
         onlyInStrongMode: false);
-    checkHasDependency('a.dart', fullyLinked: false);
+    checkHasDependency(absUri('/a.dart'), fullyLinked: false);
   }
 
   test_closure_executable_with_return_type_from_closure() {
     if (skipFullyLinkedData) {
       return;
     }
     // The closure has type `() => () => int`, where the `() => int` part refers
     // to the nested closure.
     UnlinkedExecutable executable = serializeExecutableText('''
 f() {
   print(() {}); // force the closure below to have index 1
   print(() => () => 0);
 }
 ''');
     expect(executable.localFunctions, hasLength(2));
     EntityRef closureType =
         getTypeRefForSlot(executable.localFunctions[1].inferredReturnTypeSlot);
-    checkLinkedTypeRef(closureType, null, null, '',
+    checkLinkedTypeRef(closureType, null, '',
         expectedKind: ReferenceKind.function);
     int outerClosureIndex =
         definingUnit.references[closureType.reference].containingReference;
-    checkReferenceIndex(outerClosureIndex, null, null, '',
+    checkReferenceIndex(outerClosureIndex, null, '',
         expectedKind: ReferenceKind.function, localIndex: 1);
     int topLevelFunctionIndex =
         definingUnit.references[outerClosureIndex].containingReference;
-    checkReferenceIndex(topLevelFunctionIndex, null, null, 'f',
+    checkReferenceIndex(topLevelFunctionIndex, null, 'f',
         expectedKind: ReferenceKind.topLevelFunction);
     expect(
         definingUnit.references[topLevelFunctionIndex].containingReference, 0);
   }
 
   test_closure_executable_with_unimported_return_type() {
     addNamedSource('/a.dart', 'import "b.dart"; class C { D d; }');
     addNamedSource('/b.dart', 'class D {}');
     // The closure has type `() => D`; `D` is defined in a library that is not
     // imported.
     UnlinkedExecutable executable = serializeVariableText(r'''
 import "a.dart";
 var v = (() {
   print((() => new C().d)());
 });
 ''').initializer.localFunctions[0];
     expect(executable.localFunctions, hasLength(1));
     expect(executable.localFunctions[0].returnType, isNull);
     checkInferredTypeSlot(executable.localFunctions[0].inferredReturnTypeSlot,
-        absUri('/b.dart'), 'b.dart', 'D',
+        absUri('/b.dart'), 'D',
         onlyInStrongMode: false);
     if (!skipFullyLinkedData) {
       checkHasDependency('b.dart', fullyLinked: true);
     }
   }
 
   test_constExpr_binary_add() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 + 2;');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushInt,
@@ skipping 240 matching lines @@
   final x;
   const C() : x = T;
 }
 ''';
     UnlinkedClass cls = serializeClassText(text, allowErrors: true);
     assertUnlinkedConst(cls.executables[0].constantInitializers[0].expression,
         operators: [
           UnlinkedExprOperation.pushReference
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'T',
+          (EntityRef r) => checkTypeRef(r, null, 'T',
                   expectedKind: ReferenceKind.propertyAccessor,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                         numTypeParameters: 1)
                   ])
         ]);
   }
 
   test_constExpr_conditional() {
     UnlinkedVariable variable =
@@ skipping 69 matching lines @@
         ],
         ints: [
           5,
           0,
           0,
           0,
           2,
           0
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+          (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_constExpr_functionExpression_asArgument_multiple() {
     // Even though function expressions are not allowed in constant
     // declarations, they might occur due to erroneous code, so make sure they
     // function correctly.
     UnlinkedVariable variable = serializeVariableText('''
 const v = foo(5, () => 42, () => 43);
@@ skipping 11 matching lines @@
           5,
           0,
           0,
           0,
           1,
           0,
           3,
           0
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+          (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_constExpr_functionExpression_inConstructorInitializers() {
     // Even though function expressions are not allowed in constant
     // declarations, they might occur due to erroneous code, so make sure they
     // function correctly.
     UnlinkedExecutable executable = serializeClassText('''
 class C {
@@ skipping 19 matching lines @@
 }
 const v = const C<int, String>.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, null, null, 'named',
+        checkTypeRef(r, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
                   numTypeParameters: 2)
             ],
             numTypeArguments: 2);
-        checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
-        checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
+        checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
+        checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_named_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C<int, String>.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, null, null, 'named',
+        checkTypeRef(r, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                  absoluteUri: absUri('/a.dart'),
-                  relativeUri: 'a.dart',
-                  numTypeParameters: 2)
+                  absoluteUri: absUri('/a.dart'), numTypeParameters: 2)
             ],
             numTypeArguments: 2);
-        checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
-        checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
+        checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
+        checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_named_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C<int, String>.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, null, null, 'named',
+        checkTypeRef(r, null, 'named',
             expectedKind: ReferenceKind.constructor,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                  absoluteUri: absUri('/a.dart'),
-                  relativeUri: 'a.dart',
-                  numTypeParameters: 2),
+                  absoluteUri: absUri('/a.dart'), numTypeParameters: 2),
               new _PrefixExpectation(ReferenceKind.prefix, 'p')
             ],
             numTypeArguments: 2);
-        checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
-        checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
+        checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
+        checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed() {
     UnlinkedVariable variable = serializeVariableText('''
 class C<K, V> {
   const C();
 }
 const v = const C<int, String>();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, null, null, 'C',
+        checkTypeRef(r, null, 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
             numTypeArguments: 2);
-        checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
-        checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
+        checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
+        checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C<int, String>();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
+        checkTypeRef(r, absUri('/a.dart'), 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
             numTypeArguments: 2);
-        checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
-        checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
+        checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
+        checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_generic_unnamed_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C<K, V> {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C<int, String>();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
+        checkTypeRef(r, absUri('/a.dart'), 'C',
             expectedKind: ReferenceKind.classOrEnum,
             numTypeParameters: 2,
             numTypeArguments: 2,
             prefixExpectations: [
               new _PrefixExpectation(ReferenceKind.prefix, 'p')
             ]);
-        checkTypeRef(r.typeArguments[0], 'dart:core', 'dart:core', 'int');
-        checkTypeRef(r.typeArguments[1], 'dart:core', 'dart:core', 'String');
+        checkTypeRef(r.typeArguments[0], 'dart:core', 'int');
+        checkTypeRef(r.typeArguments[1], 'dart:core', 'String');
       }
     ]);
   }
 
   test_constExpr_invokeConstructor_named() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   const C.named();
 }
 const v = const C.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_named_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C.named();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C.named();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
+                    absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   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.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                    absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   const C(a, b, c, d, {e, f, g});
 }
@@ skipping 21 matching lines @@
       4,
     ], doubles: [
       3.3
     ], strings: [
       '444',
       '777',
       'e',
       'g',
       'f'
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'C', expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = const C();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'C',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_invokeConstructor_unnamed_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   const C();
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = const p.C();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'C',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'C',
               expectedKind: ReferenceKind.classOrEnum,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 class C {}
 const v = const C.foo();
 ''',
         allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+      (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named2() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 const v = const C.foo();
 ''',
         allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+      (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'C')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named_prefixed() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
 }
 ''');
     UnlinkedVariable variable = serializeVariableText(
         '''
 import 'a.dart' as p;
 const v = const p.C.foo();
 ''',
         allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+      (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                    absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_named_prefixed2() {
     addNamedSource('/a.dart', '');
     UnlinkedVariable variable = serializeVariableText(
         '''
 import 'a.dart' as p;
 const v = const p.C.foo();
 ''',
         allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+      (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'C'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_invokeConstructor_unresolved_unnamed() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 const v = const Foo();
 ''',
         allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'Foo',
-          expectedKind: ReferenceKind.unresolved)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'Foo', expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_constExpr_invokeMethodRef_identical() {
     UnlinkedVariable variable =
         serializeVariableText('const v = identical(42, null);');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushInt,
       UnlinkedExprOperation.pushNull,
       UnlinkedExprOperation.invokeMethodRef
     ], ints: [
       42,
       0,
       2,
       0
     ], referenceValidators: [
       (EntityRef r) {
-        checkTypeRef(r, 'dart:core', 'dart:core', 'identical',
+        checkTypeRef(r, 'dart:core', 'identical',
             expectedKind: ReferenceKind.topLevelFunction);
       }
     ]);
   }
 
   test_constExpr_length_classConstField() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static const int length = 0;
 }
 const int v = C.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'length',
+      (EntityRef r) => checkTypeRef(r, null, 'length',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_length_classConstField_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static const int length = 0;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const int v = p.C.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'length',
+      (EntityRef r) => checkTypeRef(r, null, 'length',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                    absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget() {
     UnlinkedVariable variable = serializeVariableText('''
 const String a = 'aaa';
 const int v = a.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'length',
+      (EntityRef r) => checkTypeRef(r, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(
                     ReferenceKind.topLevelPropertyAccessor, 'a')
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget_classConstField() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static const String F = '';
 }
 const int v = C.F.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'length',
+      (EntityRef r) => checkTypeRef(r, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.propertyAccessor, 'F'),
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C'),
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget_imported() {
     addNamedSource(
         '/a.dart',
         '''
 const String a = 'aaa';
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const int v = a.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'length',
+      (EntityRef r) => checkTypeRef(r, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(
                     ReferenceKind.topLevelPropertyAccessor, 'a',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
+                    absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_length_identifierTarget_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 const String a = 'aaa';
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const int v = p.a.length;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'length',
+      (EntityRef r) => checkTypeRef(r, null, 'length',
               expectedKind: ReferenceKind.unresolved,
               unresolvedHasName: true,
               prefixExpectations: [
                 new _PrefixExpectation(
                     ReferenceKind.topLevelPropertyAccessor, 'a',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                    absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_length_parenthesizedBinaryTarget() {
     UnlinkedVariable variable =
         serializeVariableText('const v = ("abc" + "edf").length;');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushString,
@@ skipping 44 matching lines @@
       UnlinkedExprOperation.pushInt,
       UnlinkedExprOperation.pushInt,
       UnlinkedExprOperation.pushInt,
       UnlinkedExprOperation.makeTypedList
     ], ints: [
       11,
       22,
       33,
       3
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeTypedList_dynamic() {
     UnlinkedVariable variable =
         serializeVariableText('const v = const <dynamic>[11, 22, 33];');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushInt,
       UnlinkedExprOperation.pushInt,
@@ skipping 23 matching lines @@
     ], ints: [
       11,
       22,
       33,
       3
     ], strings: [
       'aaa',
       'bbb',
       'ccc'
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int',
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'int',
           expectedKind: ReferenceKind.classOrEnum),
-      (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String',
+      (EntityRef r) => checkTypeRef(r, 'dart:core', 'String',
           expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_makeTypedMap_dynamic() {
     UnlinkedVariable variable = serializeVariableText(
         'const v = const <dynamic, dynamic>{11: "aaa", 22: "bbb", 33: "ccc"};');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushInt,
       UnlinkedExprOperation.pushString,
@@ skipping 173 matching lines @@
   }
 
   test_constExpr_pushReference_class() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {}
 const v = C;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'C', expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_pushReference_enum() {
     UnlinkedVariable variable = serializeVariableText('''
 enum C {V1, V2, V3}
 const v = C;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'C',
-          expectedKind: ReferenceKind.classOrEnum)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'C', expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_constExpr_pushReference_enumValue() {
     UnlinkedVariable variable = serializeVariableText('''
 enum C {V1, V2, V3}
 const v = C.V1;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'V1',
+      (EntityRef r) => checkTypeRef(r, null, 'V1',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_enumValue_viaImport() {
     addNamedSource(
         '/a.dart',
         '''
 enum C {V1, V2, V3}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.V1;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'V1',
+      (EntityRef r) => checkTypeRef(r, null, 'V1',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
+                    absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_pushReference_enumValues() {
     UnlinkedVariable variable = serializeVariableText('''
 enum C {V1, V2, V3}
 const v = C.values;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'values',
+      (EntityRef r) => checkTypeRef(r, null, 'values',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_enumValues_viaImport() {
     addNamedSource(
         '/a.dart',
         '''
 enum C {V1, V2, V3}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.values;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'values',
+      (EntityRef r) => checkTypeRef(r, null, 'values',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
+                    absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_pushReference_field() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static const int F = 1;
 }
 const v = C.F;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'F',
+      (EntityRef r) => checkTypeRef(r, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static const int F = 1;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.F;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'F',
+      (EntityRef r) => checkTypeRef(r, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
+                    absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static const int F = 1;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.F;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'F',
+      (EntityRef r) => checkTypeRef(r, null, 'F',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                    absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p'),
               ])
     ]);
   }
 
   test_constExpr_pushReference_field_simpleIdentifier() {
     UnlinkedVariable variable = serializeClassText('''
 class C {
   static const a = b;
   static const b = null;
 }
 ''').fields[0];
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'b',
+      (EntityRef r) => checkTypeRef(r, null, 'b',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticGetter() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static int get x => null;
 }
 const v = C.x;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'x',
+      (EntityRef r) => checkTypeRef(r, null, 'x',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticGetter_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static int get x => null;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.x;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'x',
+      (EntityRef r) => checkTypeRef(r, null, 'x',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
+                    absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticGetter_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static int get x => null;
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.x;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'x',
+      (EntityRef r) => checkTypeRef(r, null, 'x',
               expectedKind: ReferenceKind.propertyAccessor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                    absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod() {
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static m() {}
 }
 const v = C.m;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'm',
+      (EntityRef r) => checkTypeRef(r, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_imported() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static m() {}
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = C.m;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'm',
+      (EntityRef r) => checkTypeRef(r, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart')
+                    absoluteUri: absUri('/a.dart'))
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 class C {
   static m() {}
 }
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.C.m;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'm',
+      (EntityRef r) => checkTypeRef(r, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                    absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_pushReference_staticMethod_simpleIdentifier() {
     UnlinkedVariable variable = serializeClassText('''
 class C {
   static const a = m;
   static m() {}
 }
 ''').fields[0];
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'm',
+      (EntityRef r) => checkTypeRef(r, null, 'm',
               expectedKind: ReferenceKind.method,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction() {
     UnlinkedVariable variable = serializeVariableText('''
 f() {}
 const v = f;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'f',
+      (EntityRef r) => checkTypeRef(r, null, 'f',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction_imported() {
     addNamedSource(
         '/a.dart',
         '''
 f() {}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = f;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'f',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'f',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_constExpr_pushReference_topLevelFunction_imported_withPrefix() {
     addNamedSource(
         '/a.dart',
         '''
 f() {}
 ''');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.f;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'f',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'f',
               expectedKind: ReferenceKind.topLevelFunction,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.prefix, 'p')
               ])
     ]);
   }
 
   test_constExpr_pushReference_topLevelGetter() {
     UnlinkedVariable variable = serializeVariableText('''
 int get x => null;
 const v = x;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'x',
+      (EntityRef r) => checkTypeRef(r, null, 'x',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelGetter_imported() {
     addNamedSource('/a.dart', 'int get x => null;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = x;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'x',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'x',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelGetter_imported_withPrefix() {
     addNamedSource('/a.dart', 'int get x => null;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart' as p;
 const v = p.x;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'x',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'x',
           expectedKind: ReferenceKind.topLevelPropertyAccessor,
           expectedPrefix: 'p')
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable() {
     UnlinkedVariable variable = serializeVariableText('''
 const int a = 1;
 const v = a;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
+      (EntityRef r) => checkTypeRef(r, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_constExpr_pushReference_topLevelVariable_imported() {
     addNamedSource('/a.dart', 'const int a = 1;');
     UnlinkedVariable variable = serializeVariableText('''
 import 'a.dart';
 const v = a;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
+      (EntityRef r) => checkTypeRef(r, absUri('/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.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
       (EntityRef r) {
-        return checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
+        return checkTypeRef(r, absUri('/a.dart'), 'a',
             expectedKind: ReferenceKind.topLevelPropertyAccessor,
             expectedPrefix: 'p');
       }
     ]);
   }
 
   test_constExpr_pushReference_typeParameter() {
     String text = '''
 class C<T> {
   static const a = T;
@@ skipping 12 matching lines @@
 
   test_constExpr_pushReference_unresolved_prefix0() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 const v = foo;
 ''',
         allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
-          expectedKind: ReferenceKind.unresolved)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'foo', expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix1() {
     UnlinkedVariable variable = serializeVariableText(
         '''
 class C {}
 const v = C.foo;
 ''',
         allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+      (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
               ])
     ]);
   }
 
   test_constExpr_pushReference_unresolved_prefix2() {
     addNamedSource(
         '/a.dart',
         '''
 class C {}
 ''');
     UnlinkedVariable variable = serializeVariableText(
         '''
 import 'a.dart' as p;
 const v = p.C.foo;
 ''',
         allowErrors: true);
     assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+      (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                    absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                    absoluteUri: absUri('/a.dart')),
                 new _PrefixExpectation(ReferenceKind.prefix, 'p'),
               ])
     ]);
   }
 
   test_constExpr_pushString_adjacent() {
     UnlinkedVariable variable =
         serializeVariableText('const v = "aaa" "b" "ccc";');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedExprOperation.pushString], strings: ['aaabccc']);
@@ skipping 379 matching lines @@
             serializeClassText('class C { C(this.x); final x; }').executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.isInitializingFormal, isTrue);
   }
 
   test_constructor_initializing_formal_explicit_type() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(int this.x); final x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
-    checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
+    checkTypeRef(parameter.type, 'dart:core', 'int');
   }
 
   test_constructor_initializing_formal_function_typed() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(this.x()); final x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.isFunctionTyped, isTrue);
   }
 
   test_constructor_initializing_formal_function_typed_explicit_return_type() {
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(int this.x()); Function x; }')
                 .executables);
     UnlinkedParam parameter = executable.parameters[0];
-    checkTypeRef(parameter.type, 'dart:core', 'dart:core', 'int');
+    checkTypeRef(parameter.type, 'dart:core', 'int');
   }
 
   test_constructor_initializing_formal_function_typed_implicit_return_type() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C { C(this.x()); Function x; }')
             .executables);
     UnlinkedParam parameter = executable.parameters[0];
     expect(parameter.isFunctionTyped, isTrue);
     expect(parameter.type, isNull);
   }
@@ skipping 33 matching lines @@
 }
 int foo() => 0;
 ''').executables);
     UnlinkedParam param = executable.parameters[0];
     expect(param.isFunctionTyped, isTrue);
     expect(param.kind, UnlinkedParamKind.positional);
     expect(param.defaultValueCode, 'foo');
     assertUnlinkedConst(param.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+      (EntityRef r) => checkTypeRef(r, null, 'foo',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_constructor_initializing_formal_implicit_type() {
     // Note: the implicit type of an initializing formal is the type of the
     // field.
     UnlinkedExecutable executable = findExecutable('',
         executables:
             serializeClassText('class C { C(this.x); int x; }').executables);
@@ skipping 147 matching lines @@
 }
 class D extends C {
   D.named() : super._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(executable.redirectedConstructor, null, null, 'named',
+    checkTypeRef(executable.redirectedConstructor, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
           new _PrefixExpectation(ReferenceKind.classOrEnum, 'D')
         ]);
   }
 
   test_constructor_redirected_factory_named_generic() {
     String text = '''
 class C<T, U> {
   factory C() = D<U, T>.named;
   C._();
 }
 class D<T, U> extends C<U, T> {
   D.named() : super._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(executable.redirectedConstructor, null, null, 'named',
+    checkTypeRef(executable.redirectedConstructor, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
           new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
               numTypeParameters: 2)
         ],
         numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
@@ skipping 11 matching lines @@
 class C {
   factory C() = D.named;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(executable.redirectedConstructor, null, null, 'named',
+    checkTypeRef(executable.redirectedConstructor, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
-          new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
-              absoluteUri: absUri('/foo.dart'), relativeUri: 'foo.dart')
+          new _PrefixExpectation(
+            ReferenceKind.classOrEnum,
+            'D',
+            absoluteUri: absUri('/foo.dart'),
+          )
         ]);
   }
 
   test_constructor_redirected_factory_named_imported_generic() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D<T, U> extends C<U, T> {
   D.named() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart';
 class C<T, U> {
   factory C() = D<U, T>.named;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(executable.redirectedConstructor, null, null, 'named',
+    checkTypeRef(executable.redirectedConstructor, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
-          new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
-              numTypeParameters: 2,
-              absoluteUri: absUri('/foo.dart'),
-              relativeUri: 'foo.dart')
+          new _PrefixExpectation(
+            ReferenceKind.classOrEnum,
+            'D',
+            numTypeParameters: 2,
+            absoluteUri: absUri('/foo.dart'),
+          )
         ],
         numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_named_prefixed() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D extends C {
   D.named() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart' as foo;
 class C {
   factory C() = foo.D.named;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(executable.redirectedConstructor, null, null, 'named',
+    checkTypeRef(executable.redirectedConstructor, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
-          new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
-              absoluteUri: absUri('/foo.dart'), relativeUri: 'foo.dart'),
+          new _PrefixExpectation(
+            ReferenceKind.classOrEnum,
+            'D',
+            absoluteUri: absUri('/foo.dart'),
+          ),
           new _PrefixExpectation(ReferenceKind.prefix, 'foo')
         ]);
   }
 
   test_constructor_redirected_factory_named_prefixed_generic() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D<T, U> extends C<U, T> {
   D.named() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart' as foo;
 class C<T, U> {
   factory C() = foo.D<U, T>.named;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(executable.redirectedConstructor, null, null, 'named',
+    checkTypeRef(executable.redirectedConstructor, null, 'named',
         expectedKind: ReferenceKind.constructor,
         prefixExpectations: [
-          new _PrefixExpectation(ReferenceKind.classOrEnum, 'D',
-              numTypeParameters: 2,
-              absoluteUri: absUri('/foo.dart'),
-              relativeUri: 'foo.dart'),
+          new _PrefixExpectation(
+            ReferenceKind.classOrEnum,
+            'D',
+            numTypeParameters: 2,
+            absoluteUri: absUri('/foo.dart'),
+          ),
           new _PrefixExpectation(ReferenceKind.prefix, 'foo')
         ],
         numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_unnamed() {
     String text = '''
 class C {
   factory C() = D;
   C._();
 }
 class D extends C {
   D() : super._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(executable.redirectedConstructor, null, null, 'D');
+    checkTypeRef(executable.redirectedConstructor, null, 'D');
   }
 
   test_constructor_redirected_factory_unnamed_generic() {
     String text = '''
 class C<T, U> {
   factory C() = D<U, T>;
   C._();
 }
 class D<T, U> extends C<U, T> {
   D() : super._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(executable.redirectedConstructor, null, null, 'D',
+    checkTypeRef(executable.redirectedConstructor, null, 'D',
         numTypeParameters: 2, numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_unnamed_imported() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D extends C {
   D() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart';
 class C {
   factory C() = D;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(
-        executable.redirectedConstructor, absUri('/foo.dart'), 'foo.dart', 'D');
+    checkTypeRef(executable.redirectedConstructor, absUri('/foo.dart'), 'D');
   }
 
   test_constructor_redirected_factory_unnamed_imported_generic() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D<T, U> extends C<U, T> {
   D() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart';
 class C<T, U> {
   factory C() = D<U, T>;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(
-        executable.redirectedConstructor, absUri('/foo.dart'), 'foo.dart', 'D',
+    checkTypeRef(executable.redirectedConstructor, absUri('/foo.dart'), 'D',
         numTypeParameters: 2, numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_factory_unnamed_prefixed() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D extends C {
   D() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart' as foo;
 class C {
   factory C() = foo.D;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(
-        executable.redirectedConstructor, absUri('/foo.dart'), 'foo.dart', 'D',
+    checkTypeRef(executable.redirectedConstructor, absUri('/foo.dart'), 'D',
         expectedPrefix: 'foo');
   }
 
   test_constructor_redirected_factory_unnamed_prefixed_generic() {
     addNamedSource(
         '/foo.dart',
         '''
 import 'test.dart';
 class D<T, U> extends C<U, T> {
   D() : super._();
 }
 ''');
     String text = '''
 import 'foo.dart' as foo;
 class C<T, U> {
   factory C() = foo.D<U, T>;
   C._();
 }
 ''';
     UnlinkedExecutable executable =
         serializeClassText(text, className: 'C').executables[0];
     expect(executable.isRedirectedConstructor, isTrue);
     expect(executable.isFactory, isTrue);
     expect(executable.redirectedConstructorName, isEmpty);
-    checkTypeRef(
-        executable.redirectedConstructor, absUri('/foo.dart'), 'foo.dart', 'D',
+    checkTypeRef(executable.redirectedConstructor, absUri('/foo.dart'), 'D',
         numTypeParameters: 2, expectedPrefix: 'foo', numTypeArguments: 2);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[0], 1);
     checkParamTypeRef(executable.redirectedConstructor.typeArguments[1], 2);
   }
 
   test_constructor_redirected_thisInvocation_named() {
     String text = '''
 class C {
   C() : this.named();
   C.named();
@@ skipping 580 matching lines @@
   }
 
   test_dependencies_export_to_export_unused() {
     addNamedSource('/a.dart', 'export "b.dart";');
     addNamedSource('/b.dart', '');
     serializeLibraryText('export "a.dart";');
     // The main test library depends on b.dart, even though it doesn't
     // re-export any names defined in b.dart, because a change to b.dart might
     // cause it to start exporting a name that the main test library *does*
     // use.
-    checkHasDependency('b.dart');
+    checkHasDependency(absUri('/b.dart'));
   }
 
   test_dependencies_export_unused() {
     addNamedSource('/a.dart', '');
     serializeLibraryText('export "a.dart";');
     // The main test library depends on a.dart, even though it doesn't
     // re-export any names defined in a.dart, because a change to a.dart might
     // cause it to start exporting a name that the main test library *will*
     // re-export.
-    checkHasDependency('a.dart');
+    checkHasDependency(absUri('/a.dart'));
   }
 
   test_dependencies_import_to_export() {
     addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
     addNamedSource('/b.dart', 'library b;');
     serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency('a.dart');
+    checkHasDependency(absUri('/a.dart'));
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
-    checkHasDependency('b.dart');
+    checkHasDependency(absUri('/b.dart'));
   }
 
   test_dependencies_import_to_export_in_subdirs_absolute_export() {
     addNamedSource('/a/a.dart',
         'library a; export "${absUri('/a/b/b.dart')}"; class A {}');
     addNamedSource('/a/b/b.dart', 'library b;');
     serializeLibraryText('import "a/a.dart"; A a;');
-    checkHasDependency('a/a.dart');
+    checkHasDependency(absUri('/a/a.dart'));
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
     checkHasDependency(absUri('/a/b/b.dart'));
   }
 
   test_dependencies_import_to_export_in_subdirs_absolute_import() {
     addNamedSource('/a/a.dart', 'library a; export "b/b.dart"; class A {}');
     addNamedSource('/a/b/b.dart', 'library b;');
     serializeLibraryText('import "${absUri('/a/a.dart')}"; A a;');
     checkHasDependency(absUri('/a/a.dart'));
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
     checkHasDependency(absUri('/a/b/b.dart'));
   }
 
   test_dependencies_import_to_export_in_subdirs_relative() {
     addNamedSource('/a/a.dart', 'library a; export "b/b.dart"; class A {}');
     addNamedSource('/a/b/b.dart', 'library b;');
     serializeLibraryText('import "a/a.dart"; A a;');
-    checkHasDependency('a/a.dart');
+    checkHasDependency(absUri('/a/a.dart'));
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
-    checkHasDependency('a/b/b.dart');
+    checkHasDependency(absUri('/a/b/b.dart'));
   }
 
   test_dependencies_import_to_export_loop() {
     addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
     addNamedSource('/b.dart', 'library b; export "a.dart";');
     serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency('a.dart');
+    checkHasDependency(absUri('/a.dart'));
     // Serialization should have been able to walk the transitive export
     // dependencies to b.dart without going into an infinite loop.
-    checkHasDependency('b.dart');
+    checkHasDependency(absUri('/b.dart'));
   }
 
   test_dependencies_import_to_export_transitive_closure() {
     addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
     addNamedSource('/b.dart', 'library b; export "c.dart";');
     addNamedSource('/c.dart', 'library c;');
     serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency('a.dart');
+    checkHasDependency(absUri('/a.dart'));
     // The main test library depends on c.dart, because names defined in
     // c.dart are exported by b.dart and then re-exported by a.dart.
-    checkHasDependency('c.dart');
+    checkHasDependency(absUri('/c.dart'));
   }
 
   test_dependencies_import_to_export_unused() {
     addNamedSource('/a.dart', 'export "b.dart";');
     addNamedSource('/b.dart', '');
     serializeLibraryText('import "a.dart";', allowErrors: true);
     // The main test library depends on b.dart, even though it doesn't use any
     // names defined in b.dart, because a change to b.dart might cause it to
     // start exporting a name that the main test library *does* use.
-    checkHasDependency('b.dart');
+    checkHasDependency(absUri('/b.dart'));
   }
 
   test_dependencies_import_transitive_closure() {
     addNamedSource(
         '/a.dart', 'library a; import "b.dart"; class A extends B {}');
     addNamedSource('/b.dart', 'library b; class B {}');
     serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency('a.dart');
+    checkHasDependency(absUri('/a.dart'));
     // The main test library doesn't depend on b.dart, because no change to
     // b.dart can possibly affect the serialized element model for it.
-    checkLacksDependency('b.dart');
+    checkLacksDependency(absUri('/b.dart'));
   }
 
   test_dependencies_import_unused() {
     addNamedSource('/a.dart', '');
     serializeLibraryText('import "a.dart";', allowErrors: true);
     // The main test library depends on a.dart, even though it doesn't use any
     // names defined in a.dart, because a change to a.dart might cause it to
     // start exporting a name that the main test library *does* use.
-    checkHasDependency('a.dart');
+    checkHasDependency(absUri('/a.dart'));
   }
 
   test_dependencies_parts() {
     addNamedSource(
         '/a.dart', 'library a; part "b.dart"; part "c.dart"; class A {}');
     addNamedSource('/b.dart', 'part of a;');
     addNamedSource('/c.dart', 'part of a;');
     serializeLibraryText('import "a.dart"; A a;');
-    int dep = checkHasDependency('a.dart');
-    checkDependencyParts(linked.dependencies[dep], ['b.dart', 'c.dart']);
+    int dep = checkHasDependency(absUri('/a.dart'));
+    checkDependencyParts(
+        linked.dependencies[dep], [absUri('/b.dart'), absUri('/c.dart')]);
   }
 
   test_dependencies_parts_relative_to_importing_library() {
     addNamedSource('/a/b.dart', 'export "c/d.dart";');
     addNamedSource('/a/c/d.dart',
         'library d; part "e/f.dart"; part "g/h.dart"; class D {}');
     addNamedSource('/a/c/e/f.dart', 'part of d;');
     addNamedSource('/a/c/g/h.dart', 'part of d;');
     serializeLibraryText('import "a/b.dart"; D d;');
-    int dep = checkHasDependency('a/c/d.dart');
-    checkDependencyParts(
-        linked.dependencies[dep], ['a/c/e/f.dart', 'a/c/g/h.dart']);
+    int dep = checkHasDependency(absUri('/a/c/d.dart'));
+    checkDependencyParts(linked.dependencies[dep],
+        [absUri('/a/c/e/f.dart'), absUri('/a/c/g/h.dart')]);
   }
 
   test_elements_in_part() {
     addNamedSource(
         '/part1.dart',
         '''
 part of my.lib;
 
 class C {}
 enum E { v }
@@ skipping 180 matching lines @@
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_getter_private() {
     serializeExecutableText('int get _f => 1;', executableName: '_f');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_executable_getter_type() {
     UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
-    checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
+    checkTypeRef(executable.returnType, 'dart:core', 'int');
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_getter_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('get f => 1;');
     expect(executable.returnType, isNull);
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_localFunctions() {
@@ skipping 80 matching lines @@
   } // 4
 );
 ''';
     UnlinkedExecutable executable =
         serializeVariableText(code).initializer.localFunctions[0];
     List<UnlinkedVariable> variables = executable.localVariables;
     expect(variables, hasLength(2));
     {
       UnlinkedVariable e = variables.singleWhere((v) => v.name == 'e');
       _assertVariableVisible(code, e, 'on int catch (', '} // 3');
-      checkTypeRef(e.type, 'dart:core', 'dart:core', 'int');
+      checkTypeRef(e.type, 'dart:core', 'int');
     }
     {
       UnlinkedVariable st = variables.singleWhere((v) => v.name == 'st');
       _assertVariableVisible(code, st, 'on int catch (', '} // 3');
     }
   }
 
   test_executable_localVariables_catch_noVariables() {
     String code = r'''
 f() {
@@ skipping 27 matching lines @@
 ''';
     UnlinkedExecutable executable = serializeVariableText(code)
         .initializer
         .localFunctions[0]
         .localFunctions[0];
     List<UnlinkedVariable> variables = executable.localVariables;
     expect(variables, hasLength(1));
     {
       UnlinkedVariable i = variables.singleWhere((v) => v.name == 'i');
       _assertVariableVisible(code, i, 'for', '} // 3');
-      checkTypeRef(i.type, 'dart:core', 'dart:core', 'int');
+      checkTypeRef(i.type, 'dart:core', 'int');
     }
   }
 
   test_executable_localVariables_forEachLoop_outside() {
     String code = r'''
 var v = (() {
   f() { // 1
     int i;
     for (i in <int>[]) {
       print(i);
     }
   } // 4
 });
 ''';
     UnlinkedExecutable executable = serializeVariableText(code)
         .initializer
         .localFunctions[0]
         .localFunctions[0];
     List<UnlinkedVariable> variables = executable.localVariables;
     expect(variables, hasLength(1));
     {
       UnlinkedVariable i = variables.singleWhere((v) => v.name == 'i');
       _assertVariableVisible(code, i, '{ // 1', '} // 4');
-      checkTypeRef(i.type, 'dart:core', 'dart:core', 'int');
+      checkTypeRef(i.type, 'dart:core', 'int');
     }
   }
 
   test_executable_localVariables_forLoop() {
     String code = r'''
 var v = (() {
   f() { // 1
     for (int i = 0, j = 0; i < 10; i++, j++) { // 2
       print(i);
     } // 3
   } // 4
 });
 ''';
     UnlinkedExecutable executable = serializeVariableText(code)
         .initializer
         .localFunctions[0]
         .localFunctions[0];
     List<UnlinkedVariable> variables = executable.localVariables;
     expect(variables, hasLength(2));
     {
       UnlinkedVariable i = variables.singleWhere((v) => v.name == 'i');
       _assertVariableVisible(code, i, 'for', '} // 3');
-      checkTypeRef(i.type, 'dart:core', 'dart:core', 'int');
+      checkTypeRef(i.type, 'dart:core', 'int');
     }
     {
       UnlinkedVariable i = variables.singleWhere((v) => v.name == 'j');
       _assertVariableVisible(code, i, 'for', '} // 3');
-      checkTypeRef(i.type, 'dart:core', 'dart:core', 'int');
+      checkTypeRef(i.type, 'dart:core', 'int');
     }
   }
 
   test_executable_localVariables_forLoop_noVariables() {
     String code = r'''
 var v = (() {
   f() {
     for (; true;) {}
   }
 });
@@ skipping 43 matching lines @@
     List<UnlinkedExecutable> functions = executable.localFunctions;
     expect(functions, hasLength(2));
     // f - f1
     {
       UnlinkedExecutable f1 = functions.singleWhere((v) => v.name == 'f1');
       List<UnlinkedVariable> variables = f1.localVariables;
       expect(variables, hasLength(1));
       // f1 - v1
       UnlinkedVariable v1 = variables.singleWhere((v) => v.name == 'v1');
       _assertVariableVisible(code, v1, '{ // 1', '} // 2');
-      checkTypeRef(v1.type, 'dart:core', 'dart:core', 'int');
+      checkTypeRef(v1.type, 'dart:core', 'int');
     }
     // f - f2
     {
       UnlinkedExecutable f2 = functions.singleWhere((v) => v.name == 'f2');
       List<UnlinkedVariable> variables2 = f2.localVariables;
       List<UnlinkedExecutable> functions2 = f2.localFunctions;
       expect(variables2, hasLength(1));
       expect(functions2, hasLength(1));
       // f - f2 - v1
       UnlinkedVariable v1 = variables2.singleWhere((v) => v.name == 'v1');
       _assertVariableVisible(code, v1, '{ // 3', '} // 6');
-      checkTypeRef(v1.type, 'dart:core', 'dart:core', 'int');
+      checkTypeRef(v1.type, 'dart:core', 'int');
       // f - f2 - f3
       UnlinkedExecutable f3 = functions2.singleWhere((v) => v.name == 'f3');
       _assertExecutableVisible(code, f3, '{ // 3', '} // 6');
       List<UnlinkedVariable> variables3 = f3.localVariables;
       List<UnlinkedExecutable> functions3 = f3.localFunctions;
       expect(variables3, hasLength(1));
       expect(functions3, hasLength(0));
       // f - f3 - v2
       UnlinkedVariable v2 = variables3.singleWhere((v) => v.name == 'v2');
       _assertVariableVisible(code, v2, '{ // 4', '} // 5');
-      checkTypeRef(v2.type, 'dart:core', 'dart:core', 'int');
+      checkTypeRef(v2.type, 'dart:core', 'int');
     }
   }
 
   test_executable_localVariables_inMethod() {
     String code = r'''
 class C {
   m() {
     int v;
     f() {}
   }
@@ skipping 195 matching lines @@
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '+');
     expect(executable.returnType, isNotNull);
     expect(executable.isAbstract, false);
     expect(executable.isAsynchronous, isFalse);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isGenerator, isFalse);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
-    checkTypeRef(executable.returnType, null, null, 'C');
+    checkTypeRef(executable.returnType, null, 'C');
     expect(executable.typeParameters, isEmpty);
     expect(executable.isExternal, false);
   }
 
   test_executable_operator_abstract() {
     UnlinkedExecutable executable =
         serializeClassText('class C { C operator+(C c); }', allowErrors: true)
             .executables[0];
     expect(executable.isAbstract, true);
     expect(executable.isAsynchronous, isFalse);
@@ skipping 30 matching lines @@
         serializeClassText('class C { bool operator[](int i) => null; }')
             .executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]');
     expect(executable.returnType, isNotNull);
     expect(executable.isAbstract, false);
     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');
+    checkTypeRef(executable.returnType, '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];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
     expect(executable.returnType, isNotNull);
@@ skipping 44 matching lines @@
 
   test_executable_param_function_typed_param_order() {
     UnlinkedExecutable executable = serializeExecutableText('f(g(x, y)) {}');
     expect(executable.parameters[0].parameters, hasLength(2));
     expect(executable.parameters[0].parameters[0].name, 'x');
     expect(executable.parameters[0].parameters[1].name, 'y');
   }
 
   test_executable_param_function_typed_return_type() {
     UnlinkedExecutable executable = serializeExecutableText('f(int g()) {}');
-    checkTypeRef(
-        executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
+    checkTypeRef(executable.parameters[0].type, 'dart:core', 'int');
   }
 
   test_executable_param_function_typed_return_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
     expect(executable.parameters[0].isFunctionTyped, isTrue);
     expect(executable.parameters[0].type, isNull);
   }
 
   test_executable_param_function_typed_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('f(void g()) {}');
     checkVoidTypeRef(executable.parameters[0].type);
   }
 
   test_executable_param_function_typed_withDefault() {
     UnlinkedExecutable executable = serializeExecutableText(r'''
 f([int p(int a2, String b2) = foo]) {}
 int foo(int a, String b) => 0;
 ''');
     UnlinkedParam param = executable.parameters[0];
     expect(param.kind, UnlinkedParamKind.positional);
     expect(param.initializer, isNotNull);
     expect(param.defaultValueCode, 'foo');
     assertUnlinkedConst(param.initializer.bodyExpr, operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+      (EntityRef r) => checkTypeRef(r, null, 'foo',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
   test_executable_param_isFinal() {
     String text = 'f(x, final y) {}';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.parameters, hasLength(2));
     expect(executable.parameters[0].name, 'x');
     expect(executable.parameters[0].isFinal, isFalse);
@@ skipping 128 matching lines @@
     UnlinkedExecutable executable = serializeExecutableText('f(x) {}');
     expect(executable.parameters[0].type, isNull);
   }
 
   test_executable_param_type_typedef() {
     UnlinkedExecutable executable = serializeExecutableText(r'''
 typedef MyFunction(int p);
 f(MyFunction myFunction) {}
 ''');
     expect(executable.parameters[0].isFunctionTyped, isFalse);
-    checkTypeRef(executable.parameters[0].type, null, null, 'MyFunction',
+    checkTypeRef(executable.parameters[0].type, null, 'MyFunction',
         expectedKind: ReferenceKind.typedef);
   }
 
   test_executable_return_type() {
     UnlinkedExecutable executable = serializeExecutableText('int f() => 1;');
-    checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
+    checkTypeRef(executable.returnType, 'dart:core', 'int');
   }
 
   test_executable_return_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.returnType, isNull);
   }
 
   test_executable_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('void f() {}');
     checkVoidTypeRef(executable.returnType);
@@ skipping 37 matching lines @@
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_executable_setter_type() {
     UnlinkedExecutable executable = serializeExecutableText(
         'void set f(int value) {}',
         executableName: 'f=');
     checkVoidTypeRef(executable.returnType);
     expect(executable.parameters, hasLength(1));
     expect(executable.parameters[0].name, 'value');
-    checkTypeRef(
-        executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
+    checkTypeRef(executable.parameters[0].type, 'dart:core', 'int');
   }
 
   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 =
@@ skipping 41 matching lines @@
 
   test_executable_type_param_in_return_type_method() {
     UnlinkedExecutable ex = serializeMethodText('T f<T>() => null;');
     checkParamTypeRef(ex.returnType, 1);
   }
 
   test_export_class() {
     addNamedSource('/a.dart', 'class C {}');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'C',
         ReferenceKind.classOrEnum);
   }
 
   test_export_class_alias() {
     addNamedSource(
         '/a.dart', 'class C extends _D with _E {} class _D {} class _E {}');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'C',
         ReferenceKind.classOrEnum);
   }
 
   test_export_configurations() {
     addNamedSource('/foo.dart', 'class A {}');
     addNamedSource('/foo_io.dart', 'class A {}');
     addNamedSource('/foo_html.dart', 'class A {}');
     String libraryText = r'''
 export 'foo.dart'
   if (dart.library.io) 'foo_io.dart'
@@ skipping 14 matching lines @@
       UnlinkedConfiguration configuration = exp.configurations[1];
       expect(configuration.name, 'dart.flavor');
       expect(configuration.value, 'html');
       expect(configuration.uri, 'foo_html.dart');
     }
   }
 
   test_export_dependency() {
     serializeLibraryText('export "dart:async";');
     expect(unlinkedUnits[0].exports, hasLength(1));
-    checkDependency(linked.exportDependencies[0], 'dart:async', 'dart:async');
+    checkDependency(linked.exportDependencies[0], 'dart:async');
   }
 
   test_export_enum() {
     addNamedSource('/a.dart', 'enum E { v }');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'E',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'E',
         ReferenceKind.classOrEnum);
   }
 
   test_export_from_part() {
     addNamedSource('/a.dart', 'library foo; part "b.dart";');
     addNamedSource('/b.dart', 'part of foo; f() {}');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'f',
         ReferenceKind.topLevelFunction,
         expectedTargetUnit: 1);
   }
 
   test_export_function() {
     addNamedSource('/a.dart', 'f() {}');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'f',
         ReferenceKind.topLevelFunction);
   }
 
   test_export_getter() {
     addNamedSource('/a.dart', 'get f => null');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'f',
         ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_export_hide() {
     addNamedSource('/a.dart', 'f() {} g() {}');
     serializeLibraryText('export "a.dart" hide g;');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'f',
         ReferenceKind.topLevelFunction);
   }
 
   test_export_hide_order() {
     serializeLibraryText('export "dart:async" hide Future, Stream;');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(
         unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
         isEmpty);
@@ skipping 10 matching lines @@
     }
     expect(linked.exportNames, isNotEmpty);
   }
 
   test_export_missing() {
     // Unresolved exports are included since this is necessary for proper
     // dependency tracking.
     allowMissingFiles = true;
     serializeLibraryText('export "foo.dart";', allowErrors: true);
     expect(unlinkedUnits[0].imports, hasLength(1));
-    checkDependency(
-        linked.exportDependencies[0], absUri('/foo.dart'), 'foo.dart');
+    checkDependency(linked.exportDependencies[0], absUri('/foo.dart'));
   }
 
   test_export_names_excludes_names_from_library() {
     addNamedSource('/a.dart', 'part of my.lib; int y; int _y;');
     serializeLibraryText('library my.lib; part "a.dart"; int x; int _x;');
     expect(linked.exportNames, isEmpty);
   }
 
   test_export_no_combinators() {
     serializeLibraryText('export "dart:async";');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators, isEmpty);
   }
 
   test_export_not_shadowed_by_prefix() {
     addNamedSource('/a.dart', 'f() {}');
     serializeLibraryText('export "a.dart"; import "dart:core" as f; f.int _x;');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'f',
         ReferenceKind.topLevelFunction);
   }
 
   test_export_offset() {
     String libraryText = '    export "dart:async";';
     serializeLibraryText(libraryText);
     expect(unlinkedUnits[0].exports[0].uriOffset,
         libraryText.indexOf('"dart:async"'));
     expect(unlinkedUnits[0].exports[0].uriEnd, libraryText.indexOf(';'));
     expect(unlinkedUnits[0].exports[0].offset, libraryText.indexOf('export'));
   }
 
   test_export_private() {
     // Private names should not be exported.
     addNamedSource('/a.dart', '_f() {}');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, isEmpty);
   }
 
   test_export_setter() {
     addNamedSource('/a.dart', 'void set f(value) {}');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f=',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'f=',
         ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_export_shadowed() {
     // f() is not shown in exportNames because it is already defined at top
     // level in the library.
     addNamedSource('/a.dart', 'f() {}');
     serializeLibraryText('export "a.dart"; f() {}');
     expect(linked.exportNames, isEmpty);
   }
 
   test_export_shadowed_variable() {
     // Neither `v` nor `v=` is shown in exportNames because both are defined at
     // top level in the library by the declaration `var v;`.
     addNamedSource('/a.dart', 'var v;');
     serializeLibraryText('export "a.dart"; var v;');
     expect(linked.exportNames, isEmpty);
   }
 
   test_export_shadowed_variable_const() {
     // `v=` is shown in exportNames because the top level declaration
     // `const v = 0;` only shadows `v`, not `v=`.
     addNamedSource('/a.dart', 'var v;');
     serializeLibraryText('export "a.dart"; const v = 0;');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'v=',
         ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_export_shadowed_variable_final() {
     // `v=` is shown in exportNames because the top level declaration
     // `final v = 0;` only shadows `v`, not `v=`.
     addNamedSource('/a.dart', 'var v;');
     serializeLibraryText('export "a.dart"; final v = 0;');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'v=',
         ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_export_show() {
     addNamedSource('/a.dart', 'f() {} g() {}');
     serializeLibraryText('export "a.dart" show f;');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'f',
         ReferenceKind.topLevelFunction);
   }
 
   test_export_show_order() {
     String libraryText = 'export "dart:async" show Future, Stream;';
     serializeLibraryText(libraryText);
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(
         unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
         hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides,
         isEmpty);
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[0],
         'Future');
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[1],
         'Stream');
     if (includeInformative) {
       expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].offset,
           libraryText.indexOf('show'));
       expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].end,
           libraryText.indexOf(';'));
     }
   }
 
   test_export_typedef() {
     addNamedSource('/a.dart', 'typedef F();');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(1));
-    checkExportName(linked.exportNames[0], absUri('/a.dart'), 'a.dart', 'F',
-        ReferenceKind.typedef);
+    checkExportName(
+        linked.exportNames[0], absUri('/a.dart'), 'F', ReferenceKind.typedef);
   }
 
   test_export_uri() {
     addNamedSource('/a.dart', 'library my.lib;');
     String uriString = '"a.dart"';
     String libraryText = 'export $uriString;';
     serializeLibraryText(libraryText);
     var unlinkedExports = unlinkedUnits[0].publicNamespace.exports;
     expect(unlinkedExports, hasLength(1));
     expect(unlinkedExports[0].uri, 'a.dart');
@@ skipping 19 matching lines @@
     expect(unlinkedExports[0].configurations, isEmpty);
   }
 
   test_export_variable() {
     addNamedSource('/a.dart', 'var v;');
     serializeLibraryText('export "a.dart";');
     expect(linked.exportNames, hasLength(2));
     LinkedExportName getter =
         linked.exportNames.firstWhere((e) => e.name == 'v');
     expect(getter, isNotNull);
-    checkExportName(getter, absUri('/a.dart'), 'a.dart', 'v',
-        ReferenceKind.topLevelPropertyAccessor);
+    checkExportName(
+        getter, absUri('/a.dart'), 'v', ReferenceKind.topLevelPropertyAccessor);
     LinkedExportName setter =
         linked.exportNames.firstWhere((e) => e.name == 'v=');
     expect(setter, isNotNull);
-    checkExportName(setter, absUri('/a.dart'), 'a.dart', 'v=',
+    checkExportName(setter, absUri('/a.dart'), 'v=',
         ReferenceKind.topLevelPropertyAccessor);
   }
 
   test_expr_assignOperator_assign() {
     _assertAssignmentOperator(
         '(a = 1 + 2) + 3', UnlinkedExprAssignOperator.assign);
   }
 
   test_expr_assignOperator_bitAnd() {
     _assertAssignmentOperator(
@@ skipping 82 matching lines @@
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           5,
           1
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+          (EntityRef r) => checkTypeRef(r, null, 'f',
                   expectedKind: ReferenceKind.unresolved,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
                     new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
                     new _PrefixExpectation(
                         ReferenceKind.topLevelPropertyAccessor, 'a')
                   ])
         ]);
   }
 
@@ skipping 39 matching lines @@
           5,
           1,
           2,
           3,
         ],
         strings: [
           'c',
           'f'
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'b',
+          (EntityRef r) => checkTypeRef(r, null, 'b',
                   expectedKind: ReferenceKind.unresolved,
                   prefixExpectations: [
                     new _PrefixExpectation(
                         ReferenceKind.topLevelPropertyAccessor, 'a')
                   ])
         ]);
   }
 
   test_expr_assignToIndex_ofTopLevelVariable() {
     if (skipNonConstInitializers) {
@@ skipping 13 matching lines @@
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           5,
           1,
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'a',
+          (EntityRef r) => checkTypeRef(r, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   test_expr_assignToProperty_ofInstanceCreation() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
@@ skipping 13 matching lines @@
         ],
         ints: [
           5,
           0,
           0,
         ],
         strings: [
           'f'
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'C',
+          (EntityRef r) => checkTypeRef(r, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_assignToRef_classStaticField() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   static int f;
 }
 final v = (C.f = 1);
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.pushInt,
           UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+          (EntityRef r) => checkTypeRef(r, null, 'f',
                   expectedKind: ReferenceKind.unresolved,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
                   ])
         ]);
   }
 
   test_expr_assignToRef_fieldSequence() {
     if (skipNonConstInitializers) {
       return;
@@ skipping 18 matching lines @@
           UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+          (EntityRef r) => checkTypeRef(r, null, 'f',
                   expectedKind: ReferenceKind.unresolved,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
                     new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
                     new _PrefixExpectation(
                         ReferenceKind.topLevelPropertyAccessor, 'a')
                   ])
         ]);
   }
 
@@ skipping 32 matching lines @@
           UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'a',
+          (EntityRef r) => checkTypeRef(r, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   test_expr_assignToRef_topLevelVariable_imported() {
     if (skipNonConstInitializers) {
       return;
     }
     addNamedSource(
         '/a.dart',
@@ skipping 11 matching lines @@
           UnlinkedExprOperation.assignToRef,
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
+          (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   test_expr_assignToRef_topLevelVariable_imported_withPrefix() {
     if (skipNonConstInitializers) {
       return;
     }
     addNamedSource(
         '/a.dart',
@@ skipping 12 matching lines @@
         ],
         assignmentOperators: [
           (UnlinkedExprAssignOperator.assign)
         ],
         ints: [
           1,
         ],
         strings: [],
         referenceValidators: [
           (EntityRef r) {
-            return checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'a',
+            return checkTypeRef(r, absUri('/a.dart'), 'a',
                 expectedKind: ReferenceKind.topLevelPropertyAccessor,
                 expectedPrefix: 'p');
           }
         ]);
   }
 
   test_expr_cascadeSection_assignToIndex() {
     if (skipNonConstInitializers) {
       return;
     }
@@ skipping 18 matching lines @@
         ],
         assignmentOperators: [
           UnlinkedExprAssignOperator.assign,
         ],
         ints: [
           2,
           1
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'items',
+          (EntityRef r) => checkTypeRef(r, null, 'items',
                   expectedKind: ReferenceKind.unresolved,
                   prefixExpectations: [
                     new _PrefixExpectation(
                         ReferenceKind.topLevelPropertyAccessor, 'c'),
                   ])
         ]);
   }
 
   test_expr_cascadeSection_assignToProperty() {
     if (skipNonConstInitializers) {
@@ skipping 31 matching lines @@
         ints: [
           0, 0, // new C()
           1, // f1 = 1
           2, // f2 += 2
         ],
         strings: [
           'f1',
           'f2',
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'C',
+          (EntityRef r) => checkTypeRef(r, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_cascadeSection_embedded() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
@@ skipping 52 matching lines @@
           2,
           3,
         ],
         strings: [
           'fa1',
           'fb',
           'b',
           'fa2',
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'A',
+          (EntityRef r) => checkTypeRef(r, null, 'A',
               expectedKind: ReferenceKind.classOrEnum),
-          (EntityRef r) => checkTypeRef(r, null, null, 'B',
+          (EntityRef r) => checkTypeRef(r, null, 'B',
               expectedKind: ReferenceKind.classOrEnum),
         ]);
   }
 
   test_expr_cascadeSection_invokeMethod() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
@@ skipping 26 matching lines @@
           5, 0, 1, 0, // m(5)
           0, 0, 0, // abs()
           6, 0, 1, 0, // m(5)
         ],
         strings: [
           'm',
           'abs',
           'm',
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'a',
+          (EntityRef r) => checkTypeRef(r, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor),
         ]);
   }
 
   test_expr_extractIndex_ofClassField() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
@@ skipping 11 matching lines @@
         ],
         ints: [
           0,
           0,
           5
         ],
         strings: [
           'items'
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'C',
+          (EntityRef r) => checkTypeRef(r, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_extractProperty_ofInvokeConstructor() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
   int f = 0;
 }
 final v = new C().f;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.invokeConstructor,
           UnlinkedExprOperation.extractProperty,
         ],
         ints: [
           0,
           0
         ],
         strings: [
           'f'
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'C',
+          (EntityRef r) => checkTypeRef(r, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_functionExpression_asArgument() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = foo(5, () => 42);
 foo(a, b) {}
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.pushInt,
           UnlinkedExprOperation.pushLocalFunctionReference,
           UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           5,
           0,
           0,
           0,
           2,
           0
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+          (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_functionExpression_asArgument_multiple() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = foo(5, () => 42, () => 43);
@@ skipping 11 matching lines @@
           5,
           0,
           0,
           0,
           1,
           0,
           3,
           0
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'foo',
+          (EntityRef r) => checkTypeRef(r, null, 'foo',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_functionExpression_withBlockBody() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = () { return 42; };
@@ skipping 138 matching lines @@
           UnlinkedExprOperation.conditional,
         ],
         strings: [
           'b'
         ],
         ints: [
           0,
           0
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'x',
+          (EntityRef r) => checkTypeRef(r, null, 'x',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   test_expr_inClosure_refersToParam_prefixedIdentifier() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('var v = (x) => x.y;');
     assertUnlinkedConst(variable.initializer.localFunctions[0].bodyExpr,
@@ skipping 112 matching lines @@
           2,
           1,
           0
         ],
         strings: [
           'b',
           'c',
           'm'
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'C',
+          (EntityRef r) => checkTypeRef(r, null, 'C',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_invokeMethod_withTypeParameters() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class C {
@@ skipping 11 matching lines @@
           0,
           0,
           0,
           0,
           2
         ],
         strings: [
           'f'
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'C'),
-          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int'),
-          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String')
+          (EntityRef r) => checkTypeRef(r, null, 'C'),
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'int'),
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'String')
         ]);
   }
 
   test_expr_invokeMethodRef_instance() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 class A {
   B b;
@@ skipping 16 matching lines @@
         ],
         ints: [
           10,
           20,
           0,
           2,
           0
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'm',
+          (EntityRef r) => checkTypeRef(r, null, 'm',
                   expectedKind: ReferenceKind.unresolved,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.unresolved, 'c'),
                     new _PrefixExpectation(ReferenceKind.unresolved, 'b'),
                     new _PrefixExpectation(
                         ReferenceKind.topLevelPropertyAccessor, 'a')
                   ])
         ]);
   }
 
@@ skipping 17 matching lines @@
         operators: [
           UnlinkedExprOperation.invokeMethodRef,
         ],
         ints: [
           0,
           0,
           0
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'm',
+          (EntityRef r) => checkTypeRef(r, null, 'm',
                   expectedKind: ReferenceKind.method,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C',
-                        absoluteUri: absUri('/a.dart'), relativeUri: 'a.dart'),
+                        absoluteUri: absUri('/a.dart')),
                     new _PrefixExpectation(ReferenceKind.prefix, 'p')
                   ])
         ]);
   }
 
   test_expr_invokeMethodRef_with_reference_arg() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 f(x) => null;
 final u = null;
 final v = f(u);
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.pushReference,
           UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           0,
           1,
           0
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'u',
+          (EntityRef r) => checkTypeRef(r, null, 'u',
               expectedKind: ReferenceKind.topLevelPropertyAccessor),
-          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+          (EntityRef r) => checkTypeRef(r, null, 'f',
               expectedKind: ReferenceKind.topLevelFunction)
         ]);
   }
 
   test_expr_invokeMethodRef_withTypeParameters() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 f<T, U>() => null;
 final v = f<int, String>();
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.invokeMethodRef
         ],
         ints: [
           0,
           0,
           2
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'f',
+          (EntityRef r) => checkTypeRef(r, null, 'f',
               expectedKind: ReferenceKind.topLevelFunction,
               numTypeParameters: 2),
-          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'int'),
-          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'String')
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'int'),
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'String')
         ]);
   }
 
   test_expr_super() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = super;
 ''');
@@ skipping 45 matching lines @@
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.pushInt,
           UnlinkedExprOperation.typeCast,
         ],
         ints: [
           42
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'num',
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'num',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_expr_typeCheck() {
     if (skipNonConstInitializers) {
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = 42 is num;
 ''');
     assertUnlinkedConst(variable.initializer.bodyExpr,
         isValidConst: false,
         operators: [
           UnlinkedExprOperation.pushInt,
           UnlinkedExprOperation.typeCheck,
         ],
         ints: [
           42
         ],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, 'dart:core', 'dart:core', 'num',
+          (EntityRef r) => checkTypeRef(r, 'dart:core', 'num',
               expectedKind: ReferenceKind.classOrEnum)
         ]);
   }
 
   test_field() {
     UnlinkedClass cls = serializeClassText('class C { int i; }');
     UnlinkedVariable variable = findVariable('i', variables: cls.fields);
     expect(variable, isNotNull);
     expect(variable.isConst, isFalse);
     expect(variable.isStatic, isFalse);
@@ skipping 51 matching lines @@
           UnlinkedExprOperation.add,
         ],
         ints: [
           1,
           0,
           0,
           0
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'm',
+          (EntityRef r) => checkTypeRef(r, null, 'm',
                   expectedKind: ReferenceKind.method,
                   prefixExpectations: [
                     new _PrefixExpectation(ReferenceKind.classOrEnum, 'C')
                   ])
         ]);
   }
 
   test_field_final_typeParameter() {
     UnlinkedVariable variable = serializeClassText(r'''
 class C<T> {
   final f = <T>[];
 }''').fields[0];
     expect(variable.isFinal, isTrue);
     assertUnlinkedConst(variable.initializer.bodyExpr,
         operators: [UnlinkedExprOperation.makeTypedList],
         ints: [0],
         referenceValidators: [(EntityRef r) => checkParamTypeRef(r, 1)]);
   }
 
   test_field_formal_param_inferred_type_explicit() {
     UnlinkedClass cls = serializeClassText(
         'class C extends D { var v; C(int this.v); }'
         ' abstract class D { num get v; }',
         className: 'C');
-    checkInferredTypeSlot(
-        cls.fields[0].inferredTypeSlot, 'dart:core', 'dart:core', 'num');
+    checkInferredTypeSlot(cls.fields[0].inferredTypeSlot, 'dart:core', 'num');
     expect(cls.executables[0].kind, UnlinkedExecutableKind.constructor);
     expect(cls.executables[0].parameters[0].inferredTypeSlot, 0);
   }
 
   test_field_formal_param_inferred_type_implicit() {
     // Both the field `v` and the constructor argument `this.v` will have their
     // type inferred by strong mode.  But only the field should have its
     // inferred type stored in the summary, since the standard rules for field
     // formal parameters will take care of the rest (they implicitly inherit
     // the type of the associated field).
     UnlinkedClass cls = serializeClassText(
         'class C extends D { var v; C(this.v); }'
         ' abstract class D { int get v; }',
         className: 'C');
-    checkInferredTypeSlot(
-        cls.fields[0].inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(cls.fields[0].inferredTypeSlot, 'dart:core', 'int');
     expect(cls.executables[0].kind, UnlinkedExecutableKind.constructor);
     expect(cls.executables[0].parameters[0].inferredTypeSlot, 0);
   }
 
   test_field_inferred_type_nonstatic_explicit_initialized() {
     UnlinkedVariable v = serializeClassText('class C { num v = 0; }').fields[0];
     expect(v.inferredTypeSlot, 0);
   }
 
   test_field_inferred_type_nonstatic_explicit_uninitialized() {
     UnlinkedVariable v = serializeClassText(
             'class C extends D { num v; } abstract class D { int get v; }',
             className: 'C',
             allowErrors: true)
         .fields[0];
     expect(v.inferredTypeSlot, 0);
   }
 
   test_field_inferred_type_nonstatic_implicit_initialized() {
     UnlinkedVariable v = serializeClassText('class C { var v = 0; }').fields[0];
-    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'int');
   }
 
   test_field_inferred_type_nonstatic_implicit_uninitialized() {
     UnlinkedVariable v = serializeClassText(
             'class C extends D { var v; } abstract class D { int get v; }',
             className: 'C')
         .fields[0];
-    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'int');
   }
 
   test_field_inferred_type_static_explicit_initialized() {
     UnlinkedVariable v =
         serializeClassText('class C { static int v = 0; }').fields[0];
     expect(v.inferredTypeSlot, 0);
   }
 
   test_field_inferred_type_static_implicit_initialized() {
     UnlinkedVariable v =
         serializeClassText('class C { static var v = 0; }').fields[0];
-    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'int');
   }
 
   test_field_inferred_type_static_implicit_uninitialized() {
     UnlinkedVariable v =
         serializeClassText('class C { static var v; }').fields[0];
     expect(v.inferredTypeSlot, 0);
   }
 
   test_field_static() {
     UnlinkedVariable variable =
@@ skipping 31 matching lines @@
     UnlinkedVariable variable =
         serializeClassText('class C { var x = 0; }').fields[0];
     expect(variable.initializer.bodyExpr, isNotNull);
   }
 
   test_fully_linked_references_follow_other_references() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     serializeLibraryText('final x = 0; String y;');
-    checkLinkedTypeSlot(unlinkedUnits[0].variables[0].inferredTypeSlot,
-        'dart:core', 'dart:core', 'int');
-    checkTypeRef(
-        unlinkedUnits[0].variables[1].type, 'dart:core', 'dart:core', 'String');
+    checkLinkedTypeSlot(
+        unlinkedUnits[0].variables[0].inferredTypeSlot, 'dart:core', 'int');
+    checkTypeRef(unlinkedUnits[0].variables[1].type, 'dart:core', 'String');
     // Even though the definition of y follows the definition of x, the linked
     // type reference for x should use a higher numbered reference than the
     // unlinked type reference for y.
     EntityRef propagatedType =
         getTypeRefForSlot(unlinkedUnits[0].variables[0].inferredTypeSlot);
     expect(unlinkedUnits[0].variables[1].type.reference,
         lessThan(propagatedType.reference));
   }
 
   test_function_documented() {
@@ skipping 50 matching lines @@
             allowErrors: true)
         .executables[0];
     expect(f.inferredReturnTypeSlot, 0);
   }
 
   test_getter_inferred_type_nonstatic_implicit_return() {
     UnlinkedExecutable f = serializeClassText(
             'class C extends D { get f => null; } abstract class D { int get f; }',
             className: 'C')
         .executables[0];
-    checkInferredTypeSlot(
-        f.inferredReturnTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(f.inferredReturnTypeSlot, 'dart:core', 'int');
   }
 
   test_getter_inferred_type_static_implicit_return() {
     UnlinkedExecutable f = serializeClassText(
             'class C extends D { static get f => null; }'
             ' class D { static int get f => null; }',
             className: 'C')
         .executables[0];
     expect(f.inferredReturnTypeSlot, 0);
   }
@@ skipping 42 matching lines @@
   test_import_deferred() {
     serializeLibraryText(
         'import "dart:async" deferred as a; main() { print(a.Future); }');
     expect(unlinkedUnits[0].imports[0].isDeferred, isTrue);
   }
 
   test_import_dependency() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
-    checkDependency(linked.importDependencies[0], 'dart:async', 'dart:async');
+    checkDependency(linked.importDependencies[0], 'dart:async');
   }
 
   test_import_explicit() {
     serializeLibraryText('import "dart:core"; int i;');
     expect(unlinkedUnits[0].imports, hasLength(1));
     expect(unlinkedUnits[0].imports[0].isImplicit, isFalse);
   }
 
   test_import_hide_order() {
     serializeLibraryText(
         'import "dart:async" hide Future, Stream; Completer c;');
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].imports[0].combinators[0].shows, isEmpty);
     expect(unlinkedUnits[0].imports[0].combinators[0].hides, hasLength(2));
     expect(unlinkedUnits[0].imports[0].combinators[0].hides[0], 'Future');
     expect(unlinkedUnits[0].imports[0].combinators[0].hides[1], 'Stream');
     if (includeInformative) {
       expect(unlinkedUnits[0].imports[0].combinators[0].offset, 0);
       expect(unlinkedUnits[0].imports[0].combinators[0].end, 0);
     }
   }
 
   test_import_implicit() {
     // The implicit import of dart:core is represented in the model.
     serializeLibraryText('');
     expect(unlinkedUnits[0].imports, hasLength(1));
-    checkDependency(linked.importDependencies[0], 'dart:core', 'dart:core');
+    checkDependency(linked.importDependencies[0], 'dart:core');
     expect(unlinkedUnits[0].imports[0].uri, isEmpty);
     if (includeInformative) {
       expect(unlinkedUnits[0].imports[0].uriOffset, 0);
       expect(unlinkedUnits[0].imports[0].uriEnd, 0);
     }
     expect(unlinkedUnits[0].imports[0].prefixReference, 0);
     expect(unlinkedUnits[0].imports[0].combinators, isEmpty);
     expect(unlinkedUnits[0].imports[0].isImplicit, isTrue);
   }
 
   test_import_missing() {
     // Unresolved imports are included since this is necessary for proper
     // dependency tracking.
     allowMissingFiles = true;
     serializeLibraryText('import "foo.dart";', allowErrors: true);
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
-    checkDependency(
-        linked.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
+    checkDependency(linked.importDependencies[0], absUri('/foo.dart'));
   }
 
   test_import_no_combinators() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].combinators, isEmpty);
   }
 
   test_import_no_flags() {
     serializeLibraryText('import "dart:async"; Future x;');
     expect(unlinkedUnits[0].imports[0].isImplicit, isFalse);
     expect(unlinkedUnits[0].imports[0].isDeferred, isFalse);
   }
 
   test_import_non_deferred() {
     serializeLibraryText(
         'import "dart:async" as a; main() { print(a.Future); }');
     expect(unlinkedUnits[0].imports[0].isDeferred, isFalse);
   }
 
   test_import_of_file_with_missing_part() {
     // Other references in foo.dart should be resolved even though foo.dart's
     // part declaration for bar.dart refers to a non-existent file.
     allowMissingFiles = true;
     addNamedSource('/foo.dart', 'part "bar.dart"; class C {}');
     serializeLibraryText('import "foo.dart"; C x;');
-    checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'foo.dart', 'C');
+    checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'C');
   }
 
   test_import_of_missing_export() {
     // Other references in foo.dart should be resolved even though foo.dart's
     // re-export of bar.dart refers to a non-existent file.
     allowMissingFiles = true;
     addNamedSource('/foo.dart', 'export "bar.dart"; class C {}');
     serializeLibraryText('import "foo.dart"; C x;');
-    checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'foo.dart', 'C');
+    checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'C');
   }
 
   test_import_offset() {
     String libraryText = '    import "dart:async"; Future x;';
     serializeLibraryText(libraryText);
     expect(unlinkedUnits[0].imports[0].offset, libraryText.indexOf('import'));
     expect(unlinkedUnits[0].imports[0].uriOffset,
         libraryText.indexOf('"dart:async"'));
     expect(unlinkedUnits[0].imports[0].uriEnd, libraryText.indexOf('; Future'));
   }
@@ skipping 17 matching lines @@
   test_import_prefix_not_in_public_namespace() {
     serializeLibraryText('import "dart:async" as a; a.Future v;');
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'v');
     expect(unlinkedUnits[0].publicNamespace.names[1].name, 'v=');
   }
 
   test_import_prefix_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async" as a; a.Future v;');
-    checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
+    checkTypeRef(variable.type, 'dart:async', 'Future',
         expectedPrefix: 'a', numTypeParameters: 1);
   }
 
   test_import_prefixes_take_precedence_over_imported_names() {
     addNamedSource('/a.dart', 'class b {} class A');
     addNamedSource('/b.dart', 'class Cls {}');
     addNamedSource('/c.dart', 'class Cls {}');
     addNamedSource('/d.dart', 'class c {} class D');
     serializeLibraryText('''
 import 'a.dart';
 import 'b.dart' as b;
 import 'c.dart' as c;
 import 'd.dart';
 A aCls;
 b.Cls bCls;
 c.Cls cCls;
 D dCls;
 ''');
-    checkTypeRef(findVariable('aCls').type, absUri('/a.dart'), 'a.dart', 'A');
-    checkTypeRef(findVariable('bCls').type, absUri('/b.dart'), 'b.dart', 'Cls',
+    checkTypeRef(findVariable('aCls').type, absUri('/a.dart'), 'A');
+    checkTypeRef(findVariable('bCls').type, absUri('/b.dart'), 'Cls',
         expectedPrefix: 'b');
-    checkTypeRef(findVariable('cCls').type, absUri('/c.dart'), 'c.dart', 'Cls',
+    checkTypeRef(findVariable('cCls').type, absUri('/c.dart'), 'Cls',
         expectedPrefix: 'c');
-    checkTypeRef(findVariable('dCls').type, absUri('/d.dart'), 'd.dart', 'D');
+    checkTypeRef(findVariable('dCls').type, absUri('/d.dart'), 'D');
   }
 
   test_import_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async"; Future v;');
-    checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
-        numTypeParameters: 1);
+    checkTypeRef(variable.type, 'dart:async', 'Future', numTypeParameters: 1);
   }
 
   test_import_reference_merged_no_prefix() {
     serializeLibraryText('''
 import "dart:async" show Future;
 import "dart:async" show Stream;
 
 Future f;
 Stream s;
 ''');
     {
       EntityRef typeRef = findVariable('f').type;
-      checkTypeRef(typeRef, 'dart:async', 'dart:async', 'Future',
-          numTypeParameters: 1);
+      checkTypeRef(typeRef, 'dart:async', 'Future', numTypeParameters: 1);
     }
     {
       EntityRef typeRef = findVariable('s').type;
-      checkTypeRef(typeRef, 'dart:async', 'dart:async', 'Stream',
+      checkTypeRef(typeRef, 'dart:async', 'Stream',
           expectedTargetUnit: 1, numTypeParameters: 1);
     }
   }
 
   test_import_reference_merged_prefixed() {
     serializeLibraryText('''
 import "dart:async" as a show Future;
 import "dart:async" as a show Stream;
 
 a.Future f;
 a.Stream s;
 ''');
     {
       EntityRef typeRef = findVariable('f').type;
-      checkTypeRef(typeRef, 'dart:async', 'dart:async', 'Future',
+      checkTypeRef(typeRef, 'dart:async', 'Future',
           expectedPrefix: 'a', numTypeParameters: 1);
     }
     {
       EntityRef typeRef = findVariable('s').type;
-      checkTypeRef(typeRef, 'dart:async', 'dart:async', 'Stream',
+      checkTypeRef(typeRef, 'dart:async', 'Stream',
           expectedTargetUnit: 1, expectedPrefix: 'a', numTypeParameters: 1);
     }
   }
 
   test_import_reference_merged_prefixed_separate_libraries() {
     addNamedSource('/a.dart', 'class A {}');
     addNamedSource('/b.dart', 'class B {}');
     serializeLibraryText('''
 import 'a.dart' as p;
 import 'b.dart' as p;
 
 p.A a;
 p.B b;
 ''');
-    checkTypeRef(findVariable('a').type, absUri('/a.dart'), 'a.dart', 'A',
+    checkTypeRef(findVariable('a').type, absUri('/a.dart'), 'A',
         expectedPrefix: 'p');
-    checkTypeRef(findVariable('b').type, absUri('/b.dart'), 'b.dart', 'B',
+    checkTypeRef(findVariable('b').type, absUri('/b.dart'), 'B',
         expectedPrefix: 'p');
   }
 
   test_import_self() {
     serializeLibraryText('''
 import 'test.dart' as p;
 class C {}
 class D extends p.C {} // Prevent "unused import" warning
 ''');
     expect(unlinkedUnits[0].imports[0].uri, 'test.dart');
-    checkDependency(
-        linked.importDependencies[0], absUri('/test.dart'), 'test.dart');
-    checkTypeRef(unlinkedUnits[0].classes[1].supertype, absUri('/test.dart'),
-        'test.dart', 'C',
+    checkDependency(linked.importDependencies[0], absUri('/test.dart'));
+    checkTypeRef(
+        unlinkedUnits[0].classes[1].supertype, absUri('/test.dart'), 'C',
         expectedPrefix: 'p');
   }
 
   test_import_show_order() {
     String libraryText =
         'import "dart:async" show Future, Stream; Future x; Stream y;';
     serializeLibraryText(libraryText);
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].combinators, hasLength(1));
@@ skipping 50 matching lines @@
 class C<T> extends B<T> {
   void f(g) {}
 }
 ''');
     expect(c.executables, hasLength(1));
     UnlinkedExecutable f = c.executables[0];
     expect(f.parameters, hasLength(1));
     UnlinkedParam g = f.parameters[0];
     expect(g.name, 'g');
     EntityRef typeRef = getTypeRefForSlot(g.inferredTypeSlot);
-    checkLinkedTypeRef(typeRef, null, null, 'f',
+    checkLinkedTypeRef(typeRef, null, 'f',
         expectedKind: ReferenceKind.method, numTypeArguments: 1);
     checkParamTypeRef(typeRef.typeArguments[0], 1);
   }
 
   test_inferred_type_keeps_leading_dynamic() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls =
         serializeClassText('class C { final x = <dynamic, int>{}; }');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
     // Check that x has inferred type `Map<dynamic, int>`.
-    checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
+    checkLinkedTypeRef(type, 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
-    checkLinkedTypeRef(type.typeArguments[0], null, null, 'dynamic');
-    checkLinkedTypeRef(type.typeArguments[1], 'dart:core', 'dart:core', 'int');
+    checkLinkedTypeRef(type.typeArguments[0], null, 'dynamic');
+    checkLinkedTypeRef(type.typeArguments[1], 'dart:core', 'int');
   }
 
   test_inferred_type_reference_shared_prefixed() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     // Variable `y` has an inferred type of `p.C`.  Verify that the reference
     // used by the explicit type of `x` is re-used for the inferred type.
     addNamedSource('/a.dart', 'class C {}');
     serializeLibraryText('import "a.dart" as p; p.C x; var y = new p.C();');
     EntityRef xType = findVariable('x').type;
     EntityRef yType = getTypeRefForSlot(findVariable('y').inferredTypeSlot);
     expect(yType.reference, xType.reference);
   }
 
   test_inferred_type_refers_to_bound_type_param() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText(
         'class C<T> extends D<int, T> { var v; }'
         ' abstract class D<U, V> { Map<V, U> get v; }',
         className: 'C');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
     // Check that v has inferred type Map<T, int>.
-    checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
+    checkLinkedTypeRef(type, 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
     checkParamTypeRef(type.typeArguments[0], 1);
-    checkLinkedTypeRef(type.typeArguments[1], 'dart:core', 'dart:core', 'int');
+    checkLinkedTypeRef(type.typeArguments[1], 'dart:core', 'int');
   }
 
   test_inferred_type_refers_to_function_typed_param_of_typedef() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable v = serializeVariableText('''
 typedef void F(int g(String s));
 h(F f) => null;
 var v = h((y) {});
 ''');
     expect(v.initializer.localFunctions, hasLength(1));
     UnlinkedExecutable closure = v.initializer.localFunctions[0];
     expect(closure.parameters, hasLength(1));
     UnlinkedParam y = closure.parameters[0];
     expect(y.name, 'y');
     EntityRef typeRef = getTypeRefForSlot(y.inferredTypeSlot);
-    checkLinkedTypeRef(typeRef, null, null, 'F',
-        expectedKind: ReferenceKind.typedef);
+    checkLinkedTypeRef(typeRef, null, 'F', expectedKind: ReferenceKind.typedef);
     expect(typeRef.implicitFunctionTypeIndices, [0]);
   }
 
   test_inferred_type_refers_to_function_typed_parameter_type_generic_class() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText(
         'class C<T, U> extends D<U, int> { void f(int x, g) {} }'
         ' abstract class D<V, W> { void f(int x, W g(V s)); }',
         className: 'C');
     EntityRef type =
         getTypeRefForSlot(cls.executables[0].parameters[1].inferredTypeSlot);
     // Check that parameter g's inferred type is the type implied by D.f's 1st
     // (zero-based) parameter.
     expect(type.implicitFunctionTypeIndices, [1]);
     expect(type.paramReference, 0);
     expect(type.typeArguments, hasLength(2));
     checkParamTypeRef(type.typeArguments[0], 1);
-    checkTypeRef(type.typeArguments[1], 'dart:core', 'dart:core', 'int');
+    checkTypeRef(type.typeArguments[1], 'dart:core', 'int');
     expect(type.reference,
         greaterThanOrEqualTo(unlinkedUnits[0].references.length));
     LinkedReference linkedReference =
         linked.units[0].references[type.reference];
     expect(linkedReference.dependency, 0);
     expect(linkedReference.kind, ReferenceKind.method);
     expect(linkedReference.name, 'f');
     expect(linkedReference.numTypeParameters, 0);
     expect(linkedReference.unit, 0);
     expect(linkedReference.containingReference, isNot(0));
     expect(linkedReference.containingReference, lessThan(type.reference));
-    checkReferenceIndex(linkedReference.containingReference, null, null, 'D',
+    checkReferenceIndex(linkedReference.containingReference, null, 'D',
         numTypeParameters: 2);
   }
 
   test_inferred_type_refers_to_function_typed_parameter_type_other_lib() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     addNamedSource('/a.dart', 'import "b.dart"; abstract class D extends E {}');
     addNamedSource(
         '/b.dart', 'abstract class E { void f(int x, int g(String s)); }');
@@ skipping 11 matching lines @@
     LinkedReference linkedReference =
         linked.units[0].references[type.reference];
     expect(linkedReference.dependency, 0);
     expect(linkedReference.kind, ReferenceKind.method);
     expect(linkedReference.name, 'f');
     expect(linkedReference.numTypeParameters, 0);
     expect(linkedReference.unit, 0);
     expect(linkedReference.containingReference, isNot(0));
     expect(linkedReference.containingReference, lessThan(type.reference));
     checkReferenceIndex(
-        linkedReference.containingReference, absUri('/b.dart'), 'b.dart', 'E');
+        linkedReference.containingReference, absUri('/b.dart'), 'E');
   }
 
   test_inferred_type_refers_to_method_function_typed_parameter_type() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText(
         'class C extends D { void f(int x, g) {} }'
         ' abstract class D { void f(int x, int g(String s)); }',
         className: 'C');
     EntityRef type =
         getTypeRefForSlot(cls.executables[0].parameters[1].inferredTypeSlot);
     // Check that parameter g's inferred type is the type implied by D.f's 1st
     // (zero-based) parameter.
     expect(type.implicitFunctionTypeIndices, [1]);
     expect(type.paramReference, 0);
     expect(type.typeArguments, isEmpty);
     expect(type.reference,
         greaterThanOrEqualTo(unlinkedUnits[0].references.length));
     LinkedReference linkedReference =
         linked.units[0].references[type.reference];
     expect(linkedReference.dependency, 0);
     expect(linkedReference.kind, ReferenceKind.method);
     expect(linkedReference.name, 'f');
     expect(linkedReference.numTypeParameters, 0);
     expect(linkedReference.unit, 0);
     expect(linkedReference.containingReference, isNot(0));
     expect(linkedReference.containingReference, lessThan(type.reference));
-    checkReferenceIndex(linkedReference.containingReference, null, null, 'D');
+    checkReferenceIndex(linkedReference.containingReference, null, 'D');
   }
 
   test_inferred_type_refers_to_nested_function_typed_param() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable v = serializeVariableText('''
 f(void g(int x, void h())) => null;
 var v = f((x, y) {});
 ''');
     expect(v.initializer.localFunctions, hasLength(1));
     UnlinkedExecutable closure = v.initializer.localFunctions[0];
     expect(closure.parameters, hasLength(2));
     UnlinkedParam y = closure.parameters[1];
     expect(y.name, 'y');
     EntityRef typeRef = getTypeRefForSlot(y.inferredTypeSlot);
-    checkLinkedTypeRef(typeRef, null, null, 'f',
+    checkLinkedTypeRef(typeRef, null, 'f',
         expectedKind: ReferenceKind.topLevelFunction);
     expect(typeRef.implicitFunctionTypeIndices, [0, 1]);
   }
 
   test_inferred_type_refers_to_nested_function_typed_param_named() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable v = serializeVariableText('''
 f({void g(int x, void h())}) => null;
 var v = f(g: (x, y) {});
 ''');
     expect(v.initializer.localFunctions, hasLength(1));
     UnlinkedExecutable closure = v.initializer.localFunctions[0];
     expect(closure.parameters, hasLength(2));
     UnlinkedParam y = closure.parameters[1];
     expect(y.name, 'y');
     EntityRef typeRef = getTypeRefForSlot(y.inferredTypeSlot);
-    checkLinkedTypeRef(typeRef, null, null, 'f',
+    checkLinkedTypeRef(typeRef, null, 'f',
         expectedKind: ReferenceKind.topLevelFunction);
     expect(typeRef.implicitFunctionTypeIndices, [0, 1]);
   }
 
   test_inferred_type_refers_to_setter_function_typed_parameter_type() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText(
         'class C extends D { void set f(g) {} }'
@@ skipping 10 matching lines @@
         greaterThanOrEqualTo(unlinkedUnits[0].references.length));
     LinkedReference linkedReference =
         linked.units[0].references[type.reference];
     expect(linkedReference.dependency, 0);
     expect(linkedReference.kind, ReferenceKind.propertyAccessor);
     expect(linkedReference.name, 'f=');
     expect(linkedReference.numTypeParameters, 0);
     expect(linkedReference.unit, 0);
     expect(linkedReference.containingReference, isNot(0));
     expect(linkedReference.containingReference, lessThan(type.reference));
-    checkReferenceIndex(linkedReference.containingReference, null, null, 'D');
+    checkReferenceIndex(linkedReference.containingReference, null, 'D');
   }
 
   test_inferred_type_skips_trailing_dynamic() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls =
         serializeClassText('class C { final x = <int, dynamic>{}; }');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
     // Check that x has inferred type `Map<int, dynamic>`.
-    checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
+    checkLinkedTypeRef(type, 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
-    checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'dart:core', 'int');
+    checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'int');
     checkLinkedDynamicTypeRef(type.typeArguments[1]);
   }
 
   test_inferred_type_skips_unnecessary_dynamic() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls = serializeClassText('class C { final x = []; }');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
     // Check that x has inferred type `List<dynamic>`.
-    checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'List',
+    checkLinkedTypeRef(type, 'dart:core', 'List',
         numTypeParameters: 1, numTypeArguments: 1);
   }
 
   test_initializer_executable_with_bottom_return_type() {
     // The synthetic executable for `v` has type `() => Bottom`.
     UnlinkedVariable variable = serializeVariableText('int v = null;');
     expect(variable.initializer.returnType, isNull);
     checkInferredTypeSlot(
-        variable.initializer.inferredReturnTypeSlot, null, null, '*bottom*',
+        variable.initializer.inferredReturnTypeSlot, null, '*bottom*',
         onlyInStrongMode: false);
   }
 
   test_initializer_executable_with_imported_return_type() {
     addNamedSource('/a.dart', 'class C { D d; } class D {}');
     // The synthetic executable for `v` has type `() => D`; `D` is defined in
     // a library that is imported.  Note: `v` is mis-typed as `int` to prevent
     // type propagation, which would complicate the test.
     UnlinkedVariable variable = serializeVariableText(
         'import "a.dart"; int v = new C().d;',
         allowErrors: true);
     expect(variable.initializer.returnType, isNull);
-    checkInferredTypeSlot(variable.initializer.inferredReturnTypeSlot,
-        absUri('/a.dart'), 'a.dart', 'D',
+    checkInferredTypeSlot(
+        variable.initializer.inferredReturnTypeSlot, absUri('/a.dart'), 'D',
         onlyInStrongMode: false);
-    checkHasDependency('a.dart', fullyLinked: false);
+    checkHasDependency(absUri('/a.dart'), fullyLinked: false);
   }
 
   test_initializer_executable_with_return_type_from_closure() {
     if (skipFullyLinkedData) {
       return;
     }
     // The synthetic executable for `v` has type `() => () => int`, where the
     // `() => int` part refers to the closure declared inside the initializer
     // for v.  Note: `v` is mis-typed as `int` to prevent type propagation,
     // which would complicate the test.
     UnlinkedVariable variable =
         serializeVariableText('int v = () => 0;', allowErrors: true);
     EntityRef closureType =
         getTypeRefForSlot(variable.initializer.inferredReturnTypeSlot);
-    checkLinkedTypeRef(closureType, null, null, '',
+    checkLinkedTypeRef(closureType, null, '',
         expectedKind: ReferenceKind.function);
     int initializerIndex =
         definingUnit.references[closureType.reference].containingReference;
-    checkReferenceIndex(initializerIndex, null, null, '',
+    checkReferenceIndex(initializerIndex, null, '',
         expectedKind: ReferenceKind.function);
     int variableIndex =
         definingUnit.references[initializerIndex].containingReference;
-    checkReferenceIndex(variableIndex, null, null, 'v',
+    checkReferenceIndex(variableIndex, null, 'v',
         expectedKind: ReferenceKind.topLevelPropertyAccessor);
     expect(definingUnit.references[variableIndex].containingReference, 0);
   }
 
   test_initializer_executable_with_return_type_from_closure_field() {
     if (skipFullyLinkedData) {
       return;
     }
     // The synthetic executable for `v` has type `() => () => int`, where the
     // `() => int` part refers to the closure declared inside the initializer
     // for v.  Note: `v` is mis-typed as `int` to prevent type propagation,
     // which would complicate the test.
     UnlinkedClass cls = serializeClassText(
         '''
 class C {
   int v = () => 0;
 }
 ''',
         allowErrors: true);
     UnlinkedVariable variable = cls.fields[0];
     EntityRef closureType =
         getTypeRefForSlot(variable.initializer.inferredReturnTypeSlot);
-    checkLinkedTypeRef(closureType, null, null, '',
+    checkLinkedTypeRef(closureType, null, '',
         expectedKind: ReferenceKind.function);
     int initializerIndex =
         definingUnit.references[closureType.reference].containingReference;
-    checkReferenceIndex(initializerIndex, null, null, '',
+    checkReferenceIndex(initializerIndex, null, '',
         expectedKind: ReferenceKind.function);
     int variableIndex =
         definingUnit.references[initializerIndex].containingReference;
-    checkReferenceIndex(variableIndex, null, null, 'v',
+    checkReferenceIndex(variableIndex, null, 'v',
         expectedKind: ReferenceKind.propertyAccessor);
     int classIndex = definingUnit.references[variableIndex].containingReference;
-    checkReferenceIndex(classIndex, null, null, 'C');
+    checkReferenceIndex(classIndex, null, 'C');
     expect(definingUnit.references[classIndex].containingReference, 0);
   }
 
   test_initializer_executable_with_return_type_from_closure_local() {
     if (skipFullyLinkedData) {
       return;
     }
     // The synthetic executable for `v` has type `() => () => int`, where the
     // `() => int` part refers to the closure declared inside the initializer
     // for v.  Note: `v` is mis-typed as `int` to prevent type propagation,
     // which would complicate the test.
     UnlinkedExecutable executable = serializeExecutableText(
         '''
 void f() {
   int u = 0; // force the variable below to have index 1
   int v = () => 0;
 }''',
         allowErrors: true);
     UnlinkedVariable variable = executable.localVariables[1];
     EntityRef closureType =
         getTypeRefForSlot(variable.initializer.inferredReturnTypeSlot);
-    checkLinkedTypeRef(closureType, null, null, '',
+    checkLinkedTypeRef(closureType, null, '',
         expectedKind: ReferenceKind.function);
     int initializerIndex =
         definingUnit.references[closureType.reference].containingReference;
-    checkReferenceIndex(initializerIndex, null, null, '',
+    checkReferenceIndex(initializerIndex, null, '',
         expectedKind: ReferenceKind.function);
     int variableIndex =
         definingUnit.references[initializerIndex].containingReference;
-    checkReferenceIndex(variableIndex, null, null, 'v',
+    checkReferenceIndex(variableIndex, null, 'v',
         expectedKind: ReferenceKind.variable, localIndex: 1);
     int topLevelFunctionIndex =
         definingUnit.references[variableIndex].containingReference;
-    checkReferenceIndex(topLevelFunctionIndex, null, null, 'f',
+    checkReferenceIndex(topLevelFunctionIndex, null, 'f',
         expectedKind: ReferenceKind.topLevelFunction);
     expect(
         definingUnit.references[topLevelFunctionIndex].containingReference, 0);
   }
 
   test_initializer_executable_with_unimported_return_type() {
     addNamedSource('/a.dart', 'import "b.dart"; class C { D d; }');
     addNamedSource('/b.dart', 'class D {}');
     // The synthetic executable for `v` has type `() => D`; `D` is defined in
     // a library that is not imported.  Note: `v` is mis-typed as `int` to
     // prevent type propagation, which would complicate the test.
     UnlinkedVariable variable = serializeVariableText(
         'import "a.dart"; int v = new C().d;',
         allowErrors: true);
     expect(variable.initializer.returnType, isNull);
-    checkInferredTypeSlot(variable.initializer.inferredReturnTypeSlot,
-        absUri('/b.dart'), 'b.dart', 'D',
+    checkInferredTypeSlot(
+        variable.initializer.inferredReturnTypeSlot, absUri('/b.dart'), 'D',
         onlyInStrongMode: false);
     if (!skipFullyLinkedData) {
       checkHasDependency('b.dart', fullyLinked: true);
     }
   }
 
   test_library_documented() {
     if (!includeInformative) return;
     String text = '''
 // Extra comment so doc comment offset != 0
@@ skipping 30 matching lines @@
     expect(unlinkedUnits[0].libraryNameLength, 0);
   }
 
   test_library_with_missing_part() {
     // References to other parts should still be resolved.
     allowMissingFiles = true;
     addNamedSource('/bar.dart', 'part of my.lib; class C {}');
     serializeLibraryText(
         'library my.lib; part "foo.dart"; part "bar.dart"; C c;',
         allowErrors: true);
-    checkTypeRef(findVariable('c').type, null, null, 'C',
-        expectedTargetUnit: 2);
+    checkTypeRef(findVariable('c').type, null, 'C', expectedTargetUnit: 2);
   }
 
   test_lineStarts() {
     String text = '''
 int foo;
 class Test {}
 
 int bar;'''
         .replaceAll('\r\n', '\n');
     serializeLibraryText(text);
@@ skipping 33 matching lines @@
         linked.units[0].references[dReference].dependency, explicitDependency);
   }
 
   test_local_names_take_precedence_over_imported_names() {
     addNamedSource('/a.dart', 'class C {} class D {}');
     serializeLibraryText('''
 import 'a.dart';
 class C {}
 C c;
 D d;''');
-    checkTypeRef(findVariable('c').type, null, null, 'C');
-    checkTypeRef(findVariable('d').type, absUri('/a.dart'), 'a.dart', 'D');
+    checkTypeRef(findVariable('c').type, null, 'C');
+    checkTypeRef(findVariable('d').type, absUri('/a.dart'), 'D');
   }
 
   test_localNameShadowsImportPrefix() {
     serializeLibraryText('import "dart:async" as a; class a {}; a x;');
-    checkTypeRef(findVariable('x').type, null, null, 'a');
+    checkTypeRef(findVariable('x').type, null, 'a');
   }
 
   test_metadata_classDeclaration() {
     checkAnnotationA(
         serializeClassText('const a = null; @a class C {}').annotations);
   }
 
   test_metadata_classTypeAlias() {
     checkAnnotationA(serializeClassText(
             'const a = null; @a class C = D with E; class D {} class E {}',
             className: 'C')
         .annotations);
   }
 
   test_metadata_constructor_call_named() {
     UnlinkedClass cls = serializeClassText(
         'class A { const A.named(); } @A.named() class C {}');
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'A')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_prefixed() {
     addNamedSource('/foo.dart', 'class A { const A.named(); }');
     UnlinkedClass cls = serializeClassText(
         'import "foo.dart" as foo; @foo.A.named() class C {}');
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.constructor,
               prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'A',
-                    absoluteUri: absUri('/foo.dart'), relativeUri: 'foo.dart'),
+                new _PrefixExpectation(
+                  ReferenceKind.classOrEnum,
+                  'A',
+                  absoluteUri: absUri('/foo.dart'),
+                ),
                 new _PrefixExpectation(ReferenceKind.prefix, 'foo')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_prefixed_unresolved_class() {
     addNamedSource('/foo.dart', '');
     UnlinkedClass cls = serializeClassText(
         'import "foo.dart" as foo; @foo.A.named() class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'A'),
                 new _PrefixExpectation(ReferenceKind.prefix, 'foo')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_prefixed_unresolved_constructor() {
     addNamedSource('/foo.dart', 'class A {}');
     UnlinkedClass cls = serializeClassText(
         'import "foo.dart" as foo; @foo.A.named() class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
-                new _PrefixExpectation(ReferenceKind.classOrEnum, 'A',
-                    absoluteUri: absUri('/foo.dart'), relativeUri: 'foo.dart'),
+                new _PrefixExpectation(
+                  ReferenceKind.classOrEnum,
+                  'A',
+                  absoluteUri: absUri('/foo.dart'),
+                ),
                 new _PrefixExpectation(ReferenceKind.prefix, 'foo')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_unresolved_class() {
     UnlinkedClass cls =
         serializeClassText('@A.named() class C {}', allowErrors: true);
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.unresolved, 'A')
               ])
     ]);
   }
 
   test_metadata_constructor_call_named_unresolved_constructor() {
     UnlinkedClass cls = serializeClassText('class A {} @A.named() class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'named',
+      (EntityRef r) => checkTypeRef(r, null, 'named',
               expectedKind: ReferenceKind.unresolved,
               prefixExpectations: [
                 new _PrefixExpectation(ReferenceKind.classOrEnum, 'A')
               ])
     ]);
   }
 
   test_metadata_constructor_call_unnamed() {
     UnlinkedClass cls =
         serializeClassText('class A { const A(); } @A() class C {}');
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'A',
-          expectedKind: ReferenceKind.classOrEnum)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'A', expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_metadata_constructor_call_unnamed_prefixed() {
     addNamedSource('/foo.dart', 'class A { const A(); }');
     UnlinkedClass cls =
         serializeClassText('import "foo.dart" as foo; @foo.A() class C {}');
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/foo.dart'), 'foo.dart', 'A',
+      (EntityRef r) => checkTypeRef(r, absUri('/foo.dart'), 'A',
           expectedKind: ReferenceKind.classOrEnum, expectedPrefix: 'foo')
     ]);
   }
 
   test_metadata_constructor_call_unnamed_prefixed_unresolved() {
     addNamedSource('/foo.dart', '');
     UnlinkedClass cls = serializeClassText(
         'import "foo.dart" as foo; @foo.A() class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'A',
+      (EntityRef r) => checkTypeRef(r, null, 'A',
           expectedKind: ReferenceKind.unresolved, expectedPrefix: 'foo')
     ]);
   }
 
   test_metadata_constructor_call_unnamed_unresolved() {
     UnlinkedClass cls =
         serializeClassText('@A() class C {}', allowErrors: true);
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       0
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'A',
-          expectedKind: ReferenceKind.unresolved)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'A', expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_metadata_constructor_call_with_args() {
     UnlinkedClass cls =
         serializeClassText('class A { const A(x); } @A(null) class C {}');
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.pushNull,
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       1
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'A',
-          expectedKind: ReferenceKind.classOrEnum)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'A', expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_metadata_constructorDeclaration_named() {
     checkAnnotationA(
         serializeClassText('const a = null; class C { @a C.named(); }')
             .executables[0]
             .annotations);
   }
 
@@ skipping 88 matching lines @@
 class C {}
 ''').annotations;
     expect(annotations, hasLength(1));
     assertUnlinkedConst(annotations[0], operators: [
       UnlinkedExprOperation.pushSuper,
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       1
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'A',
-          expectedKind: ReferenceKind.classOrEnum)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'A', expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_metadata_invalid_instanceCreation_argument_this() {
     List<UnlinkedExpr> annotations = serializeClassText('''
 class A {
   const A(_);
 }
 
 @A(this)
 class C {}
 ''').annotations;
     expect(annotations, hasLength(1));
     assertUnlinkedConst(annotations[0], operators: [
       UnlinkedExprOperation.pushThis,
       UnlinkedExprOperation.invokeConstructor,
     ], ints: [
       0,
       1
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'A',
-          expectedKind: ReferenceKind.classOrEnum)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'A', expectedKind: ReferenceKind.classOrEnum)
     ]);
   }
 
   test_metadata_libraryDirective() {
     serializeLibraryText('@a library L; const a = null;');
     checkAnnotationA(unlinkedUnits[0].libraryAnnotations);
   }
 
   test_metadata_methodDeclaration_getter() {
     checkAnnotationA(
@@ skipping 16 matching lines @@
   }
 
   test_metadata_multiple_annotations() {
     UnlinkedClass cls =
         serializeClassText('const a = null, b = null; @a @b class C {}');
     List<UnlinkedExpr> annotations = cls.annotations;
     expect(annotations, hasLength(2));
     assertUnlinkedConst(annotations[0], operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
+      (EntityRef r) => checkTypeRef(r, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
     assertUnlinkedConst(annotations[1], operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'b',
+      (EntityRef r) => checkTypeRef(r, null, 'b',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   test_metadata_partDirective() {
     addNamedSource('/foo.dart', 'part of L;');
     serializeLibraryText('library L; @a part "foo.dart"; const a = null;');
     checkAnnotationA(unlinkedUnits[0].parts[0].annotations);
   }
 
   test_metadata_prefixed_variable() {
     addNamedSource('/a.dart', 'const b = null;');
     UnlinkedClass cls =
         serializeClassText('import "a.dart" as a; @a.b class C {}');
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'a.dart', 'b',
+      (EntityRef r) => checkTypeRef(r, absUri('/a.dart'), 'b',
           expectedKind: ReferenceKind.topLevelPropertyAccessor,
           expectedPrefix: 'a')
     ]);
   }
 
   test_metadata_prefixed_variable_unresolved() {
     addNamedSource('/a.dart', '');
     UnlinkedClass cls = serializeClassText(
         'import "a.dart" as a; @a.b class C {}',
         allowErrors: true);
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'b',
+      (EntityRef r) => checkTypeRef(r, null, 'b',
           expectedKind: ReferenceKind.unresolved, expectedPrefix: 'a')
     ]);
   }
 
   test_metadata_simpleFormalParameter() {
     checkAnnotationA(serializeExecutableText('const a = null; f(@a x) {}')
         .parameters[0]
         .annotations);
   }
 
@@ skipping 34 matching lines @@
         .typeParameters[0]
         .annotations);
   }
 
   test_metadata_variable_unresolved() {
     UnlinkedClass cls = serializeClassText('@a class C {}', allowErrors: true);
     expect(cls.annotations, hasLength(1));
     assertUnlinkedConst(cls.annotations[0], operators: [
       UnlinkedExprOperation.pushReference
     ], referenceValidators: [
-      (EntityRef r) => checkTypeRef(r, null, null, 'a',
-          expectedKind: ReferenceKind.unresolved)
+      (EntityRef r) =>
+          checkTypeRef(r, null, 'a', expectedKind: ReferenceKind.unresolved)
     ]);
   }
 
   test_method_documented() {
     if (!includeInformative) return;
     String text = '''
 class C {
   /**
    * Docs
    */
@@ skipping 21 matching lines @@
         .executables[0];
     expect(f.inferredReturnTypeSlot, 0);
   }
 
   test_method_inferred_type_nonstatic_implicit_param() {
     UnlinkedExecutable f = serializeClassText(
             'class C extends D { void f(value) {} }'
             ' abstract class D { void f(int value); }',
             className: 'C')
         .executables[0];
-    checkInferredTypeSlot(
-        f.parameters[0].inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(f.parameters[0].inferredTypeSlot, 'dart:core', 'int');
   }
 
   test_method_inferred_type_nonstatic_implicit_return() {
     UnlinkedExecutable f = serializeClassText(
             'class C extends D { f() => null; } abstract class D { int f(); }',
             className: 'C')
         .executables[0];
-    checkInferredTypeSlot(
-        f.inferredReturnTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(f.inferredReturnTypeSlot, 'dart:core', 'int');
   }
 
   test_method_inferred_type_static_implicit_param() {
     UnlinkedExecutable f = serializeClassText(
             'class C extends D { static void f(value) {} }'
             ' class D { static void f(int value) {} }',
             className: 'C')
         .executables[0];
     expect(f.parameters[0].inferredTypeSlot, 0);
   }
@@ skipping 212 matching lines @@
             .executables[0];
     expect(f.inferredReturnTypeSlot, 0);
   }
 
   test_setter_inferred_type_nonstatic_implicit_param() {
     UnlinkedExecutable f = serializeClassText(
             'class C extends D { void set f(value) {} }'
             ' abstract class D { void set f(int value); }',
             className: 'C')
         .executables[0];
-    checkInferredTypeSlot(
-        f.parameters[0].inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(f.parameters[0].inferredTypeSlot, 'dart:core', 'int');
   }
 
   test_setter_inferred_type_nonstatic_implicit_return() {
     UnlinkedExecutable f =
         serializeClassText('class C { set f(int value) {} }').executables[0];
-    checkInferredTypeSlot(f.inferredReturnTypeSlot, null, null, 'void');
+    checkInferredTypeSlot(f.inferredReturnTypeSlot, null, 'void');
   }
 
   test_setter_inferred_type_static_implicit_param() {
     UnlinkedExecutable f = serializeClassText(
             'class C extends D { static void set f(value) {} }'
             ' class D { static void set f(int value) {} }',
             className: 'C')
         .executables[0];
     expect(f.parameters[0].inferredTypeSlot, 0);
   }
@@ skipping 37 matching lines @@
       // TODO(paulberry): once proper generic method syntax supports generic
       // closures, rewrite the test below without using generic comment syntax,
       // and remove this hack.  See dartbug.com/25819
       return;
     }
     UnlinkedVariable variable = serializeVariableText('''
 final v = f() ? /*<T>*/(T t) => 0 : /*<T>*/(T t) => 1;
 bool f() => true;
 ''');
     EntityRef inferredType = getTypeRefForSlot(variable.inferredTypeSlot);
-    checkLinkedTypeRef(
-        inferredType.syntheticReturnType, 'dart:core', 'dart:core', 'int');
+    checkLinkedTypeRef(inferredType.syntheticReturnType, 'dart:core', 'int');
     expect(inferredType.syntheticParams, hasLength(1));
-    checkLinkedTypeRef(
-        inferredType.syntheticParams[0].type, null, null, '*bottom*');
+    checkLinkedTypeRef(inferredType.syntheticParams[0].type, null, '*bottom*');
   }
 
   test_syntheticFunctionType_genericClosure_inGenericFunction() {
     if (skipFullyLinkedData) {
       return;
     }
     if (!strongMode) {
       // The test below uses generic comment syntax because proper generic
       // method syntax doesn't support generic closures.  So it can only run in
       // strong mode.
       // TODO(paulberry): once proper generic method syntax supports generic
       // closures, rewrite the test below without using generic comment syntax,
       // and remove this hack.  See dartbug.com/25819
       return;
     }
     UnlinkedVariable variable = serializeExecutableText('''
 void f<T, U>(bool b) {
   final v = b ? /*<V>*/(T t, U u, V v) => 0 : /*<V>*/(T t, U u, V v) => 1;
 }
 ''').localVariables[0];
     EntityRef inferredType = getTypeRefForSlot(variable.inferredTypeSlot);
-    checkLinkedTypeRef(
-        inferredType.syntheticReturnType, 'dart:core', 'dart:core', 'int');
+    checkLinkedTypeRef(inferredType.syntheticReturnType, 'dart:core', 'int');
     expect(inferredType.syntheticParams, hasLength(3));
     checkParamTypeRef(inferredType.syntheticParams[0].type, 2);
     checkParamTypeRef(inferredType.syntheticParams[1].type, 1);
-    checkLinkedTypeRef(
-        inferredType.syntheticParams[2].type, null, null, '*bottom*');
+    checkLinkedTypeRef(inferredType.syntheticParams[2].type, null, '*bottom*');
   }
 
   test_syntheticFunctionType_inGenericClass() {
     if (skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable variable = serializeClassText('''
 class C<T, U> {
   var v = f() ? (T t, U u) => 0 : (T t, U u) => 1;
 }
 bool f() => false;
 ''').fields[0];
     EntityRef inferredType =
         getTypeRefForSlot(variable.initializer.inferredReturnTypeSlot);
-    checkLinkedTypeRef(
-        inferredType.syntheticReturnType, 'dart:core', 'dart:core', 'int');
+    checkLinkedTypeRef(inferredType.syntheticReturnType, 'dart:core', 'int');
     checkParamTypeRef(inferredType.syntheticParams[0].type, 2);
     checkParamTypeRef(inferredType.syntheticParams[1].type, 1);
   }
 
   test_syntheticFunctionType_inGenericFunction() {
     if (skipFullyLinkedData) {
       return;
     }
     UnlinkedVariable variable = serializeExecutableText('''
 void f<T, U>(bool b) {
   var v = b ? (T t, U u) => 0 : (T t, U u) => 1;
 }
 ''').localVariables[0];
     EntityRef inferredType =
         getTypeRefForSlot(variable.initializer.inferredReturnTypeSlot);
-    checkLinkedTypeRef(
-        inferredType.syntheticReturnType, 'dart:core', 'dart:core', 'int');
+    checkLinkedTypeRef(inferredType.syntheticReturnType, 'dart:core', 'int');
     checkParamTypeRef(inferredType.syntheticParams[0].type, 2);
     checkParamTypeRef(inferredType.syntheticParams[1].type, 1);
   }
 
   test_type_arguments_explicit() {
     EntityRef typeRef = serializeTypeText('List<int>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
+    checkTypeRef(typeRef, 'dart:core', 'List',
         numTypeParameters: 1, numTypeArguments: 1);
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
+    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic() {
     EntityRef typeRef = serializeTypeText('List<dynamic>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
+    checkTypeRef(typeRef, 'dart:core', 'List',
         numTypeParameters: 1, numTypeArguments: 1);
     checkDynamicTypeRef(typeRef.typeArguments[0]);
   }
 
   test_type_arguments_explicit_dynamic_dynamic() {
     EntityRef typeRef = serializeTypeText('Map<dynamic, dynamic>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
+    checkTypeRef(typeRef, 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
     checkDynamicTypeRef(typeRef.typeArguments[0]);
     checkDynamicTypeRef(typeRef.typeArguments[1]);
   }
 
   test_type_arguments_explicit_dynamic_int() {
     EntityRef typeRef = serializeTypeText('Map<dynamic, int>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
+    checkTypeRef(typeRef, 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
     checkDynamicTypeRef(typeRef.typeArguments[0]);
-    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
+    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_dynamic_typedef() {
     EntityRef typeRef =
         serializeTypeText('F<dynamic>', otherDeclarations: 'typedef T F<T>();');
-    checkTypeRef(typeRef, null, null, 'F',
+    checkTypeRef(typeRef, null, 'F',
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1,
         numTypeArguments: 1);
     checkDynamicTypeRef(typeRef.typeArguments[0]);
   }
 
   test_type_arguments_explicit_String_dynamic() {
     EntityRef typeRef = serializeTypeText('Map<String, dynamic>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
+    checkTypeRef(typeRef, 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
+    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'String');
     checkDynamicTypeRef(typeRef.typeArguments[1]);
   }
 
   test_type_arguments_explicit_String_int() {
     EntityRef typeRef = serializeTypeText('Map<String, int>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
+    checkTypeRef(typeRef, 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'String');
-    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'int');
+    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'String');
+    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'int');
   }
 
   test_type_arguments_explicit_typedef() {
     EntityRef typeRef =
         serializeTypeText('F<int>', otherDeclarations: 'typedef T F<T>();');
-    checkTypeRef(typeRef, null, null, 'F',
+    checkTypeRef(typeRef, null, 'F',
         expectedKind: ReferenceKind.typedef,
         numTypeParameters: 1,
         numTypeArguments: 1);
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
+    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'int');
   }
 
   test_type_arguments_implicit() {
     EntityRef typeRef = serializeTypeText('List');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
-        numTypeParameters: 1);
+    checkTypeRef(typeRef, 'dart:core', 'List', numTypeParameters: 1);
   }
 
   test_type_arguments_implicit_typedef() {
     EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef T F<T>();');
-    checkTypeRef(typeRef, null, null, 'F',
+    checkTypeRef(typeRef, null, 'F',
         expectedKind: ReferenceKind.typedef, numTypeParameters: 1);
   }
 
   test_type_arguments_implicit_typedef_withBound() {
     EntityRef typeRef = serializeTypeText('F',
         otherDeclarations: 'typedef T F<T extends num>();');
-    checkTypeRef(typeRef, null, null, 'F',
+    checkTypeRef(typeRef, null, 'F',
         expectedKind: ReferenceKind.typedef, numTypeParameters: 1);
   }
 
   test_type_arguments_order() {
     EntityRef typeRef = serializeTypeText('Map<int, Object>');
-    checkTypeRef(typeRef, 'dart:core', 'dart:core', 'Map',
+    checkTypeRef(typeRef, 'dart:core', 'Map',
         numTypeParameters: 2, numTypeArguments: 2);
-    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
-    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'Object');
+    checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'int');
+    checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'Object');
   }
 
   test_type_dynamic() {
     checkDynamicTypeRef(serializeTypeText('dynamic'));
   }
 
   test_type_invalid_typeParameter_asPrefix() {
     UnlinkedClass c = serializeClassText('''
 class C<T> {
   m(T.K p) {}
 }
 ''');
     UnlinkedExecutable m = c.executables[0];
     expect(m.name, 'm');
-    checkTypeRef(m.parameters[0].type, null, null, 'dynamic');
+    checkTypeRef(m.parameters[0].type, null, 'dynamic');
   }
 
   test_type_param_codeRange() {
     if (!includeInformative) return;
     UnlinkedClass cls =
         serializeClassText('class A {} class C<T extends A> {}');
     UnlinkedTypeParam typeParameter = cls.typeParameters[0];
     _assertCodeRange(typeParameter.codeRange, 19, 11);
   }
 
@@ skipping 67 matching lines @@
     UnlinkedClass cls =
         serializeClassText('class C<T> { T f<T>(T x) => null; }');
     checkParamTypeRef(cls.executables[0].returnType, 1);
     checkParamTypeRef(cls.executables[0].parameters[0].type, 1);
   }
 
   test_type_reference_from_part() {
     addNamedSource('/a.dart', 'part of foo; C v;');
     serializeLibraryText('library foo; part "a.dart"; class C {}');
     checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
-        null, null, 'C',
+        null, 'C',
         expectedKind: ReferenceKind.classOrEnum,
         linkedSourceUnit: linked.units[1],
         unlinkedSourceUnit: unlinkedUnits[1]);
   }
 
   test_type_reference_from_part_withPrefix() {
     addNamedSource('/a.dart', 'class C {}');
     addNamedSource('/p.dart', 'part of foo; a.C v;');
     serializeLibraryText(
         'library foo; import "a.dart"; import "a.dart" as a; part "p.dart";',
         allowErrors: true);
     checkTypeRef(findVariable('v', variables: unlinkedUnits[1].variables).type,
-        absUri('/a.dart'), 'a.dart', 'C',
+        absUri('/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; }');
     {
       EntityRef typeRef =
           findVariable('t', variables: cls.fields, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 2);
     }
     {
       EntityRef 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');
+        absUri('/b.dart'), 'C');
   }
 
   test_type_reference_to_import_of_export_via_prefix() {
     addNamedSource('/a.dart', 'library a; export "b.dart";');
     addNamedSource('/b.dart', 'library b; class C {}');
     checkTypeRef(
         serializeTypeText('p.C', otherDeclarations: 'import "a.dart" as p;'),
         absUri('/b.dart'),
-        'b.dart',
         'C',
         expectedPrefix: 'p');
   }
 
   test_type_reference_to_imported_part() {
     addNamedSource('/a.dart', 'library my.lib; part "b.dart";');
     addNamedSource('/b.dart', 'part of my.lib; class C {}');
     checkTypeRef(
         serializeTypeText('C',
             otherDeclarations: 'library my.lib; import "a.dart";'),
         absUri('/a.dart'),
-        'a.dart',
         'C',
         expectedTargetUnit: 1);
   }
 
   test_type_reference_to_imported_part_with_prefix() {
     addNamedSource('/a.dart', 'library my.lib; part "b.dart";');
     addNamedSource('/b.dart', 'part of my.lib; class C {}');
     checkTypeRef(
         serializeTypeText('p.C',
             otherDeclarations: 'library my.lib; import "a.dart" as p;'),
         absUri('/a.dart'),
-        'a.dart',
         'C',
         expectedPrefix: 'p',
         expectedTargetUnit: 1);
   }
 
   test_type_reference_to_internal_class() {
-    checkTypeRef(serializeTypeText('C', otherDeclarations: 'class C {}'), null,
-        null, 'C');
+    checkTypeRef(
+        serializeTypeText('C', otherDeclarations: 'class C {}'), null, 'C');
   }
 
   test_type_reference_to_internal_class_alias() {
     checkTypeRef(
         serializeTypeText('C',
             otherDeclarations: 'class C = D with E; class D {} class E {}'),
         null,
-        null,
         'C');
   }
 
   test_type_reference_to_internal_enum() {
     checkTypeRef(serializeTypeText('E', otherDeclarations: 'enum E { value }'),
-        null, null, 'E');
+        null, 'E');
   }
 
   test_type_reference_to_local_part() {
     addNamedSource('/a.dart', 'part of my.lib; class C {}');
     checkTypeRef(
         serializeTypeText('C',
             otherDeclarations: 'library my.lib; part "a.dart";'),
         null,
-        null,
         'C',
         expectedTargetUnit: 1);
   }
 
   test_type_reference_to_nonexistent_file_via_prefix() {
     allowMissingFiles = true;
     EntityRef 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',
+    checkTypeRef(unlinkedUnits[0].variables.single.type, null, 'C',
         expectedKind: ReferenceKind.classOrEnum, expectedTargetUnit: 1);
   }
 
   test_type_reference_to_type_visible_via_multiple_import_prefixes() {
     addNamedSource('/lib1.dart', 'class C');
     addNamedSource('/lib2.dart', 'export "lib1.dart";');
     addNamedSource('/lib3.dart', 'export "lib1.dart";');
     addNamedSource('/lib4.dart', 'export "lib1.dart";');
     serializeLibraryText('''
 import 'lib2.dart';
 import 'lib3.dart' as a;
 import 'lib4.dart' as b;
 C c2;
 a.C c3;
 b.C c4;''');
     // Note: it is important that each reference to class C records the prefix
     // used to find it; otherwise it's possible that relinking might produce an
     // incorrect result after a change to lib2.dart, lib3.dart, or lib4.dart.
-    checkTypeRef(
-        findVariable('c2').type, absUri('/lib1.dart'), 'lib1.dart', 'C');
-    checkTypeRef(
-        findVariable('c3').type, absUri('/lib1.dart'), 'lib1.dart', 'C',
+    checkTypeRef(findVariable('c2').type, absUri('/lib1.dart'), 'C');
+    checkTypeRef(findVariable('c3').type, absUri('/lib1.dart'), 'C',
         expectedPrefix: 'a');
-    checkTypeRef(
-        findVariable('c4').type, absUri('/lib1.dart'), 'lib1.dart', 'C',
+    checkTypeRef(findVariable('c4').type, absUri('/lib1.dart'), 'C',
         expectedPrefix: 'b');
   }
 
   test_type_reference_to_typedef() {
     checkTypeRef(serializeTypeText('F', otherDeclarations: 'typedef void F();'),
-        null, null, 'F',
+        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 {}');
     EntityRef 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);
+    checkTypeRef(typeRef, absUri('/a.dart'), 'C', expectedTargetUnit: 2);
   }
 
   test_type_unresolved() {
     EntityRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_codeRange() {
     if (!includeInformative) return;
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
@@ skipping 40 matching lines @@
   }
 
   test_typedef_private() {
     serializeTypedefText('typedef _F();', '_F');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_typedef_reference_generic() {
     EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'typedef void F<A, B>();');
-    checkTypeRef(typeRef, null, null, 'F',
+    checkTypeRef(typeRef, null, 'F',
         numTypeParameters: 2, expectedKind: ReferenceKind.typedef);
   }
 
   test_typedef_reference_generic_imported() {
     addNamedSource('/lib.dart', 'typedef void F<A, B>();');
     EntityRef typeRef =
         serializeTypeText('F', otherDeclarations: 'import "lib.dart";');
-    checkTypeRef(typeRef, absUri('/lib.dart'), 'lib.dart', 'F',
+    checkTypeRef(typeRef, absUri('/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');
+    checkTypeRef(type.returnType, 'dart:core', 'int');
   }
 
   test_typedef_type_param_in_parameter() {
     UnlinkedTypedef type = serializeTypedefText('typedef F<T>(T t);');
     checkParamTypeRef(type.parameters[0].type, 1);
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 1);
   }
 
   test_typedef_type_param_in_return_type() {
     UnlinkedTypedef type = serializeTypedefText('typedef T F<T>();');
@@ skipping 18 matching lines @@
     UnlinkedUnit unit = unlinkedUnits[0];
     _assertCodeRange(unit.codeRange, 0, 14);
   }
 
   test_unresolved_export() {
     allowMissingFiles = true;
     serializeLibraryText("export 'foo.dart';", allowErrors: true);
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].uri, 'foo.dart');
     expect(linked.exportDependencies, hasLength(1));
-    checkDependency(
-        linked.exportDependencies[0], absUri('/foo.dart'), 'foo.dart');
+    checkDependency(linked.exportDependencies[0], absUri('/foo.dart'));
   }
 
   test_unresolved_import() {
     allowMissingFiles = true;
     serializeLibraryText("import 'foo.dart';", allowErrors: true);
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].uri, 'foo.dart');
     // Note: imports[1] is the implicit import of dart:core.
     expect(unlinkedUnits[0].imports[1].isImplicit, true);
     expect(linked.importDependencies, hasLength(2));
-    checkDependency(
-        linked.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
+    checkDependency(linked.importDependencies[0], absUri('/foo.dart'));
   }
 
   test_unresolved_part() {
     allowMissingFiles = true;
     serializeLibraryText("part 'foo.dart';", allowErrors: true);
     expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.parts[0], 'foo.dart');
   }
 
   test_unresolved_reference_in_multiple_parts() {
@@ skipping 27 matching lines @@
     UnlinkedVariable variable = serializeVariableText('''
 class C<T> {
   void f() {}
 }
 C<int> c;
 var v = c.f;
 ''');
     EntityRef type =
         getTypeRefForSlot(variable.initializer.inferredReturnTypeSlot);
     expect(type.typeArguments, hasLength(1));
-    checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'dart:core', 'int');
+    checkLinkedTypeRef(type.typeArguments[0], 'dart:core', 'int');
   }
 
   test_variable() {
     String text = 'int i;';
     UnlinkedVariable v = serializeVariableText(text, variableName: 'i');
     if (includeInformative) {
       expect(v.nameOffset, text.indexOf('i;'));
     }
     expect(findExecutable('i'), isNull);
     expect(findExecutable('i='), isNull);
@@ skipping 57 matching lines @@
     expect(variable.type, isNull);
   }
 
   test_variable_inferred_type_explicit_initialized() {
     UnlinkedVariable v = serializeVariableText('int v = 0;');
     expect(v.inferredTypeSlot, 0);
   }
 
   test_variable_inferred_type_implicit_initialized() {
     UnlinkedVariable v = serializeVariableText('var v = 0;');
-    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'dart:core', 'int');
+    checkInferredTypeSlot(v.inferredTypeSlot, 'dart:core', 'int');
   }
 
   test_variable_inferred_type_implicit_uninitialized() {
     UnlinkedVariable v = serializeVariableText('var v;');
     expect(v.inferredTypeSlot, 0);
   }
 
   test_variable_initializer_literal() {
     UnlinkedVariable variable = serializeVariableText('var v = 42;');
     UnlinkedExecutable initializer = variable.initializer;
@@ skipping 110 matching lines @@
 
   test_variable_static() {
     UnlinkedVariable variable =
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
-    checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
+    checkTypeRef(variable.type, 'dart:core', 'int');
   }
 
   /**
    * Verify invariants of the given [linkedLibrary].
    */
   void validateLinkedLibrary(LinkedLibrary linkedLibrary) {
     for (LinkedUnit unit in linkedLibrary.units) {
       for (LinkedReference reference in unit.references) {
         switch (reference.kind) {
           case ReferenceKind.classOrEnum:
@@ skipping 51 matching lines @@
         assignmentOperators: [
           expectedAssignOperator
         ],
         ints: [
           1,
           2,
           3
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'a',
+          (EntityRef r) => checkTypeRef(r, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   void _assertCodeRange(CodeRange codeRange, int offset, int length) {
     expect(codeRange, isNotNull);
     expect(codeRange.offset, offset);
     expect(codeRange.length, length);
   }
 
@@ skipping 41 matching lines @@
           UnlinkedExprOperation.add,
         ],
         assignmentOperators: [
           expectedAssignmentOperator
         ],
         ints: [
           2
         ],
         strings: [],
         referenceValidators: [
-          (EntityRef r) => checkTypeRef(r, null, null, 'a',
+          (EntityRef r) => checkTypeRef(r, null, 'a',
               expectedKind: ReferenceKind.topLevelPropertyAccessor)
         ]);
   }
 
   void _assertVariableVisible(
       String code, UnlinkedVariable v, String visibleBegin, String visibleEnd) {
     int expectedVisibleOffset = code.indexOf(visibleBegin);
     int expectedVisibleLength =
         code.indexOf(visibleEnd) - expectedVisibleOffset + 1;
     expect(v.visibleOffset, expectedVisibleOffset);
     expect(v.visibleLength, expectedVisibleLength);
   }
 }
 
 /**
  * Description of expectations for a prelinked prefix reference.
  */
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
-  final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
-      {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
+      {this.absoluteUri, this.numTypeParameters: 0});
 }