Make mixins work on native classes.

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 1153 matching lines @@
                            ClassBuilder builder) {
     assert(invariant(classElement, classElement.isDeclaration));
 
     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(
         visitMember,
         includeBackendMembers: true,
         includeSuperMembers: false);
 
     void generateIsTest(Element other) {
       jsAst.Expression code;
       if (other == compiler.objectClass && other != classElement) {
         // Avoid emitting [:$isObject:] on all classes but [Object].
         return;
@@ skipping 90 matching lines @@
       for (ClassElement check in typeChecks[cls]) {
         buffer.write('$holder.${namer.operatorIs(check)}$_=${_}true$N');
         String body = rti.getSupertypeSubstitution(cls, check);
         if (body != null) {
           buffer.write('$holder.${namer.substitutionName(check)}$_=${_}$body$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 57 matching lines @@
                  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());
+        includeSuperMembers: isInstantiated);
   }
 
   void generateGetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String getterName = namer.getterNameFromAccessorName(accessorName);
     String receiver = backend.isInterceptorClass(member.getEnclosingClass())
         ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member)
         ? ['receiver']
         : [];
@@ skipping 164 matching lines @@
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void generateClass(ClassElement classElement, CodeBuffer buffer) {
     assert(invariant(classElement, classElement.isDeclaration));
     assert(invariant(classElement, !classElement.isNative()));
 
     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 109 matching lines @@
                                   emitSubstitution,
                                   generated);
         getTypedefChecksOn(call.computeType(compiler)).forEach(emitIsTest);
       }
     }
 
     for (DartType interfaceType in cls.interfaces) {
       generateInterfacesIsTests(interfaceType.element, emitIsTest,
                                 emitSubstitution, 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,
-                                  emitSubstitution, generated);
-      }
-    });
   }
 
   /**
    * Generate "is tests" where [cls] is being implemented.
    */
   void generateInterfacesIsTests(ClassElement cls,
                                  void emitIsTest(ClassElement element),
                                  void emitSubstitution(ClassElement element),
                                  Set<Element> alreadyGenerated) {
     void tryEmitTest(ClassElement check) {
@@ skipping 1371 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].
 """;