dart2js: Support mixins in the new emitter.

pkg/compiler/lib/src/js_emitter/program_builder.dart

 // Copyright (c) 2014, 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.js_emitter.program_builder;
 
+import 'js_emitter.dart' show computeMixinClass;
 import 'model.dart';
+
 import '../common.dart';
 import '../js/js.dart' as js;
 
 import '../js_backend/js_backend.dart' show
     Namer,
     JavaScriptBackend,
     JavaScriptConstantCompiler;
 
 import '../closure.dart' show ClosureFieldElement;
 
@@ skipping 53 matching lines @@
     outputs.setAll(1, deferredOutputs);
 
     Program result =
         new Program(outputs, _task.outputContainsConstantList, _buildLoadMap());
 
     // Resolve the superclass references after we've processed all the classes.
     _classes.forEach((ClassElement element, Class c) {
       if (element.superclass != null) {
         c.setSuperclass(_classes[element.superclass]);
       }
+      if (element.isMixinApplication) {
+        MixinApplication mixinApplication = c;
+        mixinApplication.setMixinClass(_classes[computeMixinClass(element)]);
+      }
     });
 
     _markEagerClasses();
 
     return result;
   }
 
   void _markEagerClasses() {
     _markEagerInterceptorClasses();
   }
@@ skipping 140 matching lines @@
 
     List<Class> classes = elements
         .where((e) => e is ClassElement)
         .map(_buildClass)
         .toList(growable: false);
 
     return new Library(uri, statics, classes);
   }
 
   Class _buildClass(ClassElement element) {
-    bool isInstantiated =
-        _compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
-
     List<Method> methods = [];
     List<InstanceField> fields = [];
 
     void visitMember(ClassElement enclosing, Element member) {
       assert(invariant(element, member.isDeclaration));
       assert(invariant(element, element == enclosing));
 
       if (Elements.isNonAbstractInstanceMember(member)) {
         js.Expression code = backend.generatedCode[member];
         // TODO(kasperl): Figure out under which conditions code is null.
         if (code != null) methods.add(_buildMethod(member, code));
       } else if (member.isField && !member.isStatic) {
         fields.add(_buildInstanceField(member, enclosing));
       }
     }
 
     ClassElement implementation = element.implementation;
-    if (isInstantiated) {
+
+    // MixinApplications run through the members of their mixin. Here, we are
+    // only interested in direct members.
+    if (!element.isMixinApplication) {

[sigurdm, 2014/11/27 09:25:54]

What about elements that are not instantiated for other reasons than being a
mixin application?

[floitsch, 2014/11/27 12:35:16]

The only ones that I can think of are onlyForRti and I will look at them when
doing RTI.

       implementation.forEachMember(visitMember, includeBackendMembers: true);
     }
     String name = namer.getNameOfClass(element);
     String holderName = namer.globalObjectFor(element);
     Holder holder = _registry.registerHolder(holderName);
     bool onlyForRti =
         _task.typeTestEmitter.rtiNeededClasses.contains(element);
-    Class result = new Class(name, holder, methods, fields,
-                             onlyForRti: onlyForRti);
+    bool isInstantiated =
+        _compiler.codegenWorld.directlyInstantiatedClasses.contains(element);
+
+    Class result;
+    if (element.isMixinApplication) {
+      assert(methods.isEmpty);
+      assert(fields.isEmpty);
+      result = new MixinApplication(name, holder,
+                                    isDirectlyInstantiated: isInstantiated,
+                                    onlyForRti: onlyForRti);
+    } else {
+      result = new Class(name, holder, methods, fields,
+                         isDirectlyInstantiated: isInstantiated,
+                         onlyForRti: onlyForRti);
+    }
     _classes[element] = result;
     return result;
   }
 
   Method _buildMethod(FunctionElement element, js.Expression code) {
     String name = namer.getNameOfInstanceMember(element);
     return new Method(name, code);
   }
 
   // The getInterceptor methods directly access the prototype of classes.
@@ skipping 118 matching lines @@
     for (ConstantValue constantValue in constantValues) {
       assert(!_constants.containsKey(constantValue));
       String name = namer.constantName(constantValue);
       String constantObject = namer.globalObjectForConstant(constantValue);
       Holder holder = _registry.registerHolder(constantObject);
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     };
   }
 }