Move registering to the enqueuer.

dart/lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 165 matching lines @@
 
   // Records a block-information that is being handled specially.
   // Used to break bad recursion.
   HBlockInformation currentBlockInformation;
   // The subgraph is used to delimit traversal for some constructions, e.g.,
   // if branches.
   SubGraph subGraph;
 
   LibraryElement get currentLibrary() => work.element.getLibrary();
   Compiler get compiler() => backend.compiler;
+  Enqueuer get world() => backend.compiler.enqueuer.codegen;
 
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
   }
 
   SsaCodeGenerator(this.backend,
                    this.work,
                    this.parameters,
                    this.parameterNames)
     : names = new Map<int, String>(),
@@ skipping 1275 matching lines @@
       // SsaBuilder.buildFactory. Is there a cleaner way to do this?
       node.name.printOn(buffer);
       visitArguments(node.inputs);
     } else {
       buffer.add(compiler.namer.instanceMethodInvocationName(
           currentLibrary, node.name, node.selector));
       visitArguments(node.inputs);
       if (node.element !== null) {
         // If we know we're calling a specific method, register that
         // method only.
-        compiler.registerDynamicInvocationOf(node.element);
+        world.registerDynamicInvocationOf(node.element);
       } else {
-        compiler.registerDynamicInvocation(
+        world.registerDynamicInvocation(
             node.name, getOptimizedSelectorFor(node, node.selector));
       }
     }
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   Selector getOptimizedSelectorFor(HInvoke node, Selector defaultSelector) {
     Type receiverType = node.inputs[0].propagatedType.computeType(compiler);
     if (receiverType !== null) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(compiler.namer.setterName(currentLibrary, node.name));
     visitArguments(node.inputs);
-    compiler.registerDynamicSetter(
+    world.registerDynamicSetter(
         node.name, getOptimizedSelectorFor(node, Selector.SETTER));
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(compiler.namer.getterName(currentLibrary, node.name));
     visitArguments(node.inputs);
-    compiler.registerDynamicGetter(
+    world.registerDynamicGetter(
         node.name, getOptimizedSelectorFor(node, Selector.GETTER));
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(compiler.namer.closureInvocationName(node.selector));
     visitArguments(node.inputs);
     // TODO(floitsch): we should have a separate list for closure invocations.
-    compiler.registerDynamicInvocation(Namer.CLOSURE_INVOCATION_NAME,
-                                       node.selector);
+    world.registerDynamicInvocation(Namer.CLOSURE_INVOCATION_NAME,
+                                    node.selector);
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.target, JSPrecedence.CALL_PRECEDENCE);
     visitArguments(node.inputs);
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
@@ skipping 12 matching lines @@
       visitArguments(node.inputs);
     } else if (superMethod.kind == ElementKind.FIELD) {
       buffer.add('this.${compiler.namer.getName(superMethod)}');
     } else {
       assert(superMethod.kind == ElementKind.GETTER);
       String methodName =
           compiler.namer.getterName(currentLibrary, superMethod.name);
       buffer.add('$className.prototype.$methodName.call()');
     }
     endExpression(JSPrecedence.CALL_PRECEDENCE);
-    compiler.registerStaticUse(superMethod);
+    world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
     if (node.receiver !== null) {
       String name =
           compiler.namer.instanceFieldName(currentLibrary, node.name);
       beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
       use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
       buffer.add('.');
       buffer.add(name);
@@ skipping 233 matching lines @@
       use(node.value, JSPrecedence.EQUALITY_PRECEDENCE);
       buffer.add(' !== (');
       use(node.value, JSPrecedence.BITWISE_OR_PRECEDENCE);
       buffer.add(" | 0)) ");
     }
     generateThrowWithHelper('iae', node.value);
   }
 
   void generateThrowWithHelper(String helperName, HInstruction argument) {
     Element helper = compiler.findHelper(new SourceString(helperName));
-    compiler.registerStaticUse(helper);
+    world.registerStaticUse(helper);
     buffer.add('throw ');
     beginExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     buffer.add(compiler.namer.isolateAccess(helper));
     visitArguments([null, argument]);
     endExpression(JSPrecedence.CALL_PRECEDENCE);
     endExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
   }
 
   void addIndentation() {
     for (int i = 0; i < indent; i++) {
       buffer.add('  ');
     }
   }
 
   void addIndented(String text) {
     addIndentation();
     buffer.add(text);
   }
 
   void visitStatic(HStatic node) {
-    compiler.registerStaticUse(node.element);
+    world.registerStaticUse(node.element);
     buffer.add(compiler.namer.isolateAccess(node.element));
   }
 
   void visitStaticStore(HStaticStore node) {
-    compiler.registerStaticUse(node.element);
+    world.registerStaticUse(node.element);
     beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
     buffer.add(compiler.namer.isolateAccess(node.element));
     buffer.add(' = ');
     use(node.inputs[0], JSPrecedence.ASSIGNMENT_PRECEDENCE);
     endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
   }
 
   void visitLiteralList(HLiteralList node) {
     generateArrayLiteral(node);
   }
@@ skipping 242 matching lines @@
   }
 
   void visitIs(HIs node) {
     Type type = node.typeExpression;
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables", instruction: node);
     } else if (element.kind === ElementKind.TYPEDEF) {
       compiler.unimplemented("visitIs for typedefs", instruction: node);
     }
-    compiler.registerIsCheck(type.element);
+    world.registerIsCheck(type.element);
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = compiler.objectClass;
     HInstruction input = node.expression;
 
     if (node.nullOk) {
       beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
       checkNull(input);
       buffer.add(' || ');
     }
     if (element === objectClass || element === compiler.dynamicClass) {
@@ skipping 46 matching lines @@
       });
     }
     if (node.nullOk) {
       endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     }
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.checked) {
       Element element = node.type.computeType(compiler).element;
-      compiler.registerIsCheck(element);
+      world.registerIsCheck(element);
       SourceString helper;
       String additionalArgument;
       bool nativeCheck =
           backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
       beginExpression(JSPrecedence.CALL_PRECEDENCE);
 
       if (element == compiler.stringClass) {
         helper = const SourceString('stringTypeCheck');
       } else if (element == compiler.doubleClass) {
         helper = const SourceString('doubleTypeCheck');
@@ skipping 21 matching lines @@
           } else {
             helper = const SourceString('listSuperTypeCheck');
           }
         } else if (nativeCheck) {
           helper = const SourceString('callTypeCheck');
         } else {
           helper = const SourceString('propertyTypeCheck');
         }
       }
       Element helperElement = compiler.findHelper(helper);
-      compiler.registerStaticUse(helperElement);
+      world.registerStaticUse(helperElement);
       buffer.add(compiler.namer.isolateAccess(helperElement));
       buffer.add('(');
       use(node.checkedInput, JSPrecedence.EXPRESSION_PRECEDENCE);
       if (additionalArgument !== null) buffer.add(", '$additionalArgument'");
       buffer.add(')');
       endExpression(JSPrecedence.CALL_PRECEDENCE);
     } else {
       use(node.checkedInput, expectedPrecedence);
     }
   }
@@ skipping 395 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }