Finish strong mode cleaning of dart2js.

pkg/compiler/lib/src/ssa/value_range_analyzer.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.
 
 import '../constant_system_dart.dart';
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../world.dart' show ClosedWorld;
 import 'nodes.dart';
 import 'optimize.dart';
@@ skipping 114 matching lines @@
 }
 
 /**
  * An [IntValue] contains a constant integer value.
  */
 class IntValue extends Value {
   final int value;
 
   const IntValue(this.value, info) : super(info);
 
-  Value operator +(other) {
+  Value operator +(dynamic other) {
     if (other.isZero) return this;
     if (other is! IntValue) return other + this;
     ConstantSystem constantSystem = info.constantSystem;
-    var constant = constantSystem.add.fold(
+    dynamic constant = constantSystem.add.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
     if (!constant.isInt) return const UnknownValue();
     return info.newIntValue(constant.primitiveValue);
   }
 
-  Value operator -(other) {
+  Value operator -(dynamic other) {
     if (other.isZero) return this;
     if (other is! IntValue) return -other + this;
     ConstantSystem constantSystem = info.constantSystem;
-    var constant = constantSystem.subtract.fold(
+    dynamic constant = constantSystem.subtract.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
     if (!constant.isInt) return const UnknownValue();
     return info.newIntValue(constant.primitiveValue);
   }
 
   Value operator -() {
     if (isZero) return this;
     ConstantSystem constantSystem = info.constantSystem;
-    var constant = constantSystem.negate.fold(constantSystem.createInt(value));
+    dynamic constant =
+        constantSystem.negate.fold(constantSystem.createInt(value));
     if (!constant.isInt) return const UnknownValue();
     return info.newIntValue(constant.primitiveValue);
   }
 
-  Value operator &(other) {
+  Value operator &(dynamic other) {
     if (other is! IntValue) return const UnknownValue();
     ConstantSystem constantSystem = info.constantSystem;
-    var constant = constantSystem.bitAnd.fold(
+    dynamic constant = constantSystem.bitAnd.fold(
         constantSystem.createInt(value), constantSystem.createInt(other.value));
     return info.newIntValue(constant.primitiveValue);
   }
 
-  Value min(other) {
+  Value min(dynamic other) {
     if (other is! IntValue) return other.min(this);
     return this.value < other.value ? this : other;
   }
 
-  Value max(other) {
+  Value max(dynamic other) {
     if (other is! IntValue) return other.max(this);
     return this.value < other.value ? other : this;
   }
 
   bool operator ==(other) {
     if (other is! IntValue) return false;
     return this.value == other.value;
   }
 
   int get hashCode => throw new UnsupportedError('IntValue.hashCode');
@@ skipping 775 matching lines @@
           rightRange.lower + info.intOne, const MaxIntValue());
     } else if (operation == const GreaterEqualOperation()) {
       range = info.newNormalizedRange(rightRange.lower, const MaxIntValue());
     } else {
       range = info.newUnboundRange();
     }
     return range.intersection(leftRange);
   }
 
   Range visitConditionalBranch(HConditionalBranch branch) {
-    var condition = branch.condition;
+    dynamic condition = branch.condition;
     // TODO(ngeoffray): Handle complex conditions.
     if (condition is! HRelational) return info.newUnboundRange();
     if (condition is HIdentity) return info.newUnboundRange();
     HInstruction right = condition.right;
     HInstruction left = condition.left;
     if (!left.isInteger(closedWorld)) return info.newUnboundRange();
     if (!right.isInteger(closedWorld)) return info.newUnboundRange();
 
     Range rightRange = ranges[right];
     Range leftRange = ranges[left];
@@ skipping 118 matching lines @@
   }
 
   Range handleBinaryOperation(HBinaryArithmetic instruction) {
     Range leftRange = visit(instruction.left);
     Range rightRange = visit(instruction.right);
     if (leftRange == null || rightRange == null) return null;
     BinaryOperation operation = instruction.operation(info.constantSystem);
     return operation.apply(leftRange, rightRange);
   }
 }