Call base class property via super

[wgebczyk]

In following code:

class MyBase {
  getValue(): number { return 1; }
  get value(): number { return 1; }
}

class MyDerived extends MyBase {
  constructor() {
    super();

    const f1 = super.getValue();
    const f2 = super.value;
  }
}

var d = new MyDerived();
var f3 = d.value;

disallowing the line "const f2 = super.value;" to be valid is... plain stupid.
What is the scenario where this behavior is valid?

[zpdDG4gta8XKpMCd]

super is referring to the prototype object of a super class, not to the instance object, the instance object is shared between both super and sub classes, hence the limitation

[wgebczyk]

IF "super is referring to the prototype object" THEN
"super.getValue()" would not work as do not have instance reference "this".

class MyBase {
  private _value: number;
  constructor(value: number) { this._value = value; }

  getValue(): number { return this._value; }
  get value(): number { return this._value; }
}

class MyDerived extends MyBase {
  constructor() {
    super(2);

    const f1 = super.getValue();
    const f2 = super.value;
    alert(`${f1} | ${f2} | ${MyBase.prototype.value}`);
  }
}

var d = new MyDerived();
var f3 = d.value;

alert gets "2 | undefined | undefined". This means super DOES NOT represent prototype, but instance (kind of parent instance, but still instance).

IF "super is referring to the base object instance" THEN
Why "super.value" does not work.

[zpdDG4gta8XKpMCd]

IF "super is referring to the prototype object" THEN

"...super is referring to the prototype object of a super class"

class MyBase {
  getValue(): number { return 1; }
  get value(): number { return 1; }
}

class MyDerived extends MyBase {
  constructor() {
    super();

    const f1 = super.getValue();
    const f2 = super.value;
  }
}

var d = new MyDerived();
var f3 = d.value;

is compiled to:

var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
};
var MyBase = (function () {
    function MyBase() {
    }
    MyBase.prototype.getValue = function () { return 1; };
    Object.defineProperty(MyBase.prototype, "value", {
        get: function () { return 1; },
        enumerable: true,
        configurable: true
    });
    return MyBase;
})();
var MyDerived = (function (_super) {
    __extends(MyDerived, _super);
    function MyDerived() {
        _super.call(this);
        var f1 = _super.prototype.getValue.call(this);
        var f2 = _super.prototype.value;
    }
    return MyDerived;
})(MyBase);
var d = new MyDerived();
var f3 = d.value;

Look over here: live example

[zpdDG4gta8XKpMCd]

missed your point, value is a property accessor not just a property, your original complaint looks valid

(everything that i said is still valid too :) )

[RyanCavanaugh]

See #338

[wgebczyk]

Please do not close this as I'm targeting ES6.
Is there anything in ES2015 that prevents from using super.(base class field/property)?

[RyanCavanaugh]

Good point - we should at least allow this in ES6

[wgebczyk]

Thanks!

[vladima]

#5860 lifts the restriction for ES6, we still need a separate proposal for the downlevel emit

[tbebekis]

var GetPropertyDescriptor = function (o, PropName) {
    if (o !== null) {
        return o.hasOwnProperty(PropName) ?
              Object.getOwnPropertyDescriptor(o, PropName) :
             GetPropertyDescriptor(Object.getPrototypeOf(o), PropName);
    }

    return null;
};

return GetPropertyDescriptor(base, 'Name').get.call(this); // getter call
GetPropertyDescriptor(base, 'Name').set.call(this, v); // setter call

The above works in plain javascript. It looks really ugly. Typescript would make it look a little nicer, perhaps using the super keyword.

[jsep]

Maybe a bit late, but I was able to access super.<getter/setter> using bracket notation. super['value'].

I wanted to override a getter of my super, for example:

class Base {
    get value() {
        return 'a'
    }
}

class CustomBase extends Base {
    get value() {
        return super['value'] + 'b';
    }

}

[thw0rted]

@jsep this is very helpful, do you have any idea why the index operator is allowed but calling super.value directly is an error?