Find native classes with mixins in NativeClassFinder

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/names.dart' show Identifiers;
@@ skipping 487 matching lines @@
     return type.subst(
         context.typeArguments, _getThisType(context.element).typeArguments);
   }
 
   InterfaceType _getSuperType(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.supertype;
   }
 
+  bool _isUnnamedMixinApplication(KClass cls) {
+    _KClassEnv env = _classEnvs[cls.classIndex];
+    _ensureSupertypes(cls, env);
+    return env.isUnnamedMixinApplication;
+  }
+
   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);
@@ skipping 460 matching lines @@
     MemberEntity member =
         elementMap.lookupClassMember(cls, name, setter: setter);
     if (member == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The member '$name' was not found in ${cls.name}.");
     }
     return member;
   }
 
   @override
-  ClassEntity getSuperClass(ClassEntity cls) {
-    return elementMap._getSuperType(cls)?.element;
+  ClassEntity getSuperClass(ClassEntity cls,
+      {bool skipUnnamedMixinApplications: false}) {
+    ClassEntity superclass = elementMap._getSuperType(cls)?.element;
+    if (skipUnnamedMixinApplications) {
+      while (superclass != null &&
+          elementMap._isUnnamedMixinApplication(superclass)) {
+        superclass = elementMap._getSuperType(superclass)?.element;
+      }
+    }
+    return superclass;
   }
 
   @override
   void forEachSupertype(ClassEntity cls, void f(InterfaceType supertype)) {
     elementMap._forEachSupertype(cls, f);
   }
 
   @override
   void forEachMixin(ClassEntity cls, void f(ClassEntity mixin)) {
     elementMap._forEachMixin(cls, f);
@@ skipping 259 matching lines @@
 
   @override
   bool validateClass(ClassEntity cls) => true;
 
   @override
   bool checkClass(ClassEntity cls) => true;
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
-  final KernelToElementMap builder;
+  final KernelToElementMap elementMap;
 
-  WorldDeconstructionForTesting(this.builder);
+  WorldDeconstructionForTesting(this.elementMap);
 
   KClass getSuperclassForClass(KClass cls) {
-    _KClassEnv env = builder._classEnvs[cls.classIndex];
+    _KClassEnv env = elementMap._classEnvs[cls.classIndex];
     ir.Supertype supertype = env.cls.supertype;
     if (supertype == null) return null;
-    return builder.getClass(supertype.classNode);
+    return elementMap.getClass(supertype.classNode);
   }
 
   bool isUnnamedMixinApplication(KClass cls) {
-    _KClassEnv env = builder._classEnvs[cls.classIndex];
-    return env.isUnnamedMixinApplication;
+    return elementMap._isUnnamedMixinApplication(cls);
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
-    _KClassEnv env = builder._classEnvs[cls.classIndex];
+    _KClassEnv env = elementMap._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
-    return builder.createInterfaceType(
+    return elementMap.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }