Fix several element properties in 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:collection';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/dart_types.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/tree/nodes.dart';
 
+Check currentCheck;
+
+class Check {
+  final Check parent;
+  final Object object1;
+  final Object object2;
+  final String property;
+  final Object value1;
+  final Object value2;
+
+  Check(this.parent, this.object1, this.object2, this.property, this.value1, this.value2);
+
+  String printOn(StringBuffer sb, String indent) {
+    if (parent != null) {
+      indent = parent.printOn(sb, indent);
+      sb.write('\n$indent|\n');
+    }
+    sb.write("${indent}property='$property'\n ");
+    sb.write("${indent}object1=$object1 (${object1.runtimeType})\n ");
+    sb.write("${indent}value=${value1 == null ? "null" : "'$value1'"} ");
+    sb.write("(${value1.runtimeType}) vs\n ");
+    sb.write("${indent}object2=$object2 (${object2.runtimeType})\n ");
+    sb.write("${indent}value=${value2 == null ? "null" : "'$value2'"} ");
+    sb.write("(${value2.runtimeType})");
+    return ' $indent';
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    printOn(sb, '');
+    return sb.toString();
+  }
+}
+
 /// Strategy for checking equivalence.
 ///
 /// Use this strategy to fail early with contextual information in the event of
 /// inequivalence.
 class CheckStrategy implements TestStrategy {
   const CheckStrategy();
 
   @override
   bool test(var object1, var object2, String property, var value1, var value2,
             [bool equivalence(a, b) = equality]) {
@@ skipping 67 matching lines @@
       Node node1, Node node2) {
     return new NodeEquivalenceVisitor(this).testNodes(
         object1, object2, property, node1, node2);
   }
 }
 
 /// Check that the values [property] of [object1] and [object2], [value1] and
 /// [value2] respectively, are equal and throw otherwise.
 bool check(var object1, var object2, String property, var value1, var value2,
            [bool equivalence(a, b) = equality]) {
+  currentCheck = new Check(
+      currentCheck, object1, object2, property, value1, value2);
   if (!equivalence(value1, value2)) {
-    throw "property='$property'\n "
-          "object1=$object1 (${object1.runtimeType})\n "
-          "value=${value1 == null ? "null" : "'$value1'"} "
-          "(${value1.runtimeType}) <>\n "
-          "object2=$object2 (${object2.runtimeType})\n "
-          "value=${value2 == null ? "null" : "'$value2'"} "
-          "(${value2.runtimeType})";
+    throw currentCheck;
   }
+  currentCheck = currentCheck.parent;
   return true;
 }
 
 /// Check equivalence of the two lists, [list1] and [list2], using
 /// [checkEquivalence] to check the pair-wise equivalence.
 ///
 /// Uses [object1], [object2] and [property] to provide context for failures.
 bool checkListEquivalence(
     Object object1, Object object2, String property,
     Iterable list1, Iterable list2,
     void checkEquivalence(o1, o2, property, a, b)) {
+  currentCheck =
+      new Check(currentCheck, object1, object2, property, list1, list2);
   for (int i = 0; i < list1.length && i < list2.length; i++) {
     checkEquivalence(
         object1, object2, property,
         list1.elementAt(i), list2.elementAt(i));
   }
   for (int i = list1.length; i < list2.length; i++) {
     throw
         'Missing equivalent for element '
         '#$i ${list2.elementAt(i)} in `${property}` on $object2.\n'
         '`${property}` on $object1:\n ${list1.join('\n ')}\n'
         '`${property}` on $object2:\n ${list2.join('\n ')}';
   }
   for (int i = list2.length; i < list1.length; i++) {
     throw
         'Missing equivalent for element '
         '#$i ${list1.elementAt(i)} in `${property}` on $object1.\n'
         '`${property}` on $object1:\n ${list1.join('\n ')}\n'
         '`${property}` on $object2:\n ${list2.join('\n ')}';
   }
+  currentCheck = currentCheck.parent;
   return true;
 }
 
 /// Computes the set difference between [set1] and [set2] using
 /// [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(
@@ skipping 86 matching lines @@
 /// Checks the equivalence of [type1] and [type2].
 ///
 /// Uses [object1], [object2] and [property] to provide context for failures.
 bool checkTypes(
     Object object1, Object object2, String property,
     DartType type1, DartType type2) {
   if (identical(type1, type2)) return true;
   if (type1 == null || type2 == null) {
     return check(object1, object2, property, type1, type2);
   } else {
-    return const TypeEquivalence(const CheckStrategy()).visit(type1, type2);
+    return check(object1, object2, property, type1, type2,
+        (a, b) => const TypeEquivalence(const CheckStrategy()).visit(a, b));
   }
 }
 
 /// Checks the pair-wise equivalence of the types in [list1] and [list2].
 ///
 /// Uses [object1], [object2] and [property] to provide context for failures.
 bool checkTypeLists(
     Object object1, Object object2, String property,
     List<DartType> list1, List<DartType> list2) {
   return checkListEquivalence(
       object1, object2, property, list1, list2, checkTypes);
 }
 
 /// Checks the equivalence of [exp1] and [exp2].
 ///
 /// Uses [object1], [object2] and [property] to provide context for failures.
 bool checkConstants(
     Object object1, Object object2, String property,
     ConstantExpression exp1, ConstantExpression exp2) {
   if (identical(exp1, exp2)) return true;
   if (exp1 == null || exp2 == null) {
     return check(object1, object2, property, exp1, exp2);
   } else {
-    return const ConstantEquivalence(const CheckStrategy()).visit(exp1, exp2);
+    return check(object1, object2, property, exp1, exp2,
+        (a, b) => const ConstantEquivalence(const CheckStrategy()).visit(a, b));
   }
 }
 
 /// Checks the pair-wise equivalence of the contants in [list1] and [list2].
 ///
 /// Uses [object1], [object2] and [property] to provide context for failures.
 bool checkConstantLists(
     Object object1, Object object2, String property,
     List<ConstantExpression> list1,
     List<ConstantExpression> list2) {
@@ skipping 93 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());
 }