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

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 28 matching lines @@
     if (identical(name, '>>=')) return const SourceString('shr');
     if (identical(name, '|=')) return const SourceString('or');
     if (identical(name, '&=')) return const SourceString('and');
     if (identical(name, '^=')) return const SourceString('xor');
     if (identical(name, '++')) return const SourceString('add');
     if (identical(name, '--')) return const SourceString('sub');
     compiler.unimplemented('Unknown operator', node: op);
   }
 
   Element getStaticInterceptor(Selector selector) {
+    // Check if we have an interceptor implemented with classes.

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

How about:

// Check if we have an interceptor method implemented with interceptor classes.

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

Done.

+    JavaScriptBackend backend = compiler.backend;
+    if (backend.shouldInterceptSelector(selector)) {
+      backend.addInterceptedSelector(selector);
+      return backend.getInterceptorMethod;
+    }
+
+    // Fall back to the old interceptor mechanism.
     String name = selector.name.slowToString();
     if (selector.isGetter()) {
       // TODO(lrn): If there is no get-interceptor, but there is a
       // method-interceptor, we should generate a get-interceptor automatically.
       String mangledName = "get\$$name";
       return compiler.findInterceptor(new SourceString(mangledName));
     } else if (selector.isSetter()) {
       String mangledName = "set\$$name";
       return compiler.findInterceptor(new SourceString(mangledName));
     } else {
@@ skipping 334 matching lines @@
     enterScope(node, element);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
     });
     if (closureData.isClosure()) {
       // Inside closure redirect references to itself to [:this:].
-      HInstruction thisInstruction = new HThis();
-      builder.add(thisInstruction);
+      HInstruction thisInstruction = new HThis(closureData.thisElement);
+      builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (element.isInstanceMember()
                || element.isGenerativeConstructor()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       ClassElement cls = element.getEnclosingClass();
       DartType type = cls.computeType(builder.compiler);
-      HInstruction thisInstruction = new HThis(new HBoundedType.nonNull(type));
-      builder.add(thisInstruction);
+      HInstruction thisInstruction = new HThis(closureData.thisElement,
+                                               new HBoundedType.nonNull(type));
+      thisInstruction.sourceElement = closureData.thisElement;
+      builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
   }
 
   bool hasValueForDirectLocal(Element element) {
     assert(element != null);
     assert(isAccessedDirectly(element));
     return directLocals[element] != null;
   }
 
@@ skipping 1838 matching lines @@
                                                   HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     // TODO(kasperl): This is a convoluted way of checking if we're
     // generating code for a compound assignment. If we are, we need
     // to get the selector from the mapping for the AST selector node.
     Selector selector = (send.asSendSet() == null)
         ? elements.getSelector(send)
         : elements.getSelector(send.selector);
     assert(selector.isGetter());
     SourceString getterName = selector.name;
-    Element staticInterceptor = null;
+    Element interceptor = null;
     if (elements[send] == null && methodInterceptionEnabled) {
-      staticInterceptor = interceptors.getStaticInterceptor(selector);
+      interceptor = interceptors.getStaticInterceptor(selector);
     }
     bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
-    if (staticInterceptor != null) {
-      HStatic target = new HStatic(staticInterceptor);
-      add(target);
-      List<HInstruction> inputs = <HInstruction>[target, receiver];
-      pushWithPosition(new HInvokeInterceptor(selector, inputs, !hasGetter),
-                       send);
+    if (interceptor != null) {
+      if (interceptor == backend.getInterceptorMethod) {
+        // If we're using an interceptor class, emit a call to the
+        // interceptor method and then the actuall dynamic call on the

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

actuall -> actual

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

Done.

+        // interceptor object.
+        HStatic target = new HStatic(interceptor);
+        add(target);
+        HInstruction instruction =
+            new HInvokeStatic(<HInstruction>[target, receiver]);
+        add(instruction);
+        instruction = new HInvokeDynamicGetter(
+            selector, null, instruction, !hasGetter);
+        // Add the receiver as an argument to the getter call on the
+        // interceptor.
+        instruction.inputs.add(receiver);
+        pushWithPosition(instruction, send);
+      } else {
+        // Use the old, deprecated interceptor mechanism.
+        HStatic target = new HStatic(interceptor);
+        add(target);
+        List<HInstruction> inputs = <HInstruction>[target, receiver];
+        pushWithPosition(new HInvokeInterceptor(selector, inputs, !hasGetter),
+                         send);
+      }
     } else {
       pushWithPosition(
           new HInvokeDynamicGetter(selector, null, receiver, !hasGetter), send);
     }
   }
 
   void generateGetter(Send send, Element element) {
     if (Elements.isStaticOrTopLevelField(element)) {
       Constant value;
       if (element.isField() && !element.isAssignable()) {
@@ skipping 307 matching lines @@
           name, node.argumentsNode is Prefix);
     } else {
       dartMethodName = node.selector.asIdentifier().source;
     }
 
     Element interceptor = null;
     if (methodInterceptionEnabled && elements[node] == null) {
       interceptor = interceptors.getStaticInterceptor(selector);
     }
     if (interceptor != null) {
-      HStatic target = new HStatic(interceptor);
-      add(target);
-      inputs.add(target);
-      visit(node.receiver);
-      inputs.add(pop());
-      addGenericSendArgumentsToList(node.arguments, inputs);
-      pushWithPosition(new HInvokeInterceptor(selector, inputs), node);
+      // TODO(ngeoffray): This is currently the case, but should be

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

What does "This" mean here?

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

The assertion. Comment added.

+      // updated once we start implementing more of the interceptors class.
+      assert(node.receiver != null);
+      if (interceptor == backend.getInterceptorMethod) {
+        HStatic target = new HStatic(interceptor);
+        add(target);
+        visit(node.receiver);
+        HInstruction receiver = pop();
+        HInstruction instruction =
+            new HInvokeStatic(<HInstruction>[target, receiver]);
+        add(instruction);
+        inputs.add(instruction);
+        inputs.add(receiver);
+        addDynamicSendArgumentsToList(node, inputs);
+        // The first entry in the inputs list is the interceptor. The
+        // second is the receiver, and the others are the arguments.
+        instruction = new HInvokeDynamicMethod(selector, inputs);
+        pushWithPosition(instruction, node);
+      } else {
+        HStatic target = new HStatic(interceptor);
+        add(target);
+        inputs.add(target);
+        visit(node.receiver);
+        inputs.add(pop());
+        addGenericSendArgumentsToList(node.arguments, inputs);
+        pushWithPosition(new HInvokeInterceptor(selector, inputs), node);
+      }
       return;
     }
 
     Element element = elements[node];
     if (element != null && compiler.world.hasNoOverridingMember(element)) {
       if (tryInlineMethod(element, selector, node.arguments)) {
         return;
       }
     }
 
@@ skipping 2132 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }