GVN getInterceptor and use the interceptor constant when the type is known.

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 193 matching lines @@
     }
     return node;
   }
 
   HInstruction handleInterceptorCall(HInvokeDynamic node) {
     HInstruction input = node.inputs[1];
     if (input.isString(types)
         && node.selector.name == const SourceString('toString')) {
       return node.inputs[1];
     }
+    // Check if this call does not need to be intercepted.
+    HType type = types[input];
+    var interceptor = node.inputs[0];
+    if (node is HInvokeDynamicMethod
+        && 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()
+          && interceptor.interceptedClasses.contains(compiler.objectClass)) {
+        return node;
+      }
+      // Change the call to a regular invoke dynamic call.
+      return new HInvokeDynamicMethod(
+          node.selector, node.inputs.getRange(1, node.inputs.length - 1));
+    }
     return node;
   }
 
   bool isFixedSizeListConstructor(HInvokeStatic node) {
     Element element = node.target.element;
     return element.getEnclosingClass() == compiler.listClass
         && node.inputs.length == 2
         && node.inputs[1].isInteger(types);
   }
 
@@ skipping 19 matching lines @@
             node.element = element;
           }
           // TODO(ngeoffray): If the method has optional parameters,
           // we should pass the default values here.
         }
       }
     }
     return node;
   }
 
-  HInstruction fromInterceptorToDynamicInvocation(HInvokeStatic node,
-                                                  Selector selector) {
+  HInstruction fromNativeToDynamicInvocation(HInvokeStatic node,
+                                             Selector selector) {
     HBoundedType type = types[node.inputs[1]];
     HInvokeDynamicMethod result = new HInvokeDynamicMethod(
         selector,
         node.inputs.getRange(1, node.inputs.length - 1));
     if (type.isExact()) {
       HBoundedType concrete = type;
       result.element = concrete.lookupMember(selector.name);
     }
     return result;
   }
 
   HInstruction visitIntegerCheck(HIntegerCheck node) {
     HInstruction value = node.value;
     if (value.isInteger(types)) return value;
     if (value.isConstant()) {
       HConstant constantInstruction = value;
       assert(!constantInstruction.constant.isInt());
       if (!constantSystem.isInt(constantInstruction.constant)) {
         // -0.0 is a double but will pass the runtime integer check.
         node.alwaysFalse = true;
       }
     }
     return node;
   }
 
 
   HInstruction visitIndex(HIndex node) {
     if (!node.receiver.canBePrimitive(types)) {
       Selector selector = new Selector.index();
-      return fromInterceptorToDynamicInvocation(node, selector);
+      return fromNativeToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   HInstruction visitIndexAssign(HIndexAssign node) {
     if (!node.receiver.canBePrimitive(types)) {
       Selector selector = new Selector.indexSet();
-      return fromInterceptorToDynamicInvocation(node, selector);
+      return fromNativeToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   HInstruction visitInvokeBinary(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     BinaryOperation operation = node.operation(constantSystem);
     if (left is HConstant && right is HConstant) {
       HConstant op1 = left;
       HConstant op2 = right;
       Constant folded = operation.fold(op1.constant, op2.constant);
       if (folded != null) return graph.addConstant(folded);
     }
 
     if (!left.canBePrimitive(types)
         && operation.isUserDefinable()
         // The equals operation is being optimized in visitEquals.
         && node is! HEquals) {
       Selector selector = new Selector.binaryOperator(operation.name);
-      return fromInterceptorToDynamicInvocation(node, selector);
+      return fromNativeToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   bool allUsersAreBoolifies(HInstruction instruction) {
     List<HInstruction> users = instruction.usedBy;
     int length = users.length;
     for (int i = 0; i < length; i++) {
       if (users[i] is! HBoolify) return false;
     }
@@ skipping 325 matching lines @@
     for (int i = 0; i < node.inputs.length; i++) {
       HInstruction part = node.inputs[i];
       if (!part.isConstant()) return node;
       HConstant constant = part;
       if (!constant.constant.isPrimitive()) return node;
       PrimitiveConstant primitive = constant.constant;
       folded = new DartString.concat(folded, primitive.toDartString());
     }
     return graph.addConstant(constantSystem.createString(folded, node.node));
   }
+
+  HInstruction visitInterceptor(HInterceptor node) {
+    if (node.isConstant()) return node;
+    HType type = types[node.inputs[0]];
+    Element constantInterceptor;
+    if (type.isInteger()) {
+      constantInterceptor = backend.intInterceptor;
+    } else if (type.isDouble()) {
+      constantInterceptor = backend.doubleInterceptor;
+    } else if (type.isBoolean()) {
+      constantInterceptor = backend.boolInterceptor;
+    } else if (type.isString()) {
+      constantInterceptor = backend.stringInterceptor;
+    } else if (type.isArray()) {
+      constantInterceptor = backend.arrayInterceptor;
+    } else if (type.isNull()) {
+      constantInterceptor = backend.nullInterceptor;
+    } else if (type.isNumber()) {
+      Set<ClassElement> intercepted = node.interceptedClasses;
+      // If the method being intercepted is not defined in [int] or
+      // [double] we can safely use the number interceptor.
+      if (!intercepted.contains(compiler.intClass)
+          && !intercepted.contains(compiler.doubleClass)) {
+        constantInterceptor = backend.numberInterceptor;
+      }
+    }
+
+    if (constantInterceptor == null) return node;
+
+    ConstantHandler handler = compiler.constantHandler;
+    return graph.addConstant(handler.compileVariable(constantInterceptor));
+  }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final HTypeMap types;
   final ConstantSystem constantSystem;
   final Set<HInstruction> boundsChecked;
   final WorkItem work;
   final String name = "SsaCheckInserter";
   HGraph graph;
   Element lengthInterceptor;
@@ skipping 684 matching lines @@
     }
 
     // For other fields having setters in the generative constructor body, set
     // the type to UNKNOWN to avoid relying on the type set in the initializer
     // list.
     allSetters.forEach((Element element) {
       backend.registerFieldConstructor(element, HType.UNKNOWN);
     });
   }
 }