Start work on a non-complete type inferrer. Currently only analyzes return types.

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 40 matching lines @@
           new SsaDeadPhiEliminator(),
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaTypePropagator(compiler, types),
           new SsaReceiverSpecialization(compiler),
           new SsaGlobalValueNumberer(compiler, types),
           new SsaCodeMotion(),
           new SsaValueRangeAnalyzer(constantSystem, types, work),
           // Previous optimizations may have generated new
           // opportunities for constant folding.
           new SsaConstantFolder(constantSystem, backend, work, types),
-          new SsaSimplifyInterceptors(constantSystem),
+          new SsaSimplifyInterceptors(constantSystem, types),
           new SsaDeadCodeEliminator(types)];
       runPhases(graph, phases);
       if (!speculative) {
         runPhase(graph, new SsaConstructionFieldTypes(backend, work, types));
       }
     });
   }
 
   bool trySpeculativeOptimizations(CodegenWorkItem work, HGraph graph) {
     if (work.element.isField()) {
@@ skipping 71 matching lines @@
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       HInstruction replacement = instruction.accept(this);
       if (replacement != instruction) {
         block.rewrite(instruction, replacement);
 
         // If we can replace [instruction] with [replacement], then
         // [replacement]'s type can be narrowed.
-        types[replacement] =
-            types[replacement].intersection(types[instruction], compiler);
+        types[replacement] = types[replacement].intersection(
+            types[instruction], compiler);
+        replacement.guaranteedType = replacement.guaranteedType.intersection(
+            instruction.guaranteedType, compiler);
 
         // If the replacement instruction does not know its
         // source element, use the source element of the
         // instruction.
         if (replacement.sourceElement == null) {
           replacement.sourceElement = instruction.sourceElement;
         }
         if (replacement.sourcePosition == null) {
           replacement.sourcePosition = instruction.sourcePosition;
         }
@@ skipping 86 matching lines @@
       return result;
     } else if (actualReceiver.isConstantMap()) {
       HConstant constantInput = actualReceiver;
       MapConstant constant = constantInput.constant;
       return graph.addConstantInt(constant.length, constantSystem);
     }
     return node;
   }
 
   HInstruction handleInterceptorCall(HInvokeDynamic node) {
-    // We only optimize for intercepted method calls in this method.
-    Selector selector = node.selector;
-
     // Try constant folding the instruction.
     Operation operation = node.specializer.operation(constantSystem);
     if (operation != null) {
       HInstruction instruction = node.inputs.length == 2
           ? foldUnary(operation, node.inputs[1])
           : foldBinary(operation, node.inputs[1], node.inputs[2]);
       if (instruction != null) return instruction;
     }
 
     // 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];
+    Selector selector = node.selector;
     var interceptor = node.inputs[0];
 
-    if (interceptor.isConstant() && selector.isCall()) {
+    // If the intercepted call is through a constant interceptor, we
+    // know which element to call.
+    if (node is !HOneShotInterceptor
+        && interceptor.isConstant()
+        && selector.isCall()) {
       DartType type = types[interceptor].computeType(compiler);
       ClassElement cls = type.element;
       node.element = cls.lookupSelector(selector);
     }
 
+    HInstruction input = node.inputs[1];
+    HType type = types[input];
+    // Check if this call does not need to be intercepted.
     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 1196 matching lines @@
 
 /**
  * This phase replaces all interceptors that are used only once with
  * one-shot interceptors. It saves code size and makes the receiver of
  * an intercepted call a candidate for being generated at use site.
  */
 class SsaSimplifyInterceptors extends HBaseVisitor
     implements OptimizationPhase {
   final String name = "SsaSimplifyInterceptors";
   final ConstantSystem constantSystem;
+  final HTypeMap types;
   HGraph graph;
 
-  SsaSimplifyInterceptors(this.constantSystem);
+  SsaSimplifyInterceptors(this.constantSystem, this.types);
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
     visitDominatorTree(graph);
   }
 
   void visitInterceptor(HInterceptor node) {
     if (node.usedBy.length != 1) return;
     // [HBailoutTarget] instructions might have the interceptor as
     // input. In such situation we let the dead code analyzer find out
     // the interceptor is not needed.
     if (node.usedBy[0] is !HInvokeDynamic) return;
 
     HInvokeDynamic user = node.usedBy[0];
 
     // If [node] was loop hoisted, we keep the interceptor.
     if (!user.hasSameLoopHeaderAs(node)) return;
 
     // Replace the user with a [HOneShotInterceptor].
     HConstant nullConstant = graph.addConstantNull(constantSystem);
     List<HInstruction> inputs = new List<HInstruction>.from(user.inputs);
     inputs[0] = nullConstant;
     HOneShotInterceptor interceptor = new HOneShotInterceptor(
         user.selector, inputs, node.interceptedClasses);
     interceptor.sourcePosition = user.sourcePosition;
     interceptor.sourceElement = user.sourceElement;
+    interceptor.guaranteedType = user.guaranteedType;
+    types[interceptor] = types[user];
 
     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.
   }
 }