Type check binary expressions

test/checker/inferred_type_test.dart

 // Copyright (c) 2015, 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.
 
 /// Tests for type inference.
 library dev_compiler.test.inferred_type_test;
 
 import 'package:unittest/unittest.dart';
 
 import 'package:dev_compiler/src/testing.dart';
@@ skipping 651 matching lines @@
     testChecker({
       '/main.dart': '''
       class A {
         int x = 2;
       }
 
       test() {
         dynamic a = new A();
         A b = /*info:DynamicCast*/a;
         print(/*info:DynamicInvoke*/a.x);
-        print((/*info:DynamicInvoke*/a.x) + 2);
+        print(/*info:DynamicInvoke*/(/*info:DynamicInvoke*/a.x) + 2);
       }
     '''
     });
   });
 
   test('propagate inference transitively ', () {
     testChecker({
       '/main.dart': '''
       class A {
         int x = 2;
@@ skipping 542 matching lines @@
       }
       void main() {
           {  // Variables, nested literals
             var x = "hello";
             var y = 3;
             void f(List<Map<int, String>> l) {};
             f(/*info:InferredTypeLiteral*/[{y: x}]);
           }
           {
             int f(int x) {};
-            A<int> = new A(f);
+            A<int> a = /*info:InferredTypeAllocation*/new A(f);
           }
       }
       '''
     }, inferDownwards: true);
   });
 
   test('downwards inference on instance creations', () {
     String mk(String info) => '''
       class A<S, T> {
         S x;
@@ skipping 254 matching lines @@
         }
         {
           Function2<int, List<String>> l0 = (int x) => null;
           Function2<int, List<String>> l1 = /*info:InferredTypeClosure*/(int x) => ["hello"];
           Function2<int, List<String>> l2 = /*severe:StaticTypeError*/(String x) => ["hello"];
           Function2<int, List<String>> l3 = /*warning:UninferredClosure should be severe:StaticTypeError*/(int x) => [3];
           Function2<int, List<String>> l4 = /*warning:UninferredClosure should be severe:StaticTypeError*/(int x) {return [3]};
         }
         {
           Function2<int, int> l0 = /*info:InferredTypeClosure*/(x) => x;
-          Function2<int, int> l1 = /*info:InferredTypeClosure*/(x) => x+1;
+          Function2<int, int> l1 = /*info:InferredTypeClosure*/(x) => /*info:DynamicInvoke should be pass*/x+1;
           Function2<int, String> l2 = /*info:InferredTypeClosure should be severe:StaticTypeError*/(x) => x;
           Function2<int, String> l3 = /*info:InferredTypeClosure should be severe:StaticTypeError*/(x) => /*info:DynamicInvoke should be pass*/x.substring(3);
           Function2<String, String> l4 = /*info:InferredTypeClosure*/(x) => /*info:DynamicInvoke should be pass*/x.substring(3);
         }
       }
       '''
     }, inferDownwards: true, wrapClosures: false);
   });
 }