How to solve the inheritance problem when C extends MicroPython?

[Mars-CN]

When I use C to extend MicroPython, I hope to create two classes, which are inheritance relationships.

The implementation method in Python is:

class A:
    def x():
        return 10;
    
    def y():
        return 20;
    
class B(A):
    def width():
        return 230;
    
    def height():
        return 480;

The types in C are:

const mp_rom_map_elem_t &class_a_local_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_x), MP_ROM_PTR(&class_a_x_obj) },
    { MP_ROM_QSTR(MP_QSTR_y), MP_ROM_PTR(&class_a_y_obj) },
};
const mp_obj_type_t class_a_type = {
    { &mp_type_type },
    .name = MP_QSTR_A,
    .make_new = &class_a_make_new,
    .locals_dict =  (mp_obj_dict_t *)&class_a_local_dict,
};

const mp_rom_map_elem_t &class_b_local_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&class_b_width_obj) },
    { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&class_b_height_obj) },
};
const mp_obj_type_t class_b_type = {
    { &mp_type_type },
    .name = MP_QSTR_B,
    .make_new = &class_b_make_new,
    .locals_dict =  (mp_obj_dict_t *)&class_b_local_dict,
    .parent = &class_a_type,
};

But if it's the way C is written, the result is that when I

dir (B)

When the return content is

['__class__', '__module__', '__qualname__', , 'width', 'height', 'x', 'y']

But if it is

b = B()
dir(b)
['__class__', 'width', 'height']

If class inheritance is written in Python, it is not the result.

How should I solve this problem?

The result I want is

['__class__', '__module__', '__qualname__', '__dict__', 'height', 'x', 'y', 'width', 'height']

This is the result of Python class inheritance

(Edited by @jimmo to add formatting)

[jimmo]

MicroPython does not support inheritance of native classes.

The typical way this is solved is to duplicate the entries in the locals dict. This means that isinstance(B(), A) will fail, but otherwise behaves like you'd expect.

So in your case: (Note: I've also added in the missing MP_DEFINE_CONST_DICT lines)

const mp_rom_map_elem_t &class_a_local_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_x), MP_ROM_PTR(&class_a_x_obj) },
    { MP_ROM_QSTR(MP_QSTR_y), MP_ROM_PTR(&class_a_y_obj) },
};
STATIC MP_DEFINE_CONST_DICT(class_a_local_dict, class_a_local_dict_table);
const mp_obj_type_t class_a_type = {
    { &mp_type_type },
    .name = MP_QSTR_A,
    .make_new = &class_a_make_new,
    .locals_dict =  (mp_obj_dict_t *)&class_a_local_dict,
};

const mp_rom_map_elem_t &class_a_b_local_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_x), MP_ROM_PTR(&class_a_x_obj) },
    { MP_ROM_QSTR(MP_QSTR_y), MP_ROM_PTR(&class_a_y_obj) },
    { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&class_b_width_obj) },
    { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&class_b_height_obj) },
};
STATIC MP_DEFINE_CONST_DICT(class_b_local_dict, class_b_local_dict_table);
const mp_obj_type_t class_b_type = {
    { &mp_type_type },
    .name = MP_QSTR_B,
    .make_new = &class_b_make_new,
    .locals_dict =  (mp_obj_dict_t *)&class_b_local_dict,
};

There is a further code size optimisation possible here where they can both share the same locals dict table (but still separate dicts):

const mp_rom_map_elem_t &class_a_b_local_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_x), MP_ROM_PTR(&class_a_x_obj) },
    { MP_ROM_QSTR(MP_QSTR_y), MP_ROM_PTR(&class_a_y_obj) },
    { MP_ROM_QSTR(MP_QSTR_width), MP_ROM_PTR(&class_b_width_obj) },
    { MP_ROM_QSTR(MP_QSTR_height), MP_ROM_PTR(&class_b_height_obj) },
};
STATIC MP_DEFINE_CONST_DICT_WITH_SIZE(class_a_local_dict, class_a_b_local_dict_table, 2);
STATIC MP_DEFINE_CONST_DICT_WITH_SIZE(class_b_local_dict, class_a_b_local_dict_table, 4);

const mp_obj_type_t class_a_type = {
    { &mp_type_type },
    .name = MP_QSTR_A,
    .make_new = &class_a_make_new,
    .locals_dict =  (mp_obj_dict_t *)&class_a_local_dict,
};

const mp_obj_type_t class_b_type = {
    { &mp_type_type },
    .name = MP_QSTR_B,
    .make_new = &class_b_make_new,
    .locals_dict =  (mp_obj_dict_t *)&class_b_local_dict,
};

See py/objstr.c for a relatively complicated example of this where array/bytearray/memoryview/bytes/str all share the same locals table.

[Mars-CN]

Actually, if I use MP_Obj_Type_t::parent is used to specify the super class, inheritance can be implemented. isinstance(B(), A) will return true, but B will not inherit the members of A. If it is in the MicroPython environment, it can be implemented

.parent = &class_a_type,

[jimmo]

This is true and it does work (and you can see why by looking at the implementation of mp_obj_is_subclass_fast) but I'm not sure I would rely on this as there is other code that explicitly assumes that a type only has one native base and native types do not have parents.

[Mars-CN]

I've already taken care of it, I feel at ease now~~
It's actually very simple, just fill in the attr element, as follows:

const mp_obj_type_t class_b_type = {
    { &mp_type_type },
    .name = MP_QSTR_B,
    .make_new = &class_b_make_new,
    .locals_dict =  (mp_obj_dict_t *)&class_b_local_dict,
    .parent = &class_a_type,
    .attr = call_parent_methods,
};

void call_parent_methods(mp_obj_t obj, qstr attr, mp_obj_t *dest)
{
    const mp_obj_type_t *type = mp_obj_get_type(obj);
    while (type->locals_dict != NULL) {
        // generic method lookup
        // this is a lookup in the object (ie not class or type)
        assert(type->locals_dict->base.type == &mp_type_dict); // MicroPython restriction, for now
        mp_map_t *locals_map = &type->locals_dict->map;
        mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
        if (elem != NULL) {
            mp_convert_member_lookup(obj, type, elem->value, dest);
            break;
        }
        if (type->parent == NULL) {
            break;
        }
        // search parents
        type = type->parent;
    }
}

[Mars-CN]

Thank you again for @jimmo help

[rhys-mcguckin]

I required parental inheritance for native classes, and using @Mars-CN answer as a base, came up with a function that could be used directly for a .attr or as part of an attr function when handling properties and the like:

static void mp_obj_parent_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
    mp_obj_type_t * type = (mp_obj_type_t *)mp_obj_get_type(self_in);
    while (type != NULL || type != &mp_type_object) {
        if (MP_OBJ_TYPE_HAS_SLOT(type, locals_dict)) {
            mp_map_t *locals_map = &MP_OBJ_TYPE_GET_SLOT(type, locals_dict)->map;
            mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
            if (elem != NULL) {
                mp_obj_t result = elem->value;
                if (mp_obj_is_obj(result)) {
                    const mp_obj_type_t *m_type = ((mp_obj_base_t *)MP_OBJ_TO_PTR(result))->type;
                    if (m_type->flags & MP_TYPE_FLAG_BINDS_SELF) {
                        dest[0] = mp_obj_new_bound_meth(result, self_in);
                        return;
                    }
                }
                mp_convert_member_lookup(MP_OBJ_NULL, type, result, dest);
                return;
            }
        }
        type = (mp_obj_type_t *)MP_OBJ_TYPE_GET_SLOT(type, parent);
    }
}

@jimmo Is there a particular reason why there is the assumption why native classes can not inherit from native classes?