fixes #206, add checking for unary ops

test/checker/checker_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.
 
 /// General type checking tests
 library dev_compiler.test.checker_test;
 
 import 'package:test/test.dart';
 
 import 'package:dev_compiler/src/testing.dart';
@@ skipping 21 matching lines @@
           // it requires inference to work because of dartbug.com/23381
           SplayTreeMap([int compare(K key1, K key2),
                         bool isValidKey(potentialKey)]) {
             : _comparator = /*warning:DownCastComposite*/(compare == null) ? Comparable.compare : compare,
               _validKey = /*info:InferredType should be pass*/(isValidKey != null) ? isValidKey : ((v) => true);
               _Predicate<Object> _v = /*warning:DownCastComposite*/(isValidKey != null) ? isValidKey : ((v) => true);
               _v = /*info:InferredType should be pass*/(isValidKey != null) ? _v : ((v) => true);
           }
         }
         void main() {
+          Object obj = 42;
+          dynamic dyn = 42;
+          int i = 42;
+
+          // Check the boolean conversion of the condition.
+          print((/*severe:StaticTypeError*/i) ? false : true);
+          print((/*warning:DownCastImplicit*/obj) ? false : true);
+          print((/*info:DynamicCast*/dyn) ? false : true);
         }
       '''
     });
   });
 
+  test('if/for/do/while statements use boolean conversion', () => testChecker({
+    '/main.dart': '''
+      main() {
+        dynamic d = 42;
+        Object obj = 42;
+        int i = 42;
+        bool b = false;
+
+        if (b) {}
+        if (/*info:DynamicCast*/dyn) {}
+        if (/*warning:DownCastImplicit*/obj) {}
+        if (/*severe:StaticTypeError*/i) {}
+
+        while (b) {}
+        while (/*info:DynamicCast*/dyn) {}
+        while (/*warning:DownCastImplicit*/obj) {}
+        while (/*severe:StaticTypeError*/i) {}
+
+        do {} while (b);
+        do {} while (/*info:DynamicCast*/dyn);
+        do {} while (/*warning:DownCastImplicit*/obj);
+        do {} while (/*severe:StaticTypeError*/i);
+
+        for (;b;) {}
+        for (;/*info:DynamicCast*/dyn;) {}
+        for (;/*warning:DownCastImplicit*/obj;) {}
+        for (;/*severe:StaticTypeError*/i;) {}
+      }
+    '''
+  }));
+
   test('dynamic invocation', () {
     testChecker({
       '/main.dart': '''
 
       class A {
         dynamic call(dynamic x) => x;
       }
       class B extends A {
         int call(int x) => x;
         double col(double x) => x;
@@ skipping 1860 matching lines @@
             /*severe:InvalidMethodOverride*/C m2(C value) {}
             /*severe:InvalidMethodOverride*/A m3(C value) {}
             C m4(A value) {}
             /*severe:InvalidMethodOverride*/m5(value) {}
             /*severe:InvalidMethodOverride*/dynamic m6(dynamic value) {}
           }
        '''
     }, inferFromOverrides: true);
   });
 
+  test('unary operators', () => testChecker({
+    '/main.dart': '''
+      class A {
+        A operator ~() {}
+        A operator +(int x) {}
+        A operator -(int x) {}
+        A operator -() {}
+      }
+
+      foo() => new A();
+
+      test() {
+        A a = new A();
+        var c = foo();
+
+        ~a;
+        (/*info:DynamicInvoke*/~d);
+
+        !/*severe:StaticTypeError*/a;
+        !/*info:DynamicCast*/d;
+
+        -a;
+        (/*info:DynamicInvoke*/-d);
+
+        ++a;
+        --a;
+        (/*info:DynamicInvoke*/++d);
+        (/*info:DynamicInvoke*/--d);
+
+        a++;
+        a--;
+        (/*info:DynamicInvoke*/d++);
+        (/*info:DynamicInvoke*/d--);
+      }'''
+  }));
+
   test('binary and index operators', () {
     testChecker({
       '/main.dart': '''
           class A {
             A operator *(B b) {}
             A operator /(B b) {}
             A operator ~/(B b) {}
             A operator %(B b) {}
             A operator +(B b) {}
             A operator -(B b) {}
@@ skipping 1020 matching lines @@
     '/main.dart': '''
       import 'dart:foobar' show Baz;
       main() {
         print(Baz.quux);
       }'''
   },
       customUrlMappings: {
     'dart:foobar': '$testDirectory/checker/dart_foobar.dart'
   }));
 }