Create a prelinker for summaries.

pkg/analyzer/test/src/summary/summary_test.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.src.summary.summary_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/summary/base.dart';
 import 'package:analyzer/src/summary/format.dart';
+import 'package:analyzer/src/summary/prelink.dart';
 import 'package:analyzer/src/summary/public_namespace_computer.dart'
     as public_namespace;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     as summarize_elements;
 import 'package:unittest/unittest.dart';
 
 import '../../generated/resolver_test.dart';
 import '../../reflective_tests.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(SummarizeElementsTest);
+  runReflectiveTests(PrelinkerTest);
 }
 
 /**
+ * Convert a summary object (or a portion of one) into a canonical form that
+ * can be easily compared using [expect].  If [orderByName] is true, and the
+ * object is a [List], it is sorted by the `name` field of its elements.
+ */
+Object canonicalize(Object obj, {bool orderByName: false}) {
+  if (obj is SummaryClass) {
+    Map<String, Object> result = <String, Object>{};
+    obj.toMap().forEach((String key, Object value) {
+      bool orderByName = false;
+      if (obj is UnlinkedPublicNamespace && key == 'names') {
+        orderByName = true;
+      }
+      result[key] = canonicalize(value, orderByName: orderByName);
+    });
+    return result;
+  } else if (obj is List) {
+    List<Object> result = <Object>[];
+    for (Object item in obj) {
+      result.add(canonicalize(item));
+    }
+    if (orderByName) {
+      result.sort((Object a, Object b) {
+        if (a is Map && b is Map) {
+          return Comparable.compare(a['name'], b['name']);
+        } else {
+          return 0;
+        }
+      });
+    }
+    return result;
+  } else if (obj is String || obj is num || obj is bool) {
+    return obj;
+  } else {
+    return obj.toString();
+  }
+}
+
+UnlinkedPublicNamespace computePublicNamespaceFromText(
+    String text, Source source) {
+  CharacterReader reader = new CharSequenceReader(text);
+  Scanner scanner =
+      new Scanner(source, reader, AnalysisErrorListener.NULL_LISTENER);
+  Parser parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
+  parser.parseGenericMethods = true;
+  CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
+  UnlinkedPublicNamespace namespace = new UnlinkedPublicNamespace.fromBuffer(
+      public_namespace
+          .computePublicNamespace(new BuilderContext(), unit)
+          .toBuffer());
+  return namespace;
+}
+
+/**
+ * Override of [SummaryTest] which verifies the correctness of the prelinker by
+ * creating summaries from the element model, discarding their prelinked
+ * information, and then recreating it using the prelinker.
+ */
+@reflectiveTest
+class PrelinkerTest extends SummarizeElementsTest {
+  /**
+   * The public namespaces of the sdk are computed once so that we don't bog
+   * down the test.  Structured as a map from absolute URI to the corresponding
+   * public namespace.
+   *
+   * Note: should an exception occur during computation of this variable, it
+   * will silently be set to null to allow other tests to run.
+   */
+  static final Map<String, UnlinkedPublicNamespace> sdkPublicNamespace = () {
+    try {
+      AnalysisContext analysisContext =
+          AnalysisContextFactory.contextWithCore();
+      Map<String, UnlinkedPublicNamespace> uriToNamespace =
+          <String, UnlinkedPublicNamespace>{};
+      List<LibraryElement> libraries = [
+        analysisContext.typeProvider.objectType.element.library,
+        analysisContext.typeProvider.futureType.element.library
+      ];
+      for (LibraryElement library in libraries) {
+        summarize_elements.LibrarySerializationResult serializedLibrary =
+            summarize_elements.serializeLibrary(
+                new BuilderContext(), library, analysisContext.typeProvider);
+        for (int i = 0; i < serializedLibrary.unlinkedUnits.length; i++) {
+          uriToNamespace[
+              serializedLibrary.unitUris[i]] = new UnlinkedUnit.fromBuffer(
+              serializedLibrary.unlinkedUnits[i].toBuffer()).publicNamespace;
+        }
+      }
+      return uriToNamespace;
+    } catch (_) {
+      return null;
+    }
+  }();
+
+  final Map<String, UnlinkedPublicNamespace> uriToPublicNamespace =
+      <String, UnlinkedPublicNamespace>{};
+
+  @override
+  bool get expectAbsoluteUrisInDependencies => false;
+
+  @override
+  Source addNamedSource(String filePath, String contents) {
+    Source source = super.addNamedSource(filePath, contents);
+    uriToPublicNamespace[absUri(filePath)] =
+        computePublicNamespaceFromText(contents, source);
+    return source;
+  }
+
+  String resolveAbsoluteUri(LibraryElement library, String relativeUri) {

[scheglov, 2016/01/10 05:15:12]

resolveToAbsoluteUri would be better maybe?

[Paul Berry, 2016/01/10 22:15:17]

Done.

+    Source resolvedSource =
+        analysisContext.sourceFactory.resolveUri(library.source, relativeUri);
+    if (resolvedSource == null) {
+      fail('Failed to resolve relative uri "$relativeUri"');
+    }
+    String absoluteUri = resolvedSource.uri.toString();
+    return absoluteUri;

[scheglov, 2016/01/10 05:15:12]

Could be inlined.

[Paul Berry, 2016/01/10 22:15:17]

Done.

+  }
+
+  @override
+  void serializeLibraryElement(LibraryElement library) {
+    super.serializeLibraryElement(library);
+    Map<String, UnlinkedUnit> uriToUnit = <String, UnlinkedUnit>{};
+    expect(unlinkedUnits.length, unitUris.length);
+    for (int i = 1; i < unlinkedUnits.length; i++) {
+      uriToUnit[unitUris[i]] = unlinkedUnits[i];
+    }
+    UnlinkedUnit getPart(String relativeUri) {
+      String absoluteUri = resolveAbsoluteUri(library, relativeUri);
+      UnlinkedUnit unit = uriToUnit[absoluteUri];
+      if (unit == null) {
+        fail('Prelinker unexpectedly requested unit for "$relativeUri"'
+            ' (resolves to "$absoluteUri").');
+      }
+      return unit;
+    }
+    UnlinkedPublicNamespace getImport(String relativeUri) {
+      String absoluteUri = resolveAbsoluteUri(library, relativeUri);
+      UnlinkedPublicNamespace namespace = sdkPublicNamespace[absoluteUri];
+      if (namespace == null) {
+        namespace = uriToPublicNamespace[absoluteUri];
+      }
+      if (namespace == null && !allowMissingFiles) {
+        fail('Prelinker unexpectedly requested namespace for "$relativeUri"'
+            ' (resolves to "$absoluteUri").'
+            '  Namespaces available: ${uriToPublicNamespace.keys}');
+      }
+      return namespace;
+    }
+    prelinked = new PrelinkedLibrary.fromBuffer(
+        prelink(builderContext, unlinkedUnits[0], getPart, getImport)
+            .toBuffer());
+  }
+}
+
+/**
  * Override of [SummaryTest] which creates summaries from the element model.
  */
 @reflectiveTest
 class SummarizeElementsTest extends ResolverTestCase with SummaryTest {
   final BuilderContext builderContext = new BuilderContext();
 
   /**
    * The list of absolute unit URIs corresponding to the compilation units in
    * [unlinkedUnits].
    */
   List<String> unitUris;
 
   @override
   bool get checkAstDerivedData => false;
 
-  /**
-   * Convert a summary object (or a portion of one) into a canonical form that
-   * can be easily compared using [expect].  If [orderByName] is true, and the
-   * object is a [List], it is sorted by the `name` field of its elements.
-   */
-  Object canonicalize(Object obj, {bool orderByName: false}) {
-    if (obj is SummaryClass) {
-      Map<String, Object> result = <String, Object>{};
-      obj.toMap().forEach((String key, Object value) {
-        bool orderByName = false;
-        if (obj is UnlinkedPublicNamespace && key == 'names') {
-          orderByName = true;
-        }
-        result[key] = canonicalize(value, orderByName: orderByName);
-      });
-      return result;
-    } else if (obj is List) {
-      List<Object> result = <Object>[];
-      for (Object item in obj) {
-        result.add(canonicalize(item));
-      }
-      if (orderByName) {
-        result.sort((Object a, Object b) {
-          if (a is Map && b is Map) {
-            return Comparable.compare(a['name'], b['name']);
-          } else {
-            return 0;
-          }
-        });
-      }
-      return result;
-    } else {
-      return obj;
-    }
-  }
+  @override
+  bool get expectAbsoluteUrisInDependencies => true;
 
   /**
    * Serialize the library containing the given class [element], then
    * deserialize it and return the summary of the class.
    */
   UnlinkedClass serializeClassElement(ClassElement element) {
     serializeLibraryElement(element.library);
     return findClass(element.name, failIfAbsent: true);
   }
 
@@ skipping 49 matching lines @@
   }
 
   /**
    * Verify that [public_namespace.computePublicNamespace] produces data that's
    * equivalent to that produced by [summarize_elements.serializeLibrary].
    */
   void verifyPublicNamespace() {
     for (int i = 0; i < unlinkedUnits.length; i++) {
       Source source = analysisContext.sourceFactory.forUri(unitUris[i]);
       String text = analysisContext.getContents(source).data;
-      CharacterReader reader = new CharSequenceReader(text);
-      Scanner scanner =
-          new Scanner(source, reader, AnalysisErrorListener.NULL_LISTENER);
-      Parser parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
-      parser.parseGenericMethods = true;
-      CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
       UnlinkedPublicNamespace namespace =
-          new UnlinkedPublicNamespace.fromBuffer(public_namespace
-              .computePublicNamespace(builderContext, unit)
-              .toBuffer());
+          computePublicNamespaceFromText(text, source);
       expect(canonicalize(namespace),
           canonicalize(unlinkedUnits[i].publicNamespace),
           reason: 'publicNamespace(${unitUris[i]})');
     }
   }
 }
 
 /**
  * Base class containing most summary tests.  This allows summary tests to be
  * re-used to exercise all the different ways in which summaries can be
  * generated (e.g. direct from the AST, from the element model, from a
  * "relinking" process, etc.)
  */
 abstract class SummaryTest {
   /**
    * Prelinked summary that results from serializing and then deserializing the
    * library under test.
    */
   PrelinkedLibrary prelinked;
 
   /**
    * Unlinked compilation unit summaries that result from serializing and
    * deserializing the library under test.
    */
   List<UnlinkedUnit> unlinkedUnits;
 
   /**
+   * A test will set this to `true` if it contains `import`, `export`, or
+   * `part` declarations that deliberately refer to non-existent files.
+   */
+  bool allowMissingFiles = false;
+
+  /**
    * `true` if the summary was created directly from the AST (and hence
    * contains information that is not obtainable from the element model alone).
    * TODO(paulberry): modify the element model so that it contains all the data
    * that summaries need, so that this flag is no longer needed.
    */
   bool get checkAstDerivedData;
 
   /**
    * Get access to the prelinked defining compilation unit.
    */
   PrelinkedUnit get definingUnit => prelinked.units[0];
 
   /**
+   * `true` if the prelinked 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;
+
+  /**
    * Convert [path] to a suitably formatted absolute path URI for the current
    * platform.
    */
   String absUri(String path) {
     return FileUtilities2.createFile(path).toURI().toString();
   }
 
   /**
    * Add the given source file so that it may be referenced by the file under
    * test.
    */
-  addNamedSource(String filePath, String contents);
+  Source addNamedSource(String filePath, String contents);
 
   /**
    * 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) {
-    if (!checkAstDerivedData) {
+    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;
     }
     expect(dependency, new isInstanceOf<int>());
     expect(prelinked.dependencies[dependency].uri, relativeUri);
   }
 
   /**
@@ skipping 24 matching lines @@
    */
   void checkDynamicTypeRef(UnlinkedTypeRef typeRef) {
     checkTypeRef(typeRef, null, null, null);
   }
 
   /**
    * Verify that the dependency table contains an entry for a file reachable
    * via the given [absoluteUri] and [relativeUri].
    */
   void checkHasDependency(String absoluteUri, String relativeUri) {
-    if (!checkAstDerivedData) {
+    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;
     }
+    List<String> found = <String>[];
     for (PrelinkedDependency dep in prelinked.dependencies) {
       if (dep.uri == relativeUri) {
         return;
       }
+      found.add(dep.uri);
     }
-    fail('Did not find dependency $absoluteUri');
+    fail('Did not find dependency $relativeUri.  Found: $found');
   }
 
   /**
    * Verify that the dependency table *does not* contain any entries for a file
    * reachable via the given [absoluteUri] and [relativeUri].
    */
   void checkLacksDependency(String absoluteUri, String relativeUri) {
-    if (!checkAstDerivedData) {
+    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;
     }
     for (PrelinkedDependency dep in prelinked.dependencies) {
       if (dep.uri == relativeUri) {
         fail('Unexpected dependency found: $relativeUri');
       }
     }
@@ skipping 61 matching lines @@
       expect(reference.prefixReference, 0);
     }
     if (absoluteUri == null) {
       expect(referenceResolution.dependency, 0);
     } else {
       checkDependency(referenceResolution.dependency, absoluteUri, relativeUri);
     }
     if (!allowTypeParameters) {
       expect(typeRef.typeArguments, isEmpty);
     }
-    if (expectedName == null) {
+    if (expectedKind == PrelinkedReferenceKind.unresolved) {
+      // summarize_elements.dart isn't yet able to record the name of
+      // unresolved references.  TODO(paulberry): fix this.
+      expect(reference.name, '*unresolved*');
+    } else if (expectedName == null) {
       expect(reference.name, isEmpty);
     } else {
       expect(reference.name, expectedName);
     }
     if (expectedPrefix == null) {
       expect(reference.prefixReference, 0);
     } else {
       checkPrefix(reference.prefixReference, expectedPrefix);
     }
     expect(referenceResolution.kind, expectedKind);
@@ skipping 26 matching lines @@
     UnlinkedEnumValue value = serializeEnumText(text).values[0];
     expect(value.documentationComment, isNotNull);
     checkDocumentationComment(value.documentationComment, text);
   }
 
   fail_test_import_missing() {
     // TODO(paulberry): At the moment unresolved imports are not included in
     // the element model, so we can't pass this test.
     // 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(
         prelinked.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
   }
 
   fail_type_reference_to_nonexistent_file_via_prefix() {
     // TODO(paulberry): this test currently fails because there is not enough
     // information in the element model to figure out that the unresolved
     // reference `p.C` uses the prefix `p`.
+    allowMissingFiles = true;
     UnlinkedTypeRef typeRef = serializeTypeText('p.C',
         otherDeclarations: 'import "foo.dart" as p;', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, 'p', 'C');
   }
 
   fail_type_reference_to_type_visible_via_multiple_import_prefixes() {
     // TODO(paulberry): this test currently fails because the element model
     // doesn't record enough information to track which prefix is used to refer
     // to a type.
     addNamedSource('/lib1.dart', 'class C');
@@ skipping 194 matching lines @@
 
   /**
    * Serialize a type declaration using the given [text] as a type name, and
    * return a summary of the corresponding [UnlinkedTypeRef].  If the type
    * declaration needs to refer to types that are not available in core, those
    * types may be declared in [otherDeclarations].
    */
   UnlinkedTypeRef serializeTypeText(String text,
       {String otherDeclarations: '', bool allowErrors: false}) {
     return serializeVariableText('$otherDeclarations\n$text v;',
-            allowErrors: allowErrors)
-        .type;
+        allowErrors: allowErrors).type;
   }
 
   /**
    * Serialize the given library [text] and return the summary of the variable
    * with the given [variableName].
    */
   UnlinkedVariable serializeVariableText(String text,
       {String variableName: 'v', bool allowErrors: false}) {
     serializeLibraryText(text, allowErrors: allowErrors);
     return findVariable(variableName, failIfAbsent: true);
@@ skipping 658 matching lines @@
   }
 
   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');
     // 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(absUri('/a/b/b.dart'), 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'), '/a/a.dart');
+    checkHasDependency(absUri('/a/a.dart'), 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'), '/a/b/b.dart');
+    checkHasDependency(absUri('/a/b/b.dart'), 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');
     // 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');
@@ skipping 316 matching lines @@
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'bool');
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_index_set() {
     UnlinkedExecutable executable = serializeClassText(
-            'class C { void operator[]=(int i, bool v) => null; }')
-        .executables[0];
+        'class C { void operator[]=(int i, bool v) => null; }').executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(2));
     expect(executable.returnType, isNull);
     expect(executable.typeParameters, isEmpty);
@@ skipping 418 matching lines @@
 
   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');
   }
 
   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');
   }
 
   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,
@@ skipping 24 matching lines @@
     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',
         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',
+        expectedPrefix: 'b');
+    checkTypeRef(findVariable('cCls').type, absUri('/c.dart'), 'c.dart', 'Cls',
+        expectedPrefix: 'c');
+    checkTypeRef(findVariable('dCls').type, absUri('/d.dart'), 'd.dart', 'D');
+  }
+
   test_import_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async"; Future v;');
     checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
         numTypeParameters: 1);
   }
 
   test_import_reference_merged_no_prefix() {
     serializeLibraryText('''
 import "dart:async" show Future;
@@ skipping 15 matching lines @@
 
 a.Future f;
 a.Stream s;
 ''');
     checkTypeRef(findVariable('f').type, 'dart:async', 'dart:async', 'Future',
         expectedPrefix: 'a', numTypeParameters: 1);
     checkTypeRef(findVariable('s').type, 'dart:async', 'dart:async', 'Stream',
         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',
+        expectedPrefix: 'p');
+    checkTypeRef(findVariable('b').type, absUri('/b.dart'), 'b.dart', 'B',
+        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));
     expect(unlinkedUnits[0].imports[0].combinators[0].shows, hasLength(2));
     expect(unlinkedUnits[0].imports[0].combinators[0].hides, isEmpty);
     expect(unlinkedUnits[0].imports[0].combinators[0].shows[0], 'Future');
@@ skipping 38 matching lines @@
     expect(unlinkedUnits[0].libraryNameLength, 'foo.bar'.length);
   }
 
   test_library_unnamed() {
     serializeLibraryText('');
     expect(unlinkedUnits[0].libraryName, isEmpty);
     expect(unlinkedUnits[0].libraryNameOffset, 0);
     expect(unlinkedUnits[0].libraryNameLength, 0);
   }
 
+  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');
+  }
+
   test_method_documented() {
     String text = '''
 class C {
   /**
    * Docs
    */
   f() {}
 }''';
     UnlinkedExecutable executable = serializeClassText(text).executables[0];
     expect(executable.documentationComment, isNotNull);
@@ skipping 428 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_varible_private() {
     serializeVariableText('int _i;', variableName: '_i');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 }