all: Make all mp_obj_type_t defs use MP_DEFINE_CONST_OBJ_TYPE.

In preparation for upcoming rework of mp_obj_type_t layout.

Signed-off-by: Jim Mussared <jim.mussared@gmail.com>

40 files changed, 574 insertions, 520 deletions

diff --git a/py/builtinevex.c b/py/builtinevex.c
index 73b77b40b7..403cd95a9d 100644
--- a/py/builtinevex.c
+++ b/py/builtinevex.c
@@ -38,10 +38,12 @@ typedef struct _mp_obj_code_t {
     mp_obj_t module_fun;
 } mp_obj_code_t;
 
-STATIC const mp_obj_type_t mp_type_code = {
-    { &mp_type_type },
-    .name = MP_QSTR_code,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_code,
+    MP_QSTR_code,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW
+    );
 
 STATIC mp_obj_t code_execute(mp_obj_code_t *self, mp_obj_dict_t *globals, mp_obj_dict_t *locals) {
     // save context and set new context
diff --git a/py/modio.c b/py/modio.c
index d44c1948ab..093cb1f7e7 100644
--- a/py/modio.c
+++ b/py/modio.c
@@ -97,12 +97,13 @@ STATIC const mp_stream_p_t iobase_p = {
     .ioctl = iobase_ioctl,
 };
 
-STATIC const mp_obj_type_t mp_type_iobase = {
-    { &mp_type_type },
-    .name = MP_QSTR_IOBase,
-    .make_new = iobase_make_new,
-    .protocol = &iobase_p,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_iobase,
+    MP_QSTR_IOBase,
+    MP_TYPE_FLAG_NONE,
+    iobase_make_new,
+    protocol, &iobase_p
+    );
 
 #endif // MICROPY_PY_IO_IOBASE
 
@@ -191,13 +192,14 @@ STATIC const mp_stream_p_t bufwriter_stream_p = {
     .write = bufwriter_write,
 };
 
-STATIC const mp_obj_type_t mp_type_bufwriter = {
-    { &mp_type_type },
-    .name = MP_QSTR_BufferedWriter,
-    .make_new = bufwriter_make_new,
-    .protocol = &bufwriter_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&bufwriter_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_bufwriter,
+    MP_QSTR_BufferedWriter,
+    MP_TYPE_FLAG_NONE,
+    bufwriter_make_new,
+    protocol, &bufwriter_stream_p,
+    locals_dict, (mp_obj_dict_t *)&bufwriter_locals_dict
+    );
 #endif // MICROPY_PY_IO_BUFFEREDWRITER
 
 STATIC const mp_rom_map_elem_t mp_module_io_globals_table[] = {
diff --git a/py/modthread.c b/py/modthread.c
index bad94fbf2f..0a15447425 100644
--- a/py/modthread.c
+++ b/py/modthread.c
@@ -116,11 +116,13 @@ STATIC const mp_rom_map_elem_t thread_lock_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(thread_lock_locals_dict, thread_lock_locals_dict_table);
 
-STATIC const mp_obj_type_t mp_type_thread_lock = {
-    { &mp_type_type },
-    .name = MP_QSTR_lock,
-    .locals_dict = (mp_obj_dict_t *)&thread_lock_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_thread_lock,
+    MP_QSTR_lock,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t *)&thread_lock_locals_dict
+    );
 
 /****************************************************************/
 // _thread module
diff --git a/py/objarray.c b/py/objarray.c
index dca41c2931..d93cce29ee 100644
--- a/py/objarray.c
+++ b/py/objarray.c
@@ -571,54 +571,55 @@ STATIC mp_int_t array_get_buffer(mp_obj_t o_in, mp_buffer_info_t *bufinfo, mp_ui
 }
 
 #if MICROPY_PY_ARRAY
-const mp_obj_type_t mp_type_array = {
-    { &mp_type_type },
-    .name = MP_QSTR_array,
-    .print = array_print,
-    .make_new = array_make_new,
-    .getiter = array_iterator_new,
-    .unary_op = array_unary_op,
-    .binary_op = array_binary_op,
-    .subscr = array_subscr,
-    .buffer_p = array_get_buffer,
-    .locals_dict = (mp_obj_dict_t *)&mp_obj_array_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_array,
+    MP_QSTR_array,
+    MP_TYPE_FLAG_NONE,
+    array_make_new,
+    print, array_print,
+    getiter, array_iterator_new,
+    unary_op, array_unary_op,
+    binary_op, array_binary_op,
+    subscr, array_subscr,
+    buffer, array_get_buffer,
+    locals_dict, (mp_obj_dict_t *)&mp_obj_array_locals_dict
+    );
 #endif
 
 #if MICROPY_PY_BUILTINS_BYTEARRAY
-const mp_obj_type_t mp_type_bytearray = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
-    .name = MP_QSTR_bytearray,
-    .print = array_print,
-    .make_new = bytearray_make_new,
-    .getiter = array_iterator_new,
-    .unary_op = array_unary_op,
-    .binary_op = array_binary_op,
-    .subscr = array_subscr,
-    .buffer = array_get_buffer,
-    .locals_dict = (mp_obj_dict_t *)&mp_obj_bytearray_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_bytearray,
+    MP_QSTR_bytearray,
+    MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
+    bytearray_make_new,
+    print, array_print,
+    getiter, array_iterator_new,
+    unary_op, array_unary_op,
+    binary_op, array_binary_op,
+    subscr, array_subscr,
+    buffer, array_get_buffer,
+    locals_dict, (mp_obj_dict_t *)&mp_obj_bytearray_locals_dict
+    );
 #endif
 
 #if MICROPY_PY_BUILTINS_MEMORYVIEW
-const mp_obj_type_t mp_type_memoryview = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
-    .name = MP_QSTR_memoryview,
-    .make_new = memoryview_make_new,
-    .getiter = array_iterator_new,
-    .unary_op = array_unary_op,
-    .binary_op = array_binary_op,
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_memoryview,
+    MP_QSTR_memoryview,
+    MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
+    memoryview_make_new,
+    getiter, array_iterator_new,
+    unary_op, array_unary_op,
+    binary_op, array_binary_op,
     #if MICROPY_PY_BUILTINS_MEMORYVIEW_ITEMSIZE
-    .attr = memoryview_attr,
+    attr, memoryview_attr,
     #endif
     #if MICROPY_PY_BUILTINS_BYTES_HEX
-    .locals_dict = (mp_obj_dict_t *)&mp_obj_memoryview_locals_dict,
+    locals_dict, (mp_obj_dict_t *)&mp_obj_memoryview_locals_dict,
     #endif
     .subscr = array_subscr,
     .buffer = array_get_buffer,
-};
+    );
 #endif
 
 /* unused
@@ -664,12 +665,14 @@ STATIC mp_obj_t array_it_iternext(mp_obj_t self_in) {
     }
 }
 
-STATIC const mp_obj_type_t mp_type_array_it = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .getiter = mp_identity_getiter,
-    .iternext = array_it_iternext,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_array_it,
+    MP_QSTR_iterator,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, array_it_iternext
+    );
 
 STATIC mp_obj_t array_iterator_new(mp_obj_t array_in, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_array_t) <= sizeof(mp_obj_iter_buf_t));
diff --git a/py/objattrtuple.c b/py/objattrtuple.c
index 13c281aa1c..0d41ee5235 100644
--- a/py/objattrtuple.c
+++ b/py/objattrtuple.c
@@ -80,15 +80,18 @@ mp_obj_t mp_obj_new_attrtuple(const qstr *fields, size_t n, const mp_obj_t *item
     return MP_OBJ_FROM_PTR(o);
 }
 
-const mp_obj_type_t mp_type_attrtuple = {
-    { &mp_type_type },
-    .name = MP_QSTR_tuple, // reuse tuple to save on a qstr
-    .print = mp_obj_attrtuple_print,
-    .unary_op = mp_obj_tuple_unary_op,
-    .binary_op = mp_obj_tuple_binary_op,
-    .attr = mp_obj_attrtuple_attr,
-    .subscr = mp_obj_tuple_subscr,
-    .getiter = mp_obj_tuple_getiter,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_attrtuple,
+    MP_QSTR_tuple,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    // reuse tuple to save on a qstr
+    print, mp_obj_attrtuple_print,
+    unary_op, mp_obj_tuple_unary_op,
+    binary_op, mp_obj_tuple_binary_op,
+    attr, mp_obj_attrtuple_attr,
+    subscr, mp_obj_tuple_subscr,
+    getiter, mp_obj_tuple_getiter
+    );
 
 #endif // MICROPY_PY_ATTRTUPLE
diff --git a/py/objbool.c b/py/objbool.c
index 23e023d8cb..5d014bbb8e 100644
--- a/py/objbool.c
+++ b/py/objbool.c
@@ -84,15 +84,16 @@ STATIC mp_obj_t bool_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs_
     return mp_binary_op(op, MP_OBJ_NEW_SMALL_INT(value), rhs_in);
 }
 
-const mp_obj_type_t mp_type_bool = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE, // can match all numeric types
-    .name = MP_QSTR_bool,
-    .print = bool_print,
-    .make_new = bool_make_new,
-    .unary_op = bool_unary_op,
-    .binary_op = bool_binary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    // can match all numeric types
+    mp_type_bool,
+    MP_QSTR_bool,
+    MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
+    bool_make_new,
+    print, bool_print,
+    unary_op, bool_unary_op,
+    binary_op, bool_binary_op
+    );
 
 #if !MICROPY_OBJ_IMMEDIATE_OBJS
 const mp_obj_bool_t mp_const_false_obj = {{&mp_type_bool}, false};
diff --git a/py/objboundmeth.c b/py/objboundmeth.c
index 9936c06e49..353364cdc7 100644
--- a/py/objboundmeth.c
+++ b/py/objboundmeth.c
@@ -95,17 +95,19 @@ STATIC void bound_meth_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
 }
 #endif
 
-STATIC const mp_obj_type_t mp_type_bound_meth = {
-    { &mp_type_type },
-    .name = MP_QSTR_bound_method,
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_bound_meth,
+    MP_QSTR_bound_method,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
     #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
-    .print = bound_meth_print,
+    print, bound_meth_print,
     #endif
-    .call = bound_meth_call,
+    call, bound_meth_call
     #if MICROPY_PY_FUNCTION_ATTRS
-    .attr = bound_meth_attr,
+    , attr, bound_meth_attr
     #endif
-};
+    );
 
 mp_obj_t mp_obj_new_bound_meth(mp_obj_t meth, mp_obj_t self) {
     mp_obj_bound_meth_t *o = mp_obj_malloc(mp_obj_bound_meth_t, &mp_type_bound_meth);
diff --git a/py/objcell.c b/py/objcell.c
index cab0d0b030..a17a94b9b7 100644
--- a/py/objcell.c
+++ b/py/objcell.c
@@ -40,13 +40,13 @@ STATIC void cell_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t k
 }
 #endif
 
-STATIC const mp_obj_type_t mp_type_cell = {
-    { &mp_type_type },
-    .name = MP_QSTR_, // cell representation is just value in < >
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    // cell representation is just value in < >
+    mp_type_cell, MP_QSTR_, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW
     #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
-    .print = cell_print,
+    , print, cell_print
     #endif
-};
+    );
 
 mp_obj_t mp_obj_new_cell(mp_obj_t obj) {
     mp_obj_cell_t *o = mp_obj_malloc(mp_obj_cell_t, &mp_type_cell);
diff --git a/py/objclosure.c b/py/objclosure.c
index 5b9923a44b..15ed994d37 100644
--- a/py/objclosure.c
+++ b/py/objclosure.c
@@ -86,18 +86,19 @@ STATIC void mp_obj_closure_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
 }
 #endif
 
-const mp_obj_type_t mp_type_closure = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF,
-    .name = MP_QSTR_closure,
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_closure,
+    MP_QSTR_closure,
+    MP_TYPE_FLAG_BINDS_SELF,
+    MP_TYPE_NULL_MAKE_NEW,
     #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_DETAILED
-    .print = closure_print,
+    print, closure_print,
     #endif
-    .call = closure_call,
     #if MICROPY_PY_FUNCTION_ATTRS
-    .attr = mp_obj_closure_attr,
+    attr, mp_obj_closure_attr,
     #endif
-};
+    call, closure_call
+    );
 
 mp_obj_t mp_obj_new_closure(mp_obj_t fun, size_t n_closed_over, const mp_obj_t *closed) {
     mp_obj_closure_t *o = mp_obj_malloc_var(mp_obj_closure_t, mp_obj_t, n_closed_over, &mp_type_closure);
diff --git a/py/objcomplex.c b/py/objcomplex.c
index 4aa598a0bc..cf213d718a 100644
--- a/py/objcomplex.c
+++ b/py/objcomplex.c
@@ -151,16 +151,13 @@ STATIC void complex_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     }
 }
 
-const mp_obj_type_t mp_type_complex = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
-    .name = MP_QSTR_complex,
-    .print = complex_print,
-    .make_new = complex_make_new,
-    .unary_op = complex_unary_op,
-    .binary_op = complex_binary_op,
-    .attr = complex_attr,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_complex, MP_QSTR_complex, MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE, complex_make_new,
+    print, complex_print,
+    unary_op, complex_unary_op,
+    binary_op, complex_binary_op,
+    attr, complex_attr
+    );
 
 mp_obj_t mp_obj_new_complex(mp_float_t real, mp_float_t imag) {
     mp_obj_complex_t *o = mp_obj_malloc(mp_obj_complex_t, &mp_type_complex);
diff --git a/py/objdeque.c b/py/objdeque.c
index b1c59a81e9..22770317ab 100644
--- a/py/objdeque.c
+++ b/py/objdeque.c
@@ -155,12 +155,13 @@ STATIC const mp_rom_map_elem_t deque_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(deque_locals_dict, deque_locals_dict_table);
 
-const mp_obj_type_t mp_type_deque = {
-    { &mp_type_type },
-    .name = MP_QSTR_deque,
-    .make_new = deque_make_new,
-    .unary_op = deque_unary_op,
-    .locals_dict = (mp_obj_dict_t *)&deque_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_deque,
+    MP_QSTR_deque,
+    MP_TYPE_FLAG_NONE,
+    deque_make_new,
+    unary_op, deque_unary_op,
+    locals_dict, (mp_obj_dict_t *)&deque_locals_dict
+    );
 
 #endif // MICROPY_PY_COLLECTIONS_DEQUE
diff --git a/py/objdict.c b/py/objdict.c
index 1d8e9059a1..6e217d5c9a 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -461,12 +461,14 @@ STATIC mp_obj_t dict_view_it_iternext(mp_obj_t self_in) {
     }
 }
 
-STATIC const mp_obj_type_t mp_type_dict_view_it = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .getiter = mp_identity_getiter,
-    .iternext = dict_view_it_iternext,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_dict_view_it,
+    MP_QSTR_iterator,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, dict_view_it_iternext
+    );
 
 STATIC mp_obj_t dict_view_getiter(mp_obj_t view_in, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_dict_view_it_t) <= sizeof(mp_obj_iter_buf_t));
@@ -512,13 +514,15 @@ STATIC mp_obj_t dict_view_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t
     return dict_binary_op(op, o->dict, rhs_in);
 }
 
-STATIC const mp_obj_type_t mp_type_dict_view = {
-    { &mp_type_type },
-    .name = MP_QSTR_dict_view,
-    .print = dict_view_print,
-    .binary_op = dict_view_binary_op,
-    .getiter = dict_view_getiter,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_dict_view,
+    MP_QSTR_dict_view,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    print, dict_view_print,
+    binary_op, dict_view_binary_op,
+    getiter, dict_view_getiter
+    );
 
 STATIC mp_obj_t mp_obj_new_dict_view(mp_obj_t dict, mp_dict_view_kind_t kind) {
     mp_obj_dict_view_t *o = mp_obj_malloc(mp_obj_dict_view_t, &mp_type_dict_view);
@@ -585,31 +589,33 @@ STATIC const mp_rom_map_elem_t dict_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(dict_locals_dict, dict_locals_dict_table);
 
-const mp_obj_type_t mp_type_dict = {
-    { &mp_type_type },
-    .name = MP_QSTR_dict,
-    .print = dict_print,
-    .make_new = mp_obj_dict_make_new,
-    .unary_op = dict_unary_op,
-    .binary_op = dict_binary_op,
-    .subscr = dict_subscr,
-    .getiter = dict_getiter,
-    .locals_dict = (mp_obj_dict_t *)&dict_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_dict,
+    MP_QSTR_dict,
+    MP_TYPE_FLAG_NONE,
+    mp_obj_dict_make_new,
+    print, dict_print,
+    unary_op, dict_unary_op,
+    binary_op, dict_binary_op,
+    subscr, dict_subscr,
+    getiter, dict_getiter,
+    locals_dict, (mp_obj_dict_t *)&dict_locals_dict
+    );
 
 #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
-const mp_obj_type_t mp_type_ordereddict = {
-    { &mp_type_type },
-    .name = MP_QSTR_OrderedDict,
-    .print = dict_print,
-    .make_new = mp_obj_dict_make_new,
-    .unary_op = dict_unary_op,
-    .binary_op = dict_binary_op,
-    .subscr = dict_subscr,
-    .getiter = dict_getiter,
-    .parent = &mp_type_dict,
-    .locals_dict = (mp_obj_dict_t *)&dict_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_ordereddict,
+    MP_QSTR_OrderedDict,
+    MP_TYPE_FLAG_NONE,
+    mp_obj_dict_make_new,
+    print, dict_print,
+    unary_op, dict_unary_op,
+    binary_op, dict_binary_op,
+    subscr, dict_subscr,
+    getiter, dict_getiter,
+    parent, &mp_type_dict,
+    locals_dict, (mp_obj_dict_t *)&dict_locals_dict
+    );
 #endif
 
 void mp_obj_dict_init(mp_obj_dict_t *dict, size_t n_args) {
diff --git a/py/objenumerate.c b/py/objenumerate.c
index 241aef3023..f4f4ff6ae1 100644
--- a/py/objenumerate.c
+++ b/py/objenumerate.c
@@ -67,13 +67,14 @@ STATIC mp_obj_t enumerate_make_new(const mp_obj_type_t *type, size_t n_args, siz
     return MP_OBJ_FROM_PTR(o);
 }
 
-const mp_obj_type_t mp_type_enumerate = {
-    { &mp_type_type },
-    .name = MP_QSTR_enumerate,
-    .make_new = enumerate_make_new,
-    .iternext = enumerate_iternext,
-    .getiter = mp_identity_getiter,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_enumerate,
+    MP_QSTR_enumerate,
+    MP_TYPE_FLAG_NONE,
+    enumerate_make_new,
+    iternext, enumerate_iternext,
+    getiter, mp_identity_getiter
+    );
 
 STATIC mp_obj_t enumerate_iternext(mp_obj_t self_in) {
     assert(mp_obj_is_type(self_in, &mp_type_enumerate));
diff --git a/py/objexcept.c b/py/objexcept.c
index 028b73fd8b..190213e12f 100644
--- a/py/objexcept.c
+++ b/py/objexcept.c
@@ -284,13 +284,14 @@ void mp_obj_exception_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     }
 }
 
-const mp_obj_type_t mp_type_BaseException = {
-    { &mp_type_type },
-    .name = MP_QSTR_BaseException,
-    .print = mp_obj_exception_print,
-    .make_new = mp_obj_exception_make_new,
-    .attr = mp_obj_exception_attr,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_BaseException,
+    MP_QSTR_BaseException,
+    MP_TYPE_FLAG_NONE,
+    mp_obj_exception_make_new,
+    print, mp_obj_exception_print,
+    attr, mp_obj_exception_attr
+    );
 
 // *FORMAT-OFF*
 
diff --git a/py/objfilter.c b/py/objfilter.c
index a402d8c648..2b57300af3 100644
--- a/py/objfilter.c
+++ b/py/objfilter.c
@@ -60,12 +60,13 @@ STATIC mp_obj_t filter_iternext(mp_obj_t self_in) {
     return MP_OBJ_STOP_ITERATION;
 }
 
-const mp_obj_type_t mp_type_filter = {
-    { &mp_type_type },
-    .name = MP_QSTR_filter,
-    .make_new = filter_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = filter_iternext,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_filter,
+    MP_QSTR_filter,
+    MP_TYPE_FLAG_NONE,
+    filter_make_new,
+    getiter, mp_identity_getiter,
+    iternext, filter_iternext
+    );
 
 #endif // MICROPY_PY_BUILTINS_FILTER
diff --git a/py/objfloat.c b/py/objfloat.c
index 8e89b3da37..9ecbab7a4d 100644
--- a/py/objfloat.c
+++ b/py/objfloat.c
@@ -182,15 +182,12 @@ STATIC mp_obj_t float_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
     return mp_obj_float_binary_op(op, lhs_val, rhs_in);
 }
 
-const mp_obj_type_t mp_type_float = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
-    .name = MP_QSTR_float,
-    .print = float_print,
-    .make_new = float_make_new,
-    .unary_op = float_unary_op,
-    .binary_op = float_binary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_float, MP_QSTR_float, MP_TYPE_FLAG_EQ_NOT_REFLEXIVE | MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE, float_make_new,
+    print, float_print,
+    unary_op, float_unary_op,
+    binary_op, float_binary_op
+    );
 
 #if MICROPY_OBJ_REPR != MICROPY_OBJ_REPR_C && MICROPY_OBJ_REPR != MICROPY_OBJ_REPR_D
 
diff --git a/py/objfun.c b/py/objfun.c
index 5fa9d71dda..30de8670a1 100644
--- a/py/objfun.c
+++ b/py/objfun.c
@@ -56,13 +56,11 @@ STATIC mp_obj_t fun_builtin_0_call(mp_obj_t self_in, size_t n_args, size_t n_kw,
     return self->fun._0();
 }
 
-const mp_obj_type_t mp_type_fun_builtin_0 = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
-    .name = MP_QSTR_function,
-    .call = fun_builtin_0_call,
-    .unary_op = mp_generic_unary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_builtin_0, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
+    call, fun_builtin_0_call,
+    unary_op, mp_generic_unary_op
+    );
 
 STATIC mp_obj_t fun_builtin_1_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     assert(mp_obj_is_type(self_in, &mp_type_fun_builtin_1));
@@ -71,13 +69,11 @@ STATIC mp_obj_t fun_builtin_1_call(mp_obj_t self_in, size_t n_args, size_t n_kw,
     return self->fun._1(args[0]);
 }
 
-const mp_obj_type_t mp_type_fun_builtin_1 = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
-    .name = MP_QSTR_function,
-    .call = fun_builtin_1_call,
-    .unary_op = mp_generic_unary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_builtin_1, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
+    call, fun_builtin_1_call,
+    unary_op, mp_generic_unary_op
+    );
 
 STATIC mp_obj_t fun_builtin_2_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     assert(mp_obj_is_type(self_in, &mp_type_fun_builtin_2));
@@ -86,13 +82,11 @@ STATIC mp_obj_t fun_builtin_2_call(mp_obj_t self_in, size_t n_args, size_t n_kw,
     return self->fun._2(args[0], args[1]);
 }
 
-const mp_obj_type_t mp_type_fun_builtin_2 = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
-    .name = MP_QSTR_function,
-    .call = fun_builtin_2_call,
-    .unary_op = mp_generic_unary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_builtin_2, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
+    call, fun_builtin_2_call,
+    unary_op, mp_generic_unary_op
+    );
 
 STATIC mp_obj_t fun_builtin_3_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     assert(mp_obj_is_type(self_in, &mp_type_fun_builtin_3));
@@ -101,13 +95,11 @@ STATIC mp_obj_t fun_builtin_3_call(mp_obj_t self_in, size_t n_args, size_t n_kw,
     return self->fun._3(args[0], args[1], args[2]);
 }
 
-const mp_obj_type_t mp_type_fun_builtin_3 = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
-    .name = MP_QSTR_function,
-    .call = fun_builtin_3_call,
-    .unary_op = mp_generic_unary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_builtin_3, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
+    call, fun_builtin_3_call,
+    unary_op, mp_generic_unary_op
+    );
 
 STATIC mp_obj_t fun_builtin_var_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     assert(mp_obj_is_type(self_in, &mp_type_fun_builtin_var));
@@ -132,13 +124,11 @@ STATIC mp_obj_t fun_builtin_var_call(mp_obj_t self_in, size_t n_args, size_t n_k
     }
 }
 
-const mp_obj_type_t mp_type_fun_builtin_var = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN,
-    .name = MP_QSTR_function,
-    .call = fun_builtin_var_call,
-    .unary_op = mp_generic_unary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_builtin_var, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF | MP_TYPE_FLAG_BUILTIN_FUN, MP_TYPE_NULL_MAKE_NEW,
+    call, fun_builtin_var_call,
+    unary_op, mp_generic_unary_op
+    );
 
 /******************************************************************************/
 /* byte code functions                                                        */
@@ -362,19 +352,20 @@ void mp_obj_fun_bc_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
 }
 #endif
 
-const mp_obj_type_t mp_type_fun_bc = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF,
-    .name = MP_QSTR_function,
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_bc,
+    MP_QSTR_function,
+    MP_TYPE_FLAG_BINDS_SELF,
+    MP_TYPE_NULL_MAKE_NEW,
     #if MICROPY_CPYTHON_COMPAT
-    .print = fun_bc_print,
+    print, fun_bc_print,
     #endif
-    .call = fun_bc_call,
-    .unary_op = mp_generic_unary_op,
+    call, fun_bc_call,
+    unary_op, mp_generic_unary_op
     #if MICROPY_PY_FUNCTION_ATTRS
-    .attr = mp_obj_fun_bc_attr,
+    , attr, mp_obj_fun_bc_attr
     #endif
-};
+    );
 
 mp_obj_t mp_obj_new_fun_bc(const mp_obj_t *def_args, const byte *code, const mp_module_context_t *context, struct _mp_raw_code_t *const *child_table) {
     size_t n_def_args = 0;
@@ -417,19 +408,20 @@ STATIC mp_obj_t fun_native_call(mp_obj_t self_in, size_t n_args, size_t n_kw, co
     return fun(self_in, n_args, n_kw, args);
 }
 
-STATIC const mp_obj_type_t mp_type_fun_native = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF,
-    .name = MP_QSTR_function,
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_native,
+    MP_QSTR_function,
+    MP_TYPE_FLAG_BINDS_SELF,
+    MP_TYPE_NULL_MAKE_NEW,
     #if MICROPY_CPYTHON_COMPAT
-    .print = fun_bc_print,
+    print, fun_bc_print,
     #endif
-    .call = fun_native_call,
-    .unary_op = mp_generic_unary_op,
     #if MICROPY_PY_FUNCTION_ATTRS
-    .attr = mp_obj_fun_bc_attr,
+    attr, mp_obj_fun_bc_attr,
     #endif
-};
+    call, fun_native_call,
+    unary_op, mp_generic_unary_op
+    );
 
 mp_obj_t mp_obj_new_fun_native(const mp_obj_t *def_args, const void *fun_data, const mp_module_context_t *mc, struct _mp_raw_code_t *const *child_table) {
     mp_obj_fun_bc_t *o = MP_OBJ_TO_PTR(mp_obj_new_fun_bc(def_args, (const byte *)fun_data, mc, child_table));
@@ -531,13 +523,14 @@ STATIC mp_obj_t fun_asm_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
     return mp_native_to_obj(ret, self->type_sig);
 }
 
-STATIC const mp_obj_type_t mp_type_fun_asm = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF,
-    .name = MP_QSTR_function,
-    .call = fun_asm_call,
-    .unary_op = mp_generic_unary_op,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_asm,
+    MP_QSTR_function,
+    MP_TYPE_FLAG_BINDS_SELF,
+    MP_TYPE_NULL_MAKE_NEW,
+    call, fun_asm_call,
+    unary_op, mp_generic_unary_op
+    );
 
 mp_obj_t mp_obj_new_fun_asm(size_t n_args, const void *fun_data, mp_uint_t type_sig) {
     mp_obj_fun_asm_t *o = mp_obj_malloc(mp_obj_fun_asm_t, &mp_type_fun_asm);
diff --git a/py/objgenerator.c b/py/objgenerator.c
index 802fd45bbd..0ab80ca118 100644
--- a/py/objgenerator.c
+++ b/py/objgenerator.c
@@ -70,16 +70,17 @@ STATIC mp_obj_t gen_wrap_call(mp_obj_t self_in, size_t n_args, size_t n_kw, cons
     return MP_OBJ_FROM_PTR(o);
 }
 
-const mp_obj_type_t mp_type_gen_wrap = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF,
-    .name = MP_QSTR_generator,
-    .call = gen_wrap_call,
-    .unary_op = mp_generic_unary_op,
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_gen_wrap,
+    MP_QSTR_generator,
+    MP_TYPE_FLAG_BINDS_SELF,
+    MP_TYPE_NULL_MAKE_NEW,
+    call, gen_wrap_call,
+    unary_op, mp_generic_unary_op
     #if MICROPY_PY_FUNCTION_ATTRS
-    .attr = mp_obj_fun_bc_attr,
+    , attr, mp_obj_fun_bc_attr
     #endif
-};
+    );
 
 /******************************************************************************/
 // native generator wrapper
@@ -131,16 +132,17 @@ STATIC mp_obj_t native_gen_wrap_call(mp_obj_t self_in, size_t n_args, size_t n_k
     return MP_OBJ_FROM_PTR(o);
 }
 
-const mp_obj_type_t mp_type_native_gen_wrap = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF,
-    .name = MP_QSTR_generator,
-    .call = native_gen_wrap_call,
-    .unary_op = mp_generic_unary_op,
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_native_gen_wrap,
+    MP_QSTR_generator,
+    MP_TYPE_FLAG_BINDS_SELF,
+    MP_TYPE_NULL_MAKE_NEW,
+    call, native_gen_wrap_call,
+    unary_op, mp_generic_unary_op
     #if MICROPY_PY_FUNCTION_ATTRS
-    .attr = mp_obj_fun_bc_attr,
+    , attr, mp_obj_fun_bc_attr
     #endif
-};
+    );
 
 #endif // MICROPY_EMIT_NATIVE
 
@@ -357,12 +359,14 @@ STATIC const mp_rom_map_elem_t gen_instance_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(gen_instance_locals_dict, gen_instance_locals_dict_table);
 
-const mp_obj_type_t mp_type_gen_instance = {
-    { &mp_type_type },
-    .name = MP_QSTR_generator,
-    .print = gen_instance_print,
-    .unary_op = mp_generic_unary_op,
-    .getiter = mp_identity_getiter,
-    .iternext = gen_instance_iternext,
-    .locals_dict = (mp_obj_dict_t *)&gen_instance_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_gen_instance,
+    MP_QSTR_generator,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    print, gen_instance_print,
+    unary_op, mp_generic_unary_op,
+    getiter, mp_identity_getiter,
+    iternext, gen_instance_iternext,
+    locals_dict, (mp_obj_dict_t *)&gen_instance_locals_dict
+    );
diff --git a/py/objgetitemiter.c b/py/objgetitemiter.c
index 31ed4a9228..ed2dfbbe1f 100644
--- a/py/objgetitemiter.c
+++ b/py/objgetitemiter.c
@@ -56,12 +56,14 @@ STATIC mp_obj_t it_iternext(mp_obj_t self_in) {
     }
 }
 
-STATIC const mp_obj_type_t mp_type_it = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .getiter = mp_identity_getiter,
-    .iternext = it_iternext,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_it,
+    MP_QSTR_iterator,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, it_iternext
+    );
 
 // args are those returned from mp_load_method_maybe (ie either an attribute or a method)
 mp_obj_t mp_obj_new_getitem_iter(mp_obj_t *args, mp_obj_iter_buf_t *iter_buf) {
diff --git a/py/objint.c b/py/objint.c
index 645b269966..d7a3f9eb9d 100644
--- a/py/objint.c
+++ b/py/objint.c
@@ -457,12 +457,13 @@ STATIC const mp_rom_map_elem_t int_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(int_locals_dict, int_locals_dict_table);
 
-const mp_obj_type_t mp_type_int = {
-    { &mp_type_type },
-    .name = MP_QSTR_int,
-    .print = mp_obj_int_print,
-    .make_new = mp_obj_int_make_new,
-    .unary_op = mp_obj_int_unary_op,
-    .binary_op = mp_obj_int_binary_op,
-    .locals_dict = (mp_obj_dict_t *)&int_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_int,
+    MP_QSTR_int,
+    MP_TYPE_FLAG_NONE,
+    mp_obj_int_make_new,
+    print, mp_obj_int_print,
+    unary_op, mp_obj_int_unary_op,
+    binary_op, mp_obj_int_binary_op,
+    locals_dict, (mp_obj_dict_t *)&int_locals_dict
+    );
diff --git a/py/objlist.c b/py/objlist.c
index f431e273df..8c7921b989 100644
--- a/py/objlist.c
+++ b/py/objlist.c
@@ -452,17 +452,19 @@ STATIC const mp_rom_map_elem_t list_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(list_locals_dict, list_locals_dict_table);
 
-const mp_obj_type_t mp_type_list = {
-    { &mp_type_type },
-    .name = MP_QSTR_list,
-    .print = list_print,
-    .make_new = list_make_new,
-    .unary_op = list_unary_op,
-    .binary_op = list_binary_op,
-    .subscr = list_subscr,
-    .getiter = list_getiter,
-    .locals_dict = (mp_obj_dict_t *)&list_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_list,
+    MP_QSTR_list,
+    MP_TYPE_FLAG_NONE,
+    list_make_new,
+    print, list_print,
+    unary_op, list_unary_op,
+    binary_op, list_binary_op,
+    subscr, list_subscr,
+    getiter, list_getiter,
+    locals_dict, (mp_obj_dict_t *)&list_locals_dict
+    );
+
 
 void mp_obj_list_init(mp_obj_list_t *o, size_t n) {
     o->base.type = &mp_type_list;
diff --git a/py/objmap.c b/py/objmap.c
index 1f9275854f..dc305e21b5 100644
--- a/py/objmap.c
+++ b/py/objmap.c
@@ -63,10 +63,11 @@ STATIC mp_obj_t map_iternext(mp_obj_t self_in) {
     return mp_call_function_n_kw(self->fun, self->n_iters, 0, nextses);
 }
 
-const mp_obj_type_t mp_type_map = {
-    { &mp_type_type },
-    .name = MP_QSTR_map,
-    .make_new = map_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = map_iternext,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_map,
+    MP_QSTR_map,
+    MP_TYPE_FLAG_NONE,
+    map_make_new,
+    getiter, mp_identity_getiter,
+    iternext, map_iternext
+    );
diff --git a/py/objmodule.c b/py/objmodule.c
index 783d6b0508..6fc3653e6a 100644
--- a/py/objmodule.c
+++ b/py/objmodule.c
@@ -130,12 +130,14 @@ STATIC void module_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     }
 }
 
-const mp_obj_type_t mp_type_module = {
-    { &mp_type_type },
-    .name = MP_QSTR_module,
-    .print = module_print,
-    .attr = module_attr,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_module,
+    MP_QSTR_module,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    print, module_print,
+    attr, module_attr
+    );
 
 mp_obj_t mp_obj_new_module(qstr module_name) {
     mp_map_t *mp_loaded_modules_map = &MP_STATE_VM(mp_loaded_modules_dict).map;
diff --git a/py/objnone.c b/py/objnone.c
index 271a8543f9..4fffbc997e 100644
--- a/py/objnone.c
+++ b/py/objnone.c
@@ -43,12 +43,14 @@ STATIC void none_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_
     }
 }
 
-const mp_obj_type_t mp_type_NoneType = {
-    { &mp_type_type },
-    .name = MP_QSTR_NoneType,
-    .print = none_print,
-    .unary_op = mp_generic_unary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_NoneType,
+    MP_QSTR_NoneType,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    print, none_print,
+    unary_op, mp_generic_unary_op
+    );
 
 #if !MICROPY_OBJ_IMMEDIATE_OBJS
 const mp_obj_none_t mp_const_none_obj = {{&mp_type_NoneType}};
diff --git a/py/objobject.c b/py/objobject.c
index 1652802805..617b40fbbf 100644
--- a/py/objobject.c
+++ b/py/objobject.c
@@ -111,11 +111,12 @@ STATIC const mp_rom_map_elem_t object_locals_dict_table[] = {
 STATIC MP_DEFINE_CONST_DICT(object_locals_dict, object_locals_dict_table);
 #endif
 
-const mp_obj_type_t mp_type_object = {
-    { &mp_type_type },
-    .name = MP_QSTR_object,
-    .make_new = object_make_new,
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_object,
+    MP_QSTR_object,
+    MP_TYPE_FLAG_NONE,
+    object_make_new
     #if MICROPY_CPYTHON_COMPAT
-    .locals_dict = (mp_obj_dict_t *)&object_locals_dict,
+    , locals_dict, (mp_obj_dict_t *)&object_locals_dict
     #endif
-};
+    );
diff --git a/py/objpolyiter.c b/py/objpolyiter.c
index dac6a25455..326153182b 100644
--- a/py/objpolyiter.c
+++ b/py/objpolyiter.c
@@ -45,12 +45,14 @@ STATIC mp_obj_t polymorph_it_iternext(mp_obj_t self_in) {
     return self->iternext(self_in);
 }
 
-const mp_obj_type_t mp_type_polymorph_iter = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .getiter = mp_identity_getiter,
-    .iternext = polymorph_it_iternext,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_polymorph_iter,
+    MP_QSTR_iterator,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, polymorph_it_iternext
+    );
 
 #if MICROPY_ENABLE_FINALISER
 // mp_type_polymorph_iter_with_finaliser is a variant of the universal iterator
@@ -76,12 +78,13 @@ STATIC const mp_rom_map_elem_t mp_obj_polymorph_iter_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(mp_obj_polymorph_iter_locals_dict, mp_obj_polymorph_iter_locals_dict_table);
 
-const mp_obj_type_t mp_type_polymorph_iter_with_finaliser = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .getiter = mp_identity_getiter,
-    .iternext = polymorph_it_iternext,
-    .locals_dict = (mp_obj_dict_t *)&mp_obj_polymorph_iter_locals_dict,
-};
-
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_polymorph_iter_with_finaliser,
+    MP_QSTR_iterator,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, polymorph_it_iternext,
+    locals_dict, (mp_obj_dict_t *)&mp_obj_polymorph_iter_locals_dict
+    );
 #endif
diff --git a/py/objproperty.c b/py/objproperty.c
index 49327c981e..42c357f330 100644
--- a/py/objproperty.c
+++ b/py/objproperty.c
@@ -90,12 +90,13 @@ STATIC const mp_rom_map_elem_t property_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(property_locals_dict, property_locals_dict_table);
 
-const mp_obj_type_t mp_type_property = {
-    { &mp_type_type },
-    .name = MP_QSTR_property,
-    .make_new = property_make_new,
-    .locals_dict = (mp_obj_dict_t *)&property_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_property,
+    MP_QSTR_property,
+    MP_TYPE_FLAG_NONE,
+    property_make_new,
+    locals_dict, (mp_obj_dict_t *)&property_locals_dict
+    );
 
 const mp_obj_t *mp_obj_property_get(mp_obj_t self_in) {
     mp_check_self(mp_obj_is_type(self_in, &mp_type_property));
diff --git a/py/objrange.c b/py/objrange.c
index 5496021892..adf4b17466 100644
--- a/py/objrange.c
+++ b/py/objrange.c
@@ -50,12 +50,14 @@ STATIC mp_obj_t range_it_iternext(mp_obj_t o_in) {
     }
 }
 
-STATIC const mp_obj_type_t mp_type_range_it = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .getiter = mp_identity_getiter,
-    .iternext = range_it_iternext,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_range_it,
+    MP_QSTR_iterator,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, range_it_iternext
+    );
 
 STATIC mp_obj_t mp_obj_new_range_iterator(mp_int_t cur, mp_int_t stop, mp_int_t step, mp_obj_iter_buf_t *iter_buf) {
     assert(sizeof(mp_obj_range_it_t) <= sizeof(mp_obj_iter_buf_t));
@@ -208,18 +210,19 @@ STATIC void range_attr(mp_obj_t o_in, qstr attr, mp_obj_t *dest) {
 }
 #endif
 
-const mp_obj_type_t mp_type_range = {
-    { &mp_type_type },
-    .name = MP_QSTR_range,
-    .print = range_print,
-    .make_new = range_make_new,
-    .unary_op = range_unary_op,
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_range,
+    MP_QSTR_range,
+    MP_TYPE_FLAG_NONE,
+    range_make_new,
+    print, range_print,
+    unary_op, range_unary_op,
     #if MICROPY_PY_BUILTINS_RANGE_BINOP
-    .binary_op = range_binary_op,
+    binary_op, range_binary_op,
     #endif
-    .subscr = range_subscr,
-    .getiter = range_getiter,
+    subscr, range_subscr,
+    getiter, range_getiter
     #if MICROPY_PY_BUILTINS_RANGE_ATTRS
-    .attr = range_attr,
+    , attr, range_attr
     #endif
-};
+    );
diff --git a/py/objreversed.c b/py/objreversed.c
index 08961c0d2d..bc1f07ddec 100644
--- a/py/objreversed.c
+++ b/py/objreversed.c
@@ -68,12 +68,13 @@ STATIC mp_obj_t reversed_iternext(mp_obj_t self_in) {
     return mp_obj_subscr(self->seq, MP_OBJ_NEW_SMALL_INT(self->cur_index), MP_OBJ_SENTINEL);
 }
 
-const mp_obj_type_t mp_type_reversed = {
-    { &mp_type_type },
-    .name = MP_QSTR_reversed,
-    .make_new = reversed_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = reversed_iternext,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_reversed,
+    MP_QSTR_reversed,
+    MP_TYPE_FLAG_NONE,
+    reversed_make_new,
+    getiter, mp_identity_getiter,
+    iternext, reversed_iternext
+    );
 
 #endif // MICROPY_PY_BUILTINS_REVERSED
diff --git a/py/objset.c b/py/objset.c
index 26fd74398b..8fc744a140 100644
--- a/py/objset.c
+++ b/py/objset.c
@@ -539,16 +539,17 @@ STATIC const mp_rom_map_elem_t set_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(set_locals_dict, set_locals_dict_table);
 
-const mp_obj_type_t mp_type_set = {
-    { &mp_type_type },
-    .name = MP_QSTR_set,
-    .print = set_print,
-    .make_new = set_make_new,
-    .unary_op = set_unary_op,
-    .binary_op = set_binary_op,
-    .getiter = set_getiter,
-    .locals_dict = (mp_obj_dict_t *)&set_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_set,
+    MP_QSTR_set,
+    MP_TYPE_FLAG_NONE,
+    set_make_new,
+    print, set_print,
+    unary_op, set_unary_op,
+    binary_op, set_binary_op,
+    getiter, set_getiter,
+    locals_dict, (mp_obj_dict_t *)&set_locals_dict
+    );
 
 #if MICROPY_PY_BUILTINS_FROZENSET
 STATIC const mp_rom_map_elem_t frozenset_locals_dict_table[] = {
@@ -564,17 +565,17 @@ STATIC const mp_rom_map_elem_t frozenset_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(frozenset_locals_dict, frozenset_locals_dict_table);
 
-const mp_obj_type_t mp_type_frozenset = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
-    .name = MP_QSTR_frozenset,
-    .print = set_print,
-    .make_new = set_make_new,
-    .unary_op = set_unary_op,
-    .binary_op = set_binary_op,
-    .getiter = set_getiter,
-    .locals_dict = (mp_obj_dict_t *)&frozenset_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_frozenset,
+    MP_QSTR_frozenset,
+    MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE,
+    set_make_new,
+    print, set_print,
+    unary_op, set_unary_op,
+    binary_op, set_binary_op,
+    getiter, set_getiter,
+    locals_dict, (mp_obj_dict_t *)&frozenset_locals_dict
+    );
 #endif
 
 mp_obj_t mp_obj_new_set(size_t n_args, mp_obj_t *items) {
diff --git a/py/objsingleton.c b/py/objsingleton.c
index 2b896305cf..4a099657d4 100644
--- a/py/objsingleton.c
+++ b/py/objsingleton.c
@@ -43,12 +43,11 @@ STATIC void singleton_print(const mp_print_t *print, mp_obj_t self_in, mp_print_
     mp_printf(print, "%q", self->name);
 }
 
-const mp_obj_type_t mp_type_singleton = {
-    { &mp_type_type },
-    .name = MP_QSTR_,
-    .print = singleton_print,
-    .unary_op = mp_generic_unary_op,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_singleton, MP_QSTR_, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, singleton_print,
+    unary_op, mp_generic_unary_op
+    );
 
 const mp_obj_singleton_t mp_const_ellipsis_obj = {{&mp_type_singleton}, MP_QSTR_Ellipsis};
 #if MICROPY_PY_BUILTINS_NOTIMPLEMENTED
diff --git a/py/objslice.c b/py/objslice.c
index 0b34516c18..98c03485ff 100644
--- a/py/objslice.c
+++ b/py/objslice.c
@@ -92,16 +92,18 @@ STATIC const mp_rom_map_elem_t slice_locals_dict_table[] = {
 STATIC MP_DEFINE_CONST_DICT(slice_locals_dict, slice_locals_dict_table);
 #endif
 
-const mp_obj_type_t mp_type_slice = {
-    { &mp_type_type },
-    .name = MP_QSTR_slice,
-    .print = slice_print,
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_slice,
+    MP_QSTR_slice,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    print, slice_print
     #if MICROPY_PY_BUILTINS_SLICE_ATTRS
-    .attr = slice_attr,
+    , attr, slice_attr
     #elif MICROPY_PY_BUILTINS_SLICE_INDICES
-    .locals_dict = (mp_obj_dict_t *)&slice_locals_dict,
+    , locals_dict, (mp_obj_dict_t *)&slice_locals_dict
     #endif
-};
+    );
 
 mp_obj_t mp_obj_new_slice(mp_obj_t ostart, mp_obj_t ostop, mp_obj_t ostep) {
     mp_obj_slice_t *o = mp_obj_malloc(mp_obj_slice_t, &mp_type_slice);
diff --git a/py/objstr.c b/py/objstr.c
index 9dd7f65e66..77ca269d42 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -2143,31 +2143,33 @@ MP_DEFINE_CONST_DICT_WITH_SIZE(mp_obj_memoryview_locals_dict,
 #if !MICROPY_PY_BUILTINS_STR_UNICODE
 STATIC mp_obj_t mp_obj_new_str_iterator(mp_obj_t str, mp_obj_iter_buf_t *iter_buf);
 
-const mp_obj_type_t mp_type_str = {
-    { &mp_type_type },
-    .name = MP_QSTR_str,
-    .print = str_print,
-    .make_new = mp_obj_str_make_new,
-    .binary_op = mp_obj_str_binary_op,
-    .subscr = bytes_subscr,
-    .getiter = mp_obj_new_str_iterator,
-    .buffer = mp_obj_str_get_buffer,
-    .locals_dict = (mp_obj_dict_t *)&mp_obj_str_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_str,
+    MP_QSTR_str,
+    MP_TYPE_FLAG_NONE,
+    mp_obj_str_make_new,
+    print, str_print,
+    binary_op, mp_obj_str_binary_op,
+    subscr, bytes_subscr,
+    getiter, mp_obj_new_str_iterator,
+    buffer, mp_obj_str_get_buffer,
+    locals_dict, (mp_obj_dict_t *)&mp_obj_str_locals_dict
+    );
 #endif // !MICROPY_PY_BUILTINS_STR_UNICODE
 
-// Reuses most of methods from str
-const mp_obj_type_t mp_type_bytes = {
-    { &mp_type_type },
-    .name = MP_QSTR_bytes,
-    .print = str_print,
-    .make_new = bytes_make_new,
-    .binary_op = mp_obj_str_binary_op,
-    .subscr = bytes_subscr,
-    .getiter = mp_obj_new_bytes_iterator,
-    .buffer = mp_obj_str_get_buffer,
-    .locals_dict = (mp_obj_dict_t *)&mp_obj_bytes_locals_dict,
-};
+// Reuses most methods from str
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_bytes,
+    MP_QSTR_bytes,
+    MP_TYPE_FLAG_NONE,
+    bytes_make_new,
+    print, str_print,
+    binary_op, mp_obj_str_binary_op,
+    subscr, bytes_subscr,
+    getiter, mp_obj_new_bytes_iterator,
+    buffer, mp_obj_str_get_buffer,
+    locals_dict, (mp_obj_dict_t *)&mp_obj_bytes_locals_dict
+    );
 
 // The zero-length bytes object, with data that includes a null-terminating byte
 const mp_obj_str_t mp_const_empty_bytes_obj = {{&mp_type_bytes}, 0, 0, (const byte *)""};
diff --git a/py/objstringio.c b/py/objstringio.c
index 8b6c7531d7..d781ccc789 100644
--- a/py/objstringio.c
+++ b/py/objstringio.c
@@ -244,16 +244,17 @@ STATIC const mp_stream_p_t stringio_stream_p = {
     .is_text = true,
 };
 
-const mp_obj_type_t mp_type_stringio = {
-    { &mp_type_type },
-    .name = MP_QSTR_StringIO,
-    .print = stringio_print,
-    .make_new = stringio_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &stringio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&stringio_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_stringio,
+    MP_QSTR_StringIO,
+    MP_TYPE_FLAG_NONE,
+    stringio_make_new,
+    print, stringio_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &stringio_stream_p,
+    locals_dict, (mp_obj_dict_t *)&stringio_locals_dict
+    );
 
 #if MICROPY_PY_IO_BYTESIO
 STATIC const mp_stream_p_t bytesio_stream_p = {
@@ -262,16 +263,17 @@ STATIC const mp_stream_p_t bytesio_stream_p = {
     .ioctl = stringio_ioctl,
 };
 
-const mp_obj_type_t mp_type_bytesio = {
-    { &mp_type_type },
-    .name = MP_QSTR_BytesIO,
-    .print = stringio_print,
-    .make_new = stringio_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &bytesio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&stringio_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_bytesio,
+    MP_QSTR_BytesIO,
+    MP_TYPE_FLAG_NONE,
+    stringio_make_new,
+    print, stringio_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &bytesio_stream_p,
+    locals_dict, (mp_obj_dict_t *)&stringio_locals_dict
+    );
 #endif
 
 #endif
diff --git a/py/objstrunicode.c b/py/objstrunicode.c
index fef0353683..afef1498e9 100644
--- a/py/objstrunicode.c
+++ b/py/objstrunicode.c
@@ -229,18 +229,19 @@ STATIC mp_obj_t str_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
     }
 }
 
-const mp_obj_type_t mp_type_str = {
-    { &mp_type_type },
-    .name = MP_QSTR_str,
-    .print = uni_print,
-    .make_new = mp_obj_str_make_new,
-    .unary_op = uni_unary_op,
-    .binary_op = mp_obj_str_binary_op,
-    .subscr = str_subscr,
-    .getiter = mp_obj_new_str_iterator,
-    .buffer = mp_obj_str_get_buffer,
-    .locals_dict = (mp_obj_dict_t *)&mp_obj_str_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_str,
+    MP_QSTR_str,
+    MP_TYPE_FLAG_NONE,
+    mp_obj_str_make_new,
+    print, uni_print,
+    unary_op, uni_unary_op,
+    binary_op, mp_obj_str_binary_op,
+    subscr, str_subscr,
+    getiter, mp_obj_new_str_iterator,
+    buffer, mp_obj_str_get_buffer,
+    locals_dict, (mp_obj_dict_t *)&mp_obj_str_locals_dict
+    );
 
 /******************************************************************************/
 /* str iterator                                                               */
diff --git a/py/objtuple.c b/py/objtuple.c
index e0cec84473..b2ea6e380e 100644
--- a/py/objtuple.c
+++ b/py/objtuple.c
@@ -224,17 +224,18 @@ STATIC const mp_rom_map_elem_t tuple_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(tuple_locals_dict, tuple_locals_dict_table);
 
-const mp_obj_type_t mp_type_tuple = {
-    { &mp_type_type },
-    .name = MP_QSTR_tuple,
-    .print = mp_obj_tuple_print,
-    .make_new = mp_obj_tuple_make_new,
-    .unary_op = mp_obj_tuple_unary_op,
-    .binary_op = mp_obj_tuple_binary_op,
-    .subscr = mp_obj_tuple_subscr,
-    .getiter = mp_obj_tuple_getiter,
-    .locals_dict = (mp_obj_dict_t *)&tuple_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_tuple,
+    MP_QSTR_tuple,
+    MP_TYPE_FLAG_NONE,
+    mp_obj_tuple_make_new,
+    print, mp_obj_tuple_print,
+    unary_op, mp_obj_tuple_unary_op,
+    binary_op, mp_obj_tuple_binary_op,
+    subscr, mp_obj_tuple_subscr,
+    getiter, mp_obj_tuple_getiter,
+    locals_dict, (mp_obj_dict_t *)&tuple_locals_dict
+    );
 
 // the zero-length tuple
 const mp_obj_tuple_t mp_const_empty_tuple_obj = {{&mp_type_tuple}, 0};
diff --git a/py/objtype.c b/py/objtype.c
index c0f6857809..77fe8e22e3 100644
--- a/py/objtype.c
+++ b/py/objtype.c
@@ -1098,15 +1098,16 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     }
 }
 
-const mp_obj_type_t mp_type_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_type,
-    .print = type_print,
-    .make_new = type_make_new,
-    .call = type_call,
-    .unary_op = mp_generic_unary_op,
-    .attr = type_attr,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_type,
+    MP_QSTR_type,
+    MP_TYPE_FLAG_NONE,
+    type_make_new,
+    print, type_print,
+    call, type_call,
+    unary_op, mp_generic_unary_op,
+    attr, type_attr
+    );
 
 mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
     // Verify input objects have expected type
@@ -1314,13 +1315,14 @@ STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     mp_obj_class_lookup(&lookup, &mp_type_object);
 }
 
-const mp_obj_type_t mp_type_super = {
-    { &mp_type_type },
-    .name = MP_QSTR_super,
-    .print = super_print,
-    .make_new = super_make_new,
-    .attr = super_attr,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_super,
+    MP_QSTR_super,
+    MP_TYPE_FLAG_NONE,
+    super_make_new,
+    print, super_print,
+    attr, super_attr
+    );
 
 void mp_load_super_method(qstr attr, mp_obj_t *dest) {
     mp_obj_super_t super = {{&mp_type_super}, dest[1], dest[2]};
@@ -1436,14 +1438,16 @@ STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self, size_t n
     return MP_OBJ_FROM_PTR(o);
 }
 
-const mp_obj_type_t mp_type_staticmethod = {
-    { &mp_type_type },
-    .name = MP_QSTR_staticmethod,
-    .make_new = static_class_method_make_new,
-};
-
-const mp_obj_type_t mp_type_classmethod = {
-    { &mp_type_type },
-    .name = MP_QSTR_classmethod,
-    .make_new = static_class_method_make_new,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_staticmethod,
+    MP_QSTR_staticmethod,
+    MP_TYPE_FLAG_NONE,
+    static_class_method_make_new
+    );
+
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_classmethod,
+    MP_QSTR_classmethod,
+    MP_TYPE_FLAG_NONE,
+    static_class_method_make_new
+    );
diff --git a/py/objzip.c b/py/objzip.c
index 81fa1d587e..0ceafd97f2 100644
--- a/py/objzip.c
+++ b/py/objzip.c
@@ -66,10 +66,11 @@ STATIC mp_obj_t zip_iternext(mp_obj_t self_in) {
     return MP_OBJ_FROM_PTR(tuple);
 }
 
-const mp_obj_type_t mp_type_zip = {
-    { &mp_type_type },
-    .name = MP_QSTR_zip,
-    .make_new = zip_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = zip_iternext,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_zip,
+    MP_QSTR_zip,
+    MP_TYPE_FLAG_NONE,
+    zip_make_new,
+    getiter, mp_identity_getiter,
+    iternext, zip_iternext
+    );
diff --git a/py/profile.c b/py/profile.c
index 4e23e9eac4..2b9531e245 100644
--- a/py/profile.c
+++ b/py/profile.c
@@ -172,13 +172,15 @@ STATIC void code_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     }
 }
 
-const mp_obj_type_t mp_type_settrace_codeobj = {
-    { &mp_type_type },
-    .name = MP_QSTR_code,
-    .print = code_print,
-    .unary_op = mp_generic_unary_op,
-    .attr = code_attr,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_settrace_codeobj,
+    MP_QSTR_code,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    print, code_print,
+    unary_op, mp_generic_unary_op,
+    attr, code_attr
+    );
 
 mp_obj_t mp_obj_new_code(const mp_module_context_t *context, const mp_raw_code_t *rc) {
     mp_obj_code_t *o = m_new_obj_maybe(mp_obj_code_t);
@@ -241,13 +243,15 @@ STATIC void frame_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     }
 }
 
-const mp_obj_type_t mp_type_frame = {
-    { &mp_type_type },
-    .name = MP_QSTR_frame,
-    .print = frame_print,
-    .unary_op = mp_generic_unary_op,
-    .attr = frame_attr,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_frame,
+    MP_QSTR_frame,
+    MP_TYPE_FLAG_NONE,
+    MP_TYPE_NULL_MAKE_NEW,
+    print, frame_print,
+    unary_op, mp_generic_unary_op,
+    attr, frame_attr
+    );
 
 mp_obj_t mp_obj_new_frame(const mp_code_state_t *code_state) {
     if (gc_is_locked()) {
diff --git a/py/runtime.c b/py/runtime.c
index ea3553db72..27b4f05f04 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -1070,12 +1070,13 @@ STATIC mp_obj_t checked_fun_call(mp_obj_t self_in, size_t n_args, size_t n_kw, c
     return mp_call_function_n_kw(self->fun, n_args, n_kw, args);
 }
 
-STATIC const mp_obj_type_t mp_type_checked_fun = {
-    { &mp_type_type },
-    .flags = MP_TYPE_FLAG_BINDS_SELF,
-    .name = MP_QSTR_function,
-    .call = checked_fun_call,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_checked_fun,
+    MP_QSTR_function,
+    MP_TYPE_FLAG_BINDS_SELF,
+    MP_TYPE_NULL_MAKE_NEW,
+    call, checked_fun_call
+    );
 
 STATIC mp_obj_t mp_obj_new_checked_fun(const mp_obj_type_t *type, mp_obj_t fun) {
     mp_obj_checked_fun_t *o = mp_obj_malloc(mp_obj_checked_fun_t, &mp_type_checked_fun);