objtype.c 19.3 KB
Newer Older
1
2
#include <string.h>
#include <assert.h>
3
4
5
6

#include "nlr.h"
#include "misc.h"
#include "mpconfig.h"
7
#include "qstr.h"
8
#include "obj.h"
9
#include "map.h"
10
#include "runtime0.h"
11
12
13
14
15
16
17
18
19
20
21
#include "runtime.h"

/******************************************************************************/
// class object
// creating an instance of a class makes one of these objects

typedef struct _mp_obj_class_t {
    mp_obj_base_t base;
    mp_map_t members;
} mp_obj_class_t;

22
STATIC mp_obj_t mp_obj_new_class(mp_obj_t class) {
23
24
25
26
27
28
    mp_obj_class_t *o = m_new_obj(mp_obj_class_t);
    o->base.type = class;
    mp_map_init(&o->members, 0);
    return o;
}

29
// will return MP_OBJ_NULL if not found
30
STATIC mp_obj_t mp_obj_class_lookup(const mp_obj_type_t *type, qstr attr) {
31
    for (;;) {
32
        if (type->locals_dict != NULL) {
33
            // search locals_dict (the set of methods/attributes)
34
            assert(MP_OBJ_IS_TYPE(type->locals_dict, &dict_type)); // Micro Python restriction, for now
35
            mp_map_t *locals_map = mp_obj_dict_get_map(type->locals_dict);
36
37
38
39
            mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
            if (elem != NULL) {
                return elem->value;
            }
40
41
42
43
44
        }

        // attribute not found, keep searching base classes

        // for a const struct, this entry might be NULL
45
        if (type->bases_tuple == MP_OBJ_NULL) {
46
47
48
49
50
            return NULL;
        }

        uint len;
        mp_obj_t *items;
51
        mp_obj_tuple_get(type->bases_tuple, &len, &items);
52
53
54
55
        if (len == 0) {
            return NULL;
        }
        for (uint i = 0; i < len - 1; i++) {
56
            assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
57
58
59
            mp_obj_t obj = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr);
            if (obj != MP_OBJ_NULL) {
                return obj;
60
61
62
63
            }
        }

        // search last base (simple tail recursion elimination)
64
        assert(MP_OBJ_IS_TYPE(items[len - 1], &mp_type_type));
65
        type = (mp_obj_type_t*)items[len - 1];
66
67
68
    }
}

69
STATIC void class_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
    mp_obj_class_t *self = self_in;
    qstr meth = (kind == PRINT_STR) ? MP_QSTR___str__ : MP_QSTR___repr__;
    mp_obj_t member = mp_obj_class_lookup(self->base.type, meth);
    if (member == MP_OBJ_NULL && kind == PRINT_STR) {
        // If there's no __str__, fall back to __repr__
        member = mp_obj_class_lookup(self->base.type, MP_QSTR___repr__);
    }

    if (member != MP_OBJ_NULL) {
        mp_obj_t r = rt_call_function_1(member, self_in);
        mp_obj_print_helper(print, env, r, PRINT_STR);
        return;
    }

    // TODO: CPython prints fully-qualified type name
85
86
87
    print(env, "<%s object at %p>", mp_obj_get_type_str(self_in), self_in);
}

88
STATIC mp_obj_t class_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
89
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
90
    mp_obj_type_t *self = self_in;
91
92
93
94

    mp_obj_t o = mp_obj_new_class(self_in);

    // look for __init__ function
95
    mp_obj_t init_fn = mp_obj_class_lookup(self, MP_QSTR___init__);
96

97
    if (init_fn != MP_OBJ_NULL) {
98
99
        // call __init__ function
        mp_obj_t init_ret;
100
        if (n_args == 0 && n_kw == 0) {
101
            init_ret = rt_call_function_n_kw(init_fn, 1, 0, (mp_obj_t*)&o);
102
        } else {
103
104
105
            mp_obj_t *args2 = m_new(mp_obj_t, 1 + n_args + 2 * n_kw);
            args2[0] = o;
            memcpy(args2 + 1, args, (n_args + 2 * n_kw) * sizeof(mp_obj_t));
106
            init_ret = rt_call_function_n_kw(init_fn, n_args + 1, n_kw, args2);
107
            m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
108
109
        }
        if (init_ret != mp_const_none) {
110
            nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
111
112
113
114
115
        }

    } else {
        // TODO
        if (n_args != 0) {
116
            nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 0 positional arguments but %d were given", n_args));
117
118
119
120
121
122
        }
    }

    return o;
}

123
STATIC const qstr unary_op_method_name[] = {
124
125
126
127
128
    [RT_UNARY_OP_BOOL] = MP_QSTR___bool__,
    [RT_UNARY_OP_LEN] = MP_QSTR___len__,
    //[RT_UNARY_OP_POSITIVE,
    //[RT_UNARY_OP_NEGATIVE,
    //[RT_UNARY_OP_INVERT,
129
    [RT_UNARY_OP_NOT] = MP_QSTR_, // don't need to implement this, used to make sure array has full size
130
131
};

132
STATIC mp_obj_t class_unary_op(int op, mp_obj_t self_in) {
133
134
135
136
137
138
139
140
141
142
143
144
145
    mp_obj_class_t *self = self_in;
    qstr op_name = unary_op_method_name[op];
    if (op_name == 0) {
        return MP_OBJ_NULL;
    }
    mp_obj_t member = mp_obj_class_lookup(self->base.type, op_name);
    if (member != MP_OBJ_NULL) {
        return rt_call_function_1(member, self_in);
    } else {
        return MP_OBJ_NULL;
    }
}

146
STATIC const qstr binary_op_method_name[] = {
147
    [RT_BINARY_OP_SUBSCR] = MP_QSTR___getitem__,
148
149
150
151
152
153
154
    /*
    RT_BINARY_OP_OR,
    RT_BINARY_OP_XOR,
    RT_BINARY_OP_AND,
    RT_BINARY_OP_LSHIFT,
    RT_BINARY_OP_RSHIFT,
    */
155
156
    [RT_BINARY_OP_ADD] = MP_QSTR___add__,
    [RT_BINARY_OP_SUBTRACT] = MP_QSTR___sub__,
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
    /*
    RT_BINARY_OP_MULTIPLY,
    RT_BINARY_OP_FLOOR_DIVIDE,
    RT_BINARY_OP_TRUE_DIVIDE,
    RT_BINARY_OP_MODULO,
    RT_BINARY_OP_POWER,
    RT_BINARY_OP_INPLACE_OR,
    RT_BINARY_OP_INPLACE_XOR,
    RT_BINARY_OP_INPLACE_AND,
    RT_BINARY_OP_INPLACE_LSHIFT,
    RT_BINARY_OP_INPLACE_RSHIFT,
    RT_BINARY_OP_INPLACE_ADD,
    RT_BINARY_OP_INPLACE_SUBTRACT,
    RT_BINARY_OP_INPLACE_MULTIPLY,
    RT_BINARY_OP_INPLACE_FLOOR_DIVIDE,
    RT_BINARY_OP_INPLACE_TRUE_DIVIDE,
    RT_BINARY_OP_INPLACE_MODULO,
    RT_BINARY_OP_INPLACE_POWER,
175
176
177
178
179
180
181
182
    RT_BINARY_OP_LESS,
    RT_BINARY_OP_MORE,
    RT_BINARY_OP_EQUAL,
    RT_BINARY_OP_LESS_EQUAL,
    RT_BINARY_OP_MORE_EQUAL,
    RT_BINARY_OP_NOT_EQUAL,
    RT_BINARY_OP_IN,
    RT_BINARY_OP_IS,
183
    */
184
    [RT_BINARY_OP_EXCEPTION_MATCH] = MP_QSTR_, // not implemented, used to make sure array has full size
185
186
};

187
STATIC mp_obj_t class_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
188
    mp_obj_class_t *lhs = lhs_in;
189
190
    qstr op_name = binary_op_method_name[op];
    if (op_name == 0) {
191
192
        return MP_OBJ_NULL;
    }
193
    mp_obj_t member = mp_obj_class_lookup(lhs->base.type, op_name);
194
195
    if (member != MP_OBJ_NULL) {
        return rt_call_function_2(member, lhs_in, rhs_in);
196
197
198
199
200
    } else {
        return MP_OBJ_NULL;
    }
}

201
STATIC void class_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
202
203
204
205
206
    // logic: look in obj members then class locals (TODO check this against CPython)
    mp_obj_class_t *self = self_in;
    mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
    if (elem != NULL) {
        // object member, always treated as a value
207
        dest[0] = elem->value;
208
209
        return;
    }
210
211
    mp_obj_t member = mp_obj_class_lookup(self->base.type, attr);
    if (member != MP_OBJ_NULL) {
212
213
214
215
216
217
218
219
220
221
222
223
224
225
        // check if the methods are functions, static or class methods
        // see http://docs.python.org/3.3/howto/descriptor.html
        // TODO check that this is the correct place to have this logic
        if (MP_OBJ_IS_TYPE(member, &mp_type_staticmethod)) {
            // return just the function
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
            // return a bound method, with self being the type of this object
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
            dest[1] = mp_obj_get_type(self_in);
        } else if (mp_obj_is_callable(member)) {
            // return a bound method, with self being this object
            dest[0] = member;
            dest[1] = self_in;
226
227
        } else {
            // class member is a value, so just return that value
228
            dest[0] = member;
229
230
231
232
233
            return;
        }
    }
}

234
STATIC bool class_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
235
    mp_obj_class_t *self = self_in;
236
    mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
237
238
239
    return true;
}

240
241
bool class_store_item(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
    mp_obj_class_t *self = self_in;
242
    mp_obj_t member = mp_obj_class_lookup(self->base.type, MP_QSTR___setitem__);
243
    if (member != MP_OBJ_NULL) {
244
        mp_obj_t args[3] = {self_in, index, value};
245
246
        rt_call_function_n_kw(member, 3, 0, args);
        return true;
247
    } else {
248
        return false;
249
250
251
    }
}

252
253
254
/******************************************************************************/
// type object
//  - the struct is mp_obj_type_t and is defined in obj.h so const types can be made
255
//  - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
256
//  - creating a new class (a new type) creates a new mp_obj_type_t
257

258
STATIC void type_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
259
    mp_obj_type_t *self = self_in;
260
    print(env, "<class '%s'>", qstr_str(self->name));
261
262
}

263
STATIC mp_obj_t type_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
264
265
    // TODO check n_kw == 0

266
267
268
269
270
    switch (n_args) {
        case 1:
            return mp_obj_get_type(args[0]);

        case 3:
271
            // args[0] = name
272
            // args[1] = bases tuple
273
            // args[2] = locals dict
274
            return mp_obj_new_type(mp_obj_str_get_qstr(args[0]), args[1], args[2]);
275
276

        default:
277
            nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "type takes 1 or 3 arguments"));
278
279
280
    }
}

281
STATIC mp_obj_t type_call(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
282
283
    // instantiate an instance of a class

284
    mp_obj_type_t *self = self_in;
285
286

    if (self->make_new == NULL) {
287
        nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "cannot create '%s' instances", qstr_str(self->name)));
288
    }
289
290

    // make new instance
291
    mp_obj_t o = self->make_new(self, n_args, n_kw, args);
292
293
294
295
296

    // return new instance
    return o;
}

297
// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
298
STATIC void type_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
299
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
300
    mp_obj_type_t *self = self_in;
301
302
303
304
305
306
    mp_obj_t member = mp_obj_class_lookup(self, attr);
    if (member != MP_OBJ_NULL) {
        // check if the methods are functions, static or class methods
        // see http://docs.python.org/3.3/howto/descriptor.html
        if (MP_OBJ_IS_TYPE(member, &mp_type_staticmethod)) {
            // return just the function
307
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
308
309
        } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
            // return a bound method, with self being this class
310
            dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
311
312
313
314
315
            dest[1] = self_in;
        } else {
            // return just the function
            // TODO need to wrap in a type check for the first argument; eg list.append(1,1) needs to throw an exception
            dest[0] = (mp_obj_t)member;
316
317
        }
    }
318
319
}

320
STATIC bool type_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
321
    assert(MP_OBJ_IS_TYPE(self_in, &mp_type_type));
322
323
    mp_obj_type_t *self = self_in;

324
325
    // TODO CPython allows STORE_ATTR to a class, but is this the correct implementation?

326
327
    if (self->locals_dict != NULL) {
        assert(MP_OBJ_IS_TYPE(self->locals_dict, &dict_type)); // Micro Python restriction, for now
328
329
330
331
332
333
334
        mp_map_t *locals_map = mp_obj_dict_get_map(self->locals_dict);
        mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
        // note that locals_map may be in ROM, so add will fail in that case
        if (elem != NULL) {
            elem->value = value;
            return true;
        }
335
    }
336
337

    return false;
338
339
}

340
341
const mp_obj_type_t mp_type_type = {
    { &mp_type_type },
342
    .name = MP_QSTR_type,
343
    .print = type_print,
344
    .make_new = type_make_new,
345
    .call = type_call,
346
347
    .load_attr = type_load_attr,
    .store_attr = type_store_attr,
348
};
349

350
mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
351
352
    assert(MP_OBJ_IS_TYPE(bases_tuple, &tuple_type)); // Micro Python restriction, for now
    assert(MP_OBJ_IS_TYPE(locals_dict, &dict_type)); // Micro Python restriction, for now
353
    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
354
    o->base.type = &mp_type_type;
355
    o->name = name;
356
357
    o->print = class_print;
    o->make_new = class_make_new;
358
    o->unary_op = class_unary_op;
359
    o->binary_op = class_binary_op;
360
361
    o->load_attr = class_load_attr;
    o->store_attr = class_store_attr;
362
    o->store_item = class_store_item;
363
364
    o->bases_tuple = bases_tuple;
    o->locals_dict = locals_dict;
365
366
    return o;
}
367
368

/******************************************************************************/
Damien George's avatar
Damien George committed
369
370
371
372
373
374
375
376
// super object

typedef struct _mp_obj_super_t {
    mp_obj_base_t base;
    mp_obj_t type;
    mp_obj_t obj;
} mp_obj_super_t;

377
STATIC void super_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
Damien George's avatar
Damien George committed
378
379
380
381
382
383
384
385
    mp_obj_super_t *self = self_in;
    print(env, "<super: ");
    mp_obj_print_helper(print, env, self->type, PRINT_STR);
    print(env, ", ");
    mp_obj_print_helper(print, env, self->obj, PRINT_STR);
    print(env, ">");
}

386
STATIC mp_obj_t super_make_new(mp_obj_t type_in, uint n_args, uint n_kw, const mp_obj_t *args) {
Damien George's avatar
Damien George committed
387
388
389
    if (n_args != 2 || n_kw != 0) {
        // 0 arguments are turned into 2 in the compiler
        // 1 argument is not yet implemented
390
        nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "super() requires 2 arguments"));
Damien George's avatar
Damien George committed
391
392
393
394
395
    }
    return mp_obj_new_super(args[0], args[1]);
}

// for fail, do nothing; for attr, dest[0] = value; for method, dest[0] = method, dest[1] = self
396
STATIC void super_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
Damien George's avatar
Damien George committed
397
398
399
    assert(MP_OBJ_IS_TYPE(self_in, &super_type));
    mp_obj_super_t *self = self_in;

400
    assert(MP_OBJ_IS_TYPE(self->type, &mp_type_type));
Damien George's avatar
Damien George committed
401
402
403
404
405
406
407
408
409
410
411
412

    mp_obj_type_t *type = self->type;

    // for a const struct, this entry might be NULL
    if (type->bases_tuple == MP_OBJ_NULL) {
        return;
    }

    uint len;
    mp_obj_t *items;
    mp_obj_tuple_get(type->bases_tuple, &len, &items);
    for (uint i = 0; i < len; i++) {
413
        assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
Damien George's avatar
Damien George committed
414
415
416
        mp_obj_t member = mp_obj_class_lookup((mp_obj_type_t*)items[i], attr);
        if (member != MP_OBJ_NULL) {
            // XXX this and the code in class_load_attr need to be factored out
417
418
419
420
421
422
423
424
425
426
427
428
429
430
            // check if the methods are functions, static or class methods
            // see http://docs.python.org/3.3/howto/descriptor.html
            // TODO check that this is the correct place to have this logic
            if (MP_OBJ_IS_TYPE(member, &mp_type_staticmethod)) {
                // return just the function
                dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
            } else if (MP_OBJ_IS_TYPE(member, &mp_type_classmethod)) {
                // return a bound method, with self being the type of this object
                dest[0] = ((mp_obj_static_class_method_t*)member)->fun;
                dest[1] = mp_obj_get_type(self->obj);
            } if (mp_obj_is_callable(member)) {
                // return a bound method, with self being this object
                dest[0] = member;
                dest[1] = self->obj;
Damien George's avatar
Damien George committed
431
432
433
434
            } else {
                // class member is a value, so just return that value
                dest[0] = member;
            }
435
            return;
Damien George's avatar
Damien George committed
436
437
438
439
440
        }
    }
}

const mp_obj_type_t super_type = {
441
    { &mp_type_type },
442
    .name = MP_QSTR_super,
Damien George's avatar
Damien George committed
443
444
445
446
447
448
449
450
451
452
453
454
    .print = super_print,
    .make_new = super_make_new,
    .load_attr = super_load_attr,
};

mp_obj_t mp_obj_new_super(mp_obj_t type, mp_obj_t obj) {
    mp_obj_super_t *o = m_new_obj(mp_obj_super_t);
    *o = (mp_obj_super_t){{&super_type}, type, obj};
    return o;
}

/******************************************************************************/
455
// subclassing and built-ins specific to types
456

457
458
// object and classinfo should be type objects
// (but the function will fail gracefully if they are not)
459
bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
460
461
    for (;;) {
        if (object == classinfo) {
462
            return true;
463
464
465
466
        }

        // not equivalent classes, keep searching base classes

467
468
469
470
471
        // object should always be a type object, but just return false if it's not
        if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
            return false;
        }

472
        const mp_obj_type_t *self = object;
473
474
475

        // for a const struct, this entry might be NULL
        if (self->bases_tuple == MP_OBJ_NULL) {
476
            return false;
477
478
        }

479
        // get the base objects (they should be type objects)
480
481
482
483
        uint len;
        mp_obj_t *items;
        mp_obj_tuple_get(self->bases_tuple, &len, &items);
        if (len == 0) {
484
            return false;
485
        }
486
487

        // iterate through the base objects
488
        for (uint i = 0; i < len - 1; i++) {
489
            if (mp_obj_is_subclass_fast(items[i], classinfo)) {
490
                return true;
491
492
493
494
495
496
497
498
            }
        }

        // search last base (simple tail recursion elimination)
        object = items[len - 1];
    }
}

499
500
501
502
503
504
505
506
507
508
STATIC mp_obj_t mp_obj_is_subclass(mp_obj_t object, mp_obj_t classinfo) {
    uint len;
    mp_obj_t *items;
    if (MP_OBJ_IS_TYPE(classinfo, &mp_type_type)) {
        len = 1;
        items = &classinfo;
    } else if (MP_OBJ_IS_TYPE(classinfo, &tuple_type)) {
        mp_obj_tuple_get(classinfo, &len, &items);
    } else {
        nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 2 must be a class or a tuple of classes"));
509
510
    }

511
512
513
514
    for (uint i = 0; i < len; i++) {
        if (mp_obj_is_subclass_fast(object, items[i])) {
            return mp_const_true;
        }
515
    }
516
    return mp_const_false;
517
518
}

519
STATIC mp_obj_t mp_builtin_issubclass(mp_obj_t object, mp_obj_t classinfo) {
520
521
522
523
    if (!MP_OBJ_IS_TYPE(object, &mp_type_type)) {
        nlr_jump(mp_obj_new_exception_msg(&mp_type_TypeError, "issubclass() arg 1 must be a class"));
    }
    return mp_obj_is_subclass(object, classinfo);
524
525
}

526
527
MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_issubclass_obj, mp_builtin_issubclass);

528
STATIC mp_obj_t mp_builtin_isinstance(mp_obj_t object, mp_obj_t classinfo) {
529
    return mp_obj_is_subclass(mp_obj_get_type(object), classinfo);
530
531
532
}

MP_DEFINE_CONST_FUN_OBJ_2(mp_builtin_isinstance_obj, mp_builtin_isinstance);
533
534
535
536

/******************************************************************************/
// staticmethod and classmethod types (probably should go in a different file)

537
STATIC mp_obj_t static_class_method_make_new(mp_obj_t self_in, uint n_args, uint n_kw, const mp_obj_t *args) {
538
539
540
    assert(self_in == &mp_type_staticmethod || self_in == &mp_type_classmethod);

    if (n_args != 1 || n_kw != 0) {
541
        nlr_jump(mp_obj_new_exception_msg_varg(&mp_type_TypeError, "function takes 1 positional argument but %d were given", n_args));
542
543
544
545
546
547
548
    }

    mp_obj_static_class_method_t *o = m_new_obj(mp_obj_static_class_method_t);
    *o = (mp_obj_static_class_method_t){{(mp_obj_type_t*)self_in}, args[0]};
    return o;
}

549
const mp_obj_type_t mp_type_staticmethod = {
550
    { &mp_type_type },
551
    .name = MP_QSTR_staticmethod,
552
    .make_new = static_class_method_make_new
553
554
555
};

const mp_obj_type_t mp_type_classmethod = {
556
    { &mp_type_type },
557
    .name = MP_QSTR_classmethod,
558
    .make_new = static_class_method_make_new
559
};