Making "super" work outside a literal?

Allen Wirfs-Brock allen at
Tue Jun 21 08:55:24 PDT 2011

On Jun 21, 2011, at 4:13 PM, Sean Eagan wrote:

> On Tue, Jun 21, 2011 at 9:40 AM, Axel Rauschmayer <axel at> wrote:
>>>> We wish to avoid another parameter computed potentially differently for each
>>>> call. It will cost
>>> What costs do you foresee?  I am not sure that there is much to
>>> compute.  Assume a method call O.m().  Assume "m" is found on an
>>> object P within O's protoype chain.  This will result in P.m being
>>> called, for which the "super binding" can simply be computed as
>>> P.[[Prototype]].  Next assume a direct function call, e.g.
>>> or f() (this === undefined), the "super binding" here
>>> could just be calculated as this.[[Prototype]] or undefined if |this|
>>> is not an object.
>> This may already be what you are suggesting, so to clarify:
>> I would introduce a binding called "here" that points to the object P where m has been found.
>> - Method that uses super: compute super as here.[[Prototype]]
>> - Non-method function that uses super: "here" is undefined, using super causes an error.
>> If super is not used there is little computational cost! (Other than a binding per function call which may still be prohibitive.)
> Regardless of any "here" binding, "super" would only need to be bound
> within functions that actually use it (the same should be true for
> |this|).  However, as I mentioned, it seems the cost of a dynamic
> |super| binding should be relatively low, comparable to the cost of a
> dynamic |this| binding.

No, dynamic 'super' is an additional overhead  that is the same as the dynamic 'this' overhead.  Dynamic 'super' essentially doubles the dynamic 'this' overhead on every call.


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the es-discuss mailing list