dart2js cps: Introduce some built-in operators in type propagation.

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

 // Copyright (c) 2013, 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.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 744 matching lines @@
 
   @override
   ir.Primitive visitIsNot(ast.Send node,
                           ast.Node expression, DartType type, _) {
     ir.Primitive value = visit(expression);
     ir.Primitive check = irBuilder.buildTypeOperator(
         value, type, isTypeTest: true);
     return irBuilder.buildNegation(check);
   }
 
-  ir.Primitive translateBinary(ast.Node left,
+  ir.Primitive translateBinary(ast.Send node,
+                               ast.Node left,
                                op.BinaryOperator operator,
                                ast.Node right) {
-    Selector selector = new Selector.binaryOperator(operator.selectorName);
+    Selector selector = useSelectorTypeOfNode(
+        new Selector.binaryOperator(operator.selectorName),
+        node);
     ir.Primitive receiver = visit(left);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(right)];
     arguments = normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(receiver, selector, arguments);
   }
 
   @override
   ir.Primitive visitBinary(ast.Send node,
                            ast.Node left,
                            op.BinaryOperator operator,
                            ast.Node right, _) {
-    return translateBinary(left, operator, right);
+    return translateBinary(node, left, operator, right);
   }
 
   @override
   ir.Primitive visitIndex(ast.Send node,
                           ast.Node receiver,
                           ast.Node index, _) {
-    Selector selector = new Selector.index();
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
     ir.Primitive target = visit(receiver);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
     arguments = normalizeDynamicArguments(selector.callStructure, arguments);
     return irBuilder.buildDynamicInvocation(target, selector, arguments);
   }
 
   ir.Primitive translateSuperBinary(FunctionElement function,
                                     op.BinaryOperator operator,
                                     ast.Node argument) {
     CallStructure callStructure = CallStructure.ONE_ARG;
@@ skipping 21 matching lines @@
       _) {
     return irBuilder.buildSuperIndex(function, visit(index));
   }
 
   @override
   ir.Primitive visitEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
-    return translateBinary(left, op.BinaryOperator.EQ, right);
+    return translateBinary(node, left, op.BinaryOperator.EQ, right);
   }
 
   @override
   ir.Primitive visitSuperEquals(
       ast.Send node,
       FunctionElement function,
       ast.Node argument,
       _) {
     return translateSuperBinary(function, op.BinaryOperator.EQ, argument);
   }
 
   @override
   ir.Primitive visitNot(
       ast.Send node,
       ast.Node expression,
       _) {
     return irBuilder.buildNegation(visit(expression));
   }
 
   @override
   ir.Primitive visitNotEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
     return irBuilder.buildNegation(
-        translateBinary(left, op.BinaryOperator.NOT_EQ, right));
+        translateBinary(node, left, op.BinaryOperator.NOT_EQ, right));
   }
 
   @override
   ir.Primitive visitSuperNotEquals(
       ast.Send node,
       FunctionElement function,
       ast.Node argument,
       _) {
     return irBuilder.buildNegation(
         translateSuperBinary(function, op.BinaryOperator.NOT_EQ, argument));
@@ skipping 1990 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }