Create Namer and Emitter on codegen start.

pkg/compiler/lib/src/js_emitter/full_emitter/emitter.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.full_emitter;
 
 import 'dart:collection' show HashMap;
 import 'dart:convert';
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
@@ skipping 34 matching lines @@
         CompoundName,
         ConstantEmitter,
         GetterName,
         JavaScriptBackend,
         JavaScriptConstantCompiler,
         Namer,
         SetterName,
         TypeVariableHandler;
 import '../../universe/call_structure.dart' show CallStructure;
 import '../../universe/selector.dart' show Selector;
+import '../../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../../util/characters.dart' show $$, $A, $HASH, $Z, $a, $z;
 import '../../util/uri_extras.dart' show relativize;
 import '../../util/util.dart' show equalElements;
+import '../../world.dart' show ClosedWorld;
 import '../constant_ordering.dart' show deepCompareConstants;
 import '../headers.dart';
-import '../js_emitter.dart' hide Emitter;
-import '../js_emitter.dart' as js_emitter show Emitter;
+import '../js_emitter.dart' hide Emitter, EmitterFactory;
+import '../js_emitter.dart' as js_emitter show Emitter, EmitterFactory;
 import '../model.dart';
 import '../program_builder/program_builder.dart';
 
 part 'class_builder.dart';
 part 'class_emitter.dart';
 part 'code_emitter_helper.dart';
 part 'container_builder.dart';
 part 'declarations.dart';
 part 'deferred_output_unit_hash.dart';
 part 'interceptor_emitter.dart';
 part 'nsm_emitter.dart';
 part 'setup_program_builder.dart';
 
+class EmitterFactory implements js_emitter.EmitterFactory {
+  final bool generateSourceMap;
+
+  EmitterFactory({this.generateSourceMap});
+
+  @override
+  String get patchVersion => "full";
+
+  @override
+  bool get supportsReflection => true;
+
+  @override
+  Emitter createEmitter(
+      CodeEmitterTask task, Namer namer, ClosedWorld closedWorld) {
+    return new Emitter(
+        task.compiler, namer, closedWorld, generateSourceMap, task);
+  }
+}
+
 class Emitter implements js_emitter.Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   // The following fields will be set to copies of the program-builder's
   // collector.
   Map<OutputUnit, List<VariableElement>> outputStaticNonFinalFieldLists;
   Map<OutputUnit, Set<LibraryElement>> outputLibraryLists;
   List<TypedefElement> typedefsNeededForReflection;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
-  final ClassEmitter classEmitter = new ClassEmitter();
-  final NsmEmitter nsmEmitter = new NsmEmitter();
-  final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
+  final ClassEmitter classEmitter;
+  final NsmEmitter nsmEmitter;
+  final InterceptorEmitter interceptorEmitter;
 
   // TODO(johnniwinther): Wrap these fields in a caching strategy.
   final Set<ConstantValue> cachedEmittedConstants;
   final List<jsAst.Statement> cachedEmittedConstantsAst = <jsAst.Statement>[];
   final Map<Element, ClassBuilder> cachedClassBuilders;
   final Set<Element> cachedElements;
 
   bool needsClassSupport = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
@@ skipping 48 matching lines @@
    *
    * See [getElementDescriptor].
    */
   // TODO(ahe): Generate statics with their class, and store only libraries in
   // this map.
   final Map<Fragment, Map<Element, ClassBuilder>> elementDescriptors =
       new Map<Fragment, Map<Element, ClassBuilder>>();
 
   final bool generateSourceMap;
 
-  Emitter(Compiler compiler, Namer namer, this.generateSourceMap, this.task)
+  Emitter(Compiler compiler, Namer namer, ClosedWorld closedWorld,
+      this.generateSourceMap, this.task)
       : this.compiler = compiler,
         this.namer = namer,
         cachedEmittedConstants = compiler.cacheStrategy.newSet(),
         cachedClassBuilders = compiler.cacheStrategy.newMap(),
-        cachedElements = compiler.cacheStrategy.newSet() {
+        cachedElements = compiler.cacheStrategy.newSet(),
+        classEmitter = new ClassEmitter(closedWorld),
+        interceptorEmitter = new InterceptorEmitter(closedWorld),
+        nsmEmitter = new NsmEmitter(closedWorld) {
     constantEmitter = new ConstantEmitter(
         compiler, namer, this.constantReference, constantListGenerator);
     containerBuilder.emitter = this;
     classEmitter.emitter = this;
     nsmEmitter.emitter = this;
     interceptorEmitter.emitter = this;
+    if (compiler.options.hasIncrementalSupport) {
+      // Much like a scout, an incremental compiler is always prepared. For
+      // mixins, classes, and lazy statics, at least.
+      needsClassSupport = true;
+      needsMixinSupport = true;
+      needsLazyInitializer = true;
+      needsStructuredMemberInfo = true;
+    }
   }
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   List<jsAst.Node> cspPrecompiledFunctionFor(OutputUnit outputUnit) {
     return _cspPrecompiledFunctions.putIfAbsent(
         outputUnit, () => new List<jsAst.Node>());
   }
 
   List<jsAst.Expression> cspPrecompiledConstructorNamesFor(
       OutputUnit outputUnit) {
     return _cspPrecompiledConstructorNames.putIfAbsent(
         outputUnit, () => new List<jsAst.Expression>());
   }
 
   /// Erases the precompiled information for csp mode for all output units.
   /// Used by the incremental compiler.
   void clearCspPrecompiledNodes() {
     _cspPrecompiledFunctions.clear();
     _cspPrecompiledConstructorNames.clear();
   }
 
   @override
-  String get patchVersion => "full";
-
-  @override
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
     if (constant.isFunction) return true; // Already emitted.
     if (constant.isPrimitive) return true; // Inlined.
     if (constant.isDummy) return true; // Inlined.
     // The name is null when the constant is already a JS constant.
     // TODO(floitsch): every constant should be registered, so that we can
     // share the ones that take up too much space (like some strings).
     if (namer.constantName(constant) == null) return true;
     return false;
   }
@@ skipping 61 matching lines @@
   static const String FIELD_NAMES_PROPERTY_NAME = r"$__fields__";
 
   /// For deferred loading we communicate the initializers via this global var.
   final String deferredInitializers = r"$dart_deferred_initializers$";
 
   /// Contains the global state that is needed to initialize and load a
   /// deferred library.
   String get globalsHolder => r"$globals$";
 
   @override
-  bool get supportsReflection => true;
-
-  @override
   jsAst.Expression generateEmbeddedGlobalAccess(String global) {
     return js(generateEmbeddedGlobalAccessString(global));
   }
 
   String generateEmbeddedGlobalAccessString(String global) {
     // TODO(floitsch): don't use 'init' as global embedder storage.
     return '$initName.$global';
   }
 
   jsAst.PropertyAccess globalPropertyAccess(Element element) {
@@ skipping 1863 matching lines @@
     if (cachedElements.isEmpty) return;
     for (Element element in backend.codegenEnqueuer.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
       }
     }
   }
 }