Check equivalence on impact computed with KernelWorldBuilder.

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/constants/values.dart';
+import 'package:compiler/src/compiler.dart';
+import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import 'package:compiler/src/elements/types.dart';
-import 'package:compiler/src/compiler.dart';
-import 'package:compiler/src/elements/elements.dart';
+import 'package:compiler/src/kernel/elements.dart';
+import 'package:compiler/src/kernel/world_builder.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
-import 'package:compiler/src/tree/nodes.dart';
 import 'package:expect/expect.dart';
 import 'test_data.dart';
 
 Check currentCheck;
 
 class Check {
   final Check parent;
   final Object object1;
   final Object object2;
   final String property;
@@ skipping 399 matching lines @@
     print('Checking impacts for $member1 vs $member2');
   }
 
   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());
+  testResolutionImpactEquivalence(impact1, impact2,
+      strategy: const CheckStrategy());
 }
 
 void checkSets(
     Iterable set1, Iterable set2, String messagePrefix, bool sameElement(a, b),
     {bool failOnUnfound: true,
     bool failOnExtra: true,
     bool verbose: false,
     void onSameElement(a, b),
     void onUnfoundElement(a),
     void onExtraElement(b),
@@ skipping 175 matching lines @@
   }
 
   if (index == 1 && skip != 0) {
     return ['${skip}', segmentNumber(index)];
   } else if (index == count) {
     return [segmentNumber(index - 1)];
   } else {
     return [segmentNumber(index - 1), segmentNumber(index)];
   }
 }
+
+class KernelEquivalence {
+  final WorldDeconstructionForTesting testing;
+
+  KernelEquivalence(KernelWorldBuilder builder)
+      : testing = new WorldDeconstructionForTesting(builder);
+
+  TestStrategy get defaultStrategy => new TestStrategy(
+      elementEquivalence: entityEquivalence, typeEquivalence: typeEquivalence);
+
+  bool entityEquivalence(Element a, Entity b, {TestStrategy strategy}) {
+    if (identical(a, b)) return true;
+    if (a == null || b == null) return false;
+    strategy ??= defaultStrategy;
+    switch (a.kind) {
+      case ElementKind.GENERATIVE_CONSTRUCTOR:
+        if (b is KGenerativeConstructor) {
+          return strategy.test(a, b, 'name', a.name, b.name) &&
+              strategy.testElements(
+                  a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass);
+        }
+        return false;
+      case ElementKind.FACTORY_CONSTRUCTOR:
+        if (b is KFactoryConstructor) {
+          return strategy.test(a, b, 'name', a.name, b.name) &&
+              strategy.testElements(
+                  a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass);
+        }
+        return false;
+      case ElementKind.CLASS:
+        if (b is KClass) {
+          return strategy.test(a, b, 'name', a.name, b.name) &&
+              strategy.testElements(
+                  a, b, 'library', a.library, testing.getLibraryForClass(b));
+        }
+        return false;
+      case ElementKind.LIBRARY:
+        if (b is KLibrary) {
+          LibraryElement libraryA = a;
+          return libraryA.canonicalUri == testing.getLibraryUri(b);
+        }
+        return false;
+      case ElementKind.FUNCTION:
+        if (b is KMethod) {
+          if (!strategy.test(a, b, 'name', a.name, b.name)) return false;
+          if (b.enclosingClass != null) {
+            return strategy.testElements(
+                a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass);
+          } else {
+            return strategy.testElements(
+                a, b, 'library', a.library, testing.getLibraryForFunction(b));
+          }
+        } else if (b is KLocalFunction) {
+          LocalFunctionElement aLocalFunction = a;
+          return strategy.test(a, b, 'name', a.name, b.name ?? '') &&
+              strategy.testElements(a, b, 'executableContext',
+                  aLocalFunction.executableContext, b.executableContext) &&
+              strategy.testElements(a, b, 'memberContext',
+                  aLocalFunction.memberContext, b.memberContext);
+        }
+        return false;
+      case ElementKind.GETTER:
+        if (b is KGetter) {
+          if (!strategy.test(a, b, 'name', a.name, b.name)) return false;
+          if (b.enclosingClass != null) {
+            return strategy.testElements(
+                a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass);
+          } else {
+            return strategy.testElements(
+                a, b, 'library', a.library, testing.getLibraryForFunction(b));
+          }
+        }
+        return false;
+      case ElementKind.SETTER:
+        if (b is KSetter) {
+          if (!strategy.test(a, b, 'name', a.name, b.name)) return false;
+          if (b.enclosingClass != null) {
+            return strategy.testElements(
+                a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass);
+          } else {
+            return strategy.testElements(
+                a, b, 'library', a.library, testing.getLibraryForFunction(b));
+          }
+        }
+        return false;
+      case ElementKind.FIELD:
+        if (b is KField) {
+          if (!strategy.test(a, b, 'name', a.name, b.name)) return false;
+          if (b.enclosingClass != null) {
+            return strategy.testElements(
+                a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass);
+          } else {
+            return strategy.testElements(
+                a, b, 'library', a.library, testing.getLibraryForField(b));
+          }
+        }
+        return false;
+      case ElementKind.TYPE_VARIABLE:
+        if (b is KTypeVariable) {
+          TypeVariableElement aElement = a;
+          return strategy.test(a, b, 'index', aElement.index, b.index) &&
+              strategy.testElements(a, b, 'typeDeclaration',
+                  aElement.typeDeclaration, b.typeDeclaration);
+        }
+        return false;
+      default:
+        throw new UnsupportedError('Unsupported equivalence: '
+            '$a (${a.runtimeType}) vs $b (${b.runtimeType})');
+    }
+  }
+
+  bool typeEquivalence(ResolutionDartType a, DartType b,
+      {TestStrategy strategy}) {
+    if (identical(a, b)) return true;
+    if (a == null || b == null) return false;
+    strategy ??= defaultStrategy;
+    switch (a.kind) {
+      case ResolutionTypeKind.DYNAMIC:
+        return b is DynamicType;
+      case ResolutionTypeKind.VOID:
+        return b is VoidType;
+      case ResolutionTypeKind.INTERFACE:
+        if (b is InterfaceType) {
+          ResolutionInterfaceType aType = a;
+          return strategy.testElements(a, b, 'element', a.element, b.element) &&
+              strategy.testTypeLists(
+                  a, b, 'typeArguments', aType.typeArguments, b.typeArguments);
+        }
+        return false;
+      case ResolutionTypeKind.TYPE_VARIABLE:
+        if (b is TypeVariableType) {
+          return strategy.testElements(a, b, 'element', a.element, b.element);
+        }
+        return false;
+      case ResolutionTypeKind.FUNCTION:
+        if (b is FunctionType) {
+          ResolutionFunctionType aType = a;
+          return strategy.testTypes(
+                  a, b, 'returnType', aType.returnType, b.returnType) &&
+              strategy.testTypeLists(a, b, 'parameterTypes',
+                  aType.parameterTypes, b.parameterTypes) &&
+              strategy.testTypeLists(a, b, 'optionalParameterTypes',
+                  aType.optionalParameterTypes, b.optionalParameterTypes) &&
+              strategy.testLists(a, b, 'namedParameters', aType.namedParameters,
+                  b.namedParameters) &&
+              strategy.testTypeLists(a, b, 'namedParameterTypes',
+                  aType.namedParameterTypes, b.namedParameterTypes);
+        }
+        return false;
+      default:
+        throw new UnsupportedError('Unsupported equivalence: '
+            '$a (${a.runtimeType}) vs $b (${b.runtimeType})');
+    }
+  }
+}