Handle mixed in members

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 144 matching lines @@
     _KClassEnv classEnv = libraryEnv.lookupClass(name);
     if (classEnv != null) {
       return _getClass(classEnv.cls, classEnv);
     }
     return null;
   }
 
   void _forEachClass(KLibrary library, void f(ClassEntity cls)) {
     _KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     libraryEnv.forEachClass((_KClassEnv classEnv) {
-      f(_getClass(classEnv.cls, classEnv));
+      if (!classEnv.isUnnamedMixinApplication) {
+        f(_getClass(classEnv.cls, classEnv));
+      }
     });
   }
 
   MemberEntity lookupClassMember(KClass cls, String name,
       {bool setter: false}) {
     _KClassEnv classEnv = _classEnvs[cls.classIndex];
     ir.Member member = classEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
@@ skipping 524 matching lines @@
         }
       }
     }
     return _memberMap[name];
   }
 }
 
 /// Environment for fast lookup of class members.
 class _KClassEnv {
   final ir.Class cls;
+  final bool isUnnamedMixinApplication;
 
   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);
+  _KClassEnv(this.cls)
+      // TODO(johnniwinther): Change this to use a property on [cls] when such
+      // is added to kernel.
+      : isUnnamedMixinApplication = cls.name.contains('+');
 
   void _ensureMaps() {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _setterMap = <String, ir.Member>{};
       _constructorMap = <String, ir.Member>{};
-      for (ir.Member member in cls.members) {
-        if (member is ir.Constructor ||
-            member is ir.Procedure && member.kind == ir.ProcedureKind.Factory) {
-          _constructorMap[member.name.name] = member;
-        } else if (member is ir.Procedure) {
-          if (member.kind == ir.ProcedureKind.Setter) {
-            _setterMap[member.name.name] = member;
+
+      void addMembers(ir.Class c) {
+        for (ir.Member member in c.members) {
+          if (member is ir.Constructor ||
+              member is ir.Procedure &&
+                  member.kind == ir.ProcedureKind.Factory) {
+            _constructorMap[member.name.name] = member;
+          } else if (member is ir.Procedure) {
+            if (member.kind == ir.ProcedureKind.Setter) {
+              _setterMap[member.name.name] = member;
+            } else {
+              _memberMap[member.name.name] = member;
+            }
+          } else if (member is ir.Field) {
+            _memberMap[member.name.name] = member;
+            if (member.isMutable) {
+              _setterMap[member.name.name] = member;
+            }
+            _memberMap[member.name.name] = member;
           } else {
-            _memberMap[member.name.name] = member;
+            throw new SpannableAssertionFailure(
+                NO_LOCATION_SPANNABLE, "Unexpected class member node: $member");
           }
-        } else if (member is ir.Field) {
-          _memberMap[member.name.name] = member;
-          if (member.isMutable) {
-            _setterMap[member.name.name] = member;
-          }
-          _memberMap[member.name.name] = member;
-        } else {
-          throw new SpannableAssertionFailure(
-              NO_LOCATION_SPANNABLE, "Unexpected class member node: $member");
         }
       }
+
+      if (cls.mixedInClass != null) {
+        addMembers(cls.mixedInClass);
+      }
+      addMembers(cls);
     }
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupMember(String name, {bool setter: false}) {
     _ensureMaps();
     return setter ? _setterMap[name] : _memberMap[name];
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
@@ skipping 467 matching lines @@
   @override
   bool checkClass(ClassEntity cls) => true;
 }
 
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
   final KernelToElementMap builder;
 
   WorldDeconstructionForTesting(this.builder);
 
-  Uri getLibraryUri(KLibrary library) {
-    return builder._libraryEnvs[library.libraryIndex].library.importUri;
-  }
-
-  KLibrary getLibraryForClass(KClass cls) {
-    _KClassEnv env = builder._classEnvs[cls.classIndex];
-    return builder.getLibrary(env.cls.enclosingLibrary);
-  }
-
   KLibrary _getLibrary<E>(E member, Map<ir.Member, E> map) {
     ir.Library library;
     map.forEach((ir.Member node, E other) {
       if (library == null && member == other) {
         library = node.enclosingLibrary;
       }
     });
     if (library == null) {
       throw new ArgumentError("No library found for $member");
     }
     return builder._getLibrary(library);
   }
 
   KLibrary getLibraryForFunction(KFunction function) =>
       _getLibrary(function, builder._methodMap);
 
   KLibrary getLibraryForField(KField field) =>
       _getLibrary(field, builder._fieldMap);
 
   KClass getSuperclassForClass(KClass cls) {
     _KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype supertype = env.cls.supertype;
     if (supertype == null) return null;
     return builder.getClass(supertype.classNode);
   }
 
+  bool isUnnamedMixinApplication(KClass cls) {
+    _KClassEnv env = builder._classEnvs[cls.classIndex];
+    return env.isUnnamedMixinApplication;
+  }
+
   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);
   }
 }