Also intialize methods inherited from mixin classes.

pkg/compiler/lib/src/js_emitter/old_emitter/setup_program_builder.dart

 // Copyright (c) 2013, 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;
 
 // TODO(ahe): Share these with js_helper.dart.
 const FUNCTION_INDEX = 0;
 const NAME_INDEX = 1;
 const CALL_NAME_INDEX = 2;
@@ skipping 105 matching lines @@
      'isolateName': namer.isolateName,
      'classIdExtractor': classIdExtractorAccess,
      'classFieldsExtractor': classFieldsExtractorAccess,
      'instanceFromClassId': instanceFromClassIdAccess,
      'initializeEmptyInstance': initializeEmptyInstanceAccess,
      'allClasses': allClassesAccess,
      'debugFastObjects': DEBUG_FAST_OBJECTS,
      'isTreeShakingDisabled': backend.isTreeShakingDisabled,
      'precompiled': precompiledAccess,
      'finishedClassesAccess': finishedClassesAccess,
-     'markerFun': emitter.markerFun,
      'needsMixinSupport': emitter.needsMixinSupport,
      'needsNativeSupport': program.needsNativeSupport,
      'isInterceptorClass': namer.operatorIs(backend.jsInterceptorClass),
      'isObject' : namer.operatorIs(compiler.objectClass),
      'specProperty': js.string(namer.nativeSpecProperty),
      'trivialNsmHandlers': emitter.buildTrivialNsmHandlers(),
      'hasRetainedMetadata': backend.hasRetainedMetadata,
      'types': typesAccess,
      'objectClassName': js.string(namer.runtimeTypeName(compiler.objectClass)),
      'needsStructuredMemberInfo': emitter.needsStructuredMemberInfo,
@@ skipping 261 matching lines @@
         // 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") {
           // Inlined special case of InheritFrom here for performance reasons.
           // Fix up the the Dart Object class' prototype.
           var constructor = allClasses[cls];
           var prototype = constructor.prototype;
           prototype.constructor = constructor;
           prototype.#isObject = constructor;
-          prototype.#deferredAction = #markerFun;
+          prototype.#deferredAction = function() {};
           return;
         }
         finishClass(superclass);
         var superConstructor = allClasses[superclass];
 
         if (!superConstructor) {
           superConstructor = existingIsolateProperties[superclass];
         }
 
         var constructor = allClasses[cls];
         var prototype = inheritFrom(constructor, superConstructor);
 
+        if (#needsMixinSupport) {
+          if (mixinPrototype) {
+            prototype.#deferredAction
+              = mixinDeferredActionHelper(mixinPrototype, prototype);
+          }
+        }
+
         if (#needsNativeSupport) {
           if (Object.prototype.hasOwnProperty.call(prototype, #specProperty)) {
             #nativeInfoHandler;
             // As native classes can come into existence without a constructor
             // call, we have to ensure that the class has been fully
             // initialized.
-            if (constructor.prototype.#deferredAction)
-              finishAddStubsHelper(constructor.prototype);
+            prototype.#deferredAction();
           }
         }
         // Interceptors (or rather their prototypes) are also used without
         // first instantiating them first.
-        if (prototype.#isInterceptorClass &&
-            constructor.prototype.#deferredAction) {
-          finishAddStubsHelper(constructor.prototype);
+        if (prototype.#isInterceptorClass) {
+          prototype.#deferredAction();
         }
       }
 
       #trivialNsmHandlers;
 
       var properties = Object.keys(processedClasses.pending);
       for (var i = 0; i < properties.length; i++) finishClass(properties[i]);
     }
 
+    // Generic handler for deferred class setup. The handler updates the 
+    // prototype that it is installed on (it traverses the prototype chain
+    // of [this] to find itself) and then removes itself. It recurses by
+    // calling deferred handling again, which terminates on Object due to
+    // the final handler.
+    function finishAddStubsHelper() {
+      var prototype = this;
+      // Find the actual prototype that this handler is installed on.
+      while (!prototype.hasOwnProperty(#deferredActionString)) {
+        prototype = prototype.__proto__;
+      }
+      delete prototype.#deferredAction; // Intended to make it slow, too.
+      var properties = Object.keys(prototype);
+      for (var index = 0; index < properties.length; index++) {
+        var property = properties[index];
+        var firstChar = property.charCodeAt(0);
+        var elem;
+        // We have to filter out some special properties that are used for
+        // metadata in descriptors. Currently, we filter everything that
+        // starts with + or *. This has to stay in sync with the special
+        // properties that are used by processClassData below.
+        if (property !== "${namer.classDescriptorProperty}" &&
+            property !== "$reflectableField" &&
+            firstChar !== 43 && // 43 is aka "+".
+            firstChar !== 42 && // 42 is aka "*"
+            (elem = prototype[property]) != null &&
+            elem.constructor === Array &&
+            property !== "<>") {
+          addStubs(prototype, elem, property, false, []);
+        }
+      }
+      convertToFastObject(prototype);
+      prototype = prototype.__proto__;
+      // Call other handlers.
+      prototype.#deferredAction();
+    }
 
-    // For convenience, this method can be called with a prototype as argument
-    // or, if it was bound to an object, by invoking it as a method. Therefore,
-    // if prototype is undefined, this is used as prototype.
-    function finishAddStubsHelper(prototype) {
-      var prototype = prototype || this;
-      var object;
-      while (prototype.#deferredAction != #markerFun) {
-        if (prototype.hasOwnProperty(#deferredActionString)) {
-          delete prototype.#deferredAction; // Intended to make it slow, too.
-          var properties = Object.keys(prototype);
-          for (var index = 0; index < properties.length; index++) {
-            var property = properties[index];
-            var firstChar = property.charCodeAt(0);
-            var elem;
-            // We have to filter out some special properties that are used for
-            // metadata in descriptors. Currently, we filter everything that
-            // starts with + or *. This has to stay in sync with the special
-            // properties that are used by processClassData below.
-            if (property !== "${namer.classDescriptorProperty}" &&
-                property !== "$reflectableField" &&
-                firstChar !== 43 && // 43 is aka "+".
-                firstChar !== 42 && // 42 is aka "*"
-                (elem = prototype[property]) != null &&
-                elem.constructor === Array &&
-                property !== "<>") {
-              addStubs(prototype, elem, property, false, []);
-            }
+    if (#needsMixinSupport) {
+      // Returns a deferred class setup handler that first invokes the
+      // handler on [mixinPrototype] and then resumes handling on
+      // [targetPrototype]. If [targetPrototype] already has a handler
+      // installed, the handler is preserved in the generated closure and
+      // thus can be safely overwritten.
+      function mixinDeferredActionHelper(mixinPrototype, targetPrototype) {
+        var chain;
+        if (targetPrototype.hasOwnProperty(#deferredActionString)) {
+          chain = targetPrototype.#deferredAction;
+        }
+        return function foo() {
+          var prototype = this;
+          // Find the actual prototype that this handler is installed on.
+          while (!prototype.hasOwnProperty(#deferredActionString)) {
+            prototype = prototype.__proto__;
           }
-          convertToFastObject(prototype);
+          if (chain) {
+            prototype.#deferredAction = chain;
+          } else {
+            delete prototype.#deferredAction;
+            convertToFastObject(prototype);
+          }
+          mixinPrototype.#deferredAction();
+          prototype.#deferredAction();
         }
-        prototype = prototype.__proto__;
       }
     }
 
     function processClassData(cls, descriptor, processedClasses) {
       descriptor = convertToSlowObject(descriptor); // Use a slow object.
       var previousProperty;
       var properties = Object.keys(descriptor);
       var hasDeferredWork = false;
       var shouldDeferWork =
           supportsDirectProtoAccess && cls != #objectClassName;
@@ skipping 317 matching lines @@
 (function() {
   var result = $array[$index];
   if ($check) {
     throw new Error(
         name + ": expected value of type \'$type\' at index " + ($index) +
         " but got " + (typeof result));
   }
   return result;
 })()''';
 }