Revert "Handle named mixin application in emitter"

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 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 506 matching lines @@
   }
 
   void _ensureSupertypes(KClass cls, _KClassEnv env) {
     if (env.orderedTypeSet == null) {
       _ensureThisAndRawType(cls, env);
 
       ir.Class node = env.cls;
 
       if (node.supertype == null) {
         env.orderedTypeSet = new OrderedTypeSet.singleton(env.thisType);
-        env.isMixinApplication = false;
       } else {
         InterfaceType processSupertype(ir.Supertype node) {
           InterfaceType type = _typeConverter.visitSupertype(node);
           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) {
-          env.isMixinApplication = true;
           linkBuilder
               .addLast(env.mixedInType = processSupertype(node.mixedInType));
-        } else {
-          env.isMixinApplication = false;
         }
         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 @@
     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 _isMixinApplication(KClass cls) {
-    _KClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.isMixinApplication;
-  }
-
   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);
@@ skipping 270 matching lines @@
       } else {
         // Skip fields; these are also in _memberMap.
       }
     }
   }
 }
 
 /// Environment for fast lookup of class members.
 class _KClassEnv {
   final ir.Class cls;
-  bool isMixinApplication;
   final bool isUnnamedMixinApplication;
 
   InterfaceType thisType;
   InterfaceType rawType;
   InterfaceType supertype;
   InterfaceType mixedInType;
   OrderedTypeSet orderedTypeSet;
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
@@ skipping 250 matching lines @@
   InterfaceType getRawType(ClassEntity cls) {
     return elementMap._getRawType(cls);
   }
 
   @override
   bool isGenericClass(ClassEntity cls) {
     return getThisType(cls).typeArguments.isNotEmpty;
   }
 
   @override
-  bool isMixinApplication(KClass cls) {
-    return elementMap._isMixinApplication(cls);
-  }
-
-  @override
   bool isUnnamedMixinApplication(KClass cls) {
     return elementMap._isUnnamedMixinApplication(cls);
   }
 
   @override
   DartType getTypeVariableBound(TypeVariableEntity typeVariable) {
     throw new UnimplementedError(
         'KernelElementEnvironment.getTypeVariableBound');
   }
 
@@ skipping 520 matching lines @@
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(johnniwinther): Compute this.
     return false;
   }
 }