Encode super calls via extra properties on prototypes.

pkg/compiler/lib/src/js_emitter/old_emitter/container_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;
 
 /// This class should morph into something that makes it easy to build
 /// JavaScript representations of libraries, class-sides, and instance-sides.
 /// Initially, it is just a placeholder for code that is moved from
 /// [CodeEmitterTask].
@@ skipping 370 matching lines @@
       }
     } else {
       canTearOff =
           compiler.codegenWorld.staticFunctionsNeedingGetter.contains(member) ||
           canBeReflected;
       tearOffName = namer.getStaticClosureName(member);
     }
     final bool canBeApplied = compiler.enabledFunctionApply &&
                               compiler.world.getMightBePassedToApply(member);
 
+    final bool hasSuperAlias = backend.isAliasedSuperMember(member);
+
     final bool needStructuredInfo =
-        canTearOff || canBeReflected || canBeApplied;
+        canTearOff || canBeReflected || canBeApplied || hasSuperAlias;
+
 
     if (canTearOff) {
       assert(invariant(member, !member.isGenerativeConstructor));
       assert(invariant(member, !member.isGenerativeConstructorBody));
       assert(invariant(member, !member.isConstructor));
     }
 
     return new MemberInfo(
         member,
         name,
         parameters,
         code,
         needsStubs: needsStubs,
         canTearOff: canTearOff,
         isClosure: isClosure,
         tearOffName: tearOffName,
         canBeReflected: canBeReflected,
         canBeApplied: canBeApplied,
-        needStructuredInfo: needStructuredInfo);
-
+        hasSuperAlias: hasSuperAlias,
+        needStructuredInfo: needStructuredInfo
+    );
   }
 
   void addMemberMethodFromInfo(MemberInfo info, ClassBuilder builder) {
     final FunctionElement member = info.member;
-    final String name = info.name;
+    String name = info.name;
     final FunctionSignature parameters = info.parameters;
     jsAst.Expression code = info.code;
     final bool needsStubs = info.needsStubs;
     final bool canTearOff = info.canTearOff;
     final bool isClosure = info.isClosure;
     final String tearOffName = info.tearOffName;
     final bool canBeReflected = info.canBeReflected;
     final bool canBeApplied = info.canBeApplied;
     final bool needStructuredInfo = info.needStructuredInfo;
+    final bool hasSuperAlias = info.hasSuperAlias;
 
     emitter.interceptorEmitter.recordMangledNameOfMemberMethod(member, name);
 
     if (!needStructuredInfo) {
       compiler.dumpInfoTask.registerElementAst(member,
           builder.addProperty(name, code));
       if (needsStubs) {
         addParameterStubs(
             member,
             (Selector selector, jsAst.Fun function) {
               compiler.dumpInfoTask.registerElementAst(member,
-                  builder.addProperty(namer.invocationName(selector), function));
+                  builder.addProperty(namer.invocationName(selector),
+                                      function));
             });
       }
       return;
     }
 
 
-    // This element is needed for reflection or needs additional stubs. So we
-    // need to retain additional information.
+    // This element is needed for reflection or needs additional stubs or has a
+    // super alias. So we need to retain additional information.
 
     // The information is stored in an array with this format:
     //
-    // 1.   The JS function for this member.
-    // 2.   First stub.
-    // 3.   Name of first stub.
+    // 1.   The alias name for this function (optional).
+    // 2.   The JS function for this member.
+    // 3.   First stub.
+    // 4.   Name of first stub.
     // ...
     // M.   Call name of this member.
     // M+1. Call name of first stub.
     // ...
     // N.   Getter name for tearOff.
     // N+1. (Required parameter count << 1) + (member.isAccessor ? 1 : 0).
     // N+2. (Optional parameter count << 1) +
     //                      (parameters.optionalParametersAreNamed ? 1 : 0).
     // N+3. Index to function type in constant pool.
     // N+4. First default argument.
     // ...
     // O.   First parameter name (if needed for reflection or Function.apply).
     // ...
     // P.   Unmangled name (if reflectable).
     // P+1. First metadata (if reflectable).
     // ...
     // TODO(ahe): Consider one of the parameter counts can be replaced by the
     // length property of the JavaScript function object.
 
     List<jsAst.Expression> expressions = <jsAst.Expression>[];
 
+    // Create the optional aliasing entry if this method is called via super.
+    if (backend.isAliasedSuperMember(member)) {
+      expressions.add(new jsAst.LiteralString(
+          '"${namer.getNameOfAliasedSuperMember(member)}"'));
+    }
+
+    expressions.add(code);
+
+    final bool onlyNeedsSuperAlias =
+        !(canTearOff || canBeReflected || canBeApplied || needsStubs);
+
+    if (onlyNeedsSuperAlias) {
+      jsAst.ArrayInitializer arrayInit =
+            new jsAst.ArrayInitializer.from(expressions);
+          compiler.dumpInfoTask.registerElementAst(member,
+              builder.addProperty(name, arrayInit));
+      return;
+    }
+
     String callSelectorString = 'null';
     if (member.isFunction) {
       Selector callSelector = new Selector.fromElement(member).toCallSelector();
       callSelectorString = '"${namer.invocationName(callSelector)}"';
     }
 
     // On [requiredParameterCount], the lower bit is set if this method can be
     // called reflectively.
     int requiredParameterCount = parameters.requiredParameterCount << 1;
     if (member.isAccessor) requiredParameterCount++;
 
     int optionalParameterCount = parameters.optionalParameterCount << 1;
     if (parameters.optionalParametersAreNamed) optionalParameterCount++;
 
-    expressions.add(code);
-
     // TODO(sra): Don't use LiteralString for non-strings.
     List tearOffInfo = [new jsAst.LiteralString(callSelectorString)];
 
     if (needsStubs || canTearOff) {
       addParameterStubs(member, (Selector selector, jsAst.Fun function) {
         expressions.add(function);
         if (member.isInstanceMember) {
           Set invokedSelectors =
               compiler.codegenWorld.invokedNames[member.name];
             expressions.add(js.string(namer.invocationName(selector)));
@@ skipping 74 matching lines @@
             js.string(namer.privateName(member.library, member.name));
       }
       expressions
           ..add(reflectionName)
           ..addAll(emitter.metadataEmitter
               .computeMetadata(member).map(js.number));
     } else if (isClosure && canBeApplied) {
       expressions.add(js.string(namer.privateName(member.library,
                                                   member.name)));
     }
+
     jsAst.ArrayInitializer arrayInit =
       new jsAst.ArrayInitializer.from(expressions);
     compiler.dumpInfoTask.registerElementAst(member,
         builder.addProperty(name, arrayInit));
   }
 
   void addMemberField(VariableElement member, ClassBuilder builder) {
     // For now, do nothing.
   }
 }
@@ skipping 14 matching lines @@
   final bool isClosure;
 
   final String tearOffName;
 
   final bool canBeReflected;
 
   final bool canBeApplied;
 
   final bool needStructuredInfo;
 
+  final bool hasSuperAlias;
+
   MemberInfo(
       this.member,
       this.name,
       this.parameters,
       this.code,
       {this.needsStubs,
        this.canTearOff,
        this.isClosure,
        this.tearOffName,
        this.canBeReflected,
        this.canBeApplied,
+       this.hasSuperAlias,
        this.needStructuredInfo}) {
     assert(member != null);
     assert(name != null);
     assert(parameters != null);
     assert(code != null);
     assert(needsStubs != null);
     assert(canTearOff != null);
     assert(isClosure != null);
     assert(tearOffName != null || !canTearOff);
     assert(canBeReflected != null);
     assert(canBeApplied != null);
+    assert(hasSuperAlias != null);
     assert(needStructuredInfo != null);
   }
 }