Create specialized versions of getInterceptor.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 1663 matching lines @@
     ${mainCall};
   }
 }
 //
 // END invoke [main].
 //
 
 """);
   }
 
+  /**
+   * Emit the code for doing a type check on [cls]. [cls] must
+   * be an interceptor class.
+   */
+  void emitTypeCheck(ClassElement cls, CodeBuffer buffer) {

[ahe, 2012/11/27 14:29:45]

This is not really emitting a type check, which would be what you emit in
checked mode for:

int x = foo(); // Here is a type check that foo returns an int.

[ngeoffray, 2012/11/27 15:50:54]

I renamed the method emitInterceptorCheck.

+    JavaScriptBackend backend = compiler.backend;
+    assert(backend.isInterceptorClass(cls));
+    String then = 'return ${namer.isolateAccess(cls)}.prototype;';

[ahe, 2012/11/27 14:29:45]

Weird variable name.  How about interceptorObject?

[ngeoffray, 2012/11/27 15:50:54]

Done.

+    if (cls == backend.jsBoolClass) {
+      buffer.add("if (typeof receiver == 'boolean') $then");

[ahe, 2012/11/27 14:29:45]

This pattern really hurts my eyes :-)

How about:

buffer.add("if (typeof receiver == 'boolean') return ");
buffer.add(namer.isolateAccess(cls));
buffer.add('.prototype');

Notice that the last two lines can be shared at the end of this method.  So you
don't need the "then" variable.

[ngeoffray, 2012/11/27 15:50:54]

Done.

+    } else if (cls == backend.jsIntClass) {
+      buffer.add("if (typeof receiver == 'number' "
+                 "&& Math.floor(receiver) == receiver) $then");
+    } else if (cls == backend.jsDoubleClass || cls == backend.jsNumberClass) {
+      buffer.add("if (typeof receiver == 'number') $then");
+    } else if (cls == backend.jsArrayClass) {
+      buffer.add("if (receiver != null "
+                 "&& receiver.constructor == Array) $then");
+    } else if (cls == backend.jsStringClass) {
+      buffer.add("if (typeof receiver == 'string') $then");
+    } else if (cls == backend.jsNullClass) {
+      buffer.add("if (receiver == null) $then");
+    } else if (cls == backend.jsFunctionClass) {
+      buffer.add("if (typeof receiver == 'function') $then");
+    }
+  }
+
+  /**
+   * Emit all versions of the [:getInterceptor:] method.
+   */
+  void emitGetInterceptors(CodeBuffer buffer) {

[ahe, 2012/11/27 14:29:45]

How about "emitGetInterceptorMethods"?

[ngeoffray, 2012/11/27 15:50:54]

Done.

+    JavaScriptBackend backend = compiler.backend;
+    String objectName = namer.isolateAccess(backend.objectInterceptorClass);
+    backend.specializedGetInterceptors.forEach(
+        (String key, Collection<ClassElement> classes) {
+          buffer.add('$isolateProperties.$key = function(receiver) {');
+          for (ClassElement cls in classes) {
+            if (compiler.codegenWorld.instantiatedClasses.contains(cls)) {
+              buffer.add('\n  ');
+              emitTypeCheck(cls, buffer);
+            }
+          }
+          buffer.add('\n  return $objectName.prototype;\n};\n');
+        });
+  }
+
   String assembleProgram() {
     measure(() {
       mainBuffer.add(HOOKS_API_USAGE);
       mainBuffer.add('function ${namer.ISOLATE}() {}\n');
       mainBuffer.add('init();\n\n');
       // Shorten the code by using "$$" as temporary.
       classesCollector = r"$$";
       mainBuffer.add('var $classesCollector = {};\n');
       // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
       isolateProperties = namer.CURRENT_ISOLATE;
       mainBuffer.add('var $isolateProperties = $isolatePropertiesName;\n');
       emitClasses(mainBuffer);
       mainBuffer.add(boundClosureBuffer);
       // Clear the buffer, so that we can reuse it for the native classes.
       boundClosureBuffer.clear();
       emitStaticFunctions(mainBuffer);
       emitStaticFunctionGetters(mainBuffer);
       // We need to finish the classes before we construct compile time
       // constants.
       emitFinishClassesInvocationIfNecessary(mainBuffer);
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
       emitStaticNonFinalFieldInitializations(mainBuffer);
+      emitGetInterceptors(mainBuffer);
       emitLazilyInitializedStaticFields(mainBuffer);
 
       isolateProperties = isolatePropertiesName;
       // The following code should not use the short-hand for the
       // initialStatics.
       mainBuffer.add('var ${namer.CURRENT_ISOLATE} = null;\n');
       mainBuffer.add(boundClosureBuffer);
       emitFinishClassesInvocationIfNecessary(mainBuffer);
       // After this assignment we will produce invalid JavaScript code if we use
       // the classesCollector variable.
@@ skipping 38 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;