Handle constants that mix eager and deferred types.

dart/sdk/lib/_internal/compiler/implementation/deferred_load.dart

 // Copyright (c) 2013, 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 deferred_load;
 
 import 'dart:uri'
        show Uri;
 
 import 'dart:collection'
@@ skipping 146 matching lines @@
     });
   }
 
   /// Returns all elements in the tree map of [element], but not the
   /// transitive closure.
   Set<Element> allElementsResolvedFrom(Element element) {
     element = element.implementation;
     Set<Element> result = new LinkedHashSet<Element>();
     if (element.isGenerativeConstructor()) {
       // When instantiating a class, we record a reference to the
-      // constructor, not the class itself.
-      element = element.getEnclosingClass().implementation;
+      // constructor, not the class itself.  We must add all the
+      // instance members of the constructor's class (see below).
+      result.addAll(
+          allElementsResolvedFrom(element.getEnclosingClass().implementation));
     }
     if (element.isClass()) {
       // If we see a class, add everything its instance members refer
       // to.  Static members are not relevant.
       ClassElement cls = element.declaration;
       cls.forEachLocalMember((Element e) {
         if (!e.isInstanceMember()) return;
         result.addAll(DependencyCollector.collect(e.implementation, compiler));
       });
       if (cls.implementation != cls) {
         // TODO(ahe): Why doesn't ClassElement.forEachLocalMember do this?
         cls.implementation.forEachLocalMember((Element e) {
           if (!e.isInstanceMember()) return;
           result.addAll(DependencyCollector.collect(e.implementation,
                                                     compiler));
         });
       }
       for (var type in cls.allSupertypes) {
         result.add(type.element.implementation);
       }
       result.add(cls.implementation);
-    } else if (Elements.isStaticOrTopLevel(element)) {
+    } else if (Elements.isStaticOrTopLevel(element)
+               || element.isConstructor()) {
       result.addAll(DependencyCollector.collect(element, compiler));
     }
     // Other elements, in particular instance members, are ignored as
     // they are processed as part of the class.
     return result;
   }
 
   void addTransitiveClosureTo(Set<Element> elements) {
     Set<Element> workSet = new LinkedHashSet.from(elements);
     Set<Element> closure = new LinkedHashSet<Element>();
@@ skipping 40 matching lines @@
 class DependencyCollector extends Visitor {
   final Set<Element> dependencies = new LinkedHashSet<Element>();
   final TreeElements elements;
   final Compiler compiler;
 
   DependencyCollector(this.elements, this.compiler);
 
   visitNode(Node node) {
     node.visitChildren(this);
     Element dependency = elements[node];
-    if (dependency == null) return;
+    if (Elements.isUnresolved(dependency)) return;
     dependencies.add(dependency.implementation);
   }
 
   static Set<Element> collect(Element element, Compiler compiler) {
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(element);
     if (elements == null) return new LinkedHashSet<Element>();
     Node node = element.parseNode(compiler);
     var collector = new DependencyCollector(elements, compiler);
     node.accept(collector);
     collector.dependencies.addAll(elements.otherDependencies);
     return collector.dependencies;
   }
 }