Fix 56 hints in pkg/compiler

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.
 
 part of ssa;
 
 /**
  * [InvokeDynamicSpecializer] and its subclasses are helpers to
  * optimize intercepted dynamic calls. It knows what input types
  * would be beneficial for performance, and how to change a invoke
@@ skipping 124 matching lines @@
     // integer or throw an error.
     JavaScriptBackend backend = compiler.backend;
     if (instruction.inputs[1].isPrimitiveOrNull(compiler)) {
       return backend.uint32Type;
     }
     return super.computeTypeFromInputTypes(instruction, compiler);
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
-    JavaScriptBackend backend = compiler.backend;
     HInstruction input = instruction.inputs[1];
     if (input.isNumber(compiler)) {
       return new HBitNot(input, instruction.selector,
                          computeTypeFromInputTypes(instruction, compiler));
     }
     return null;
   }
 }
 
 class UnaryNegateSpecializer extends InvokeDynamicSpecializer {
@@ skipping 254 matching lines @@
       }
       if (left.isUInt32(compiler) && isTwoOrGreater(right, compiler)) {
         return true;
       }
     }
     return false;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
-    HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (isBuiltin(instruction, compiler)) {
       if (right.isPositiveInteger(compiler) && isNotZero(right, compiler)) {
         if (hasUint31Result(instruction, compiler)) {
           return newBuiltinVariant(instruction, compiler);
         }
         // We can call _tdivFast because the rhs is a 32bit integer
         // and not 0, nor -1.
         instruction.selector = renameToOptimizedSelector(
             '_tdivFast', instruction.selector, compiler);
@@ skipping 53 matching lines @@
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (left.isNumber(compiler)) {
       if (argumentLessThan32(right)) {
         return newBuiltinVariant(instruction, compiler);
       }
       // 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);
-      Selector selector = instruction.selector;
       if (isPositive(right, compiler)) {
         instruction.selector = renameToOptimizedSelector(
             '_shlPositive', instruction.selector, compiler);
       }
     }
     return null;
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
-    JavaScriptBackend backend = compiler.backend;
     return new HShiftLeft(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, computeTypeFromInputTypes(instruction, compiler));
   }
 }
 
 class ShiftRightSpecializer extends BinaryBitOpSpecializer {
   const ShiftRightSpecializer();
 
   TypeMask computeTypeFromInputTypes(HInvokeDynamic instruction,
                                      Compiler compiler) {
     HInstruction left = instruction.inputs[1];
-    HInstruction right = instruction.inputs[2];
-    JavaScriptBackend backend = compiler.backend;
     if (left.isUInt32(compiler)) return left.instructionType;
     return super.computeTypeFromInputTypes(instruction, compiler);
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     if (left.isNumber(compiler)) {
       if (argumentLessThan32(right) && isPositive(left, compiler)) {
@@ skipping 12 matching lines @@
       } else if (isPositive(right, compiler)) {
         instruction.selector = renameToOptimizedSelector(
             '_shrOtherPositive', instruction.selector, compiler);
       }
     }
     return null;
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
-    JavaScriptBackend backend = compiler.backend;
     return new HShiftRight(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, computeTypeFromInputTypes(instruction, compiler));
   }
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.shiftRight;
   }
 }
 
@@ skipping 10 matching lines @@
     HInstruction right = instruction.inputs[2];
     JavaScriptBackend backend = compiler.backend;
     if (left.isUInt31(compiler) && right.isUInt31(compiler)) {
       return backend.uint31Type;
     }
     return super.computeTypeFromInputTypes(instruction, compiler);
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
-    JavaScriptBackend backend = compiler.backend;
     return new HBitOr(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, computeTypeFromInputTypes(instruction, compiler));
   }
 }
 
 class BitAndSpecializer extends BinaryBitOpSpecializer {
   const BitAndSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.bitAnd;
   }
 
   TypeMask computeTypeFromInputTypes(HInvokeDynamic instruction,
                                      Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     JavaScriptBackend backend = compiler.backend;
     if (left.isPrimitiveOrNull(compiler) &&
         (left.isUInt31(compiler) || right.isUInt31(compiler))) {
       return backend.uint31Type;
     }
     return super.computeTypeFromInputTypes(instruction, compiler);
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
-    JavaScriptBackend backend = compiler.backend;
     return new HBitAnd(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, computeTypeFromInputTypes(instruction, compiler));
   }
 }
 
 class BitXorSpecializer extends BinaryBitOpSpecializer {
   const BitXorSpecializer();
 
   BinaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.bitXor;
   }
 
   TypeMask computeTypeFromInputTypes(HInvokeDynamic instruction,
                                      Compiler compiler) {
     HInstruction left = instruction.inputs[1];
     HInstruction right = instruction.inputs[2];
     JavaScriptBackend backend = compiler.backend;
     if (left.isUInt31(compiler) && right.isUInt31(compiler)) {
       return backend.uint31Type;
     }
     return super.computeTypeFromInputTypes(instruction, compiler);
   }
 
   HInstruction newBuiltinVariant(HInvokeDynamic instruction,
                                  Compiler compiler) {
-    JavaScriptBackend backend = compiler.backend;
     return new HBitXor(
         instruction.inputs[1], instruction.inputs[2],
         instruction.selector, computeTypeFromInputTypes(instruction, compiler));
   }
 }
 
 abstract class RelationalSpecializer extends InvokeDynamicSpecializer {
   const RelationalSpecializer();
 
   TypeMask computeTypeFromInputTypes(HInvokeDynamic instruction,
@@ skipping 127 matching lines @@
     return constantSystem.codeUnitAt;
   }
 
   HInstruction tryConvertToBuiltin(HInvokeDynamic instruction,
                                    Compiler compiler) {
     // TODO(sra): Implement a builtin HCodeUnitAt instruction and the same index
     // bounds checking optimizations as for HIndex.
     return null;
   }
 }