Allow intercepted calls to have typed selectors.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 1501 matching lines @@
     SourceString name = node.selector.name;
     String methodName;
     List<js.Expression> arguments = visitArguments(node.inputs);
     Element target = node.element;
 
     if (target != null) {
       // Avoid adding the generative constructor name to the list of
       // seen selectors.
       if (target.isGenerativeConstructorBody()) {
         methodName = name.slowToString();
-      } else if (target == backend.jsArrayAdd) {
-        methodName = 'push';
-      } else if (target == backend.jsArrayRemoveLast) {
-        methodName = 'pop';
-      } else if (target == backend.jsStringSplit) {
-        methodName = 'split';
-        // Split returns a List, so we make sure the backend knows the
-        // list class is instantiated.
-        world.registerInstantiatedClass(compiler.listClass);
-      } else if (target == backend.jsStringConcat) {
-        push(new js.Binary('+', object, arguments[0]), node);
-        return;
+      } else if (!node.isInterceptorCall) {
+        if (target == backend.jsArrayAdd) {
+          methodName = 'push';
+        } else if (target == backend.jsArrayRemoveLast) {
+          methodName = 'pop';
+        } else if (target == backend.jsStringSplit) {
+          methodName = 'split';
+          // Split returns a List, so we make sure the backend knows the
+          // list class is instantiated.
+          world.registerInstantiatedClass(compiler.listClass);
+        } else if (target == backend.jsStringConcat) {
+          push(new js.Binary('+', object, arguments[0]), node);
+          return;
+        }
       }
     }
 
     if (methodName == null) {
       methodName = backend.namer.invocationName(node.selector);
       registerMethodInvoke(node);
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
   void visitOneShotInterceptor(HOneShotInterceptor node) {
     List<js.Expression> arguments = visitArguments(node.inputs);
     var isolate = new js.VariableUse(backend.namer.CURRENT_ISOLATE);
     Selector selector = node.selector;
     String methodName = backend.namer.oneShotInterceptorName(selector);
     push(jsPropertyCall(isolate, methodName, arguments), node);
     backend.registerSpecializedGetInterceptor(node.interceptedClasses);
     backend.addOneShotInterceptor(selector);
     if (selector.isGetter()) {
       registerGetter(node);
     } else if (selector.isSetter()) {
       registerSetter(node);
     } else {
       registerMethodInvoke(node);
     }
   }
 
   Selector getOptimizedSelectorFor(HInvokeDynamic node,
                                    Selector defaultSelector) {
-    // TODO(ngeoffray): Type intercepted calls.
-    if (node.isInterceptorCall) return defaultSelector;
     // If [JSInvocationMirror.invokeOn] has been called, we must not create a
     // typed selector based on the receiver type.
     if (node.element == null && // Invocation is not exact.
         backend.compiler.enabledInvokeOn) {
       return defaultSelector;
     }
-    HType receiverHType = types[node.inputs[0]];
+    int receiverIndex = node.isInterceptorCall ? 1 : 0;
+    HType receiverHType = types[node.inputs[receiverIndex]];
     DartType receiverType = receiverHType.computeType(compiler);
     if (receiverType != null &&
         !identical(receiverType.kind, TypeKind.MALFORMED_TYPE)) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   void registerInvoke(HInvokeDynamic node) {
@@ skipping 26 matching lines @@
       // TODO(kasperl): If we have a typed selector for the call, we
       // may know something about the types of closures that need
       // the specific closure call method.
       Selector call = new Selector.callClosureFrom(selector);
       world.registerDynamicInvocation(call.name, call);
     }
 
     if (target != null) {
       // If we know we're calling a specific method, register that
       // method only.
-      world.registerDynamicInvocationOf(target);
+      world.registerDynamicInvocationOf(target, selector);
     } else {
       SourceString name = node.selector.name;
       world.registerDynamicInvocation(name, selector);
     }
     registerInvoke(node);
   }
 
   void registerSetter(HInvokeDynamic node) {
     Selector selector = getOptimizedSelectorFor(node, node.selector);
     world.registerDynamicSetter(selector.name, selector);
@@ skipping 787 matching lines @@
       "malformedTypeCheck":
           const SourceString("malformedTypeCheck")
     };
 
     if (node.isChecked) {
       DartType type = node.type.computeType(compiler);
       Element element = type.element;
       world.registerIsCheck(type);
 
       if (node.isArgumentTypeCheck) {
-        if (element == compiler.intClass) {
+        if (element == backend.jsIntClass) {
           checkInt(node.checkedInput, '!==');
         } else {
-          assert(element == compiler.numClass);
+          assert(element == backend.jsNumberClass);
           checkNum(node.checkedInput, '!==');
         }
         js.Expression test = pop();
         js.Block oldContainer = currentContainer;
         js.Statement body = new js.Block.empty();
         currentContainer = body;
         generateThrowWithHelper('iae', node.checkedInput);
         currentContainer = oldContainer;
         body = unwrapStatement(body);
         pushStatement(new js.If.noElse(test, body), node);
@@ skipping 561 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }