Fix modulo and bitwise operators.

lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 2792 matching lines @@
         js.call('# != null ? # : #', [l, l, _visit(right)])
       ]);
     }
 
     if (binaryOperationIsPrimitive(leftType, rightType) ||
         leftType == types.stringType && op.type == TokenType.PLUS) {
       // special cases where we inline the operation
       // these values are assumed to be non-null (determined by the checker)
       // TODO(jmesserly): it would be nice to just inline the method from core,
       // instead of special cases here.
-      if (op.type == TokenType.TILDE_SLASH) {
-        // `a ~/ b` is equivalent to `(a / b).truncate()`
-        var div = AstBuilder.binaryExpression(left, '/', right)
-          ..staticType = node.staticType;
-        return _emitSend(div, 'truncate', []);
-      } else {
-        // TODO(vsm): When do Dart ops not map to JS?
-        code = '# $op #';
+      JS.Expression binary(String code) {
+        return js.call(code, [notNull(left), notNull(right)]);
       }
-      return js.call(code, [notNull(left), notNull(right)]);
+
+      JS.Expression bitwise(String code) {
+        return _coerceBitOperationResultToUnsigned(node, binary(code));
+      }
+
+      switch (op.type) {
+        case TokenType.TILDE_SLASH:

[Jennifer Messerly, 2016/04/28 20:08:52]

this looks great, love the refactoring!

+          // `a ~/ b` is equivalent to `(a / b).truncate()`
+          var div = AstBuilder.binaryExpression(left, '/', right)
+              ..staticType = node.staticType;
+          return _emitSend(div, 'truncate', []);
+
+        case TokenType.PERCENT:
+          // TODO(sra): We can generate `a % b + 0` if both are non-negative
+          // (the `+ 0` is to coerce -0.0 to 0).
+          return _emitSend(left, op.lexeme, [right]);
+
+        case TokenType.AMPERSAND:
+          return bitwise('# & #');
+
+        case TokenType.BAR:
+          return bitwise('# | #');
+
+        case TokenType.CARET:
+          return bitwise('# ^ #');
+
+        case TokenType.GT_GT:
+          // TODO(sra): Detect when JS shift does the right thing.
+          return _emitSend(left, op.lexeme, [right]);
+
+        case TokenType.LT_LT:
+          // TODO(sra): Detect when JS shift does the right thing.
+          return _emitSend(left, op.lexeme, [right]);
+
+        default:
+          // TODO(vsm): When do Dart ops not map to JS?
+          return binary('# $op #');
+      }
     }
 
     return _emitSend(left, op.lexeme, [right]);
   }
 
+  JS.Expression _coerceBitOperationResultToUnsigned(
+      Expression node, JS.Expression operation) {
+    // Bit operations are coerced to values on [0, 2^32). The coercion changes

[Jennifer Messerly, 2016/04/28 20:08:52]

move this to be a doc comment?

+    // the interpretation of the the 32-bit value from signed to unsigned.  Most
+    // JavaScript operations interpret their operands as signed and generate
+    // signed results.
+    return js.call('# >>> 0', operation);
+  }
+
   /// If the type [t] is [int] or [double], or a type parameter
   /// bounded by [int], [double] or [num] returns [num].
   /// Otherwise returns [t].
   DartType _canonicalizeNumTypes(DartType t) {
     var numType = types.numType;
     if (rules.isSubtypeOf(t, numType)) return numType;
     return t;
   }
 
   bool _canUsePrimitiveEquality(Expression left, Expression right) {
@@ skipping 156 matching lines @@
     return new JS.MetaLet(vars, body, statelessResult: true);
   }
 
   @override
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
     if (unaryOperationIsPrimitive(dispatchType)) {
+      if (op.lexeme == '~') {
+        if (_isNumberInJS(dispatchType)) {
+          JS.Expression jsExpr = js.call('~#', notNull(expr));
+          return _coerceBitOperationResultToUnsigned(node, jsExpr);
+        }
+        return _emitSend(expr, op.lexeme[0], []);
+      }
       if (!isNullable(expr)) {
         return js.call('$op#', _visit(expr));
-      } else if (op.lexeme == '++' || op.lexeme == '--') {
+      }
+      if (op.lexeme == '++' || op.lexeme == '--') {
         // We need a null check, so the increment must be expanded out.
         var vars = <JS.MetaLetVariable, JS.Expression>{};
         var x = _bindLeftHandSide(vars, expr, context: expr);
 
         var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
         var increment = AstBuilder.binaryExpression(x, op.lexeme[0], one)
           ..staticElement = node.staticElement
           ..staticType = getStaticType(expr);
 
         return new JS.MetaLet(vars, [_emitSet(x, increment)]);
-      } else {
-        return js.call('$op#', notNull(expr));
       }
+      return js.call('$op#', notNull(expr));
     }
 
     if (op.lexeme == '++' || op.lexeme == '--') {
       // Increment or decrement requires expansion.
       // Desugar `++x` as `x = x + 1`, ensuring that if `x` has subexpressions
       // (for example, x is IndexExpression) we evaluate those once.
       var one = AstBuilder.integerLiteral(1)..staticType = types.intType;
       return _emitOpAssign(expr, one, op.lexeme[0], node.staticElement,
           context: expr);
     }
@@ skipping 860 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';