Better bitwise and binary arithmetic when the left operand is known to be a number.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 1111 matching lines @@
       use(node.right, operatorPrecedences.right);
       endExpression(operatorPrecedences.precedence);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeBinary(HBinaryBitOp node, String op) {
-    if (node.builtin){
+    if (node.builtin) {
       beginExpression(unsignedShiftPrecedences.precedence);
       int oldPrecedence = this.expectedPrecedence;
       this.expectedPrecedence = JSPrecedence.SHIFT_PRECEDENCE;
       visitInvokeBinary(node, op);
       buffer.add(' >>> 0');
       this.expectedPrecedence = oldPrecedence;
       endExpression(unsignedShiftPrecedences.precedence);
     } else {
       visitInvokeBinary(node, op);
     }
@@ skipping 52 matching lines @@
   visitSubtract(HSubtract node)     => visitInvokeBinary(node, '-');
   // Truncating divide does not have a JS equivalent.
   visitTruncatingDivide(HTruncatingDivide node) => visitInvokeStatic(node);
   // Modulo cannot be mapped to the native operator (different semantics).
   visitModulo(HModulo node)                     => visitInvokeStatic(node);
 
   visitBitAnd(HBitAnd node)         => visitBitInvokeBinary(node, '&');
   visitBitNot(HBitNot node)         => visitBitInvokeUnary(node, '~');
   visitBitOr(HBitOr node)           => visitBitInvokeBinary(node, '|');
   visitBitXor(HBitXor node)         => visitBitInvokeBinary(node, '^');
-
-  // We need to check if the left operand is negative in order to use
-  // the native operator.
-  visitShiftRight(HShiftRight node) => visitInvokeStatic(node);
-
-  // Shift left cannot be mapped to the native operator (different semantics).
-  visitShiftLeft(HShiftLeft node)   => visitInvokeStatic(node);
+  visitShiftRight(HShiftRight node) => visitBitInvokeBinary(node, '>>');
+  visitShiftLeft(HShiftLeft node)   => visitBitInvokeBinary(node, '<<');
 
   visitNegate(HNegate node)         => visitInvokeUnary(node, '-');
 
   visitIdentity(HIdentity node)         => visitInvokeBinary(node, '===');
   visitLess(HLess node)                 => visitInvokeBinary(node, '<');
   visitLessEqual(HLessEqual node)       => visitInvokeBinary(node, '<=');
   visitGreater(HGreater node)           => visitInvokeBinary(node, '>');
   visitGreaterEqual(HGreaterEqual node) => visitInvokeBinary(node, '>=');
 
   visitBoolify(HBoolify node) {
@@ skipping 779 matching lines @@
       buffer.add(' >= ');
       use(node.length, JSPrecedence.SHIFT_PRECEDENCE);
       buffer.add(") ");
     }
     generateThrowWithHelper('ioore', node.index);
   }
 
   visitIntegerCheck(HIntegerCheck node) {
     if (!node.alwaysFalse) {
       buffer.add('if (');
-      use(node.value, JSPrecedence.EQUALITY_PRECEDENCE);
-      buffer.add(' !== (');
-      use(node.value, JSPrecedence.BITWISE_OR_PRECEDENCE);
-      buffer.add(" | 0)) ");
+      checkInt(node.value, '!==');
+      buffer.add(') ');
     }
     generateThrowWithHelper('iae', node.value);
   }
 
   void generateThrowWithHelper(String helperName, HInstruction argument) {
     Element helper = compiler.findHelper(new SourceString(helperName));
     world.registerStaticUse(helper);
     buffer.add('throw ');
     beginExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
@@ skipping 383 matching lines @@
         buffer.add(".${name.slowToString()} === '${arguments.head}'");
         endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       });
     }
     if (node.nullOk) {
       endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     }
   }
 
   void visitTypeConversion(HTypeConversion node) {
-    if (node.checked) {
+    if (node.isChecked()) {
       Element element = node.type.computeType(compiler).element;
       world.registerIsCheck(element);
       SourceString helper;
       String additionalArgument;
       bool nativeCheck =
           backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
       beginExpression(JSPrecedence.CALL_PRECEDENCE);
 
+      if (node.isArgumentTypeCheck()) {
+        buffer.add('if (');
+        if (element == compiler.intClass) {
+          checkInt(node.checkedInput, '!==');
+        } else {
+          assert(element == compiler.numClass);
+          checkNum(node.checkedInput, '!==');
+        }
+        buffer.add(') ');
+        generateThrowWithHelper('iae', node.checkedInput);
+        return;
+      }
+
+      assert(node.isCheckedModeCheck());
       if (element == compiler.stringClass) {
         helper = const SourceString('stringTypeCheck');
       } else if (element == compiler.doubleClass) {
         helper = const SourceString('doubleTypeCheck');
       } else if (element == compiler.numClass) {
         helper = const SourceString('numTypeCheck');
       } else if (element == compiler.boolClass) {
         helper = const SourceString('boolTypeCheck');
       } else if (element == compiler.functionClass || element.isTypedef()) {
         helper = const SourceString('functionTypeCheck');
@@ skipping 471 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }