dart2js: fix mixin support in deferred libraries.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 510 matching lines @@
           split = supr.split(":");
           if (split.length == 2) {
             supr = split[0];
             var functionSignature = split[1];
             if (functionSignature)
               desc.$signaturePropertyName = (function(s) {
                   return function(){ return #metadata[s]; };
                 })(functionSignature);
           }
 
-          if (#needsMixinSupport)
-            if (supr && supr.indexOf("+") > 0) {
-              s = supr.split("+");
-              supr = s[0];
-              var mixin = collectedClasses[s[1]];
-              if (mixin instanceof Array) mixin = mixin[1];
-              for (var d in mixin) {
-                if (hasOwnProperty.call(mixin, d) &&
-                    !hasOwnProperty.call(desc, d))
-                  desc[d] = mixin[d];
-              }
-            }
-
           if (typeof dart_precompiled != "function") {
             combinedConstructorFunction += defineClass(cls, fields);
             constructorsList.push(cls);
           }
           if (supr) pendingClasses[cls] = supr;
         }
 
         if (typeof dart_precompiled != "function") {
           combinedConstructorFunction +=
              "return [\\n  " + constructorsList.join(",\\n  ") + "\\n]";
@@ skipping 22 matching lines @@
 
         #finishClassFunction;
 
         #trivialNsmHandlers;
 
         for (var cls in pendingClasses) finishClass(cls);
       }''', { 'allClasses': allClassesAccess,
               'debugFastObjects': DEBUG_FAST_OBJECTS,
               'hasRetainedMetadata': backend.hasRetainedMetadata,
               'metadata': metadataAccess,
-              'needsMixinSupport': needsMixinSupport,
               'isTreeShakingDisabled': backend.isTreeShakingDisabled,
               'finishClassFunction': buildFinishClass(),
               'trivialNsmHandlers': nsmEmitter.buildTrivialNsmHandlers()});
   }
 
   jsAst.Node optional(bool condition, jsAst.Node node) {
     return condition ? node : new jsAst.EmptyStatement();
   }
 
   jsAst.Statement buildFinishClass() {
     String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
 
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
 
     return js.statement('''
     {
       var finishedClasses = #finishedClassesAccess;
 
       function finishClass(cls) {
 
         if (finishedClasses[cls]) return;
         finishedClasses[cls] = true;
 
         var superclass = pendingClasses[cls];
+
+        if (#needsMixinSupport) {
+          if (superclass && superclass.indexOf("+") > 0) {
+            var s = superclass.split("+");
+            superclass = s[0];
+            var mixinClass = s[1];
+            finishClass(mixinClass);
+            var mixin = allClasses[mixinClass];
+            // TODO(floitsch): this test shouldn't be necessary. Without it
+            // we have a crash in pkg/analysis_server/tool/spec/check_all_test.
+            if (mixin) {
+              var mixinPrototype = mixin.prototype;
+              var clsPrototype = allClasses[cls].prototype;
+              for (var d in mixinPrototype) {
+                if (hasOwnProperty.call(mixinPrototype, d) &&
+                    !hasOwnProperty.call(clsPrototype, d))
+                  clsPrototype[d] = mixinPrototype[d];
+              }
+            }
+          }
+        }
+
         // The superclass is only false (empty string) for the Dart Object
         // class.  The minifier together with noSuchMethod can put methods on
         // the Object.prototype object, and they show through here, so we check
         // that we have a string.
         if (!superclass || typeof superclass != "string") return;
         finishClass(superclass);
         var superConstructor = allClasses[superclass];
 
         if (!superConstructor)
           superConstructor = existingIsolateProperties[superclass];
@@ skipping 45 matching lines @@
                 for (i = 0; i < tags.length; i++) {
                   #interceptorsByTagAccess[tags[i]] = constructor;
                   #leafTagsAccess[tags[i]] = false;
                 }
               }
             }
           }
         }
       }
     }''', {'finishedClassesAccess': finishedClassesAccess,
+           'needsMixinSupport': needsMixinSupport,
            'hasNativeClasses': nativeClasses.isNotEmpty,
            'interceptorsByTagAccess': interceptorsByTagAccess,
            'leafTagsAccess': leafTagsAccess,
            'allowNativesSubclassing': true});
   }
 
   jsAst.Fun get finishIsolateConstructorFunction {
     // We replace the old Isolate function with a new one that initializes
     // all its fields with the initial (and often final) value of all globals.
     //
@@ skipping 1525 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }