More dart2js strong mode cleanup.

pkg/compiler/lib/src/serialization/equivalence.dart

 // Copyright (c) 2016, 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.
 
 /// Functions for asserting equivalence across serialization.
 
 library dart2js.serialization.equivalence;
 
 import '../closure.dart';
 import '../common/resolution.dart';
@@ skipping 36 matching lines @@
     }
   }
   return true;
 }
 
 /// Returns `true` if the elements in [a] and [b] are equivalent as sets using
 /// [elementEquivalence] to determine element equivalence.
 bool areSetsEquivalent(Iterable set1, Iterable set2,
     [bool elementEquivalence(a, b) = equality]) {
   Set remaining = set2.toSet();
-  for (var element1 in set1) {
+  for (dynamic element1 in set1) {
     bool found = false;
-    for (var element2 in set2) {
+    for (dynamic element2 in set2) {
       if (elementEquivalence(element1, element2)) {
         found = true;
         remaining.remove(element2);
         break;
       }
     }
     if (!found) {
       return false;
     }
   }
   return remaining.isEmpty;
 }
 
 /// Returns `true` if the content of [map1] and [map2] is equivalent using
 /// [keyEquivalence] and [valueEquivalence] to determine key/value equivalence.
 bool areMapsEquivalent(Map map1, Map map2,
     [bool keyEquivalence(a, b) = equality,
     bool valueEquivalence(a, b) = equality]) {
   Set remaining = map2.keys.toSet();
-  for (var key1 in map1.keys) {
+  for (dynamic key1 in map1.keys) {
     bool found = false;
-    for (var key2 in map2.keys) {
+    for (dynamic key2 in map2.keys) {
       if (keyEquivalence(key1, key2)) {
         found = true;
         remaining.remove(key2);
         if (!valueEquivalence(map1[key1], map2[key2])) {
           return false;
         }
         break;
       }
     }
     if (!found) {
@@ skipping 166 matching lines @@
       throw new UnsupportedError('Unsupported access kind: ${a.kind}');
   }
 }
 
 /// Returns `true` if the send structures [a] and [b] are equivalent.
 bool areSendStructuresEquivalent(SendStructure a, SendStructure b) {
   if (identical(a, b)) return true;
   if (a == null || b == null) return false;
   if (a.kind != b.kind) return false;
 
-  var ad = a;
-  var bd = b;
+  dynamic ad = a;
+  dynamic bd = b;
   switch (a.kind) {
     case SendStructureKind.IF_NULL:
     case SendStructureKind.LOGICAL_AND:
     case SendStructureKind.LOGICAL_OR:
     case SendStructureKind.NOT:
     case SendStructureKind.INVALID_UNARY:
     case SendStructureKind.INVALID_BINARY:
       // No additional properties.
       return true;
 
@@ skipping 35 matching lines @@
   }
   throw new UnsupportedError('Unexpected send structures $a vs $b');
 }
 
 /// Returns `true` if the new structures [a] and [b] are equivalent.
 bool areNewStructuresEquivalent(NewStructure a, NewStructure b) {
   if (identical(a, b)) return true;
   if (a == null || b == null) return false;
   if (a.kind != b.kind) return false;
 
-  var ad = a;
-  var bd = b;
+  dynamic ad = a;
+  dynamic bd = b;
   switch (a.kind) {
     case NewStructureKind.NEW_INVOKE:
       return ad.semantics.kind == bd.semantics.kind &&
           areElementsEquivalent(ad.semantics.element, bd.semantics.element) &&
           areTypesEquivalent(ad.semantics.type, bd.semantics.type) &&
           areSelectorsEquivalent(ad.selector, bd.selector);
     case NewStructureKind.CONST_INVOKE:
       return ad.constantInvokeKind == bd.constantInvokeKind &&
           areConstantsEquivalent(ad.constant, bd.constant);
     case NewStructureKind.LATE_CONST:
@@ skipping 20 matching lines @@
 
   const TestStrategy(
       {this.elementEquivalence: areElementsEquivalent,
       this.typeEquivalence: areTypesEquivalent,
       this.constantEquivalence: areConstantsEquivalent,
       this.constantValueEquivalence: areConstantValuesEquivalent});
 
   /// An equivalence [TestStrategy] that doesn't throw on inequivalence.
   TestStrategy get testOnly => this;
 
-  bool test(var object1, var object2, String property, var value1, var value2,
+  bool test(dynamic object1, dynamic object2, String property, dynamic value1,
+      dynamic value2,
       [bool equivalence(a, b) = equality]) {
     return equivalence(value1, value2);
   }
 
   bool testLists(
       Object object1, Object object2, String property, List list1, List list2,
       [bool elementEquivalence(a, b) = equality]) {
     return areListsEquivalent(list1, list2, elementEquivalence);
   }
 
-  bool testSets(
-      var object1, var object2, String property, Iterable set1, Iterable set2,
+  bool testSets(dynamic object1, dynamic object2, String property,
+      Iterable set1, Iterable set2,
       [bool elementEquivalence(a, b) = equality]) {
     return areSetsEquivalent(set1, set2, elementEquivalence);
   }
 
-  bool testMaps(var object1, var object2, String property, Map map1, Map map2,
+  bool testMaps(
+      dynamic object1, dynamic object2, String property, Map map1, Map map2,
       [bool keyEquivalence(a, b) = equality,
       bool valueEquivalence(a, b) = equality]) {
     return areMapsEquivalent(map1, map2, keyEquivalence, valueEquivalence);
   }
 
   bool testElements(Object object1, Object object2, String property,
       Entity element1, Entity element2) {
     return test(object1, object2, property, element1, element2,
         (a, b) => elementEquivalence(a, b, strategy: this));
   }
@@ skipping 701 matching lines @@
           resolvedAst2.node) &&
       strategy.testNodes(resolvedAst1, resolvedAst2, 'body', resolvedAst1.body,
           resolvedAst2.body) &&
       testTreeElementsEquivalence(resolvedAst1, resolvedAst2, strategy) &&
       strategy.test(resolvedAst1, resolvedAst2, 'sourceUri',
           resolvedAst1.sourceUri, resolvedAst2.sourceUri);
   if (resolvedAst1.element is FunctionElement) {
     FunctionElement element1 = resolvedAst1.element;
     FunctionElement element2 = resolvedAst2.element;
     for (int index = 0; index < element1.parameters.length; index++) {
-      var parameter1 = element1.parameters[index];
-      var parameter2 = element2.parameters[index];
+      dynamic parameter1 = element1.parameters[index];
+      dynamic parameter2 = element2.parameters[index];
       result = result &&
           strategy.testNodes(parameter1, parameter2, 'node',
               parameter1.implementation.node, parameter2.implementation.node) &&
           strategy.testNodes(
               parameter1,
               parameter2,
               'initializer',
               parameter1.implementation.initializer,
               parameter2.implementation.initializer);
     }
@@ skipping 280 matching lines @@
         elements1.getLabelDefinition(node1),
         elements2.getLabelDefinition(node2));
   }
 }
 
 class NodeEquivalenceVisitor implements Visitor1<bool, Node> {
   final TestStrategy strategy;
 
   const NodeEquivalenceVisitor([this.strategy = const TestStrategy()]);
 
-  bool testNodes(
-      var object1, var object2, String property, Node node1, Node node2) {
+  bool testNodes(dynamic object1, dynamic object2, String property, Node node1,
+      Node node2) {
     return strategy.test(object1, object2, property, node1, node2,
         (Node n1, Node n2) {
       if (n1 == n2) return true;
       if (n1 == null || n2 == null) return false;
       return n1.accept1(this, n2);
     });
   }
 
-  bool testNodeLists(var object1, var object2, String property,
+  bool testNodeLists(dynamic object1, dynamic object2, String property,
       Link<Node> list1, Link<Node> list2) {
     return strategy.test(object1, object2, property, list1, list2,
         (Link<Node> l1, Link<Node> l2) {
       if (l1 == l2) return true;
       if (l1 == null || l2 == null) return false;
       while (l1.isNotEmpty && l2.isNotEmpty) {
         if (!l1.head.accept1(this, l2.head)) {
           return false;
         }
         l1 = l1.tail;
         l2 = l2.tail;
       }
       return l1.isEmpty && l2.isEmpty;
     });
   }
 
-  bool testTokens(
-      var object1, var object2, String property, Token token1, Token token2) {
+  bool testTokens(dynamic object1, dynamic object2, String property,
+      Token token1, Token token2) {
     return strategy.test(object1, object2, property, token1, token2,
         (Token t1, Token t2) {
       if (t1 == t2) return true;
       if (t1 == null || t2 == null) return false;
       return strategy.test(
               t1, t2, 'charOffset', t1.charOffset, t2.charOffset) &&
           strategy.test(t1, t2, 'info', t1.type, t2.type) &&
           strategy.test(t1, t2, 'value', t1.lexeme, t2.lexeme);
     });
   }
@@ skipping 688 matching lines @@
 }
 
 bool areMetadataAnnotationsEquivalent(
     MetadataAnnotation metadata1, MetadataAnnotation metadata2) {
   if (metadata1 == metadata2) return true;
   if (metadata1 == null || metadata2 == null) return false;
   return areElementsEquivalent(
           metadata1.annotatedElement, metadata2.annotatedElement) &&
       areConstantsEquivalent(metadata1.constant, metadata2.constant);
 }