dart2js cps: Narrow the receiver mask on InvokeMethod.

pkg/compiler/lib/src/cps_ir/type_propagation.dart

 // Copyright (c) 2014, 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.
 library dart2js.cps_ir.type_propagation;
 
 import 'optimizers.dart';
 
 import '../closure.dart' show
     ClosureClassElement;
 import '../common.dart';
@@ skipping 1700 matching lines @@
 
   void visitInvokeMethod(InvokeMethod node) {
     if (constifyExpression(node)) return;
     if (specializeOperatorCall(node)) return;
     if (specializeFieldAccess(node)) return;
     if (specializeIndexableAccess(node)) return;
     if (specializeArrayAccess(node)) return;
     if (specializeSingleUseClosureCall(node)) return;
     if (specializeClosureCall(node)) return;
 
+    node.mask =
+      typeSystem.intersection(node.mask, getValue(getDartReceiver(node)).type);
+
     AbstractValue receiver = getValue(node.receiver.definition);
 
     if (node.receiverIsIntercepted &&
         node.receiver.definition.sameValue(node.arguments[0].definition)) {
       // The receiver and first argument are the same; that means we already
       // determined in visitInterceptor that we are targeting a non-interceptor.
 
       // Check if any of the possible targets depend on the extra receiver
       // argument. Mixins do this, and tear-offs always needs the extra receiver
       // argument because BoundClosure uses it for equality and hash code.
@@ skipping 1005 matching lines @@
         setReachable(cont);
         setValue(cont.parameters.single, input);
         break;
 
       case AbstractBool.False:
         break; // Cast fails. Continuation should remain unreachable.
 
       case AbstractBool.Maybe:
         setReachable(cont);
         // Narrow type of output to those that survive the cast.
-        TypeMask type = input.type.intersection(
-            typeSystem.subtypesOf(node.dartType),
-            classWorld);
+        TypeMask type = typeSystem.intersection(
+            input.type,
+            typeSystem.subtypesOf(node.dartType));
         setValue(cont.parameters.single, nonConstant(type));
         break;
     }
   }
 
   void visitSetMutable(SetMutable node) {
     setValue(node.variable.definition, getValue(node.value.definition));
   }
 
   void visitLiteralList(LiteralList node) {
@@ skipping 276 matching lines @@
   processLetPrim(LetPrim node) {
     node.primitive.type = null;
     values[node.primitive] = null;
   }
 
   processLetMutable(LetMutable node) {
     node.variable.type = null;
     values[node.variable] = null;
   }
 }