Add most equivalence tests to js_model/model_test

pkg/compiler/lib/src/js_model/js_strategy.dart

 // Copyright (c) 2017, 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.js_model.strategy;
 
 import '../closure.dart' show ClosureConversionTask;
 import '../common/tasks.dart';
 import '../common_elements.dart';
 import '../compiler.dart';
@@ skipping 46 matching lines @@
     KernelFrontEndStrategy strategy = _compiler.frontendStrategy;
     KernelToElementMapForImpact elementMap = strategy.elementMap;
     _elementMap = new JsKernelToElementMap(
         _compiler.reporter, _compiler.environment, elementMap);
     _elementEnvironment = _elementMap.elementEnvironment;
     _commonElements = _elementMap.commonElements;
     JsToFrontendMap _map = _elementMap.jsToFrontendMap;
     BackendUsage backendUsage =
         new JsBackendUsage(_map, closedWorld.backendUsage);
     NativeData nativeData = new JsNativeData(_map, closedWorld.nativeData);
+    InterceptorDataImpl interceptorDataImpl = closedWorld.interceptorData;
+    Map<String, Set<MemberEntity>> interceptedMembers =
+        <String, Set<MemberEntity>>{};
+    interceptorDataImpl.interceptedMembers
+        .forEach((String name, Set<MemberEntity> members) {
+      interceptedMembers[name] = members.map(_map.toBackendMember).toSet();

[Siggi Cherem (dart-lang), 2017/07/05 21:25:52]

since we have a few of these conversions here and in a few other places, it
might be worth adding a couple helper methods... 

  convertList(l) => l.map(_map.toBackendMember).toList();
  convertSet(s) => l.map(_map.toBackendMember).toSet();
  convertMapOfSets(m) {
    var m2 = {};
    m.forEach((k, v) => m2[k] = convertSet(v);
  }

[Johnni Winther, 2017/07/06 14:53:40]

Sometimes we convert members, sometimes classes. We would need to parameters
such method so it doesn't really pay off.

+    });
     InterceptorData interceptorData = new InterceptorDataImpl(
         nativeData,
         _commonElements,
-        // TODO(johnniwinther): Convert these.
-        const {},
-        new Set(),
-        new Set());
+        interceptedMembers,
+        interceptorDataImpl.interceptedClasses.map(_map.toBackendClass).toSet(),
+        interceptorDataImpl.classesMixedIntoInterceptedClasses
+            .map(_map.toBackendClass)
+            .toSet());
 
     Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes =
         <ClassEntity, ClassHierarchyNode>{};
     Map<ClassEntity, ClassSet> classSets = <ClassEntity, ClassSet>{};
     Set<ClassEntity> implementedClasses = new Set<ClassEntity>();
 
     ClassHierarchyNode convertClassHierarchyNode(ClassHierarchyNode node) {
       ClassEntity cls = _map.toBackendClass(node.cls);
       if (closedWorld.isImplemented(node.cls)) {
         implementedClasses.add(cls);
@@ skipping 32 matching lines @@
     List<MemberEntity> liveInstanceMembers =
         closedWorld.liveInstanceMembers.map(_map.toBackendMember).toList();
 
     Map<ClassEntity, Set<ClassEntity>> mixinUses =
         <ClassEntity, Set<ClassEntity>>{};
     closedWorld.mixinUses.forEach((ClassEntity cls, Set<ClassEntity> uses) {
       mixinUses[_map.toBackendClass(cls)] =
           uses.map(_map.toBackendClass).toSet();
     });
 
+    Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses =
+        <ClassEntity, Set<ClassEntity>>{};
+    closedWorld.typesImplementedBySubclasses
+        .forEach((ClassEntity cls, Set<ClassEntity> uses) {
+      typesImplementedBySubclasses[_map.toBackendClass(cls)] =
+          uses.map(_map.toBackendClass).toSet();
+    });
+
     Iterable<MemberEntity> assignedInstanceMembers =
         closedWorld.assignedInstanceMembers.map(_map.toBackendMember).toList();
 
     return new JsClosedWorld(_elementMap,
         elementEnvironment: _elementEnvironment,
         dartTypes: _elementMap.types,
         commonElements: _commonElements,
         constantSystem: const JavaScriptConstantSystem(),
         backendUsage: backendUsage,
         nativeData: nativeData,
         interceptorData: interceptorData,
         classHierarchyNodes: classHierarchyNodes,
         classSets: classSets,
         implementedClasses: implementedClasses,
         liveInstanceMembers: liveInstanceMembers,
         assignedInstanceMembers: assignedInstanceMembers,
-        // TODO(johnniwinther): Support these.
-        allTypedefs: new ImmutableEmptySet<TypedefElement>(),
         mixinUses: mixinUses,
-        typesImplementedBySubclasses: null);
+        typesImplementedBySubclasses: typesImplementedBySubclasses,
+        // TODO(johnniwinther): Support this:
+        allTypedefs: new ImmutableEmptySet<TypedefElement>());
   }
 
   @override
   Sorter get sorter {
     return _sorter ??= new KernelSorter(elementMap);
   }
 
   @override
   ClosureConversionTask get closureDataLookup =>
       _closureDataLookup ??= new KernelClosureConversionTask(
@@ skipping 21 matching lines @@
       ClosedWorld closedWorld,
       SelectorConstraintsStrategy selectorConstraintsStrategy) {
     return new KernelCodegenWorldBuilder(
         elementMap,
         closedWorld.elementEnvironment,
         nativeBasicData,
         closedWorld,
         selectorConstraintsStrategy);
   }
 }