Handle deserialized compilation of closures

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 '../common.dart';
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/visitor.dart';
 import '../js_backend/backend_serialization.dart'
     show JavaScriptBackendSerializer;
 import '../native/native.dart' show NativeBehavior;
 import '../resolution/access_semantics.dart';
 import '../resolution/send_structure.dart';
@@ skipping 1028 matching lines @@
   }
 }
 
 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) {
-    if (node1 == node2) return true;
-    if (node1 == null || node2 == null) return false;
-    return node1.accept1(this, 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,
       Link<Node> list1, Link<Node> list2) {
-    if (list1 == list2) return true;
-    if (list1 == null || list2 == null) return false;
-    while (list1.isNotEmpty && list2.isNotEmpty) {
-      if (!list1.head.accept1(this, list2.head)) {
-        return false;
+    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;
       }
-      list1 = list1.tail;
-      list2 = list2.tail;
-    }
-    return list1.isEmpty && list2.isEmpty;
+      return l1.isEmpty && l2.isEmpty;
+    });
   }
 
   bool testTokens(
       var object1, var object2, String property, Token token1, Token token2) {
-    if (token1 == token2) return true;
-    if (token1 == null || token2 == null) return false;
-    return token1.hashCode == token2.hashCode;
+    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, 'hashCode', t1.hashCode, t2.hashCode);
+    });
   }
 
   @override
   bool visitAssert(Assert node1, Assert node2) {
     return testTokens(node1, node2, 'assertToken', node1.assertToken,
             node2.assertToken) &&
         testNodes(
             node1, node2, 'condition', node1.condition, node2.condition) &&
         testNodes(node1, node2, 'message', node1.message, node2.message);
   }
@@ skipping 654 matching lines @@
   @override
   bool visitStatement(Statement node1, Statement node2) {
     throw new UnsupportedError('Unexpected nodes: $node1 <> $node2');
   }
 
   @override
   bool visitStringNode(StringNode node1, StringNode node2) {
     throw new UnsupportedError('Unexpected nodes: $node1 <> $node2');
   }
 }