Lower shift-left when count is masked into valid range.

pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart

 // Copyright (c) 2013, 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 '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart' show Name;
 import '../elements/entities.dart';
 import '../js_backend/js_backend.dart';
@@ skipping 521 matching lines @@
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     HInstruction left = instruction.inputs[1];
     if (left.isPrimitiveOrNull(closedWorld)) {
       return closedWorld.commonMasks.uint32Type;
     }
     return super.computeTypeFromInputTypes(instruction, compiler, closedWorld);
   }
 
   bool argumentLessThan32(HInstruction instruction) {
-    if (!instruction.isConstantInteger()) return false;
-    HConstant rightConstant = instruction;
-    IntConstantValue intConstant = rightConstant.constant;
-    int count = intConstant.primitiveValue;
-    return count >= 0 && count <= 31;
+    return argumentInRange(instruction, 0, 31);
+  }
+
+  bool argumentInRange(HInstruction instruction, int low, int high) {
+    if (instruction.isConstantInteger()) {
+      HConstant rightConstant = instruction;
+      IntConstantValue intConstant = rightConstant.constant;
+      int value = intConstant.primitiveValue;
+      return value >= low && value <= high;
+    }
+    // TODO(sra): Integrate with the bit-width analysis in codegen.dart.
+    if (instruction is HBitAnd) {
+      return low == 0 &&
+          (argumentInRange(instruction.inputs[0], low, high) ||
+           argumentInRange(instruction.inputs[1], low, high));
+    }
+    return false;
   }
 
   bool isPositive(HInstruction instruction, ClosedWorld closedWorld) {
     // TODO: We should use the value range analysis. Currently, ranges
     // are discarded just after the analysis.
     return instruction.isPositiveInteger(closedWorld);
   }
 }
 
 class ShiftLeftSpecializer extends BinaryBitOpSpecializer {
@@ skipping 353 matching lines @@
       HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
     HInstruction receiver = instruction.getDartReceiver(closedWorld);
     if (receiver.isNumberOrNull(closedWorld)) {
       // Even if there is no builtin equivalent instruction, we know the
       // instruction does not have any side effect, and that it can be GVN'ed.
       clearAllSideEffects(instruction);
     }
     return null;
   }
 }