Start new design for interceptors and implement String.charCodeAt with it.

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 26 matching lines @@
   bool needsLazyInitializer = false;
   final Namer namer;
   ConstantEmitter constantEmitter;
   NativeEmitter nativeEmitter;
   CodeBuffer boundClosureBuffer;
   CodeBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
+
+  /**
+   * A cache of closures that are used to closurize instance methods.
+   * A closure is dynamically bound to the instance used when closurization.
+   */
   final Map<int, String> boundClosureCache;
+
+  /**
+   * A cache of closures that are used to closurize instance methods
+   * of interceptors. Such closure is dynmically bound to the
+   * interceptor instance, and the actuall receiver of the method.

[ahe, 2012/11/13 12:42:41]

actuall -> actual.

[ngeoffray, 2012/11/13 12:51:50]

Done.

+   */
+  final Map<int, String> interceptorClosureCache;
   Set<ClassElement> checkedClasses;
 
   final bool generateSourceMap;
 
   CodeEmitterTask(Compiler compiler, Namer namer, this.generateSourceMap)
       : boundClosureBuffer = new CodeBuffer(),
         mainBuffer = new CodeBuffer(),
         this.namer = namer,
         boundClosureCache = new Map<int, String>(),
+        interceptorClosureCache = new Map<int, String>(),
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void computeRequiredTypeChecks() {
     assert(checkedClasses == null);
     checkedClasses = new Set<ClassElement>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
       if (t is InterfaceType) checkedClasses.add(t.element);
@@ skipping 543 matching lines @@
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void emitInstanceMembers(ClassElement classElement,
                            CodeBuffer buffer,
                            bool needsLeadingComma) {
     assert(invariant(classElement, classElement.isDeclaration));
     bool needsComma = needsLeadingComma;
-    void defineInstanceMember(String name, CodeBuffer memberBuffer) {
+    void defineInstanceMember(String name, StringBuffer memberBuffer) {
       if (needsComma) buffer.add(',');
       needsComma = true;
       buffer.add('\n');
       buffer.add(' $name: ');
       buffer.add(memberBuffer);
     }
 
+    JavaScriptBackend backend = compiler.backend;
+    if (classElement == backend.objectInterceptorClass) {
+      emitInterceptorMethods(defineInstanceMember);
+      // The ObjectInterceptor does not have any instance methods.
+      return;
+    }
+
     classElement.implementation.forEachMember(
         (ClassElement enclosing, Element member) {
           assert(invariant(classElement, member.isDeclaration));
           if (member.isInstanceMember()) {
             addInstanceMember(member, defineInstanceMember);
           }
         },
         includeBackendMembers: true);
 
     generateIsTestsOn(classElement, (ClassElement other) {
@@ skipping 210 matching lines @@
     emitClassFields(classElement, buffer);
     // TODO(floitsch): the emitInstanceMember should simply always emit a ',\n'.
     // That does currently not work because the native classes have a different
     // syntax.
     buffer.add(',\n "super": "$superName"');
     emitClassGettersSetters(classElement, buffer);
     emitInstanceMembers(classElement, buffer, true);
     buffer.add('\n};\n\n');
   }
 
+  void emitInterceptorMethods(
+      void defineInstanceMember(String name, StringBuffer memberBuffer)) {
+    JavaScriptBackend backend = compiler.backend;
+    // Emit forwarders for the ObjectInterceptor class. We need to
+    // emit all possible sends on intercepted methods.
+    for (Selector selector in backend.usedInterceptors) {
+      String name;
+      String comma = '';
+      String parameters = '';
+      if (selector.isGetter()) {
+        name = backend.namer.getterName(selector.library, selector.name);
+      } else if (selector.isSetter()) {
+        name = backend.namer.setterName(selector.library, selector.name);
+      } else {
+        assert(selector.isCall());
+        name = backend.namer.instanceMethodInvocationName(
+            selector.library, selector.name, selector);
+        if (selector.argumentCount > 0) {
+          comma = ', ';
+          int i = 0;
+          for (; i < selector.argumentCount - 1; i++) {
+            parameters = '${parameters}a$i, ';
+          }
+          parameters = '${parameters}a$i';
+        }
+      }
+      StringBuffer body = new StringBuffer(
+          "function(receiver$comma$parameters) {"
+              " return receiver.$name($parameters); }");
+      defineInstanceMember(name, body);
+    }
+  }
+
   /**
    * Generate "is tests" for [cls]: itself, and the "is tests" for the
    * classes it implements. We don't need to add the "is tests" of the
    * super class because they will be inherited at runtime.
    */
   void generateIsTestsOn(ClassElement cls,
                          void emitIsTest(ClassElement element)) {
     if (checkedClasses.contains(cls)) {
       emitIsTest(cls);
     }
@@ skipping 141 matching lines @@
         buffer.add('$fieldAccess.$name = $value;\n');
       });
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.add('$fieldAccess.$fieldName = "$staticName";\n');
     }
   }
 
   void emitBoundClosureClassHeader(String mangledName,
-                             String superName,
-                             CodeBuffer buffer) {
+                                   String superName,
+                                   String extraArgument,
+                                   CodeBuffer buffer) {
+    extraArgument = extraArgument.isEmpty ? '' : ", '$extraArgument'";
     buffer.add("""
 $classesCollector.$mangledName = {'':
-['self', 'target'],
+['self'$extraArgument, 'target'],
 'super': '$superName',
 """);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitDynamicFunctionGetter(FunctionElement member,
@@ skipping 16 matching lines @@
 
     // TODO(floitsch): share the closure classes with other classes
     // if they share methods with the same signature. Currently we do this only
     // if there are no optional parameters. Closures with optional parameters
     // are more difficult to canonicalize because they would need to have the
     // same default values.
 
     bool hasOptionalParameters = member.optionalParameterCount(compiler) != 0;
     int parameterCount = member.parameterCount(compiler);
 
+    Map<int, String> cache;
+    String extraArg;
+    String extraArgWithThis;
+    String extraArgWithoutComma;
+    // Methods on foreign classes take an extra parameter, which is
+    // the actual receiver of the call.
+    JavaScriptBackend backend = compiler.backend;
+    if (backend.isInterceptorClass(member.getEnclosingClass())) {
+      cache = interceptorClosureCache;
+      extraArg = 'receiver, ';
+      extraArgWithThis = 'this.receiver, ';
+      extraArgWithoutComma = 'receiver';
+    } else {
+      cache = boundClosureCache;
+      extraArg = '';
+      extraArgWithoutComma = '';
+      extraArgWithThis = '';
+    }
+
     String closureClass =
-        hasOptionalParameters ? null : boundClosureCache[parameterCount];
+        hasOptionalParameters ? null : cache[parameterCount];
     if (closureClass == null) {
       // Either the class was not cached yet, or there are optional parameters.
       // Create a new closure class.
       SourceString name = const SourceString("BoundClosure");
       ClassElement closureClassElement = new ClosureClassElement(
           name, compiler, member, member.getCompilationUnit());
       String mangledName = namer.getName(closureClassElement);
       String superName = namer.getName(closureClassElement.superclass);
       needsClosureClass = true;
 
       // Define the constructor with a name so that Object.toString can
       // find the class name of the closure class.
-      emitBoundClosureClassHeader(mangledName, superName, boundClosureBuffer);
+      emitBoundClosureClassHeader(
+          mangledName, superName, extraArgWithoutComma, boundClosureBuffer);
       // Now add the methods on the closure class. The instance method does not
       // have the correct name. Since [addParameterStubs] use the name to create
       // its stubs we simply create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(Namer.CLOSURE_INVOCATION_NAME, member);
-
+      
       String invocationName = namer.instanceMethodName(callElement);
       List<String> arguments = new List<String>(parameterCount);
       for (int i = 0; i < parameterCount; i++) {
         arguments[i] = "p$i";
       }
       String joinedArgs = Strings.join(arguments, ", ");
       boundClosureBuffer.add(
           "$invocationName: function($joinedArgs) {");
-      boundClosureBuffer.add(" return this.self[this.target]($joinedArgs);");
+      boundClosureBuffer.add(
+          " return this.self[this.target]($extraArgWithThis$joinedArgs);");
       boundClosureBuffer.add(" }");
       addParameterStubs(callElement, (String stubName, CodeBuffer memberValue) {
         boundClosureBuffer.add(',\n $stubName: $memberValue');
       });
       boundClosureBuffer.add("\n};\n");
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (!hasOptionalParameters) {
-        boundClosureCache[parameterCount] = closureClass;
+        cache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
     String getterName = namer.getterName(member.getLibrary(), member.name);
     String targetName = namer.instanceMethodName(member);
     CodeBuffer getterBuffer = new CodeBuffer();
-    getterBuffer.add(
-        "function() { return new $closureClass(this, '$targetName'); }");
+    getterBuffer.add("function($extraArgWithoutComma) "
+        "{ return new $closureClass(this, $extraArg'$targetName'); }");
     defineInstanceMember(getterName, getterBuffer);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
@@ skipping 463 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].
 """;