Check closure data for serialization

tests/compiler/dart2js/serialization/test_helper.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.
 
 library dart2js.serialization_test_helper;
 
 import 'dart:io';
 import '../memory_compiler.dart';
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/common/resolution.dart';
@@ skipping 145 matching lines @@
 /// [elementEquivalence] to determine element equivalence.
 ///
 /// Elements both in [set1] and [set2] are added to [common], elements in [set1]
 /// but not in [set2] are added to [unfound], and the set of elements in [set2]
 /// but not in [set1] are returned.
 Set computeSetDifference(
     Iterable set1,
     Iterable set2,
     List common,
     List unfound,
-    [bool sameElement(a, b) = equality]) {
+    {bool sameElement(a, b): equality,
+     void checkElements(a, b)}) {
   // TODO(johnniwinther): Avoid the quadratic cost here. Some ideas:
   // - convert each set to a list and sort it first, then compare by walking
   // both lists in parallel
   // - map each element to a canonical object, create a map containing those
   // mappings, use the mapped sets to compare (then operations like
   // set.difference would work)
   Set remaining = set2.toSet();
   for (var element1 in set1) {
     bool found = false;
     for (var element2 in remaining) {
       if (sameElement(element1, element2)) {
+        if (checkElements != null) {
+          checkElements(element1, element2);
+        }
         found = true;
         remaining.remove(element2);
         break;
       }
     }
     if (found) {
       common.add(element1);
     } else {
       unfound.add(element1);
     }
   }
   return remaining;
 }
 
 /// Check equivalence of the two iterables, [set1] and [set1], as sets using
 /// [elementEquivalence] to compute the pair-wise equivalence.
 ///
 /// Uses [object1], [object2] and [property] to provide context for failures.
 bool checkSetEquivalence(
     var object1,
     var object2,
     String property,
     Iterable set1,
     Iterable set2,
-    bool sameElement(a, b)) {
+    bool sameElement(a, b),
+    {void onSameElement(a, b)}) {
   List common = [];
   List unfound = [];
   Set remaining =
-      computeSetDifference(set1, set2, common, unfound, sameElement);
+      computeSetDifference(set1, set2, common, unfound,
+          sameElement: sameElement, checkElements: onSameElement);
   if (unfound.isNotEmpty || remaining.isNotEmpty) {
     String message =
         "Set mismatch for `$property` on $object1 vs $object2: \n"
         "Common:\n ${common.join('\n ')}\n"
         "Unfound:\n ${unfound.join('\n ')}\n"
         "Extra: \n ${remaining.join('\n ')}";
     throw message;
   }
   return true;
 }
@@ skipping 163 matching lines @@
 
   if (impact1 == null) {
     throw 'Missing impact for $member1. $member2 has $impact2';
   }
   if (impact2 == null) {
     throw 'Missing impact for $member2. $member1 has $impact1';
   }
 
   testResolutionImpactEquivalence(impact1, impact2, const CheckStrategy());
 }