Handle instance/super methods in js_model/model_test

pkg/compiler/lib/src/kernel/element_map_impl.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.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 14 matching lines @@
 import '../js_backend/backend_usage.dart';
 import '../js_backend/constant_system_javascript.dart';
 import '../js_backend/interceptor_data.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../js_model/elements.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../ordered_typeset.dart';
 import '../universe/class_set.dart';
-import '../universe/function_set.dart';
 import '../universe/selector.dart';
 import '../universe/world_builder.dart';
 import '../world.dart';
 import '../util/util.dart' show Link, LinkBuilder;
 import 'element_map.dart';
 import 'element_map_mixins.dart';
 import 'elements.dart';
 import 'env.dart';
 import 'kelements.dart';
 
@@ skipping 1415 matching lines @@
     return elementMap._getAppliedMixin(cls);
   }
 
   @override
   bool validateClass(ClassEntity cls) => true;
 
   @override
   bool checkClass(ClassEntity cls) => true;
 }
 
-class KernelClosedWorld extends ClosedWorldBase {
+abstract class KernelClosedWorldMixin implements ClosedWorld {
+  @override
+  bool hasElementIn(ClassEntity cls, Selector selector, Entity element) {
+    while (cls != null) {
+      MemberEntity member = elementEnvironment
+          .lookupClassMember(cls, selector.name, setter: selector.isSetter);
+      if (member != null &&
+          (!selector.memberName.isPrivate ||
+              member.library == selector.library)) {
+        return member == element;
+      }
+      cls = elementEnvironment.getSuperClass(cls);
+    }
+    return false;
+  }
+}
+
+class KernelClosedWorld extends ClosedWorldBase with KernelClosedWorldMixin {
   final KernelToElementMapForImpactImpl _elementMap;
 
   KernelClosedWorld(this._elementMap,
       {ElementEnvironment elementEnvironment,
       DartTypes dartTypes,
       CommonElements commonElements,
       ConstantSystem constantSystem,
       NativeData nativeData,
       InterceptorData interceptorData,
       BackendUsage backendUsage,
       ResolutionWorldBuilder resolutionWorldBuilder,
       Set<ClassEntity> implementedClasses,
-      FunctionSet functionSet,
+      Iterable<MemberEntity> liveInstanceMembers,
       Set<TypedefElement> allTypedefs,
       Map<ClassEntity, Set<ClassEntity>> mixinUses,
       Map<ClassEntity, Set<ClassEntity>> typesImplementedBySubclasses,
       Map<ClassEntity, ClassHierarchyNode> classHierarchyNodes,
       Map<ClassEntity, ClassSet> classSets})
       : super(
-            elementEnvironment: elementEnvironment,
-            dartTypes: dartTypes,
-            commonElements: commonElements,
-            constantSystem: constantSystem,
-            nativeData: nativeData,
-            interceptorData: interceptorData,
-            backendUsage: backendUsage,
-            resolutionWorldBuilder: resolutionWorldBuilder,
-            implementedClasses: implementedClasses,
-            functionSet: functionSet,
-            allTypedefs: allTypedefs,
-            mixinUses: mixinUses,
-            typesImplementedBySubclasses: typesImplementedBySubclasses,
-            classHierarchyNodes: classHierarchyNodes,
-            classSets: classSets);
+            elementEnvironment,
+            dartTypes,
+            commonElements,
+            constantSystem,
+            nativeData,
+            interceptorData,
+            backendUsage,
+            resolutionWorldBuilder,
+            implementedClasses,
+            liveInstanceMembers,
+            allTypedefs,
+            mixinUses,
+            typesImplementedBySubclasses,
+            classHierarchyNodes,
+            classSets);
 
   @override
   bool hasConcreteMatch(ClassEntity cls, Selector selector,
       {ClassEntity stopAtSuperclass}) {
     throw new UnimplementedError('KernelClosedWorld.hasConcreteMatch');
   }
 
   @override
   bool isNamedMixinApplication(ClassEntity cls) {
     throw new UnimplementedError('KernelClosedWorld.isNamedMixinApplication');
@@ skipping 31 matching lines @@
   @override
   bool checkClass(ClassEntity cls) => true;
 
   @override
   bool checkEntity(Entity element) => true;
 
   @override
   void registerClosureClass(ClassElement cls) {
     throw new UnimplementedError('KernelClosedWorld.registerClosureClass');
   }
-
-  @override
-  bool hasElementIn(ClassEntity cls, Selector selector, Entity element) {
-    while (cls != null) {
-      MemberEntity member = elementEnvironment
-          .lookupClassMember(cls, selector.name, setter: selector.isSetter);
-      if (member != null &&
-          (!selector.memberName.isPrivate ||
-              member.library == selector.library)) {
-        return member == element;
-      }
-      cls = elementEnvironment.getSuperClass(cls);
-    }
-    return false;
-  }
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
   final KernelToElementMapBase elementMap;
 
   WorldDeconstructionForTesting(this.elementMap);
 
   KClass getSuperclassForClass(KClass cls) {
     ClassEnv env = elementMap._classEnvs[cls.classIndex];
@@ skipping 253 matching lines @@
     throw new UnsupportedError(
         "JsKernelToElementMap.getConstantFieldInitializer");
   }
 
   @override
   bool hasConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.hasConstantFieldInitializer");
   }
 }