Encode super calls via extra properties on prototypes.

sdk/lib/_internal/compiler/implementation/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 294 matching lines @@
   /** Needs defineClass to be defined. */
   List buildInheritFrom() {
     return [js(r'''
         var inheritFrom = function() {
           function tmp() {}
           var hasOwnProperty = Object.prototype.hasOwnProperty;
           return function (constructor, superConstructor) {
             tmp.prototype = superConstructor.prototype;
             var object = new tmp();
             var properties = constructor.prototype;
-            for (var member in properties)
-              if (hasOwnProperty.call(properties, member))
+            for (var member in properties) {
+              if (hasOwnProperty.call(properties, member)) {
                 object[member] = properties[member];
+              }
+            }
             object.constructor = constructor;
             constructor.prototype = object;
             return object;
           };
         }()
       ''')];
   }
 
+  List buildSplitOffAliases() {
+    return [js(r'''
+        var splitOffAliases = function(constructor) {
+          var hasOwnProperty = Object.prototype.hasOwnProperty;
+          var properties = constructor.prototype;
+          for (var member in properties) {
+            if (hasOwnProperty.call(properties, member)) {
+              var s = member.split(':');
+              if (s.length > 1) {
+                properties[s[0]] = properties[s[1]] = properties[member];
+                delete properties[member];
+              }
+            }
+          }
+        }
+      ''')];
+  }
+
   jsAst.Fun get finishClassesFunction {
     // Class descriptions are collected in a JS object.
     // 'finishClasses' takes all collected descriptions and sets up
     // the prototype.
     // Once set up, the constructors prototype field satisfy:
     //  - it contains all (local) members.
     //  - its internal prototype (__proto__) points to the superclass'
     //    prototype field.
     //  - the prototype's constructor field points to the JavaScript
     //    constructor.
@@ skipping 30 matching lines @@
              "function \$reflectable(fn){fn.$reflectableField=1;return fn};\\n"+
              "var \$desc;\\n";
           var constructorsList = [];
         }
 
         for (var cls in collectedClasses) {
           var desc = collectedClasses[cls];
           if (desc instanceof Array) desc = desc[1];
 
           /* The 'fields' are either a constructor function or a
-           * string encoding fields, constructor and superclass.  Get
-           * the superclass and the fields in the format
+           * string encoding fields, constructor and superclass. Gets the
+           * superclass and fields in the format
            *   '[name/]Super;field1,field2'
            * from the CLASS_DESCRIPTOR_PROPERTY property on the descriptor.
            * The 'name/' is optional and contains the name that should be used
            * when printing the runtime type string.  It is used, for example,
            * to print the runtime type JSInt as 'int'.
            */
           var classData = desc["${namer.classDescriptorProperty}"],
               supr, name = cls, fields = classData;
           if (#)  // backend.hasRetainedMetadata
             if (typeof classData == "object" &&
@@ skipping 102 matching lines @@
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
 
     return js.statement('''
       function finishClass(cls) {
 
         if (finishedClasses[cls]) return;
         finishedClasses[cls] = true;
 
         var superclass = pendingClasses[cls];
+        var constructor = allClasses[cls];
+
+        // Process aliased members due to super calls. We have to do this early
+        // to ensure that we also hit the object class.
+        splitOffAliases(constructor);
 
         // 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 constructor = allClasses[cls];
         var superConstructor = allClasses[superclass];
 
         if (!superConstructor)
           superConstructor = existingIsolateProperties[superclass];
 
         var prototype = inheritFrom(constructor, superConstructor);
 
         if (#) {  // !nativeClasses.isEmpty,
           // The property looks like this:
           //
@@ skipping 147 matching lines @@
       }
     ''', [laziesAccess, laziesAccess,
           laziesAccess,
           cyclicThrow]);
   }
 
   List buildDefineClassAndFinishClassFunctionsIfNecessary() {
     if (!needsDefineClass) return [];
     return defineClassFunction
     ..addAll(buildInheritFrom())
+    ..addAll(buildSplitOffAliases())
     ..addAll([
       js('$finishClassesName = #', finishClassesFunction)
     ]);
   }
 
   List buildLazyInitializerFunctionIfNecessary() {
     if (!needsLazyInitializer) return [];
 
     return [js('# = #', [js(lazyInitializerName), lazyInitializerFunction])];
   }
@@ skipping 1304 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }