Handle instantiation of native classes in closed_world2_test

pkg/compiler/lib/src/kernel/element_map.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/resolution.dart';
@@ skipping 15 matching lines @@
 import '../native/resolver.dart';
 import '../ordered_typeset.dart';
 import '../ssa/kernel_impact.dart';
 import '../universe/call_structure.dart';
 import '../universe/world_builder.dart';
 import '../util/util.dart' show Link, LinkBuilder;
 import 'element_adapter.dart';
 import 'elements.dart';
 
 part 'native_basic_data.dart';
-part 'native_class_resolver.dart';
 part 'no_such_method_resolver.dart';
 part 'types.dart';
 
 /// Element builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
 class KernelToElementMap extends KernelElementAdapterMixin {
   CommonElements _commonElements;
   native.BehaviorBuilder _nativeBehaviorBuilder;
   final DiagnosticReporter reporter;
   ElementEnvironment _elementEnvironment;
@@ skipping 389 matching lines @@
           KClass superclass = type.element;
           _KClassEnv env = _classEnvs[superclass.classIndex];
           _ensureSupertypes(superclass, env);
           return type;
         }
 
         env.supertype = processSupertype(node.supertype);
         LinkBuilder<InterfaceType> linkBuilder =
             new LinkBuilder<InterfaceType>();
         if (node.mixedInType != null) {
-          linkBuilder.addLast(processSupertype(node.mixedInType));
+          linkBuilder
+              .addLast(env.mixedInType = processSupertype(node.mixedInType));
         }
         node.implementedTypes.forEach((ir.Supertype supertype) {
           linkBuilder.addLast(processSupertype(supertype));
         });
         Link<InterfaceType> interfaces = linkBuilder.toLink();
         OrderedTypeSetBuilder setBuilder =
             new _KernelOrderedTypeSetBuilder(this, cls);
         env.orderedTypeSet =
             setBuilder.createOrderedTypeSet(env.supertype, interfaces);
       }
@@ skipping 22 matching lines @@
     _ensureSupertypes(cls, env);
     return env.supertype;
   }
 
   void _forEachSupertype(KClass cls, void f(InterfaceType supertype)) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     env.orderedTypeSet.supertypes.forEach(f);
   }
 
+  void _forEachMixin(KClass cls, void f(ClassEntity mixin)) {
+    while (cls != null) {
+      _KClassEnv env = _classEnvs[cls.classIndex];
+      _ensureSupertypes(cls, env);
+      if (env.mixedInType != null) {
+        f(env.mixedInType.element);
+      }
+      cls = env.supertype?.element;
+    }
+  }
+
   void _forEachClassMember(
       KClass cls, void f(ClassEntity cls, MemberEntity member)) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     env.forEachMember((ir.Member member) {
       f(cls, getMember(member));
     });
     _ensureSupertypes(cls, env);
     if (env.supertype != null) {
       _forEachClassMember(env.supertype.element, f);
     }
@@ skipping 193 matching lines @@
   }
 }
 
 /// Environment for fast lookup of class members.
 class _KClassEnv {
   final ir.Class cls;
 
   InterfaceType thisType;
   InterfaceType rawType;
   InterfaceType supertype;
+  InterfaceType mixedInType;
   OrderedTypeSet orderedTypeSet;
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
   Iterable<ConstantExpression> _metadata;
 
   _KClassEnv(this.cls);
 
@@ skipping 213 matching lines @@
     return elementMap._getSuperType(cls)?.element;
   }
 
   @override
   void forEachSupertype(ClassEntity cls, void f(InterfaceType supertype)) {
     elementMap._forEachSupertype(cls, f);
   }
 
   @override
   void forEachMixin(ClassEntity cls, void f(ClassEntity mixin)) {
-    throw new UnimplementedError('KernelElementEnvironment.forEachMixin');
+    elementMap._forEachMixin(cls, f);
   }
 
   @override
   void forEachClassMember(
       ClassEntity cls, void f(ClassEntity declarer, MemberEntity member)) {
     elementMap._forEachClassMember(cls, f);
   }
 
   @override
   MemberEntity lookupLibraryMember(LibraryEntity library, String name,
@@ skipping 305 matching lines @@
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     _KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }