Using `this.super()` and `this.super.method()` via any kind of object or prototype (proof of concept)

super.js

var withSuperContext = (function (Object) {
  //! (c) Andrea Giammarchi
  var
    defineProperty = Object.defineProperty,
    getPrototypeOf = Object.getPrototypeOf,
    setPrototypeOf = Object.setPrototypeOf ||
                     function (o, p) { o.__proto__ = p; },
    handler = {
      get: function get(target, property, receiver) {
        return function () {
          var
            self = target.self,
            proto = getPrototypeOf(self),
            method = self[property],
            parent = proto,
            result
          ;
          do {
            parent = getPrototypeOf(parent);
          } while (method === parent[property]);
          setPrototypeOf(self, parent);
          try {
            result = parent[property].apply(self, arguments);
            setPrototypeOf(self, proto);
          } catch(e) {
            setPrototypeOf(self, proto);
            throw e;
          }
          return result;
        };
      }
    }
  ;
  return function withSuperContext(object) {
    defineProperty(
      typeof object === 'function' ?
        object.prototype : object,
      'super',
      {
        get: function get() {
          var
            self = this,
            parent = function () {
              return proxy.constructor.apply(self, arguments);
            },
            proxy = new Proxy(parent, handler)
          ;
          parent.self = self;
          return proxy;
        }
      }
    );
    return object;
  };
}(Object));

Usage example

function A() {
  console.log(this.constructor.name);
}
A.prototype.method = function () {
  console.log('method from ' + this.constructor.name);
};

function B() {
  this.super();
  console.log(this.constructor.name);
}
B.prototype = Object.create(A.prototype, {constructor: {value: B}});
withSuperContext(B.prototype).method = function () {
  this.super.method();
  console.log('method from ' + this.constructor.name);
};

function C() {
  this.super();
  console.log(this.constructor.name);
}
C.prototype = withSuperContext(
  Object.create(B.prototype, {constructor: {value: C}})
);
C.prototype.method = function () {
  this.super.method();
  console.log('method from ' + this.constructor.name);
};

var c = new C;
// will log
// A
// B
// C

c.method();
// method from A
// method from B
// method from C

This does not seem to work if C does not define the method: When B.prototype.method does call super, the self will refer to the C instance, proto to C.prototype, and you'll get an infinite recursion when Bs method calls itself.
Instead of assuming that the super was gotten in a method on the current direct prototype of this/self, you rather should pass the object/object.prototype into the proxy to be used as the proto.

Also you will totally want to wrap setPrototypeOf(self, proto); in a finally clause, or otherwise the prototype chain will explode in your face when one of the method throws an exception.

which part of quick and dirty wasn't clear? it's a proof of concept ;-)