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 290 matching lines @@
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
   }
 
   /** Needs defineClass to be defined. */
   List buildInheritFrom() {
     return [js(r'''
         var inheritFrom = function() {
           function tmp() {}
           var hasOwnProperty = Object.prototype.hasOwnProperty;
-          return function (constructor, superConstructor) {
+          return function (constructor, superConstructor, aliases) {
             tmp.prototype = superConstructor.prototype;
             var object = new tmp();
+            if (aliases) {
+              for (var pos = 0; pos < aliases.length; pos++) {
+                var member = aliases[pos].split(':');
+                object[member[0]] = object[member[1]];
+              }
+            }
             var properties = constructor.prototype;
             for (var member in properties)
               if (hasOwnProperty.call(properties, member))
                 object[member] = properties[member];

[sra1, 2014/11/03 18:30:56]

If you moved the alias logic here (split member), the encoding would be more
compact:

  "foo$3,super$Node$foo$3": function...

Are there problems with doing this?

[herhut, 2014/11/04 12:52:49]

No, great suggestion. Done.

             object.constructor = constructor;
             constructor.prototype = object;
             return object;
           };
         }()
       ''')];
   }
 
   jsAst.Fun get finishClassesFunction {
     // Class descriptions are collected in a JS object.
@@ skipping 15 matching lines @@
     jsAst.Expression metadataAccess =
         generateEmbeddedGlobalAccess(embeddedNames.METADATA);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
 
     return js('''
       function(collectedClasses, isolateProperties, existingIsolateProperties) {
         var pendingClasses = Object.create(null);
+        var pendingAliases = Object.create(null);
         if (!#) # = Object.create(null);  // embedded allClasses.
         var allClasses = #;  // embedded allClasses;
 
         if (#)  // DEBUG_FAST_OBJECTS
           print("Number of classes: " +
               Object.getOwnPropertyNames(\$\$).length);
 
         var hasOwnProperty = Object.prototype.hasOwnProperty;
 
         if (typeof dart_precompiled == "function") {
           var constructors = dart_precompiled(collectedClasses);
         } else {
           var combinedConstructorFunction =
              "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
-           *   '[name/]Super;field1,field2'
+           * string encoding fields, constructor, superclass and methods from
+           * the superclass that need aliasing.  Get the superclass, fields 
+           * and aliases in the format
+           *   '[name/]Super;field1,field2;alias,alias2'
            * 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;
+              supr, name = cls, fields = classData, aliases = false;
           if (#)  // backend.hasRetainedMetadata
             if (typeof classData == "object" &&
                 classData instanceof Array) {
               classData = fields = classData[0];
             }
           if (typeof classData == "string") {
             var split = classData.split("/");
             if (split.length == 2) {
               name = split[0];
               fields = split[1];
             }
           }
 
           var s = fields.split(";");
           fields = s[1] == "" ? [] : s[1].split(",");
+          if (s.length == 3) aliases = s[2].split(",");
           supr = s[0];
+
           split = supr.split(":");
           if (split.length == 2) {
             supr = split[0];
             var functionSignature = split[1];
             if (functionSignature)
               desc.\$signature = (function(s) {
                   return function(){ return #[s]; };  // embedded metadata.
                 })(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(name, cls, fields);
             constructorsList.push(cls);
           }
           if (supr) pendingClasses[cls] = supr;
+          if (aliases) pendingAliases[cls] = aliases;
         }
 
         if (typeof dart_precompiled != "function") {
           combinedConstructorFunction +=
              "return [\\n  " + constructorsList.join(",\\n  ") + "\\n]";
            var constructors =
             new Function("\$collectedClasses", combinedConstructorFunction)
             (collectedClasses);
           combinedConstructorFunction = null;
         }
@@ skipping 50 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 aliases = pendingAliases[cls];
 
         // 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);
+        var prototype = inheritFrom(constructor, superConstructor, aliases);
 
         if (#) {  // !nativeClasses.isEmpty,
           // The property looks like this:
           //
           // HtmlElement: {
           //     "%": "HTMLDivElement|HTMLAnchorElement;HTMLElement;FancyButton"
           //
           // The first two semicolon-separated parts contain dispatch tags, the
           // third contains the JavaScript names for classes.
           //
@@ skipping 1465 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }