Allow native classes to mixin behavior from an ordinary Dart class.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.dart

 // Copyright (c) 2012, 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.
 
 part of js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 717 matching lines @@
   void emitInstanceMembers(ClassElement classElement,
                            ClassBuilder builder) {
     assert(invariant(classElement, classElement.isDeclaration));
     JavaScriptBackend backend = compiler.backend;
     if (classElement == backend.objectInterceptorClass) {
       emitInterceptorMethods(builder);
       // The ObjectInterceptor does not have any instance methods.
       return;
     }
 
+    void visitMember(ClassElement enclosing, Element member) {
+      assert(invariant(classElement, member.isDeclaration));
+      if (member.isInstanceMember()) {
+        addInstanceMember(member, builder);
+      }
+    }
+
+    // TODO(kasperl): We should make sure to only emit one version of
+    // overridden methods. Right now, we rely on the ordering so the
+    // methods pulled in from mixins are replaced with the members
+    // from the class definition, but it is broken if you a chain of
+    // mixin applications.
+
+    // If the class is a native class, we have to add the instance
+    // members defined in the non-native mixin applications used by
+    // the class.
+    if (classElement.isNative()) {
+      ClassElement superclass = classElement.superclass;
+      while (superclass.isMixinApplication) {
+        assert(!superclass.isNative());
+        superclass.forEachMember(
+            visitMember,
+            includeBackendMembers: true,
+            includeSuperMembers: false);
+        superclass = superclass.superclass;
+      }
+    }
+
     classElement.implementation.forEachMember(
-        (ClassElement enclosing, Element member) {
-          assert(invariant(classElement, member.isDeclaration));
-          if (member.isInstanceMember()) {
-            addInstanceMember(member, builder);
-          }
-        },
-        includeBackendMembers: true);
+        visitMember,
+        includeBackendMembers: true,
+        includeSuperMembers: false);
 
     generateIsTestsOn(classElement, (Element other) {
       js.Expression code;
       if (compiler.objectClass == other) return;
       if (nativeEmitter.requiresNativeIsCheck(other)) {
         code = js.fun([], js.block1(js.return_(new js.LiteralBool(true))));
       } else {
         code = new js.LiteralBool(true);
       }
       builder.addProperty(namer.operatorIs(other), code);
@@ skipping 128 matching lines @@
         // Getters and setters with suffixes will be generated dynamically.
         addField(member,
                  fieldName,
                  accessorName,
                  needsGetter,
                  needsSetter,
                  needsCheckedSetter);
       }
     }
 
+    // TODO(kasperl): We should make sure to only emit one version of
+    // overridden fields. Right now, we rely on the ordering so the
+    // fields pulled in from mixins are replaced with the fields from
+    // the class definition, but it is broken if you a chain of mixin
+    // applications.
+
+    // If the class is a native class, we have to add the fields
+    // defined in the non-native mixin applications used by the class.
+    if (classElement.isNative()) {
+      ClassElement superclass = classElement.superclass;
+      while (superclass.isMixinApplication) {
+        assert(!superclass.isNative());
+        superclass.forEachInstanceField(
+            visitField,
+            includeBackendMembers: true,
+            includeSuperMembers: false);
+        superclass = superclass.superclass;
+      }
+    }
+
     // If a class is not instantiated then we add the field just so we can
     // generate the field getter/setter dynamically. Since this is only
     // allowed on fields that are in [classElement] we don't need to visit
     // superclasses for non-instantiated classes.
     classElement.implementation.forEachInstanceField(
         visitField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
   }
 
@@ skipping 157 matching lines @@
       return;
     } else {
       // TODO(ngeoffray): Instead of switching between buffer, we
       // should create code sections, and decide where to emit them at
       // the end.
       buffer = mainBuffer;
     }
 
     needsDefineClass = true;
     String className = namer.getName(classElement);
+
+    // Find the first non-native superclass.
     ClassElement superclass = classElement.superclass;
+    while (superclass != null && superclass.isNative()) {
+      superclass = superclass.superclass;
+    }
+
     String superName = "";
     if (superclass != null) {
       superName = namer.getName(superclass);
     }
 
     ClassBuilder builder = new ClassBuilder();
 
     emitClassConstructor(classElement, builder);
     emitSuper(superName, builder);
     emitClassFields(classElement, builder,
@@ skipping 74 matching lines @@
         call = cls.lookupBackendMember(Compiler.CALL_OPERATOR_NAME);
       }
       if (call != null) {
         generateInterfacesIsTests(compiler.functionClass,
                                   emitIsTest,
                                   generated);
         getTypedefChecksOn(call.computeType(compiler)).forEach(emitIsTest);
       }
     }
     for (DartType interfaceType in cls.interfaces) {
-      generateInterfacesIsTests(interfaceType.element, emitIsTest, generated);
+      ClassElement interfaceElement = interfaceType.element;
+      generateInterfacesIsTests(interfaceElement, emitIsTest, generated);
     }
+
+    // For native classes, we also have to run through their
+    // non-native mixin applications and make sure we deal with 'is'
+    // tests correctly for those.
+    if (cls.isNative()) {
+      ClassElement superclass = cls.superclass;
+      while (superclass != null && superclass.isMixinApplication) {
+        assert(!superclass.isNative());
+        for (DartType interfaceType in superclass.interfaces) {
+          ClassElement interfaceElement = interfaceType.element;
+          generateInterfacesIsTests(interfaceElement, emitIsTest, generated);
+        }
+        superclass = superclass.superclass;
+      }
+    }
+
   }
 
   /**
    * Generate "is tests" where [cls] is being implemented.
    */
   void generateInterfacesIsTests(ClassElement cls,
                                  void emitIsTest(ClassElement element),
                                  Set<Element> alreadyGenerated) {
     void tryEmitTest(ClassElement cls) {
       if (!alreadyGenerated.contains(cls) && checkedClasses.contains(cls)) {
@@ skipping 1000 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;