Record dependency information to implement first version of dependency

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

 // Copyright (c) 2012, 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.
 
 part of dart2js;
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 49 matching lines @@
     if (element.isForeign(compiler)) return;
 
     if (!addElementToWorkList(element, elements)) return;
 
     // Enable runtime type support if we discover a getter called runtimeType.
     // We have to enable runtime type before hitting the codegen, so
     // that constructors know whether they need to generate code for
     // runtime type.
     if (element.isGetter() && element.name == Compiler.RUNTIME_TYPE) {
       compiler.enabledRuntimeType = true;
-      compiler.backend.registerRuntimeType();
+      // TODO(ahe): Record precise dependency here.
+      compiler.backend.registerRuntimeType(compiler.globalDependencies);
     } else if (element == compiler.functionApplyMethod) {
       compiler.enabledFunctionApply = true;
     } else if (element == compiler.invokeOnMethod) {
       compiler.enabledInvokeOn = true;
     }
 
     nativeEnqueuer.registerElement(element);
   }
 
   /**
    * Adds [element] to the work list if it has not already been processed.
    *
    * Returns [:true:] if the [element] should be processed.
    */
   // TODO(johnniwinther): Change to 'Returns true if the element was added to
   // the work list'?
   bool addElementToWorkList(Element element, [TreeElements elements]);
 
-  void registerInstantiatedType(InterfaceType type) {
+  void registerInstantiatedType(InterfaceType type, TreeElements elements) {
     ClassElement cls = type.element;
+    elements.registerDependency(cls);
     cls.ensureResolved(compiler);
     universe.instantiatedTypes.add(type);
     if (universe.instantiatedClasses.contains(cls)) return;
     if (!cls.isAbstract(compiler)) {
       universe.instantiatedClasses.add(cls);
     }
     onRegisterInstantiatedClass(cls);
-    compiler.backend.registerInstantiatedClass(cls, this);
+    // We only tell the backend once that [cls] was instantiated, so
+    // any additional dependencies must be treated as global
+    // dependencies.
+    compiler.backend.registerInstantiatedClass(
+        cls, this, compiler.globalDependencies);
   }
 
-  void registerInstantiatedClass(ClassElement cls) {
+  void registerInstantiatedClass(ClassElement cls, TreeElements elements) {
     cls.ensureResolved(compiler);
-    registerInstantiatedType(cls.rawType);
+    registerInstantiatedType(cls.rawType, elements);
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     task.measure(() {
       // Run through the classes and see if we need to compile methods.
       for (ClassElement classElement in universe.instantiatedClasses) {
         for (ClassElement currentClass = classElement;
              currentClass != null;
              currentClass = currentClass.superclass) {
           processInstantiatedClass(currentClass);
@@ skipping 32 matching lines @@
       }
       if (universe.hasInvocation(member, compiler)) {
         return addToWorkList(member);
       }
       // If there is a property access with the same name as a method we
       // need to emit the method.
       if (universe.hasInvokedGetter(member, compiler)) {
         // We will emit a closure, so make sure the closure class is
         // generated.
         compiler.closureClass.ensureResolved(compiler);
-        registerInstantiatedClass(compiler.closureClass);
+        registerInstantiatedClass(compiler.closureClass,
+                                  // Precise dependency is not important here.
+                                  compiler.globalDependencies);
         return addToWorkList(member);
       }
     } else if (member.kind == ElementKind.GETTER) {
       if (universe.hasInvokedGetter(member, compiler)) {
         return addToWorkList(member);
       }
       // We don't know what selectors the returned closure accepts. If
       // the set contains any selector we have to assume that it matches.
       if (universe.hasInvocation(member, compiler)) {
         return addToWorkList(member);
@@ skipping 194 matching lines @@
   }
 
   void registerFieldGetter(Element element) {
     universe.fieldGetters.add(element);
   }
 
   void registerFieldSetter(Element element) {
     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);
-    compiler.backend.registerAsCheck(type);
+  void registerAsCheck(DartType type, TreeElements elements) {
+    registerIsCheck(type, elements);
+    compiler.backend.registerAsCheck(type, elements);
   }
 
   void forEach(f(WorkItem work));
 
   void logSummary(log(message)) {
     _logSpecificSummary(log);
     nativeEnqueuer.logSummary(log);
   }
 
   /// Log summary specific to the concrete enqueuer.
@@ skipping 24 matching lines @@
 
   bool isProcessed(Element member) => resolvedElements.containsKey(member);
 
   TreeElements getCachedElements(Element element) {
     // TODO(ngeoffray): Get rid of this check.
     if (element.enclosingElement.isClosure()) {
       closureMapping.ClosureClassElement cls = element.enclosingElement;
       element = cls.methodElement;
     }
     Element owner = element.getOutermostEnclosingMemberOrTopLevel();
+    if (owner == null) {
+      owner = element;
+    }
     return resolvedElements[owner.declaration];
   }
 
   /**
    * Sets the resolved elements of [element] to [elements], or if [elements] is
    * [:null:], to the elements found through [getCachedElements].
    *
    * Returns the resolved elements.
    */
   TreeElements ensureCachedElements(Element element, TreeElements elements) {
@@ skipping 35 matching lines @@
           enableIsolateSupport(library);
         }
       }
     }
 
     return true;
   }
 
   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);
+    compiler.globalDependencies.registerDependency(startRootIsolate);
     addToWorkList(compiler.isolateHelperLibrary.find(
         const SourceString('_currentIsolate')));
     addToWorkList(compiler.isolateHelperLibrary.find(
         const SourceString('_callInIsolate')));
   }
 
   void enableNoSuchMethod(Element element) {
     if (compiler.enabledNoSuchMethod) return;
     if (element.getEnclosingClass() == compiler.objectClass) return;
     Selector selector = new Selector.noSuchMethod();
@@ skipping 54 matching lines @@
     while(!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for codegen.
       f(queue.removeLast());
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }