We can actually map the Dart shift right to the JavaScript one under certain conditions.

sdk/lib/_internal/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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 203 matching lines @@
     }
     return false;
   }
 
   // We want the outcome of bit-operations to be positive. However, if
   // the result of a bit-operation is only used by other bit
   // operations we do not have to convert to an unsigned
   // integer. Also, if we are using & with a positive constant we know
   // that the result is positive already and need no conversion.
   bool requiresUintConversion(HInstruction instruction) {
+    if (instruction is HShiftRight) {
+      return false;
+    }
     if (instruction is HBitAnd) {
       HBitAnd bitAnd = instruction;
       if (isNonNegativeInt32Constant(bitAnd.left) ||
           isNonNegativeInt32Constant(bitAnd.right)) {
         return false;
       }
     }
     return hasNonBitOpUser(instruction, new Set<HPhi>());
   }
 
@@ skipping 1036 matching lines @@
 
   visitAdd(HAdd node)               => visitInvokeBinary(node, '+');
   visitDivide(HDivide node)         => visitInvokeBinary(node, '/');
   visitMultiply(HMultiply node)     => visitInvokeBinary(node, '*');
   visitSubtract(HSubtract node)     => visitInvokeBinary(node, '-');
   visitBitAnd(HBitAnd node)         => visitBitInvokeBinary(node, '&');
   visitBitNot(HBitNot node)         => visitBitInvokeUnary(node, '~');
   visitBitOr(HBitOr node)           => visitBitInvokeBinary(node, '|');
   visitBitXor(HBitXor node)         => visitBitInvokeBinary(node, '^');
   visitShiftLeft(HShiftLeft node)   => visitBitInvokeBinary(node, '<<');
+  visitShiftRight(HShiftRight node) => visitBitInvokeBinary(node, '>>>');
 
   visitNegate(HNegate node)         => visitInvokeUnary(node, '-');
 
   visitLess(HLess node)                 => visitRelational(node, '<');
   visitLessEqual(HLessEqual node)       => visitRelational(node, '<=');
   visitGreater(HGreater node)           => visitRelational(node, '>');
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node, '>=');
 
   visitBoolify(HBoolify node) {
     assert(node.inputs.length == 1);
@@ skipping 1288 matching lines @@
     if (left.isConstantNull() || right.isConstantNull() ||
         (left.isPrimitive(compiler) &&
          left.instructionType == right.instructionType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }