How to properly extends a class?

[neko-para]

I've already setup a class Base with prototype and got the constructor. Now I'd like to setup another class Inherit that would inherit Base. I've tried to do the following things:

1. use JS_SetPrototype(ctx, inheritCtor, baseCtor) to chain the constructor.
2. Instead of using JS_NewObjectClass, use JS_CallConstructor to get the super object. Just like the super() in js code.

But then a problem comes out. The result object will still contains the classId of Base, thus obj instanceof Inherit results to false. Also, as JS_GetOpaque would check if classId matches, I would have to maintain a list to track all the data.

---

In perspective of js, I think I shall always use JS_NewObjectClass with the final classid to obtain the object, but I havn't figured out how to call super() for it. Also, methods from Base cannot get the opaque data.

E.g. I've got an object of Inherit, and I call a native method that comes from Base. Then, I must use classid of Inherit to get the data, which just doesn't make sense.

[bnoordhuis]

There's no concept of inheritance at the C API level but you can distinguish between types in your C callback:

JSValue callback(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
    Inherit *inherit;
    Base *base;

    if ((inherit = JS_GetOpaque(this_val, inherit_classid))) {
        // called as Inherit method
    } else if ((base = JS_GetOpaque(this_val, base_classid))) { // JS_GetOpaque2 if it should throw TypeError
        // called as Base method
    } else {
        // called as something else, maybe throw a TypeError
    }
   // ...
}

As to constructor inheritance, just call the constructor function manually:

JSValue base_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv) {
    // ...
    return JS_UNDEFINED;
}

JSValue inherit_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv) {
    // ...
    if (JS_IsException(base_constructor(ctx, new_target, argc, argv)))
        return JS_EXCEPTION;
    // ...
    return JS_UNDEFINED;
}

Your base constructor needs to be aware it can get called that way, of course; it has to take that into account when e.g. calling JS_GetOpaque/JS_SetOpaque. You could use the JSCFunctionMagic function prototype to signal that.

JSCFunctionMagic is the same as regular JSCFunction except it takes an extra int magic parameter that you're free to use in whatever way you want.