Record dependency information to implement first version of dependency

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

Index: dart/sdk/lib/_internal/compiler/implementation/enqueue.dart
diff --git a/dart/sdk/lib/_internal/compiler/implementation/enqueue.dart b/dart/sdk/lib/_internal/compiler/implementation/enqueue.dart
index 615ffe8e2e10cc9b308168fa6887986d89af11b9..436011eda0502a652105f9fdefeffb9620db67e4 100644
--- a/dart/sdk/lib/_internal/compiler/implementation/enqueue.dart
+++ b/dart/sdk/lib/_internal/compiler/implementation/enqueue.dart
@@ -88,16 +88,16 @@ abstract class Enqueuer {
 
   void registerInstantiatedType(InterfaceType type) {
     universe.instantiatedTypes.add(type);
-    registerInstantiatedClass(type.element);
+    registerInstantiatedClass(type.element, compiler.globalDependencies);
   }
 
-  void registerInstantiatedClass(ClassElement cls) {
+  void registerInstantiatedClass(ClassElement cls, TreeElements elements) {
     if (universe.instantiatedClasses.contains(cls)) return;
     if (!cls.isAbstract(compiler)) {
       universe.instantiatedClasses.add(cls);
     }
     onRegisterInstantiatedClass(cls);
-    compiler.backend.registerInstantiatedClass(cls, this);
+    compiler.backend.registerInstantiatedClass(cls, this, elements);
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
@@ -150,7 +150,8 @@ abstract class Enqueuer {
         // We will emit a closure, so make sure the closure class is
         // generated.
         compiler.closureClass.ensureResolved(compiler);
-        registerInstantiatedClass(compiler.closureClass);
+        registerInstantiatedClass(compiler.closureClass,
+                                  compiler.globalDependencies);
         return addToWorkList(member);
       }
     } else if (member.kind == ElementKind.GETTER) {
@@ -355,18 +356,18 @@ abstract class Enqueuer {
     universe.fieldSetters.add(element);
   }
 
-  void registerIsCheck(DartType type) {
+  void registerIsCheck(DartType type, TreeElements elements) {
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     assert(type.kind != TypeKind.TYPE_VARIABLE ||
            !type.element.enclosingElement.isTypedef());
     universe.isChecks.add(type);
-    compiler.backend.registerIsCheck(type, this);
+    compiler.backend.registerIsCheck(type, this, elements);
   }
 
   void registerAsCheck(DartType type) {
-    registerIsCheck(type);
+    registerIsCheck(type, compiler.globalDependencies);
     compiler.backend.registerAsCheck(type);
   }
 
@@ -412,6 +413,9 @@ class ResolutionEnqueuer extends Enqueuer {
       element = cls.methodElement;
     }
     Element owner = element.getOutermostEnclosingMemberOrTopLevel();
+    if (owner == null) {
+      owner = element;
+    }
     return resolvedElements[owner.declaration];
   }
 
@@ -467,8 +471,11 @@ class ResolutionEnqueuer extends Enqueuer {
 
   void enableIsolateSupport(LibraryElement element) {
     compiler.isolateLibrary = element.patch;
-    addToWorkList(
-        compiler.isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE));
+    var startRootIsolate =
+        compiler.isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE);
+    addToWorkList(startRootIsolate);
+    // TODO(ahe): This doesn't seem to be necessary. Why is that?
+    compiler.globalDependencies.registerBackendDependency(startRootIsolate);
     addToWorkList(compiler.isolateHelperLibrary.find(
         const SourceString('_currentIsolate')));
     addToWorkList(compiler.isolateHelperLibrary.find(