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.
+
+    // 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.
+    visitNativeMixins(classElement, (MixinApplicationElement mixin) {
+      mixin.forEachMember(
+          visitMember,
+          includeBackendMembers: true,
+          includeSuperMembers: false);
+    });
+
     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 63 matching lines @@
         // class.
         continue;
       }
       String holder = namer.isolateAccess(cls);
       for (ClassElement check in typeChecks[cls]) {
         buffer.add('$holder.${namer.operatorIs(check)}$_=${_}true$N');
       };
     }
   }
 
+  void visitNativeMixins(ClassElement classElement,
+                         void visit(MixinApplicationElement mixinApplication)) {
+    if (!classElement.isNative()) return;
+    // Use recursion to make sure to visit the superclasses before the
+    // subclasses. Once we start keeping track of the emitted fields
+    // and members, we're going to want to visit these in the other
+    // order so we get the most specialized definition first.
+    void recurse(ClassElement cls) {
+      if (cls == null || !cls.isMixinApplication) return;
+      recurse(cls.superclass);
+      assert(!cls.isNative());
+      visit(cls);
+    }
+    recurse(classElement.superclass);
+  }
+
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void visitClassFields(ClassElement classElement,
                         void addField(Element member,
                                       String name,
                                       String accessorName,
                                       bool needsGetter,
@@ skipping 45 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.
+
+    // If the class is a native class, we have to add the fields
+    // defined in the non-native mixin applications used by the class.
+    visitNativeMixins(classElement, (MixinApplicationElement mixin) {
+      mixin.forEachInstanceField(
+          visitField,
+          includeBackendMembers: true,
+          includeSuperMembers: false);
+    });
+
     // 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 73 matching lines @@
         // If [cls] is a closure, it has a synthetic call operator method.
         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);
     }
+
+    // For native classes, we also have to run through their mixin
+    // applications and make sure we deal with 'is' tests correctly
+    // for those.
+    visitNativeMixins(cls, (MixinApplicationElement mixin) {
+      for (DartType interfaceType in mixin.interfaces) {
+        ClassElement interfaceElement = interfaceType.element;
+        generateInterfacesIsTests(interfaceType.element, emitIsTest, generated);
+      }
+    });
   }
 
   /**
    * 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 1044 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].
 """;