Merge the prefix and references tables.

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 87 matching lines @@
    * 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 => lib.units[0];
 
   /**
-   * Get access to the "unlinked" section of the summary.
-   */
-  UnlinkedLibrary get unlinked => lib.unlinked;
-
-  /**
    * 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.
@@ skipping 74 matching lines @@
    * having the given [deBruijnIndex].
    */
   void checkParamTypeRef(UnlinkedTypeRef typeRef, int deBruijnIndex) {
     expect(typeRef, new isInstanceOf<UnlinkedTypeRef>());
     expect(typeRef.reference, 0);
     expect(typeRef.typeArguments, isEmpty);
     expect(typeRef.paramReference, deBruijnIndex);
   }
 
   /**
+   * Verify that [prefixReference] is a valid reference to a prefix having the
+   * given [name].
+   */
+  void checkPrefix(int prefixReference, String name) {
+    expect(prefixReference, isNot(0));
+    expect(
+        definingUnit.unlinked.references[prefixReference].prefixReference, 0);
+    expect(definingUnit.unlinked.references[prefixReference].name, name);
+    expect(definingUnit.references[prefixReference].dependency, 0);
+    expect(definingUnit.references[prefixReference].kind,
+        PrelinkedReferenceKind.prefix);
+    expect(definingUnit.references[prefixReference].unit, 0);
+  }
+
+  /**
    * 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.  [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 expectedTargetUnit: 0,
       PrelinkedUnit sourceUnit}) {
     sourceUnit ??= definingUnit;
     expect(typeRef, new isInstanceOf<UnlinkedTypeRef>());
     expect(typeRef.paramReference, 0);
     int index = typeRef.reference;
     UnlinkedReference reference = sourceUnit.unlinked.references[index];
     PrelinkedReference referenceResolution = sourceUnit.references[index];
     if (index == 0) {
       // Index 0 is reserved for "dynamic".
       expect(reference.name, isEmpty);
-      expect(reference.prefix, 0);
+      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) {
       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);
+        expect(reference.prefixReference, 0);
       } else {
-        expect(reference.prefix, isNot(0));
-        expect(unlinked.prefixes[reference.prefix].name, expectedPrefix);
+        checkPrefix(reference.prefixReference, expectedPrefix);
       }
     }
     expect(referenceResolution.kind, expectedKind);
     expect(referenceResolution.unit, expectedTargetUnit);
   }
 
   /**
    * Verify that the given [typeRef] represents a reference to an unresolved
    * type.
    */
@@ skipping 1222 matching lines @@
     checkCombinatorName(
         definingUnit.unlinked.imports[0].combinators[0].hides[1], 'Stream');
   }
 
   test_import_implicit() {
     // The implicit import of dart:core is represented in the model.
     serializeLibraryText('');
     expect(definingUnit.unlinked.imports, hasLength(1));
     checkDependency(lib.importDependencies[0], 'dart:core', 'dart:core');
     expect(definingUnit.unlinked.imports[0].uri, isEmpty);
-    expect(definingUnit.unlinked.imports[0].prefix, 0);
+    expect(definingUnit.unlinked.imports[0].prefixReference, 0);
     expect(definingUnit.unlinked.imports[0].combinators, isEmpty);
     expect(definingUnit.unlinked.imports[0].isImplicit, isTrue);
   }
 
   test_import_no_combinators() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
     expect(definingUnit.unlinked.imports, hasLength(2));
     expect(definingUnit.unlinked.imports[0].combinators, isEmpty);
   }
@@ skipping 31 matching lines @@
     serializeLibraryText(libraryText);
     expect(
         definingUnit.unlinked.imports[0].offset, libraryText.indexOf('import'));
   }
 
   test_import_prefix_name() {
     String libraryText = 'import "dart:async" as a; a.Future x;';
     serializeLibraryText(libraryText);
     // Second import is the implicit import of dart:core
     expect(definingUnit.unlinked.imports, hasLength(2));
-    expect(definingUnit.unlinked.imports[0].prefix, isNot(0));
-    expect(
-        unlinked.prefixes[definingUnit.unlinked.imports[0].prefix].name, 'a');
+    checkPrefix(definingUnit.unlinked.imports[0].prefixReference, 'a');
   }
 
   test_import_prefix_none() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
     expect(definingUnit.unlinked.imports, hasLength(2));
-    expect(definingUnit.unlinked.imports[0].prefix, 0);
-    expect(unlinked.prefixes[definingUnit.unlinked.imports[0].prefix].name,
-        isEmpty);
+    expect(definingUnit.unlinked.imports[0].prefixReference, 0);
   }
 
   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');
   }
 
   test_import_reference() {
@@ skipping 401 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');
   }
 }