More fixes to summary linking.

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 112 matching lines @@
  */
 abstract class ClassElementForLink
     implements ClassElement, ReferenceableElementForLink {
   Map<String, ReferenceableElementForLink> _containedNames;
 
   @override
   ConstructorElementForLink get asConstructor => unnamedConstructor;
 
   @override
   ConstVariableNode get asConstVariable {
-    // TODO(paulberry): implement.
-    throw new UnimplementedError();
+    // When a class name is used as a constant variable, it doesn't depend on
+    // anything, so it is not necessary to include it in the constant
+    // dependency graph.
+    return null;
   }
 
   @override
   List<ConstructorElementForLink> get constructors;
 
   @override
   List<FieldElementForLink> get fields;
 
   /**
    * Indicates whether this is the core class `Object`.
@@ skipping 289 matching lines @@
    * Return the element referred to by the given [index] in
    * [UnlinkedUnit.references].  If the reference is unresolved,
    * return [UndefinedElementForLink.instance].
    */
   ReferenceableElementForLink _resolveRef(int index) {
     if (_references[index] == null) {
       UnlinkedReference unlinkedReference = _unlinkedUnit.references[index];
       LinkedReference linkedReference = _linkedUnit.references[index];
       String name = unlinkedReference.name;
       int containingReference = unlinkedReference.prefixReference;
-      if (containingReference != 0) {
+      if (containingReference != 0 &&
+          _linkedUnit.references[containingReference].kind !=
+              ReferenceKind.prefix) {
         _references[index] =
             _resolveRef(containingReference).getContainedName(name);
       } else if (linkedReference.dependency == 0) {
         _references[index] = enclosingElement.getContainedName(name);
       } else {
-        // TODO(paulberry): implement.
-        throw new UnimplementedError();
+        LibraryElementForLink dependency =
+            enclosingElement._getDependency(linkedReference.dependency);
+        _references[index] = dependency.getContainedName(name);
       }
     }
     return _references[index];
   }
 
   /**
    * Resolve an [EntityRef] into a type.  If the reference is
    * unresolved, return [DynamicTypeImpl.instance].
    *
    * TODO(paulberry): or should we have a class representing an
@@ skipping 638 matching lines @@
   final _Linker _linker;
 
   /**
    * The absolute URI of this library.
    */
   final Uri _absoluteUri;
 
   List<UnitElement> _units;
   final Map<String, ReferenceableElementForLink> _containedNames =
       <String, ReferenceableElementForLink>{};
+  final List<LibraryElementForLink> _dependencies = <LibraryElementForLink>[];
 
-  LibraryElementForLink(this._linker, this._absoluteUri);
+  LibraryElementForLink(this._linker, this._absoluteUri) {
+    _dependencies.length = _linkedLibrary.dependencies.length;
+  }
 
   @override
   List<UnitElement> get units {
     if (_units == null) {
       UnlinkedUnit definingUnit = _linker.getUnit(_absoluteUri.toString());
       _units = <UnitElement>[_makeUnitElement(definingUnit, 0)];
       int numParts = definingUnit.parts.length;
       for (int i = 0; i < numParts; i++) {
         // TODO(paulberry): make sure we handle the case where Uri.parse fails.
         // TODO(paulberry): make sure we handle the case where
@@ skipping 26 matching lines @@
             return element;
           }
         }
         return UndefinedElementForLink.instance;
       });
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   /**
+   * Return the [LibraryElement] corresponding to the given dependency [index].
+   */
+  LibraryElementForLink _getDependency(int index) {
+    return _dependencies[index] ??= _linker.getLibrary(resolveRelativeUri(
+        _absoluteUri, Uri.parse(_linkedLibrary.dependencies[index].uri)));
+  }
+
+  /**
    * Create a [UnitElement] for one of the library's compilation
    * units.
    */
   UnitElement _makeUnitElement(UnlinkedUnit unlinkedUnit, int i);
 }
 
 /**
  * Element representing a library which is part of the build unit
  * being linked.
  */
@@ skipping 350 matching lines @@
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.unlink();
     }
   }
 }