Implement "one-shot" interceptors.

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 2077 matching lines @@
     for (ClassElement element in instantiatedClasses) {
       for (ClassElement superclass = element.superclass;
           superclass != null;
           superclass = superclass.superclass) {
         if (neededClasses.contains(superclass)) break;
         neededClasses.add(superclass);
       }
     }
   }
 
+  void emitOneShotInterceptors(CodeBuffer buffer) {

[kasperl, 2013/01/24 07:19:14]

How difficult would it be to build these one shot interceptors in SSA form
instead? The reason I ask is that it would be nice for us to get to a point
where we could unfold the call to getInterceptor like this:

  function foo$oneshot(receiver, x) {
    if (typeof receiver == "number")
      return $.JSNumber.prototype.foo(receiver, x);
    else 
      return $.ObjectInterceptor.prototype.foo(receiver, x);
  }

and then let the builder decide if it wants to inline the calls to two different
calls to foo (based on the code size implications, etc.). 

[ngeoffray, 2013/01/24 08:39:15]

As discussed, I agree it will be pretty neat to rely on the SSA to do further
optimizations. I'll leave that to another CL. Filed
https://code.google.com/p/dart/issues/detail?id=8089 to not forget about it.

+    JavaScriptBackend backend = compiler.backend;
+    for (Selector selector in backend.oneShotInterceptors) {

[sra1, 2013/01/23 21:21:30]

These need to be sorted to have stable output.

It would be useful to have a canonical sort order for selectors.  If you think
this is a separate CL, add an issue to the tracker to implement and use the
order here and make Issue 2388 blocking on it.

[ngeoffray, 2013/01/24 08:39:15]

Issue filed: https://code.google.com/p/dart/issues/detail?id=8088.

+      Set<ClassElement> classes = backend.getInterceptedClassesOn(selector);
+      String oneShotInterceptorName = namer.oneShotInterceptorName(selector);
+      String getInterceptorName =
+          namer.getInterceptorName(backend.getInterceptorMethod, classes);
+
+      List<js.Parameter> parameters = <js.Parameter>[];
+      List<js.Expression> arguments = <js.Expression>[];
+      parameters.add(new js.Parameter('receiver'));
+      arguments.add(new js.VariableUse('receiver'));

[sra1, 2013/01/23 21:21:30]

also: js.use('receiver')

[ngeoffray, 2013/01/24 08:39:15]

Done.

+
+      if (selector.isSetter()) {
+        parameters.add(new js.Parameter('value'));
+        arguments.add(new js.VariableUse('value'));
+      } else {
+        for (int i = 0; i < selector.argumentCount; i++) {
+          String argName = 'a$i';
+          parameters.add(new js.Parameter(argName));
+          arguments.add(new js.VariableUse(argName));
+        }
+      }
+
+      String invocationName = backend.namer.invocationName(selector);
+      js.Fun function =
+          new js.Fun(parameters,
+              new js.Block(
+                  <js.Statement>[
+                      new js.Return(

[sra1, 2013/01/23 21:21:30]

also: js.return_(x)

[ngeoffray, 2013/01/24 08:39:15]

Done.

+                          js.use(isolateProperties)
+                              .dot(getInterceptorName)
+                              .callWith([js.use('receiver')])
+                                  .dot(invocationName)
+                                  .callWith(arguments))]));
+
+      js.PropertyAccess property =
+          js.fieldAccess(js.use(isolateProperties), oneShotInterceptorName);
+
+      buffer.add(js.prettyPrint(js.assign(property, function), compiler));
+      buffer.add(N);
+    }
+  }
+
   String assembleProgram() {
     measure(() {
       computeNeededClasses();
 
       mainBuffer.add(GENERATED_BY);
       if (!compiler.enableMinification) mainBuffer.add(HOOKS_API_USAGE);
       mainBuffer.add('function ${namer.isolateName}()$_{}\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);
       emitRuntimeClassesAndTests(mainBuffer);
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
       emitStaticNonFinalFieldInitializations(mainBuffer);
+      emitOneShotInterceptors(mainBuffer);
       emitGetInterceptorMethods(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
@@ skipping 39 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // 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].
 """;