Record dependency information to implement first version of dependency

dart/sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 834 matching lines @@
   void addInterceptors(ClassElement cls, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       cls.ensureResolved(compiler);
       cls.forEachMember((ClassElement classElement, Element member) {
           Set<Element> set = interceptedElements.putIfAbsent(
               member.name, () => new Set<Element>());
           set.add(member);
         },
         includeSuperMembers: true);
     }
-    enqueuer.registerInstantiatedClass(cls);
+    // This is a true global dependency.

[kasperl, 2013/03/06 20:39:43]

Extend comment to explain why? You could also add a special method in the
enqueuer for registering these "true global dependencies". That seems better
than have comments in the code.

[ahe, 2013/03/06 20:54:03]

Actually, I need to think more about this.  How many times are we calling
registerInstantiatedClass for the same class?  I think we only call it once, so
I should remove the "elements" parameter from registerInstantiatedClass as well.

+    enqueuer.registerInstantiatedClass(cls, compiler.globalDependencies);
   }
 
   void registerSpecializedGetInterceptor(Set<ClassElement> classes) {
     String name = namer.getInterceptorName(getInterceptorMethod, classes);
     if (classes.contains(compiler.objectClass)) {
       // We can't use a specialized [getInterceptorMethod], so we make
       // sure we emit the one with all checks.
       specializedGetInterceptors[name] = interceptedClasses;
     } else {
       specializedGetInterceptors[name] = classes;
     }
   }
 
   void initializeNoSuchMethod() {
     // In case the emitter generates noSuchMethod calls, we need to
     // make sure all [noSuchMethod] methods know they might take a
     // [JsInvocationMirror] as parameter.
     HTypeList types = new HTypeList(1);
     types[0] = new HType.nonNullExact(
         compiler.jsInvocationMirrorClass.computeType(compiler),
         compiler);
     argumentTypes.registerDynamicInvocation(types, new Selector.noSuchMethod());
   }
 
-  void registerInstantiatedClass(ClassElement cls, Enqueuer enqueuer) {
+  void registerInstantiatedClass(ClassElement cls,
+                                 Enqueuer enqueuer,
+                                 TreeElements elements) {
     if (!seenAnyClass) {
       initializeNoSuchMethod();
       seenAnyClass = true;
     }
 
     // Register any helper that will be needed by the backend.
     if (enqueuer.isResolutionQueue) {
       if (cls == compiler.intClass
           || cls == compiler.doubleClass
           || cls == compiler.numClass) {
         // The backend will try to optimize number operations and use the
         // `iae` helper directly.
         enqueuer.registerStaticUse(
             compiler.findHelper(const SourceString('iae')));
       } else if (cls == compiler.listClass
                  || cls == compiler.stringClass) {
         // The backend will try to optimize array and string access and use the
         // `ioore` and `iae` helpers directly.
         enqueuer.registerStaticUse(
             compiler.findHelper(const SourceString('ioore')));
         enqueuer.registerStaticUse(
             compiler.findHelper(const SourceString('iae')));
       } else if (cls == compiler.functionClass) {
-        enqueuer.registerInstantiatedClass(compiler.closureClass);
+        enqueuer.registerInstantiatedClass(compiler.closureClass, elements);
       } else if (cls == compiler.mapClass) {
         // The backend will use a literal list to initialize the entries
         // of the map.
-        enqueuer.registerInstantiatedClass(compiler.listClass);
-        enqueuer.registerInstantiatedClass(compiler.mapLiteralClass);
-        enqueueInResolution(getMapMaker());
+        enqueuer.registerInstantiatedClass(compiler.listClass, elements);
+        enqueuer.registerInstantiatedClass(compiler.mapLiteralClass, elements);
+        enqueueInResolution(getMapMaker(), elements);
       }
     }
     ClassElement result = null;
     if (cls == compiler.stringClass) {
       addInterceptors(jsStringClass, enqueuer);
     } else if (cls == compiler.listClass) {
       addInterceptors(jsArrayClass, enqueuer);
     } else if (cls == compiler.intClass) {
       addInterceptors(jsIntClass, enqueuer);
       addInterceptors(jsNumberClass, enqueuer);
@@ skipping 11 matching lines @@
       addInterceptors(jsDoubleClass, enqueuer);
       addInterceptors(jsNumberClass, enqueuer);
     } else if (cls == compiler.mapClass) {
     }
 
     if (compiler.enableTypeAssertions) {
       // We need to register is checks for assignments to fields.
       cls.forEachLocalMember((Element member) {
         if (!member.isInstanceMember() || !member.isField()) return;
         DartType type = member.computeType(compiler);
-        enqueuer.registerIsCheck(type);
+        enqueuer.registerIsCheck(type, elements);
       });
     }
   }
 
   JavaScriptItemCompilationContext createItemCompilationContext() {
     return new JavaScriptItemCompilationContext();
   }
 
   void addBackendRtiDependencies(World world) {
     if (jsArrayClass != null) {
       world.registerRtiDependency(jsArrayClass, compiler.listClass);
     }
   }
 
   void enqueueHelpers(ResolutionEnqueuer world) {
     jsIndexingBehaviorInterface =
         compiler.findHelper(const SourceString('JavaScriptIndexingBehavior'));
     if (jsIndexingBehaviorInterface != null) {
-      world.registerIsCheck(jsIndexingBehaviorInterface.computeType(compiler));
+      world.registerIsCheck(jsIndexingBehaviorInterface.computeType(compiler),
+                            // This is a true global dependency.
+                            compiler.globalDependencies);
     }
 
     if (compiler.enableTypeAssertions) {
       // Unconditionally register the helper that checks if the
       // expression in an if/while/for is a boolean.
       // TODO(ngeoffray): Should we have the resolver register those instead?
       Element e =
           compiler.findHelper(const SourceString('boolConversionCheck'));
       if (e != null) world.addToWorkList(e);
     }
   }
 
-  void registerStringInterpolation() {
-    enqueueInResolution(getStringInterpolationHelper());
+  void registerStringInterpolation(TreeElements elements) {
+    enqueueInResolution(getStringInterpolationHelper(), elements);
   }
 
-  void registerCatchStatement() {
-    enqueueInResolution(getExceptionUnwrapper());
+  void registerCatchStatement(TreeElements elements) {
+    enqueueInResolution(getExceptionUnwrapper(), elements);
   }
 
-  void registerThrow() {
-    enqueueInResolution(getThrowHelper());
+  void registerThrow(TreeElements elements) {
+    enqueueInResolution(getThrowHelper(), elements);
   }
 
-  void registerLazyField() {
-    enqueueInResolution(getCyclicThrowHelper());
+  void registerLazyField(TreeElements elements) {
+    enqueueInResolution(getCyclicThrowHelper(), elements);
   }
 
-  void registerTypeLiteral() {
-    enqueueInResolution(getCreateRuntimeType());
+  void registerTypeLiteral(TreeElements elements) {
+    enqueueInResolution(getCreateRuntimeType(), elements);
   }
 
-  void registerStackTraceInCatch() {
-    enqueueInResolution(getTraceFromException());
+  void registerStackTraceInCatch(TreeElements elements) {
+    enqueueInResolution(getTraceFromException(), elements);
   }
 
-  void registerSetRuntimeType() {
-    enqueueInResolution(getSetRuntimeTypeInfo());
+  void registerSetRuntimeType(TreeElements elements) {
+    enqueueInResolution(getSetRuntimeTypeInfo(), elements);
   }
 
-  void registerGetRuntimeTypeArgument() {
-    enqueueInResolution(getGetRuntimeTypeArgument());
+  void registerGetRuntimeTypeArgument(TreeElements elements) {
+    enqueueInResolution(getGetRuntimeTypeArgument(), elements);
   }
 
-  void registerRuntimeType() {
-    enqueueInResolution(getSetRuntimeTypeInfo());
-    enqueueInResolution(getGetRuntimeTypeInfo());
-    enqueueInResolution(getGetRuntimeTypeArgument());
-    compiler.enqueuer.resolution.registerInstantiatedClass(compiler.listClass);
+  void registerRuntimeType(TreeElements elements) {
+    enqueueInResolution(getSetRuntimeTypeInfo(), elements);
+    enqueueInResolution(getGetRuntimeTypeInfo(), elements);
+    enqueueInResolution(getGetRuntimeTypeArgument(), elements);
+    compiler.enqueuer.resolution.registerInstantiatedClass(
+        compiler.listClass, elements);
   }
 
-  void registerIsCheck(DartType type, Enqueuer world) {
+  void registerIsCheck(DartType type, Enqueuer world, TreeElements elements) {
     bool isTypeVariable = type.kind == TypeKind.TYPE_VARIABLE;
     if (!type.isRaw || isTypeVariable) {
-      enqueueInResolution(getSetRuntimeTypeInfo());
-      enqueueInResolution(getGetRuntimeTypeInfo());
-      enqueueInResolution(getGetRuntimeTypeArgument());
-      enqueueInResolution(getCheckArguments());
-      if (isTypeVariable) enqueueInResolution(getGetObjectIsSubtype());
-      world.registerInstantiatedClass(compiler.listClass);
+      enqueueInResolution(getSetRuntimeTypeInfo(), elements);
+      enqueueInResolution(getGetRuntimeTypeInfo(), elements);
+      enqueueInResolution(getGetRuntimeTypeArgument(), elements);
+      enqueueInResolution(getCheckArguments(), elements);
+      if (isTypeVariable) {
+        enqueueInResolution(getGetObjectIsSubtype(), elements);
+      }
+      world.registerInstantiatedClass(compiler.listClass, elements);
     }
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
     if (compiler.enableTypeAssertions) {
       Element e = getCheckedModeHelper(type, typeCast: false);
       if (e != null) world.addToWorkList(e);
       // We also need the native variant of the check (for DOM types).
       e = getNativeCheckedModeHelper(type, typeCast: false);
       if (e != null) world.addToWorkList(e);
     }
   }
 
-  void registerAsCheck(DartType type) {
+  void registerAsCheck(DartType type, TreeElements elements) {
     Element e = getCheckedModeHelper(type, typeCast: true);
-    enqueueInResolution(e);
+    enqueueInResolution(e, elements);
     // We also need the native variant of the check (for DOM types).
     e = getNativeCheckedModeHelper(type, typeCast: true);
-    enqueueInResolution(e);
+    enqueueInResolution(e, elements);
   }
 
-  void registerThrowNoSuchMethod() {
-    enqueueInResolution(getThrowNoSuchMethod());
+  void registerThrowNoSuchMethod(TreeElements elements) {
+    enqueueInResolution(getThrowNoSuchMethod(), elements);
   }
 
-  void registerThrowRuntimeError() {
-    enqueueInResolution(getThrowRuntimeError());
+  void registerThrowRuntimeError(TreeElements elements) {
+    enqueueInResolution(getThrowRuntimeError(), elements);
   }
 
-  void registerAbstractClassInstantiation() {
-    enqueueInResolution(getThrowAbstractClassInstantiationError());
+  void registerAbstractClassInstantiation(TreeElements elements) {
+    enqueueInResolution(getThrowAbstractClassInstantiationError(), elements);
   }
 
-  void registerFallThroughError() {
-    enqueueInResolution(getFallThroughError());
+  void registerFallThroughError(TreeElements elements) {
+    enqueueInResolution(getFallThroughError(), elements);
   }
 
-  void registerSuperNoSuchMethod() {
-    enqueueInResolution(getCreateInvocationMirror());
+  void registerSuperNoSuchMethod(TreeElements elements) {
+    enqueueInResolution(getCreateInvocationMirror(), elements);
     enqueueInResolution(
-        compiler.objectClass.lookupLocalMember(Compiler.NO_SUCH_METHOD));
-    compiler.enqueuer.resolution.registerInstantiatedClass(compiler.listClass);
+        compiler.objectClass.lookupLocalMember(Compiler.NO_SUCH_METHOD),
+        elements);
+    compiler.enqueuer.resolution.registerInstantiatedClass(
+        compiler.listClass, elements);
   }
 
-  void enqueueInResolution(Element e) {
-    if (e != null) compiler.enqueuer.resolution.addToWorkList(e);
+  void enqueueInResolution(Element e, TreeElements elements) {
+    if (e == null) return;
+    ResolutionEnqueuer enqueuer = compiler.enqueuer.resolution;
+    enqueuer.addToWorkList(e);
+    elements.registerBackendDependency(e);
   }
 
-  void registerConstantMap() {
+  void registerConstantMap(TreeElements elements) {
     Element e = compiler.findHelper(const SourceString('ConstantMap'));
-    if (e != null) compiler.enqueuer.resolution.registerInstantiatedClass(e);
+    if (e != null) {
+      compiler.enqueuer.resolution.registerInstantiatedClass(e, elements);
+    }
     e = compiler.findHelper(const SourceString('ConstantProtoMap'));
-    if (e != null) compiler.enqueuer.resolution.registerInstantiatedClass(e);
+    if (e != null) {
+      compiler.enqueuer.resolution.registerInstantiatedClass(e, elements);
+    }
   }
 
   void codegen(CodegenWorkItem work) {
     Element element = work.element;
     if (element.kind.category == ElementCategory.VARIABLE) {
       Constant initialValue = compiler.constantHandler.compileWorkItem(work);
       if (initialValue != null) {
         return;
       } else {
         // If the constant-handler was not able to produce a result we have to
@@ skipping 412 matching lines @@
    *
    * Invariant: [element] must be a declaration element.
    */
   void eagerRecompile(Element element) {
     assert(invariant(element, element.isDeclaration));
     generatedCode.remove(element);
     generatedBailoutCode.remove(element);
     compiler.enqueuer.codegen.addToWorkList(element);
   }
 }