dart2js: move mapTypeToInterceptor generation to interceptor_stub_generator. and rename to typeToIn…

pkg/compiler/lib/src/js_emitter/interceptor_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 InterceptorStubGenerator {
   final Compiler compiler;
   final Namer namer;
   final JavaScriptBackend backend;
 
   InterceptorStubGenerator(this.compiler, this.namer, this.backend);
 
+  Emitter get emitter => backend.emitter.emitter;
+
   jsAst.Expression generateGetInterceptorMethod(Set<ClassElement> classes) {
     jsAst.Expression interceptorFor(ClassElement cls) {
       return backend.emitter.interceptorPrototypeAccess(cls);
     }
 
     /**
      * Build a JavaScrit AST node for doing a type check on
      * [cls]. [cls] must be a non-native interceptor class.
      */
     jsAst.Statement buildInterceptorCheck(ClassElement cls) {
@@ skipping 285 matching lines @@
     jsAst.Statement optimizedPath =
         _fastPathForOneShotInterceptor(selector, classes);
     if (optimizedPath == null) optimizedPath = js.statement(';');
 
     return js(
         'function(#) { #; return #.#(receiver).#(#) }',
         [parameterNames,
          optimizedPath,
          globalObject, getInterceptorName, invocationName, parameterNames]);
   }
-}
+
+  jsAst.ArrayInitializer generateTypeToInterceptorMap() {

[floitsch, 2015/01/26 13:42:31]

code is copied over from interceptor_emitter.

+    // TODO(sra): Perhaps inject a constant instead?
+    CustomElementsAnalysis analysis = backend.customElementsAnalysis;
+    if (!analysis.needsTable) return null;
+
+    List<jsAst.Expression> elements = <jsAst.Expression>[];
+    JavaScriptConstantCompiler handler = backend.constants;
+    List<ConstantValue> constants =
+        handler.getConstantsForEmission(emitter.compareConstants);
+    for (ConstantValue constant in constants) {
+      if (constant is TypeConstantValue) {
+        TypeConstantValue typeConstant = constant;
+        Element element = typeConstant.representedType.element;
+        if (element is ClassElement) {
+          ClassElement classElement = element;
+          if (!analysis.needsClass(classElement)) continue;
+
+          elements.add(emitter.constantReference(constant));
+          elements.add(backend.emitter.interceptorClassAccess(classElement));
+
+          // Create JavaScript Object map for by-name lookup of generative
+          // constructors.  For example, the class A has three generative
+          // constructors
+          //
+          //     class A {
+          //       A() {}
+          //       A.foo() {}
+          //       A.bar() {}
+          //     }
+          //
+          // Which are described by the map
+          //
+          //     {"": A.A$, "foo": A.A$foo, "bar": A.A$bar}
+          //
+          // We expect most of the time the map will be a singleton.
+          var properties = [];
+          for (Element member in analysis.constructors(classElement)) {
+            properties.add(
+                new jsAst.Property(
+                    js.string(member.name),
+                    backend.emitter.staticFunctionAccess(member)));
+          }
+
+          var map = new jsAst.ObjectInitializer(properties);
+          elements.add(map);
+        }
+      }
+    }
+
+    return new jsAst.ArrayInitializer(elements);
+  }
+}