Allow intercepted calls to have typed selectors.

sdk/lib/_internal/compiler/implementation/ssa/optimize.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;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 167 matching lines @@
   }
 
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
-    if (input.isBoolean(types)) return input;
+    HType type = types[input];
+    if (type.isBoolean()) return input;
     // All values !== true are boolified to false.
-    DartType type = types[input].computeType(compiler);
-    if (type != null && !identical(type.element, compiler.boolClass)) {
+    if (!type.isBooleanOrNull() && !type.isUnknown()) {
       return graph.addConstantBool(false, constantSystem);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input is HConstant) {
@@ skipping 70 matching lines @@
 
     // Try converting the instruction to a builtin instruction.
     HInstruction instruction =
         node.specializer.tryConvertToBuiltin(node, types);
     if (instruction != null) return instruction;
 
     // Check if this call does not need to be intercepted.
     HInstruction input = node.inputs[1];
     HType type = types[input];
     var interceptor = node.inputs[0];
+
+    if (interceptor.isConstant() && selector.isCall()) {
+      DartType type = types[interceptor].computeType(compiler);
+      node.element = type.element.lookupSelector(selector);
+    }
+
     if (interceptor is !HThis && !type.canBePrimitive()) {
       // If the type can be null, and the intercepted method can be in
       // the object class, keep the interceptor.
       if (type.canBeNull()) {
         Set<ClassElement> interceptedClasses;
         if (interceptor is HInterceptor) {
           interceptedClasses = interceptor.interceptedClasses;
         } else if (node is HOneShotInterceptor) {
           var oneShotInterceptor = node;
           interceptedClasses = oneShotInterceptor.interceptedClasses;
@@ skipping 32 matching lines @@
           }
         } else if (selector.applies(backend.jsStringConcat, compiler)) {
           if (node.inputs[2].isString(types)) {
             target = backend.jsStringConcat;
           }
         } else if (selector.applies(backend.jsStringToString, compiler)) {
           return input;
         }
       }
       if (target != null) {
+        // TODO(ngeoffray): There is a strong dependency between codegen
+        // and this optimization that the dynamic invoke does not need an
+        // interceptor. We currently need to keep a
+        // HInvokeDynamicMethod and not create a HForeign because
+        // HForeign is too opaque for the SssaCheckInserter (that adds a
+        // bounds check on removeLast). Once we start inlining, the
+        // bounds check will become explicit, so we won't need this
+        // optimization.
         HInvokeDynamicMethod result = new HInvokeDynamicMethod(
             node.selector, node.inputs.getRange(1, node.inputs.length - 1));
         result.element = target;
         return result;
       }
     } else if (selector.isGetter()) {
       if (selector.applies(backend.jsArrayLength, compiler)) {
         return optimizeLengthInterceptedGetter(node);
       }
     }
@@ skipping 461 matching lines @@
     HInstruction index = node.index;
     if (!node.index.isInteger(types)) {
       index = insertIntegerCheck(node, index);
     }
     index = insertBoundsCheck(node, node.receiver, index);
     node.changeUse(node.index, index);
   }
 
   void visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     Element element = node.element;
+    if (node.isInterceptorCall) return;
     if (element != backend.jsArrayRemoveLast) return;
     if (boundsChecked.contains(node)) return;
     insertBoundsCheck(
         node, node.receiver, graph.addConstantInt(0, backend.constantSystem));
   }
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
   final HTypeMap types;
   final String name = "SsaDeadCodeEliminator";
@@ skipping 695 matching lines @@
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
     block.rewrite(user, interceptor);
     block.remove(user);
 
     // The interceptor will be removed in the dead code elimination
     // phase. Note that removing it here would not work because of how
     // the [visitBasicBlock] is implemented.
   }
 }