Create Namer and Emitter on codegen start.

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.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.
 
 library dart2js.js_emitter.program_builder;
 
 import '../../closure.dart' show ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../compiler.dart' show Compiler;
@@ skipping 16 matching lines @@
         ParameterElement,
         TypedefElement,
         VariableElement;
 import '../../js/js.dart' as js;
 import '../../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../../js_backend/js_backend.dart'
     show Namer, JavaScriptBackend, JavaScriptConstantCompiler, StringBackedName;
 import '../../universe/selector.dart' show Selector;
 import '../../universe/world_builder.dart'
     show CodegenWorldBuilder, SelectorConstraints;
+import '../../world.dart' show ClosedWorld;
 import '../js_emitter.dart'
     show
         ClassStubGenerator,
         CodeEmitterTask,
         computeMixinClass,
         Emitter,
         InterceptorStubGenerator,
         MainCallStubGenerator,
         ParameterStubGenerator,
         RuntimeTypeGenerator,
         TypeTestProperties;
 import '../model.dart';
 
 part 'collector.dart';
 part 'field_visitor.dart';
 part 'registry.dart';
 
 /// Builds a self-contained representation of the program that can then be
 /// emitted more easily by the individual emitters.
 class ProgramBuilder {
   final Compiler _compiler;
   final Namer namer;
   final CodeEmitterTask _task;
+  final ClosedWorld closedWorld;
 
   /// Contains the collected information the program builder used to build
   /// the model.
   // The collector will be filled on the first call to `buildProgram`.
   // It is stored and publicly exposed for backwards compatibility. New code
   // (and in particular new emitters) should not use it.
   final Collector collector;
 
   final Registry _registry;
 
   /// True if the program should store function types in the metadata.
   bool _storeFunctionTypesInMetadata = false;
 
   ProgramBuilder(Compiler compiler, Namer namer, this._task, Emitter emitter,
-      Set<ClassElement> rtiNeededClasses)
+      ClosedWorld closedWorld, Set<ClassElement> rtiNeededClasses)
       : this._compiler = compiler,
         this.namer = namer,
-        this.collector =
-            new Collector(compiler, namer, rtiNeededClasses, emitter),
+        this.closedWorld = closedWorld,
+        this.collector = new Collector(
+            compiler, namer, closedWorld, rtiNeededClasses, emitter),
         this._registry = new Registry(compiler);
 
   JavaScriptBackend get backend => _compiler.backend;
   BackendHelpers get helpers => backend.helpers;
   CodegenWorldBuilder get universe => _compiler.codegenWorld;
 
   /// Mapping from [ClassElement] to constructed [Class]. We need this to
   /// update the superclass in the [Class].
   final Map<ClassElement, Class> _classes = <ClassElement, Class>{};
 
@@ skipping 109 matching lines @@
         .forEach((String loadId, List<OutputUnit> outputUnits) {
       loadMap[loadId] = outputUnits
           .map((OutputUnit unit) => _outputs[unit])
           .toList(growable: false);
     });
     return loadMap;
   }
 
   js.Expression _buildTypeToInterceptorMap() {
     InterceptorStubGenerator stubGenerator =
-        new InterceptorStubGenerator(_compiler, namer, backend);
+        new InterceptorStubGenerator(_compiler, namer, backend, closedWorld);
     return stubGenerator.generateTypeToInterceptorMap();
   }
 
   MainFragment _buildMainFragment(LibrariesMap librariesMap) {
     // Construct the main output from the libraries and the registered holders.
     MainFragment result = new MainFragment(
         librariesMap.outputUnit,
         "", // The empty string is the name for the main output file.
         _buildInvokeMain(),
         _buildLibraries(librariesMap),
@@ skipping 291 matching lines @@
     bool hasRtiField = backend.classNeedsRtiField(element);
     if (backend.isJsInterop(element)) {
       // TODO(jacobr): check whether the class has any active static fields
       // if it does not we can suppress it completely.
       onlyForRti = true;
     }
 
     List<Method> methods = [];
     List<StubMethod> callStubs = <StubMethod>[];
 
-    ClassStubGenerator classStubGenerator =
-        new ClassStubGenerator(_compiler, namer, backend);
+    ClassStubGenerator classStubGenerator = new ClassStubGenerator(
+        namer, backend, universe, closedWorld,
+        enableMinification: _compiler.options.enableMinification);
     RuntimeTypeGenerator runtimeTypeGenerator =
         new RuntimeTypeGenerator(_compiler, _task, namer);
 
     void visitMember(ClassElement enclosing, Element member) {
       assert(invariant(element, member.isDeclaration));
       assert(invariant(element, element == enclosing));
 
       if (Elements.isNonAbstractInstanceMember(member)) {
         // TODO(herhut): Remove once _buildMethod can no longer return null.
         Method method = _buildMethod(member);
@@ skipping 137 matching lines @@
 
   bool _methodCanBeReflected(FunctionElement method) {
     return backend.isAccessibleByReflection(method) ||
         // During incremental compilation, we have to assume that reflection
         // *might* get enabled.
         _compiler.options.hasIncrementalSupport;
   }
 
   bool _methodCanBeApplied(FunctionElement method) {
     return backend.hasFunctionApplySupport &&
-        _compiler.closedWorld.getMightBePassedToApply(method);
+        closedWorld.getMightBePassedToApply(method);
   }
 
   // TODO(herhut): Refactor incremental compilation and remove method.
   Method buildMethodHackForIncrementalCompilation(FunctionElement element) {
     assert(_compiler.options.hasIncrementalSupport);
     if (element.isInstanceMember) {
       return _buildMethod(element);
     } else {
       return _buildStaticMethod(element);
     }
@@ skipping 39 matching lines @@
         : null;
 
     if (isNotApplyTarget) {
       canTearOff = false;
     } else {
       if (element.enclosingClass.isClosure) {
         canTearOff = false;
         isClosureCallMethod = true;
       } else {
         // Careful with operators.
-        canTearOff =
-            universe.hasInvokedGetter(element, _compiler.closedWorld) ||
-                (canBeReflected && !element.isOperator);
+        canTearOff = universe.hasInvokedGetter(element, closedWorld) ||
+            (canBeReflected && !element.isOperator);
         assert(canTearOff ||
             !universe.methodsNeedingSuperGetter.contains(element));
         tearOffName = namer.getterForElement(element);
       }
     }
 
     if (canTearOff) {
       assert(invariant(element, !element.isGenerativeConstructor));
       assert(invariant(element, !element.isGenerativeConstructorBody));
       assert(invariant(element, !element.isConstructor));
@@ skipping 54 matching lines @@
       return backend.emitter.metadataCollector
           .reifyTypeForOutputUnit(type, outputUnit);
     }
   }
 
   List<ParameterStubMethod> _generateParameterStubs(
       MethodElement element, bool canTearOff) {
     if (!_methodNeedsStubs(element)) return const <ParameterStubMethod>[];
 
     ParameterStubGenerator generator =
-        new ParameterStubGenerator(_compiler, namer, backend);
+        new ParameterStubGenerator(_compiler, namer, backend, closedWorld);
     return generator.generateParameterStubs(element, canTearOff: canTearOff);
   }
 
   /// Builds a stub method.
   ///
   /// Stub methods may have an element that can be used for code-size
   /// attribution.
   Method _buildStubMethod(js.Name name, js.Expression code, {Element element}) {
     return new StubMethod(name, code, element: element);
   }
 
   // The getInterceptor methods directly access the prototype of classes.
   // We must evaluate these classes eagerly so that the prototype is
   // accessible.
   void _markEagerInterceptorClasses() {
     Map<js.Name, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     for (Set<ClassElement> classes in specializedGetInterceptors.values) {
       for (ClassElement element in classes) {
         Class cls = _classes[element];
         if (cls != null) cls.isEager = true;
       }
     }
   }
 
   Iterable<StaticStubMethod> _generateGetInterceptorMethods() {
     InterceptorStubGenerator stubGenerator =
-        new InterceptorStubGenerator(_compiler, namer, backend);
+        new InterceptorStubGenerator(_compiler, namer, backend, closedWorld);
 
     String holderName = namer.globalObjectFor(helpers.interceptorsLibrary);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // generating the interceptor methods.
     Holder holder = _registry.registerHolder(holderName);
 
     Map<js.Name, Set<ClassElement>> specializedGetInterceptors =
         backend.specializedGetInterceptors;
     List<js.Name> names = specializedGetInterceptors.keys.toList()..sort();
     return names.map((js.Name name) {
       Set<ClassElement> classes = specializedGetInterceptors[name];
       js.Expression code = stubGenerator.generateGetInterceptorMethod(classes);
       return new StaticStubMethod(name, holder, code);
     });
   }
 
   List<Field> _buildFields(Element holder, bool visitStatics) {
     List<Field> fields = <Field>[];
-    new FieldVisitor(_compiler, namer).visitFields(holder, visitStatics,
-        (VariableElement field, js.Name name, js.Name accessorName,
-            bool needsGetter, bool needsSetter, bool needsCheckedSetter) {
+    new FieldVisitor(_compiler, namer, closedWorld)
+        .visitFields(holder, visitStatics, (VariableElement field,
+            js.Name name,
+            js.Name accessorName,
+            bool needsGetter,
+            bool needsSetter,
+            bool needsCheckedSetter) {
       assert(invariant(field, field.isDeclaration));
 
       int getterFlags = 0;
       if (needsGetter) {
         if (visitStatics || !backend.fieldHasInterceptedGetter(field)) {
           getterFlags = 1;
         } else {
           getterFlags += 2;
           // TODO(sra): 'isInterceptorClass' might not be the correct test
           // for methods forced to use the interceptor convention because
@@ skipping 18 matching lines @@
 
       fields.add(new Field(field, name, accessorName, getterFlags, setterFlags,
           needsCheckedSetter));
     });
 
     return fields;
   }
 
   Iterable<StaticStubMethod> _generateOneShotInterceptors() {
     InterceptorStubGenerator stubGenerator =
-        new InterceptorStubGenerator(_compiler, namer, backend);
+        new InterceptorStubGenerator(_compiler, namer, backend, closedWorld);
 
     String holderName = namer.globalObjectFor(helpers.interceptorsLibrary);
     // TODO(floitsch): we shouldn't update the registry in the middle of
     // generating the interceptor methods.
     Holder holder = _registry.registerHolder(holderName);
 
     List<js.Name> names = backend.oneShotInterceptors.keys.toList()..sort();
     return names.map((js.Name name) {
       js.Expression code = stubGenerator.generateOneShotInterceptor(name);
       return new StaticStubMethod(name, holder, code);
@@ skipping 66 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }