Add most equivalence tests to js_model/model_test

tests/compiler/dart2js/kernel/test_helpers.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.kernel.equivalence;
 
 import 'package:compiler/src/common/backend_api.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/common/work.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/enqueue.dart';
-import 'package:compiler/src/kernel/kelements.dart';
+import 'package:compiler/src/kernel/elements.dart';
+import 'package:compiler/src/kernel/kelements.dart' show KLocalFunction;
+import 'package:compiler/src/kernel/element_map.dart';
 import 'package:compiler/src/kernel/element_map_impl.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/ssa/kernel_impact.dart';
 import 'package:compiler/src/universe/world_impact.dart';
 import 'package:compiler/src/util/util.dart';
 
 class KernelEquivalence {
   final WorldDeconstructionForTesting testing;
 
   /// Set of mixin applications assumed to be equivalent.
   ///
   /// We need co-inductive reasoning because mixin applications are compared
   /// structurally and therefore, in the case of generic mixin applications,
   /// meet themselves through the equivalence check of their type variables.
   Set<Pair<ClassEntity, ClassEntity>> assumedMixinApplications =
       new Set<Pair<ClassEntity, ClassEntity>>();
 
-  KernelEquivalence(KernelToElementMapImpl builder)
+  KernelEquivalence(KernelToElementMap builder)
       : testing = new WorldDeconstructionForTesting(builder);
 
   TestStrategy get defaultStrategy => new TestStrategy(
       elementEquivalence: entityEquivalence,
       typeEquivalence: typeEquivalence,
       constantEquivalence: constantEquivalence,
       constantValueEquivalence: constantValueEquivalence);
 
   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) {
+        if (b is IndexedConstructor && b.isGenerativeConstructor) {
           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) {
+        if (b is IndexedConstructor && b.isFactoryConstructor) {
           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) {
+        if (b is IndexedClass) {
           List<InterfaceType> aMixinTypes = [];
           List<InterfaceType> bMixinTypes = [];
           ClassElement aClass = a;
           if (aClass.isUnnamedMixinApplication) {
             if (!testing.isUnnamedMixinApplication(b)) {
               return false;
             }
             while (aClass.isMixinApplication) {
               MixinApplicationElement aMixinApplication = aClass;
               aMixinTypes.add(aMixinApplication.mixinType);
               aClass = aMixinApplication.superclass;
             }
-            KClass bClass = b;
+            IndexedClass bClass = b;
             while (bClass != null) {
               InterfaceType mixinType = testing.getMixinTypeForClass(bClass);
               if (mixinType == null) break;
               bMixinTypes.add(mixinType);
               bClass = testing.getSuperclassForClass(bClass);
             }
             if (aMixinTypes.isNotEmpty || aMixinTypes.isNotEmpty) {
               Pair<ClassEntity, ClassEntity> pair =
                   new Pair<ClassEntity, ClassEntity>(aClass, bClass);
               if (assumedMixinApplications.contains(pair)) {
                 return true;
               } else {
                 assumedMixinApplications.add(pair);
                 bool result = strategy.testTypeLists(
                     a, b, 'mixinTypes', aMixinTypes, bMixinTypes);
                 assumedMixinApplications.remove(pair);
                 return result;
               }
             }
           } else {
             if (testing.isUnnamedMixinApplication(b)) {
               return false;
             }
           }
           return strategy.test(a, b, 'name', a.name, b.name) &&
               strategy.testElements(a, b, 'library', a.library, b.library);
         }
         return false;
       case ElementKind.LIBRARY:
-        if (b is KLibrary) {
+        if (b is IndexedLibrary) {
           LibraryElement libraryA = a;
           return libraryA.canonicalUri == b.canonicalUri;
         }
         return false;
       case ElementKind.FUNCTION:
-        if (b is KMethod) {
+        if (b is IndexedFunction && b.isFunction) {
           return strategy.test(a, b, 'name', a.name, b.name) &&
               strategy.testElements(
                   a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass) &&
               strategy.testElements(a, b, 'library', a.library, b.library);
         } 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 (b is IndexedFunction && b.isGetter) {
           return strategy.test(a, b, 'name', a.name, b.name) &&
               strategy.testElements(
                   a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass) &&
               strategy.testElements(a, b, 'library', a.library, b.library);
         }
         return false;
       case ElementKind.SETTER:
-        if (b is KSetter) {
+        if (b is IndexedFunction && b.isSetter) {
           return strategy.test(a, b, 'name', a.name, b.name) &&
               strategy.testElements(
                   a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass) &&
               strategy.testElements(a, b, 'library', a.library, b.library);
         }
         return false;
       case ElementKind.FIELD:
-        if (b is KField) {
+        if (b is IndexedField) {
           return strategy.test(a, b, 'name', a.name, b.name) &&
               strategy.testElements(
                   a, b, 'enclosingClass', a.enclosingClass, b.enclosingClass) &&
               strategy.testElements(a, b, 'library', a.library, b.library);
         }
         return false;
       case ElementKind.TYPE_VARIABLE:
-        if (b is KTypeVariable) {
+        if (b is IndexedTypeVariable) {
           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})');
     }
@@ skipping 134 matching lines @@
     for (ConstructorElement constructor in element.constructors) {
       if (!constructor.isRedirectingFactory) {
         return true;
       }
     }
     // The class cannot itself be instantiated.
     return false;
   }
   return true;
 }