Clean up unnecessary absolute URIs in summary tests.

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 123 matching lines @@
    * `part` declarations that deliberately refer to non-existent files.
    */
   bool allowMissingFiles = false;
 
   /**
    * Get access to the linked defining compilation unit.
    */
   LinkedUnit get definingUnit => linked.units[0];
 
   /**
-   * `true` if the linked portion of the summary is expected to contain
-   * absolute URIs.  This happens because the element model doesn't (yet) store
-   * enough information to recover relative URIs, TODO(paulberry): fix this.
-   */
-  bool get expectAbsoluteUrisInDependencies;
-
-  /**
    * Get access to the linked summary that results from serializing and
    * then deserializing the library under test.
    */
   LinkedLibrary get linked;
 
   /**
    * `true` if the linked portion of the summary only contains prelinked data.
    * This happens because we don't yet have a full linker; only a prelinker.
    */
   bool get skipFullyLinkedData;
@@ skipping 49 matching lines @@
               : isNot(contains(constCycleSlot)));
     }
   }
 
   /**
    * Verify that the [dependency]th element of the dependency table represents
    * a file reachable via the given [absoluteUri] and [relativeUri].
    */
   void checkDependency(int dependency, String absoluteUri, String relativeUri) {
     expect(dependency, new isInstanceOf<int>());
-    if (expectAbsoluteUrisInDependencies) {
-      // The element model doesn't (yet) store enough information to recover
-      // relative URIs, so we have to use the absolute URI.
-      // TODO(paulberry): fix this.
-      expect(linked.dependencies[dependency].uri, absoluteUri);
-    } else if (dependency >= linked.numPrelinkedDependencies) {
+    if (dependency >= linked.numPrelinkedDependencies) {
       // Fully-linked dependencies are always absolute URIs.
       expect(linked.dependencies[dependency].uri, absoluteUri);
     } else {
       expect(linked.dependencies[dependency].uri, relativeUri);
     }
   }
 
   /**
-   * Verify that the given [dependency] lists the given [absoluteUris] or
+   * Verify that the given [dependency] lists the given
    * [relativeUris] as its parts.
    */
-  void checkDependencyParts(LinkedDependency dependency,
-      List<String> absoluteUris, List<String> relativeUris) {
-    if (expectAbsoluteUrisInDependencies) {
-      // The element model doesn't (yet) store enough information to recover
-      // relative URIs, so we have to use the absolute URI.
-      // TODO(paulberry): fix this.
-      relativeUris = absoluteUris;
-    }
+  void checkDependencyParts(
+      LinkedDependency dependency, List<String> relativeUris) {
     expect(dependency.parts, relativeUris);
   }
 
   /**
    * Check that the given [documentationComment] matches the first
    * Javadoc-style comment found in [text].
    *
    * Note that the algorithm for finding the Javadoc-style comment in [text] is
    * a simple-minded text search; it is easily confused by corner cases such as
    * strings containing comments, nested comments, etc.
@@ skipping 33 matching lines @@
     // Exported names must come from other libraries.
     expect(exportName.dependency, isNot(0));
     checkDependency(exportName.dependency, absoluteUri, relativeUri);
     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 [absoluteUri] and [relativeUri].  If [fullyLinked] is
+   * via the given [relativeUri].  If [fullyLinked] is
    * `true`, then the dependency should be a fully-linked dependency; otherwise
    * it should be a prelinked dependency.
    *
    * The index of the [LinkedDependency] is returned.
    */
-  int checkHasDependency(String absoluteUri, String relativeUri,
-      {bool fullyLinked: false}) {
-    if (expectAbsoluteUrisInDependencies) {
-      // The element model doesn't (yet) store enough information to recover
-      // relative URIs, so we have to use the absolute URI.
-      // TODO(paulberry): fix this.
-      relativeUri = absoluteUri;
-    }
+  int checkHasDependency(String relativeUri, {bool fullyLinked: false}) {
     List<String> found = <String>[];
     for (int i = 0; i < linked.dependencies.length; i++) {
       LinkedDependency dep = linked.dependencies[i];
       if (dep.uri == relativeUri) {
         if (fullyLinked) {
           expect(i, greaterThanOrEqualTo(linked.numPrelinkedDependencies));
         } else {
           expect(i, lessThan(linked.numPrelinkedDependencies));
         }
         return i;
@@ skipping 30 matching lines @@
       // A slot id should have been assigned but it should not be associated
       // with any type.
       expect(slotId, isNot(0));
       expect(getTypeRefForSlot(slotId, linkedSourceUnit: linkedSourceUnit),
           isNull);
     }
   }
 
   /**
    * Verify that the dependency table *does not* contain any entries for a file
-   * reachable via the given [absoluteUri] and [relativeUri].
+   * reachable via the given [relativeUri].
    */
-  void checkLacksDependency(String absoluteUri, String relativeUri) {
-    if (expectAbsoluteUrisInDependencies) {
-      // The element model doesn't (yet) store enough information to recover
-      // relative URIs, so we have to use the absolute URI.
-      // TODO(paulberry): fix this.
-      relativeUri = absoluteUri;
-    }
+  void checkLacksDependency(String relativeUri) {
     for (LinkedDependency dep in linked.dependencies) {
       if (dep.uri == relativeUri) {
         fail('Unexpected dependency found: $relativeUri');
       }
     }
   }
 
   /**
    * Verify that the given [typeRef] represents the type `dynamic`.
    */
@@ skipping 232 matching lines @@
         unlinkedSourceUnit: unlinkedSourceUnit);
   }
 
   /**
    * Verify that the given [typeRef] represents the type `void`.
    */
   void checkVoidTypeRef(EntityRef typeRef) {
     checkTypeRef(typeRef, null, 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');
+  }
+
+  fail_invalid_prefix_type_parameter() {
+//    if (checkAstDerivedData) {
+//      // TODO(paulberry): get this to work properly.
+//      return;
+//    }
+    checkUnresolvedTypeRef(
+        serializeClassText('class C<T> { T.U x; }', allowErrors: true)
+            .fields[0]
+            .type,
+        'T',
+        'U');
+  }
+
+  fail_invalid_prefix_void() {
+//    if (checkAstDerivedData) {
+//      // TODO(paulberry): get this to work properly.
+//      return;
+//    }
+    checkUnresolvedTypeRef(
+        serializeTypeText('void.T', allowErrors: true), 'void', 'T');
+  }
+
   /**
    * Find the class with the given [className] in the summary, and return its
    * [UnlinkedClass] data structure.  If [unit] is not given, the class is
    * looked for in the defining compilation unit.
    */
   UnlinkedClass findClass(String className,
       {bool failIfAbsent: false, UnlinkedUnit unit}) {
     unit ??= unlinkedUnits[0];
     UnlinkedClass result;
     for (UnlinkedClass cls in unit.classes) {
@@ skipping 723 matching lines @@
     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 = serializeExecutableText(
         'import "a.dart"; f() { print((() => new C().d)()); }');
     expect(executable.localFunctions, hasLength(1));
     expect(executable.localFunctions[0].returnType, isNull);
     checkInferredTypeSlot(executable.localFunctions[0].inferredReturnTypeSlot,
         absUri('/a.dart'), 'a.dart', 'D',
         onlyInStrongMode: false);
-    checkHasDependency(absUri('/a.dart'), 'a.dart', fullyLinked: false);
+    checkHasDependency('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() {
@@ skipping 24 matching lines @@
     // The closure has type `() => D`; `D` is defined in a library that is not
     // imported.
     UnlinkedExecutable executable = serializeExecutableText(
         'import "a.dart"; f() { print((() => new C().d)()); }');
     expect(executable.localFunctions, hasLength(1));
     expect(executable.localFunctions[0].returnType, isNull);
     checkInferredTypeSlot(executable.localFunctions[0].inferredReturnTypeSlot,
         absUri('/b.dart'), 'b.dart', 'D',
         onlyInStrongMode: false);
     if (!skipFullyLinkedData) {
-      checkHasDependency(absUri('/b.dart'), 'b.dart', fullyLinked: true);
+      checkHasDependency('b.dart', fullyLinked: true);
     }
   }
 
   test_constExpr_binary_add() {
     UnlinkedVariable variable = serializeVariableText('const v = 1 + 2;');
     _assertUnlinkedConst(variable.initializer.bodyExpr, operators: [
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.pushInt,
       UnlinkedConstOperation.add
     ], ints: [
@@ skipping 3270 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(absUri('/b.dart'), 'b.dart');
+    checkHasDependency('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(absUri('/a.dart'), 'a.dart');
+    checkHasDependency('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(absUri('/a.dart'), 'a.dart');
+    checkHasDependency('a.dart');
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
-    checkHasDependency(absUri('/b.dart'), 'b.dart');
+    checkHasDependency('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(absUri('/a/a.dart'), 'a/a.dart');
+    checkHasDependency('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'), absUri('/a/b/b.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'), absUri('/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'), absUri('/a/b/b.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(absUri('/a/a.dart'), 'a/a.dart');
+    checkHasDependency('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'), 'a/b/b.dart');
+    checkHasDependency('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(absUri('/a.dart'), 'a.dart');
+    checkHasDependency('a.dart');
     // Serialization should have been able to walk the transitive export
     // dependencies to b.dart without going into an infinite loop.
-    checkHasDependency(absUri('/b.dart'), 'b.dart');
+    checkHasDependency('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(absUri('/a.dart'), 'a.dart');
+    checkHasDependency('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(absUri('/c.dart'), 'c.dart');
+    checkHasDependency('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(absUri('/b.dart'), 'b.dart');
+    checkHasDependency('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(absUri('/a.dart'), 'a.dart');
+    checkHasDependency('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(absUri('/b.dart'), 'b.dart');
+    checkLacksDependency('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(absUri('/a.dart'), 'a.dart');
+    checkHasDependency('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(absUri('/a.dart'), 'a.dart');
-    checkDependencyParts(linked.dependencies[dep],
-        [absUri('/b.dart'), absUri('/c.dart')], ['b.dart', 'c.dart']);
+    int dep = checkHasDependency('a.dart');
+    checkDependencyParts(linked.dependencies[dep], ['b.dart', '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(absUri('/a/c/d.dart'), 'a/c/d.dart');
+    int dep = checkHasDependency('a/c/d.dart');
     checkDependencyParts(
-        linked.dependencies[dep],
-        [absUri('/a/c/e/f.dart'), absUri('/a/c/g/h.dart')],
-        ['a/c/e/f.dart', 'a/c/g/h.dart']);
+        linked.dependencies[dep], ['a/c/e/f.dart', 'a/c/g/h.dart']);
   }
 
   test_elements_in_part() {
     addNamedSource(
         '/part1.dart',
         '''
 part of my.lib;
 
 class C {}
 enum E { v }
@@ skipping 2945 matching lines @@
   test_implicit_dependencies_follow_other_dependencies() {
     if (skipFullyLinkedData) {
       return;
     }
     addNamedSource('/a.dart', 'import "b.dart"; class C {} D f() => null;');
     addNamedSource('/b.dart', 'class D {}');
     serializeLibraryText('import "a.dart"; final x = f(); C y;');
     // The dependency on b.dart is implicit, so it should be placed at the end
     // of the dependency list, after a.dart, even though the code that refers
     // to b.dart comes before the code that refers to a.dart.
-    int aDep =
-        checkHasDependency(absUri('/a.dart'), 'a.dart', fullyLinked: false);
-    int bDep =
-        checkHasDependency(absUri('/b.dart'), 'b.dart', fullyLinked: true);
+    int aDep = checkHasDependency('a.dart', fullyLinked: false);
+    int bDep = checkHasDependency('b.dart', fullyLinked: true);
     expect(aDep, lessThan(bDep));
   }
 
   test_import_configurations() {
     addNamedSource('/foo.dart', 'bar() {}');
     addNamedSource('/foo_io.dart', 'bar() {}');
     addNamedSource('/foo_html.dart', 'bar() {}');
     String libraryText = r'''
 import 'foo.dart'
   if (dart.library.io) 'foo_io.dart'
@@ skipping 563 matching lines @@
     // 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',
         onlyInStrongMode: false);
-    checkHasDependency(absUri('/a.dart'), 'a.dart', fullyLinked: false);
+    checkHasDependency('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.
@@ skipping 90 matching lines @@
     // 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',
         onlyInStrongMode: false);
     if (!skipFullyLinkedData) {
-      checkHasDependency(absUri('/b.dart'), 'b.dart', fullyLinked: true);
+      checkHasDependency('b.dart', fullyLinked: true);
     }
   }
 
-  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');
-  }
-
-  fail_invalid_prefix_type_parameter() {
-//    if (checkAstDerivedData) {
-//      // TODO(paulberry): get this to work properly.
-//      return;
-//    }
-    checkUnresolvedTypeRef(
-        serializeClassText('class C<T> { T.U x; }', allowErrors: true)
-            .fields[0]
-            .type,
-        'T',
-        'U');
-  }
-
-  fail_invalid_prefix_void() {
-//    if (checkAstDerivedData) {
-//      // TODO(paulberry): get this to work properly.
-//      return;
-//    }
-    checkUnresolvedTypeRef(
-        serializeTypeText('void.T', allowErrors: true), 'void', 'T');
-  }
-
   test_library_documented() {
     String text = '''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
 library foo;''';
     serializeLibraryText(text);
     expect(unlinkedUnits[0].libraryDocumentationComment, isNotNull);
     checkDocumentationComment(
@@ skipping 1799 matching lines @@
 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});
 }