Finish strong mode cleaning of dart2js.

pkg/compiler/lib/src/ssa/optimize.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 '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 905 matching lines @@
         if (value != null) {
           return _graph.addConstant(value, _closedWorld);
         }
       }
     }
 
     return node;
   }
 
   HInstruction visitGetLength(HGetLength node) {
-    var receiver = node.receiver;
+    dynamic receiver = node.receiver;
     if (_graph.allocatedFixedLists.contains(receiver)) {
       // TODO(ngeoffray): checking if the second input is an integer
       // should not be necessary but it currently makes it easier for
       // other optimizations to reason about a fixed length constructor
       // that we know takes an int.
       if (receiver.inputs[0].isInteger(_closedWorld)) {
         return receiver.inputs[0];
       }
     } else if (receiver.isConstantList() || receiver.isConstantString()) {
       return _graph.addConstantInt(receiver.constant.length, _closedWorld);
     } else {
-      var type = receiver.instructionType;
+      dynamic type = receiver.instructionType;
       if (type.isContainer && type.length != null) {
         HInstruction constant =
             _graph.addConstantInt(type.length, _closedWorld);
         if (type.isNullable) {
           // If the container can be null, we update all uses of the length
           // access to use the constant instead, but keep the length access in
           // the graph, to ensure we still have a null check.
           node.block.rewrite(node, constant);
           return node;
         } else {
           return constant;
         }
       }
     }
 
     if (node.isAssignable &&
         isFixedLength(receiver.instructionType, _closedWorld)) {
       // The input type has changed to fixed-length so change to an unassignable
       // HGetLength to allow more GVN optimizations.
       return new HGetLength(receiver, node.instructionType,
           isAssignable: false);
     }
     return node;
   }
 
   HInstruction visitIndex(HIndex node) {
     if (node.receiver.isConstantList() && node.index.isConstantInteger()) {
-      var instruction = node.receiver;
+      dynamic instruction = node.receiver;
       List<ConstantValue> entries = instruction.constant.entries;
       instruction = node.index;
       int index = instruction.constant.primitiveValue;
       if (index >= 0 && index < entries.length) {
         return _graph.addConstant(entries[index], _closedWorld);
       }
     }
     return node;
   }
 
@@ skipping 2011 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }