Move summary references into UnlinkedUnit and PrelinkedUnit.

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/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 42 matching lines @@
 
   @override
   void serializeLibraryText(String text, {bool allowErrors: false}) {
     Source source = addSource(text);
     LibraryElement library = resolve2(source);
     if (!allowErrors) {
       assertNoErrors(source);
     }
     serializeLibraryElement(library);
     expect(definingUnit.unlinked.imports.length, lib.importDependencies.length);
-    expect(unlinked.references.length, lib.references.length);
+    for (PrelinkedUnit unit in lib.units) {
+      expect(unit.unlinked.references.length, unit.references.length);
+    }
   }
 
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableGenericMethods = true;
     resetWithOptions(options);
   }
 
@@ skipping 126 matching lines @@
     expect(typeRef.typeArguments, isEmpty);
     expect(typeRef.paramReference, deBruijnIndex);
   }
 
   /**
    * 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.  If [allowTypeParameters] is true, allow the
    * type reference to supply type parameters.  [expectedKind] is the kind of
-   * object referenced.
+   * object referenced.  [sourceUnit] is the compilation unit within which the
+   * [typeRef] appears; if not specified it is assumed to be 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.
    */
   void checkTypeRef(UnlinkedTypeRef typeRef, String absoluteUri,
       String relativeUri, String expectedName,
       {String expectedPrefix,
       bool allowTypeParameters: false,
       PrelinkedReferenceKind expectedKind: PrelinkedReferenceKind.classOrEnum,
-      int expectedUnit: 0}) {
+      int expectedTargetUnit: 0,
+      PrelinkedUnit sourceUnit}) {
+    sourceUnit ??= definingUnit;
     expect(typeRef, new isInstanceOf<UnlinkedTypeRef>());
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
-    UnlinkedReference reference = unlinked.references[index];
-    PrelinkedReference referenceResolution = lib.references[index];
+    UnlinkedReference reference = sourceUnit.unlinked.references[index];
+    PrelinkedReference referenceResolution = sourceUnit.references[index];
     if (absoluteUri == null) {
       expect(referenceResolution.dependency, 0);
     } else {
       checkDependency(referenceResolution.dependency, absoluteUri, relativeUri);
     }
     if (!allowTypeParameters) {
       expect(typeRef.typeArguments, isEmpty);
     }
     if (expectedName == null) {
       expect(reference.name, isEmpty);
     } else {
       expect(reference.name, expectedName);
     }
     if (checkAstDerivedData) {
       if (expectedPrefix == null) {
         expect(reference.prefix, 0);
         expect(unlinked.prefixes[reference.prefix].name, isEmpty);
       } else {
         expect(reference.prefix, isNot(0));
         expect(unlinked.prefixes[reference.prefix].name, expectedPrefix);
       }
     }
     expect(referenceResolution.kind, expectedKind);
-    expect(referenceResolution.unit, expectedUnit);
+    expect(referenceResolution.unit, expectedTargetUnit);
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to an unresolved
    * type.
    */
   void checkUnresolvedTypeRef(
       UnlinkedTypeRef typeRef, String expectedPrefix, String expectedName) {
     // When serializing from the element model, unresolved type refs lose their
     // name.
@@ skipping 187 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 1229 matching lines @@
         allowTypeParameters: true);
     expect(typeRef.typeArguments, hasLength(2));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
     checkTypeRef(typeRef.typeArguments[1], 'dart:core', 'dart:core', 'Object');
   }
 
   test_type_dynamic() {
     checkDynamicTypeRef(serializeTypeText('dynamic'));
   }
 
+  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: lib.units[1].unlinked.variables).type,
+        null,
+        null,
+        'C',
+        expectedKind: PrelinkedReferenceKind.classOrEnum,
+        sourceUnit: lib.units[1]);
+  }
+
   test_type_reference_to_class_argument() {
     UnlinkedClass cls = serializeClassText('class C<T, U> { T t; U u; }');
     {
       UnlinkedTypeRef typeRef =
           findVariable('t', variables: cls.fields, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 2);
     }
     {
       UnlinkedTypeRef typeRef =
           findVariable('u', variables: cls.fields, failIfAbsent: true).type;
@@ skipping 21 matching lines @@
 
   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',
-        expectedUnit: 1);
+        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',
-        expectedUnit: 1);
+        expectedTargetUnit: 1);
   }
 
   test_type_reference_to_internal_class() {
     checkTypeRef(serializeTypeText('C', otherDeclarations: 'class C {}'), null,
         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');
   }
 
   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',
-        expectedUnit: 1);
+        expectedTargetUnit: 1);
   }
 
   test_type_reference_to_nonexistent_file_via_prefix() {
     UnlinkedTypeRef 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 {}');
+    checkTypeRef(
+        serializeTypeText('C',
+            otherDeclarations: 'library foo; part "a.dart";'),
+        null,
+        null,
+        'C',
+        expectedKind: PrelinkedReferenceKind.classOrEnum,
+        expectedTargetUnit: 1);
+  }
+
   test_type_reference_to_typedef() {
     checkTypeRef(serializeTypeText('F', otherDeclarations: 'typedef void F();'),
         null, null, 'F',
         expectedKind: PrelinkedReferenceKind.typedef);
   }
 
   test_type_unit_counts_unreferenced_units() {
     addNamedSource('/a.dart', 'library a; part "b.dart"; part "c.dart";');
     addNamedSource('/b.dart', 'part of a;');
     addNamedSource('/c.dart', 'part of a; class C {}');
     UnlinkedTypeRef typeRef =
         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', expectedUnit: 2);
+    checkTypeRef(typeRef, absUri('/a.dart'), 'a.dart', 'C',
+        expectedTargetUnit: 2);
   }
 
   test_type_unresolved() {
     UnlinkedTypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_name() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.name, 'F');
@@ skipping 112 matching lines @@
         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');
   }
 }