When doing SSA type propagation, refine the receiver after a call.

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 62 matching lines @@
       compiler.tracer.traceGraph("codegen", graph);
       SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work);
       codegen.visitGraph(graph);
       return new js.Fun(codegen.parameters,
           attachPosition(codegen.body, work.element));
     });
   }
 
   js.Expression generateMethod(CodegenWorkItem work, HGraph graph) {
     return measure(() {
-      compiler.tracer.traceGraph("codegen", graph);
       SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work);
       codegen.visitGraph(graph);
+      compiler.tracer.traceGraph("codegen", graph);
       FunctionElement element = work.element;
       return buildJavaScriptFunction(element, codegen.parameters, codegen.body);
     });
   }
 }
 
 typedef void ElementAction(Element element);
 
 class SsaCodeGenerator implements HVisitor, HBlockInformationVisitor {
   /**
@@ skipping 179 matching lines @@
                               SourceFileLocation endSourcePosition) {
     jsNode.sourcePosition = sourcePosition;
     jsNode.endSourcePosition = endSourcePosition;
     return jsNode;
   }
 
   beginGraph(HGraph graph);
   endGraph(HGraph graph);
 
   void preGenerateMethod(HGraph graph) {
+    new SsaTypeKnownRemover().visitGraph(graph);
     new SsaInstructionMerger(generateAtUseSite, compiler).visitGraph(graph);
     new SsaConditionMerger(
         generateAtUseSite, controlFlowOperators).visitGraph(graph);
     SsaLiveIntervalBuilder intervalBuilder = new SsaLiveIntervalBuilder(
         compiler, generateAtUseSite, controlFlowOperators);
     intervalBuilder.visitGraph(graph);
     SsaVariableAllocator allocator = new SsaVariableAllocator(
         compiler,
         intervalBuilder.liveInstructions,
         intervalBuilder.liveIntervals,
@@ skipping 1243 matching lines @@
       // type because our optimizations might end up in a state where the
       // invoke dynamic knows more than the receiver.
       ClassElement enclosing = node.element.getEnclosingClass();
       HType receiverType = new HType.fromMask(
           new TypeMask.nonNullExact(enclosing.declaration),
           compiler);
       return receiverType.refine(selector, compiler);
     }
     // If [JSInvocationMirror._invokeOn] has been called, we must not create a
     // typed selector based on the receiver type.
-    if (backend.compiler.enabledInvokeOn) {
-      return selector.asUntyped;
-    }
-    HType receiverType = node.getDartReceiver(compiler).instructionType;
-    return receiverType.refine(selector, compiler);
+    return backend.compiler.enabledInvokeOn ? selector.asUntyped : selector;
   }
 
   void registerMethodInvoke(HInvokeDynamic node) {
     Selector selector = getOptimizedSelectorFor(node, node.selector);
 
     // If we don't know what we're calling or if we are calling a getter,
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
     Element target = node.element;
     if (target == null || target.isGetter()) {
@@ skipping 1007 matching lines @@
           const CheckedModeHelper('boolConversionCheck');
     } else {
       helper =
           backend.getCheckedModeHelper(type, typeCast: node.isCastTypeCheck);
     }
 
     push(helper.generateCall(this, node));
   }
 
   void visitTypeKnown(HTypeKnown node) {
-    use(node.checkedInput);
+    // [HTypeKnown] instructions are removed before generating code.
+    assert(false);
   }
 }
 
 String singleIdentityComparison(HInstruction left,
                                 HInstruction right,
                                 Compiler compiler) {
   // Returns the single identity comparison (== or ===) or null if a more
   // complex expression is required.
   if ((left.isConstant() && left.isConstantSentinel()) ||
       (right.isConstant() && right.isConstantSentinel())) return '===';
   HType leftType = left.instructionType;
   HType rightType = right.instructionType;
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive(compiler) && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }