Create Namer and Emitter on codegen start.

pkg/compiler/lib/src/js_emitter/class_stub_generator.dart

 // Copyright (c) 2014, 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.js_emitter;
 
 class ClassStubGenerator {
   final Namer namer;
-  final Compiler compiler;
   final JavaScriptBackend backend;
+  final CodegenWorldBuilder codegenWorld;
+  final ClosedWorld closedWorld;
+  final bool enableMinification;
 
-  ClassStubGenerator(this.compiler, this.namer, this.backend);
+  ClassStubGenerator(
+      this.namer, this.backend, this.codegenWorld, this.closedWorld,
+      {this.enableMinification});
 
   jsAst.Expression generateClassConstructor(ClassElement classElement,
       Iterable<jsAst.Name> fields, bool hasRtiField) {
     // TODO(sra): Implement placeholders in VariableDeclaration position:
     //
     //     String constructorName = namer.getNameOfClass(classElement);
     //     return js.statement('function #(#) { #; }',
     //        [ constructorName, fields,
     //            fields.map(
     //                (name) => js('this.# = #', [name, name]))]));
@@ skipping 63 matching lines @@
     Map<jsAst.Name, jsAst.Expression> generatedStubs =
         <jsAst.Name, jsAst.Expression>{};
 
     // Two selectors may match but differ only in type.  To avoid generating
     // identical stubs for each we track untyped selectors which already have
     // stubs.
     Set<Selector> generatedSelectors = new Set<Selector>();
     for (Selector selector in selectors.keys) {
       if (generatedSelectors.contains(selector)) continue;
       if (!selector.appliesUnnamed(member)) continue;
-      if (selectors[selector].applies(member, selector, compiler.closedWorld)) {
+      if (selectors[selector].applies(member, selector, closedWorld)) {
         generatedSelectors.add(selector);
 
         jsAst.Name invocationName = namer.invocationName(selector);
         Selector callSelector = new Selector.callClosureFrom(selector);
         jsAst.Name closureCallName = namer.invocationName(callSelector);
 
         List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
         List<jsAst.Expression> arguments = <jsAst.Expression>[];
         if (isInterceptedMethod) {
           parameters.add(new jsAst.Parameter(receiverArgumentName));
@@ skipping 12 matching lines @@
       }
     }
 
     return generatedStubs;
   }
 
   Map<jsAst.Name, Selector> computeSelectorsForNsmHandlers() {
     Map<jsAst.Name, Selector> jsNames = <jsAst.Name, Selector>{};
 
     // Do not generate no such method handlers if there is no class.
-    if (compiler.codegenWorld.directlyInstantiatedClasses.isEmpty) {
+    if (codegenWorld.directlyInstantiatedClasses.isEmpty) {
       return jsNames;
     }
 
     void addNoSuchMethodHandlers(
         String ignore, Map<Selector, SelectorConstraints> selectors) {
       for (Selector selector in selectors.keys) {
         SelectorConstraints maskSet = selectors[selector];
-        if (maskSet.needsNoSuchMethodHandling(selector, compiler.closedWorld)) {
+        if (maskSet.needsNoSuchMethodHandling(selector, closedWorld)) {
           jsAst.Name jsName = namer.invocationMirrorInternalName(selector);
           jsNames[jsName] = selector;
         }
       }
     }
 
-    compiler.codegenWorld.forEachInvokedName(addNoSuchMethodHandlers);
-    compiler.codegenWorld.forEachInvokedGetter(addNoSuchMethodHandlers);
-    compiler.codegenWorld.forEachInvokedSetter(addNoSuchMethodHandlers);
+    codegenWorld.forEachInvokedName(addNoSuchMethodHandlers);
+    codegenWorld.forEachInvokedGetter(addNoSuchMethodHandlers);
+    codegenWorld.forEachInvokedSetter(addNoSuchMethodHandlers);
     return jsNames;
   }
 
   StubMethod generateStubForNoSuchMethod(jsAst.Name name, Selector selector) {
     // Values match JSInvocationMirror in js-helper library.
     int type = selector.invocationMirrorKind;
     List<String> parameterNames =
         new List.generate(selector.argumentCount, (i) => '\$$i');
 
     List<jsAst.Expression> argNames = selector.callStructure
@@ skipping 11 matching lines @@
                     #createInvocationMirror(#methodName,
                                             #internalName,
                                             #type,
                                             #arguments,
                                             #namedArguments))''',
         {
           'receiver': isIntercepted ? r'$receiver' : 'this',
           'noSuchMethodName': namer.noSuchMethodName,
           'createInvocationMirror': backend.emitter
               .staticFunctionAccess(backend.helpers.createInvocationMirror),
-          'methodName': js.quoteName(
-              compiler.options.enableMinification ? internalName : methodName),
+          'methodName':
+              js.quoteName(enableMinification ? internalName : methodName),
           'internalName': js.quoteName(internalName),
           'type': js.number(type),
           'arguments':
               new jsAst.ArrayInitializer(parameterNames.map(js).toList()),
           'namedArguments': new jsAst.ArrayInitializer(argNames)
         });
 
     jsAst.Expression function;
     if (isIntercepted) {
       function = js(
@@ skipping 100 matching lines @@
               if (cache === void 0) cache = #tearOff(
                   this, funcs, reflectionInfo, true, [], name).prototype;
               return cache;
             }
           : tearOffGetter(funcs, reflectionInfo, name, isIntercepted);
     }''',
       {'tearOff': tearOffAccessExpression});
 
   return <jsAst.Statement>[tearOffGetter, tearOff];
 }