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));

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 ;-)