fixes #206, add checking for unary ops

lib/src/codegen/js_codegen.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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1780 matching lines @@
     if (expr is Conversion) {
       return _isNonNullableExpression(expr.expression);
     }
     if (expr is SimpleIdentifier) {
       // Type literals are not null.
       Element e = expr.staticElement;
       if (e is ClassElement || e is FunctionTypeAliasElement) return true;
     }
     DartType type = null;
     if (expr is BinaryExpression) {
+      switch (expr.operator.type) {
+        case TokenType.EQ_EQ:
+        case TokenType.BANG_EQ:
+        case TokenType.AMPERSAND_AMPERSAND:
+        case TokenType.BAR_BAR:
+          return true;
+      }
       type = getStaticType(expr.leftOperand);
     } else if (expr is PrefixExpression) {
+      if (expr.operator.type == TokenType.BANG) return true;
       type = getStaticType(expr.operand);
     } else if (expr is PostfixExpression) {
       type = getStaticType(expr.operand);
     }
     if (type != null && _isJSBuiltinType(type)) {
       return true;
     }
     if (expr is MethodInvocation) {
       // TODO(vsm): This logic overlaps with the resolver.
       // Where is the best place to put this?
@@ skipping 15 matching lines @@
           if (!types.split('|').contains('Null')) {
             return true;
           }
         }
       }
     }
     return false;
   }
 
   JS.Expression notNull(Expression expr) {
-    if (_isNonNullableExpression(expr)) {
-      return _visit(expr);
-    } else {
-      return js.call('dart.notNull(#)', _visit(expr));
-    }
+    if (expr == null) return null;
+    var jsExpr = _visit(expr);
+    if (_isNonNullableExpression(expr)) return jsExpr;
+    return js.call('dart.notNull(#)', jsExpr);
   }
 
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
     var leftType = getStaticType(left);
     var rightType = getStaticType(right);
 
@@ skipping 342 matching lines @@
   /// Those two nodes are special because they're both allowed on left side of
   /// an assignment expression and cascades.
   Expression _getTarget(node) {
     assert(node is IndexExpression || node is PropertyAccess);
     return node.isCascaded ? _cascadeTarget : node.target;
   }
 
   @override
   visitConditionalExpression(ConditionalExpression node) {
     return js.call('# ? # : #', [
-      _visit(node.condition),
+      notNull(node.condition),
       _visit(node.thenExpression),
       _visit(node.elseExpression)
     ]);
   }
 
   @override
   visitThrowExpression(ThrowExpression node) {
     var expr = _visit(node.expression);
     if (node.parent is ExpressionStatement) {
       return js.statement('throw #;', expr);
     } else {
       return js.call('dart.throw_(#)', expr);
     }
   }
 
   @override
   visitRethrowExpression(RethrowExpression node) {
     if (node.parent is ExpressionStatement) {
       return js.statement('throw #;', _visit(_catchParameter));
     } else {
       return js.call('dart.throw_(#)', _visit(_catchParameter));
     }
   }
 
   @override
   JS.If visitIfStatement(IfStatement node) {
-    return new JS.If(_visit(node.condition), _visit(node.thenStatement),
+    return new JS.If(notNull(node.condition), _visit(node.thenStatement),
         _visit(node.elseStatement));
   }
 
   @override
   JS.For visitForStatement(ForStatement node) {
     var init = _visit(node.initialization);
     if (init == null) init = _visit(node.variables);
     var update = _visitListToBinary(node.updaters, ',');
     if (update != null) update = update.toVoidExpression();
-    return new JS.For(init, _visit(node.condition), update, _visit(node.body));
+    return new JS.For(init, notNull(node.condition), update, _visit(node.body));
   }
 
   @override
   JS.While visitWhileStatement(WhileStatement node) {
-    return new JS.While(_visit(node.condition), _visit(node.body));
+    return new JS.While(notNull(node.condition), _visit(node.body));
   }
 
   @override
   JS.Do visitDoStatement(DoStatement node) {
-    return new JS.Do(_visit(node.body), _visit(node.condition));
+    return new JS.Do(_visit(node.body), notNull(node.condition));
   }
 
   @override
   JS.ForOf visitForEachStatement(ForEachStatement node) {
     var init = _visit(node.identifier);
     if (init == null) {
       init = js.call('let #', node.loopVariable.identifier.name);
     }
     return new JS.ForOf(init, _visit(node.iterable), _visit(node.body));
   }
@@ skipping 288 matching lines @@
   ///       Point(x, y) {
   ///         this[_x] = x;
   ///         this[_y] = y;
   ///       }
   ///       get x() { return this[_x]; }
   ///       get y() { return this[_y]; }
   ///     }
   ///
   /// For user-defined operators the following names are allowed:
   ///
-  ///     <, >, <=, >=, ==, -, +, /, ˜/, *, %, |, ˆ, &, <<, >>, []=, [], ˜
+  ///     <, >, <=, >=, ==, -, +, /, ~/, *, %, |, ^, &, <<, >>, []=, [], ~
   ///
   /// They generate code like:
   ///
   ///     x['+'](y)
   ///
   /// There are three exceptions: [], []= and unary -.
   /// The indexing operators we use `get` and `set` instead:
   ///
   ///     x.get('hi')
   ///     x.set('hi', 123)
@@ skipping 127 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }