- Add support for binary operators

tests/compiler/dart2js/cpa_inference_test.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.
 
 import "dart:uri";
 import "../../../lib/compiler/implementation/elements/elements.dart";
 import '../../../lib/compiler/implementation/scanner/scannerlib.dart';
 import '../../../lib/compiler/implementation/source_file.dart';
 import '../../../lib/compiler/implementation/types/types.dart';
 import '../../../lib/compiler/implementation/tree/tree.dart';
@@ skipping 27 matching lines @@
   }
 }
 
 class AnalysisResult {
   MockCompiler compiler;
   ConcreteTypesInferrer inferrer;
   Node ast;
 
   BaseType int;
   BaseType double;
+  BaseType num;
   BaseType bool;
   BaseType string;
   BaseType list;
   BaseType map;
   BaseType nullType;
 
   AnalysisResult(MockCompiler compiler) : this.compiler = compiler {
     inferrer = compiler.typesTask.concreteTypesInferrer;
     int = inferrer.baseTypes.intBaseType;
     double = inferrer.baseTypes.doubleBaseType;
+    num = inferrer.baseTypes.numBaseType;
     bool = inferrer.baseTypes.boolBaseType;
     string = inferrer.baseTypes.stringBaseType;
     list = inferrer.baseTypes.listBaseType;
     map = inferrer.baseTypes.mapBaseType;
     nullType = new NullBaseType();
     Element mainElement = compiler.mainApp.find(buildSourceString('main'));
     ast = mainElement.parseNode(compiler);
   }
 
   BaseType base(String className) {
@@ skipping 45 matching lines @@
    * made of [baseTypes].
    */
   void checkFieldHasType(String className, String fieldName,
                          List<BaseType> baseTypes) {
     return Expect.equals(
         concreteFrom(baseTypes),
         inferrer.inferredFieldTypes[findField(className, fieldName)]);
   }
 }
 
+const String CORELIB = r'''
+  print(var obj) {}
+  abstract class num { operator +(x); operator *(x); operator -(x); }
+  abstract class int extends num { }
+  abstract class double extends num { }
+  class bool {}
+  class String {}
+  class Object {}
+  class Function {}
+  abstract class List {}
+  abstract class Map {}
+  class Closure {}
+  class Null {}
+  class Dynamic_ {}
+  bool identical(Object a, Object b) {}''';
+
 AnalysisResult analyze(String code) {
   Uri uri = new Uri.fromComponents(scheme: 'source');
-  MockCompiler compiler = new MockCompiler(enableConcreteTypeInference: true);
+  MockCompiler compiler = new MockCompiler(coreSource: CORELIB,
+                                           enableConcreteTypeInference: true);
   compiler.sourceFiles[uri.toString()] = new SourceFile(uri.toString(), code);
   compiler.runCompiler(uri);
   return new AnalysisResult(compiler);
 }
 
 testLiterals() {
   final String source = r"""
       main() {
         var v1 = 42;
         var v2 = 42.0;
@@ skipping 305 matching lines @@
         var x = f();
         var y = g();
         x; y;
       }
       """;
   AnalysisResult result = analyze(source);
   result.checkNodeHasType('x', [result.int, result.nullType]);
   result.checkNodeHasType('y', [result.nullType]);
 }
 
+testArithmeticOperators() {
+  String source(op) {
+    return """
+        main() {
+          var a = 1 $op 2;
+          var b = 1 $op 2.0;
+          var c = 1.0 $op 2;
+          var d = 1.0 $op 2.0;
+          var e = (1 $op 2.0) $op 1;
+          var f = 1 $op (1 $op 2.0);
+          var g = (1 $op 2.0) $op 1.0;
+          var h = 1.0 $op (1 $op 2);
+          var i = (1 $op 2) $op 1;
+          var j = 1 $op (1 $op 2);
+          var k = (1.0 $op 2.0) $op 1.0;
+          var l = 1.0 $op (1.0 $op 2.0);
+          a; b; c; d; e; f; g; h; i; j; k; l;
+        }""";
+  }
+  for (String op in ['+', '*', '-']) {
+    AnalysisResult result = analyze(source(op));
+    result.checkNodeHasType('a', [result.int]);
+    result.checkNodeHasType('b', [result.num]);
+    result.checkNodeHasType('c', [result.num]);
+    result.checkNodeHasType('d', [result.double]);
+    result.checkNodeHasType('e', [result.num]);
+    result.checkNodeHasType('f', [result.num]);
+    result.checkNodeHasType('g', [result.num]);
+    result.checkNodeHasType('h', [result.num]);
+    result.checkNodeHasType('i', [result.int]);
+    result.checkNodeHasType('j', [result.int]);
+    result.checkNodeHasType('k', [result.double]);
+    result.checkNodeHasType('l', [result.double]);
+  }
+}
+
+testOperators() {
+  final String source = r"""
+      class A {
+        operator <(x) => 42;
+        operator <<(x) => "a";
+      }
+      main() {
+        var x = new A() < "foo";
+        var y = new A() << "foo";
+        x; y;
+      }
+      """;
+  AnalysisResult result = analyze(source);
+  result.checkNodeHasType('x', [result.int]);
+  result.checkNodeHasType('y', [result.string]);
+}
+
 void main() {
   testLiterals();
   testRedefinition();
   testIfThenElse();
   testTernaryIf();
   testWhile();
   testFor1();
   testFor2();
   testNonRecusiveFunction();
   testRecusiveFunction();
   testMutuallyRecusiveFunction();
   testSendToThis1();
   testSendToThis2();
   testConstructor();
   testGetters();
   testSetters();
   testNamedParameters();
   testListLiterals();
   testMapLiterals();
   testReturn();
   // testNoReturn(); // right now we infer the empty type instead of null
+  testArithmeticOperators();
+  testOperators();
 }