Split interceptor emitter.

sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.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 dart2js.js_emitter;
 
 const USE_NEW_EMITTER = const bool.fromEnvironment("dart2js.use.new.emitter");
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
   // TODO(floitsch): the code-emitter task should not need a namer.
   final Namer namer;
   final TypeTestEmitter typeTestEmitter = new TypeTestEmitter();
-  final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
   NativeEmitter nativeEmitter;
   OldEmitter oldEmitter;
   Emitter emitter;
 
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
   final Map<OutputUnit, List<ClassElement>> outputClassLists =
       new Map<OutputUnit, List<ClassElement>>();
   final Map<OutputUnit, List<Constant>> outputConstantLists =
       new Map<OutputUnit, List<Constant>>();
   final List<ClassElement> nativeClasses = <ClassElement>[];
@@ skipping 10 matching lines @@
 
   CodeEmitterTask(Compiler compiler, Namer namer, bool generateSourceMap)
       : super(compiler),
         this.namer = namer {
     oldEmitter = new OldEmitter(compiler, namer, generateSourceMap, this);
     emitter = USE_NEW_EMITTER
         ? new new_js_emitter.Emitter(compiler, namer, generateSourceMap, this)
         : oldEmitter;
     nativeEmitter = new NativeEmitter(this);
     typeTestEmitter.emitter = this.oldEmitter;
-    interceptorEmitter.emitter = this.oldEmitter;
     // TODO(18886): Remove this call (and the show in the import) once the
     // memory-leak in the VM is fixed.
     templateManager.clear();
   }
 
 
   jsAst.Expression generateEmbeddedGlobalAccess(String global) {
     return emitter.generateEmbeddedGlobalAccess(global);
   }
 
   jsAst.Expression constantReference(Constant value) {
     return emitter.constantReference(value);
   }
 
+  Set<ClassElement> interceptorsReferencedFromConstants() {

[floitsch, 2014/09/24 14:02:06]

Straight copy from `interceptor_emitter.dart`.

+    Set<ClassElement> classes = new Set<ClassElement>();
+    JavaScriptConstantCompiler handler = backend.constants;
+    List<Constant> constants = handler.getConstantsForEmission();
+    for (Constant constant in constants) {
+      if (constant is InterceptorConstant) {
+        InterceptorConstant interceptorConstant = constant;
+        classes.add(interceptorConstant.dispatchedType.element);
+      }
+    }
+    return classes;
+  }
+
   /**
    * Return a function that returns true if its argument is a class
    * that needs to be emitted.
    */
   Function computeClassFilter() {
     if (backend.isTreeShakingDisabled) return (ClassElement cls) => true;
 
     Set<ClassElement> unneededClasses = new Set<ClassElement>();
     // The [Bool] class is not marked as abstract, but has a factory
     // constructor that always throws. We never need to emit it.
     unneededClasses.add(compiler.boolClass);
 
     // Go over specialized interceptors and then constants to know which
     // interceptors are needed.
     Set<ClassElement> needed = new Set<ClassElement>();
     backend.specializedGetInterceptors.forEach(
         (_, Iterable<ClassElement> elements) {
           needed.addAll(elements);
         }
     );
 
     // Add interceptors referenced by constants.
-    needed.addAll(interceptorEmitter.interceptorsReferencedFromConstants());
+    needed.addAll(interceptorsReferencedFromConstants());
 
     // Add unneeded interceptors to the [unneededClasses] set.
     for (ClassElement interceptor in backend.interceptedClasses) {
       if (!needed.contains(interceptor)
           && interceptor != compiler.objectClass) {
         unneededClasses.add(interceptor);
       }
     }
 
     // These classes are just helpers for the backend's type system.
@@ skipping 176 matching lines @@
 }
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
 
   final ContainerBuilder containerBuilder = new ContainerBuilder();
   final ClassEmitter classEmitter = new ClassEmitter();
   final NsmEmitter nsmEmitter = new NsmEmitter();
   TypeTestEmitter get typeTestEmitter => task.typeTestEmitter;
-  InterceptorEmitter get interceptorEmitter => task.interceptorEmitter;
+  final InterceptorEmitter interceptorEmitter = new InterceptorEmitter();
   final MetadataEmitter metadataEmitter = new MetadataEmitter();
 
   final Set<Constant> cachedEmittedConstants;
   final CodeBuffer cachedEmittedConstantsBuffer = new CodeBuffer();
   final Map<Element, ClassBuilder> cachedClassBuilders;
   final Set<Element> cachedElements;
 
   bool needsDefineClass = false;
   bool needsMixinSupport = false;
   bool needsLazyInitializer = false;
@@ skipping 1875 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }