diff --git a/examples/natmod/btree/btree_c.c b/examples/natmod/btree/btree_c.c
index 5e8a34ac40095..7e93c9088513b 100644
--- a/examples/natmod/btree/btree_c.c
+++ b/examples/natmod/btree/btree_c.c
@@ -51,7 +51,7 @@ int *__errno (void)
 
 ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
     mp_obj_base_t* o = stream;
-    const mp_stream_p_t *stream_p = o->type->protocol;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
     mp_uint_t out_sz = stream_p->write(MP_OBJ_FROM_PTR(stream), buf, len, &native_errno);
     if (out_sz == MP_STREAM_ERROR) {
         return -1;
@@ -62,7 +62,7 @@ ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
 
 ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
     mp_obj_base_t* o = stream;
-    const mp_stream_p_t *stream_p = o->type->protocol;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
     mp_uint_t out_sz = stream_p->read(MP_OBJ_FROM_PTR(stream), buf, len, &native_errno);
     if (out_sz == MP_STREAM_ERROR) {
         return -1;
@@ -73,7 +73,7 @@ ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
 
 off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
     const mp_obj_base_t* o = stream;
-    const mp_stream_p_t *stream_p = o->type->protocol;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
     struct mp_stream_seek_t seek_s;
     seek_s.offset = offset;
     seek_s.whence = whence;
@@ -86,7 +86,7 @@ off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
 
 int mp_stream_posix_fsync(void *stream) {
     mp_obj_base_t* o = stream;
-    const mp_stream_p_t *stream_p = o->type->protocol;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
     mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_FLUSH, 0, &native_errno);
     if (res == MP_STREAM_ERROR) {
         return -1;
@@ -94,7 +94,7 @@ int mp_stream_posix_fsync(void *stream) {
     return res;
 }
 
-mp_obj_type_t btree_type;
+mp_obj_full_type_t btree_type;
 
 #include "extmod/modbtree.c"
 
@@ -124,11 +124,11 @@ mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *a
 
     btree_type.base.type = (void*)&mp_fun_table.type_type;
     btree_type.name = MP_QSTR_btree;
-    btree_type.print = btree_print;
-    btree_type.getiter = btree_getiter;
-    btree_type.iternext = btree_iternext;
-    btree_type.binary_op = btree_binary_op;
-    btree_type.subscr = btree_subscr;
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, print, btree_print, 1);
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, getiter, btree_getiter, 2);
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, iternext, btree_iternext, 3);
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, binary_op, btree_binary_op, 4);
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, subscr, btree_subscr, 5);
     btree_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_close), MP_OBJ_FROM_PTR(&btree_close_obj) };
     btree_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_flush), MP_OBJ_FROM_PTR(&btree_flush_obj) };
     btree_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_get), MP_OBJ_FROM_PTR(&btree_get_obj) };
@@ -137,7 +137,7 @@ mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *a
     btree_locals_dict_table[5] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_keys), MP_OBJ_FROM_PTR(&btree_keys_obj) };
     btree_locals_dict_table[6] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_values), MP_OBJ_FROM_PTR(&btree_values_obj) };
     btree_locals_dict_table[7] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_items), MP_OBJ_FROM_PTR(&btree_items_obj) };
-    btree_type.locals_dict = (void*)&btree_locals_dict;
+    MP_OBJ_TYPE_SET_SLOT(&btree_type, locals_dict, (void*)&btree_locals_dict, 6);
 
     mp_store_global(MP_QSTR__open, MP_OBJ_FROM_PTR(&btree_open_obj));
     mp_store_global(MP_QSTR_INCL, MP_OBJ_NEW_SMALL_INT(FLAG_END_KEY_INCL));
diff --git a/examples/natmod/framebuf/framebuf.c b/examples/natmod/framebuf/framebuf.c
index 8d488cffd685a..fcd11cf5837c5 100644
--- a/examples/natmod/framebuf/framebuf.c
+++ b/examples/natmod/framebuf/framebuf.c
@@ -8,7 +8,7 @@ void *memset(void *s, int c, size_t n) {
 }
 #endif
 
-mp_obj_type_t mp_type_framebuf;
+mp_obj_full_type_t mp_type_framebuf;
 
 #include "extmod/modframebuf.c"
 
@@ -21,7 +21,7 @@ mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *a
     mp_type_framebuf.base.type = (void*)&mp_type_type;
     mp_type_framebuf.name = MP_QSTR_FrameBuffer;
     mp_type_framebuf.make_new = framebuf_make_new;
-    mp_type_framebuf.buffer_p.get_buffer = framebuf_get_buffer;
+    MP_OBJ_TYPE_SET_SLOT(&mp_type_framebuf, buffer, framebuf_get_buffer, 1);
     framebuf_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_fill), MP_OBJ_FROM_PTR(&framebuf_fill_obj) };
     framebuf_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_fill_rect), MP_OBJ_FROM_PTR(&framebuf_fill_rect_obj) };
     framebuf_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_pixel), MP_OBJ_FROM_PTR(&framebuf_pixel_obj) };
@@ -32,7 +32,7 @@ mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *a
     framebuf_locals_dict_table[7] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_blit), MP_OBJ_FROM_PTR(&framebuf_blit_obj) };
     framebuf_locals_dict_table[8] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_scroll), MP_OBJ_FROM_PTR(&framebuf_scroll_obj) };
     framebuf_locals_dict_table[9] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_text), MP_OBJ_FROM_PTR(&framebuf_text_obj) };
-    mp_type_framebuf.locals_dict = (void*)&framebuf_locals_dict;
+    MP_OBJ_TYPE_SET_SLOT(&mp_type_framebuf, locals_dict, (void*)&framebuf_locals_dict, 2);
 
     mp_store_global(MP_QSTR_FrameBuffer, MP_OBJ_FROM_PTR(&mp_type_framebuf));
     mp_store_global(MP_QSTR_FrameBuffer1, MP_OBJ_FROM_PTR(&legacy_framebuffer1_obj));
diff --git a/examples/natmod/ure/ure.c b/examples/natmod/ure/ure.c
index 175b93e395ef9..ca11bde539acd 100644
--- a/examples/natmod/ure/ure.c
+++ b/examples/natmod/ure/ure.c
@@ -32,8 +32,8 @@ void *memmove(void *dest, const void *src, size_t n) {
     return mp_fun_table.memmove_(dest, src, n);
 }
 
-mp_obj_type_t match_type;
-mp_obj_type_t re_type;
+mp_obj_full_type_t match_type;
+mp_obj_full_type_t re_type;
 
 #include "extmod/modure.c"
 
@@ -54,21 +54,21 @@ mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *a
 
     match_type.base.type = (void*)&mp_fun_table.type_type;
     match_type.name = MP_QSTR_match;
-    match_type.print = match_print;
+    MP_OBJ_TYPE_SET_SLOT(&match_type, print, match_print, 1);
     match_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_group), MP_OBJ_FROM_PTR(&match_group_obj) };
     match_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_groups), MP_OBJ_FROM_PTR(&match_groups_obj) };
     match_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_span), MP_OBJ_FROM_PTR(&match_span_obj) };
     match_locals_dict_table[3] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_start), MP_OBJ_FROM_PTR(&match_start_obj) };
     match_locals_dict_table[4] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_end), MP_OBJ_FROM_PTR(&match_end_obj) };
-    match_type.locals_dict = (void*)&match_locals_dict;
+    MP_OBJ_TYPE_SET_SLOT(&match_type, locals_dict, (void*)&match_locals_dict, 2);
 
     re_type.base.type = (void*)&mp_fun_table.type_type;
     re_type.name = MP_QSTR_ure;
-    re_type.print = re_print;
+    MP_OBJ_TYPE_SET_SLOT(&re_type, print, re_print, 1);
     re_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_match), MP_OBJ_FROM_PTR(&re_match_obj) };
     re_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_search), MP_OBJ_FROM_PTR(&re_search_obj) };
     re_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_split), MP_OBJ_FROM_PTR(&re_split_obj) };
-    re_type.locals_dict = (void*)&re_locals_dict;
+    MP_OBJ_TYPE_SET_SLOT(&re_type, locals_dict, (void*)&re_locals_dict, 2);
 
     mp_store_global(MP_QSTR_compile, MP_OBJ_FROM_PTR(&mod_re_compile_obj));
     mp_store_global(MP_QSTR_match, MP_OBJ_FROM_PTR(&re_match_obj));
diff --git a/examples/natmod/uzlib/uzlib.c b/examples/natmod/uzlib/uzlib.c
index 99b3691761ea4..228a70ea6cc92 100644
--- a/examples/natmod/uzlib/uzlib.c
+++ b/examples/natmod/uzlib/uzlib.c
@@ -8,7 +8,7 @@ void *memset(void *s, int c, size_t n) {
 }
 #endif
 
-mp_obj_type_t decompio_type;
+mp_obj_full_type_t decompio_type;
 
 #include "extmod/moduzlib.c"
 
@@ -20,12 +20,12 @@ mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *a
 
     decompio_type.base.type = mp_fun_table.type_type;
     decompio_type.name = MP_QSTR_DecompIO;
-    decompio_type.make_new = decompio_make_new;
-    decompio_type.protocol = &decompio_stream_p;
+    decompio_type.make_new = &decompio_make_new;
+    MP_OBJ_TYPE_SET_SLOT(&decompio_type, protocol, &decompio_stream_p, 1);
     decompio_locals_dict_table[0] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_read), MP_OBJ_FROM_PTR(&mp_stream_read_obj) };
     decompio_locals_dict_table[1] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_readinto), MP_OBJ_FROM_PTR(&mp_stream_readinto_obj) };
     decompio_locals_dict_table[2] = (mp_map_elem_t){ MP_OBJ_NEW_QSTR(MP_QSTR_readline), MP_OBJ_FROM_PTR(&mp_stream_unbuffered_readline_obj) };
-    decompio_type.locals_dict = (void*)&decompio_locals_dict;
+    MP_OBJ_TYPE_SET_SLOT(&decompio_type, locals_dict, (void*)&decompio_locals_dict, 2);
 
     mp_store_global(MP_QSTR___name__, MP_OBJ_NEW_QSTR(MP_QSTR_uzlib));
     mp_store_global(MP_QSTR_decompress, MP_OBJ_FROM_PTR(&mod_uzlib_decompress_obj));
diff --git a/extmod/machine_i2c.c b/extmod/machine_i2c.c
index 2b1275e5bb724..efcc1da5feb6d 100644
--- a/extmod/machine_i2c.c
+++ b/extmod/machine_i2c.c
@@ -273,7 +273,7 @@ int mp_machine_i2c_transfer_adaptor(mp_obj_base_t *self, uint16_t addr, size_t n
         }
     }
 
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     int ret = i2c_p->transfer_single(self, addr, len, buf, flags);
 
     if (n > 1) {
@@ -292,14 +292,14 @@ int mp_machine_i2c_transfer_adaptor(mp_obj_base_t *self, uint16_t addr, size_t n
 }
 
 STATIC int mp_machine_i2c_readfrom(mp_obj_base_t *self, uint16_t addr, uint8_t *dest, size_t len, bool stop) {
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     mp_machine_i2c_buf_t buf = {.len = len, .buf = dest};
     unsigned int flags = MP_MACHINE_I2C_FLAG_READ | (stop ? MP_MACHINE_I2C_FLAG_STOP : 0);
     return i2c_p->transfer(self, addr, 1, &buf, flags);
 }
 
 STATIC int mp_machine_i2c_writeto(mp_obj_base_t *self, uint16_t addr, const uint8_t *src, size_t len, bool stop) {
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     mp_machine_i2c_buf_t buf = {.len = len, .buf = (uint8_t *)src};
     unsigned int flags = stop ? MP_MACHINE_I2C_FLAG_STOP : 0;
     return i2c_p->transfer(self, addr, 1, &buf, flags);
@@ -310,7 +310,7 @@ STATIC int mp_machine_i2c_writeto(mp_obj_base_t *self, uint16_t addr, const uint
 
 STATIC mp_obj_t machine_i2c_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
     mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     if (i2c_p->init == NULL) {
         mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
@@ -335,7 +335,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_scan_obj, machine_i2c_scan);
 
 STATIC mp_obj_t machine_i2c_start(mp_obj_t self_in) {
     mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     if (i2c_p->start == NULL) {
         mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
@@ -349,7 +349,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_start_obj, machine_i2c_start);
 
 STATIC mp_obj_t machine_i2c_stop(mp_obj_t self_in) {
     mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     if (i2c_p->stop == NULL) {
         mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
@@ -363,7 +363,7 @@ MP_DEFINE_CONST_FUN_OBJ_1(machine_i2c_stop_obj, machine_i2c_stop);
 
 STATIC mp_obj_t machine_i2c_readinto(size_t n_args, const mp_obj_t *args) {
     mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     if (i2c_p->read == NULL) {
         mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
@@ -387,7 +387,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(machine_i2c_readinto_obj, 2, 3, machine_i2c_
 
 STATIC mp_obj_t machine_i2c_write(mp_obj_t self_in, mp_obj_t buf_in) {
     mp_obj_base_t *self = (mp_obj_base_t *)MP_OBJ_TO_PTR(self_in);
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     if (i2c_p->write == NULL) {
         mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("I2C operation not supported"));
     }
@@ -483,7 +483,7 @@ STATIC mp_obj_t machine_i2c_writevto(size_t n_args, const mp_obj_t *args) {
     }
 
     // Do the I2C transfer
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     int ret = i2c_p->transfer(self, addr, nbufs, bufs, stop ? MP_MACHINE_I2C_FLAG_STOP : 0);
     mp_local_free(bufs);
 
@@ -537,7 +537,7 @@ STATIC int write_mem(mp_obj_t self_in, uint16_t addr, uint32_t memaddr, uint8_t
     };
 
     // Do I2C transfer
-    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)self->type->protocol;
+    mp_machine_i2c_p_t *i2c_p = (mp_machine_i2c_p_t *)MP_OBJ_TYPE_GET_SLOT(self->type, protocol);
     return i2c_p->transfer(self, addr, 2, bufs, MP_MACHINE_I2C_FLAG_STOP);
 }
 
@@ -712,13 +712,11 @@ STATIC const mp_machine_i2c_p_t mp_machine_soft_i2c_p = {
     .transfer = mp_machine_soft_i2c_transfer,
 };
 
-const mp_obj_type_t mp_machine_soft_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SoftI2C,
-    .print = mp_machine_soft_i2c_print,
-    .make_new = mp_machine_soft_i2c_make_new,
-    .protocol = &mp_machine_soft_i2c_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_machine_soft_i2c_type, MP_QSTR_SoftI2C, MP_TYPE_FLAG_NONE, mp_machine_soft_i2c_make_new,
+    print, mp_machine_soft_i2c_print,
+    protocol, &mp_machine_soft_i2c_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_i2c_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_SOFTI2C
diff --git a/extmod/machine_mem.c b/extmod/machine_mem.c
index 73e2f7fd1fcb0..4c9402ebded8f 100644
--- a/extmod/machine_mem.c
+++ b/extmod/machine_mem.c
@@ -101,12 +101,11 @@ STATIC mp_obj_t machine_mem_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t va
     }
 }
 
-const mp_obj_type_t machine_mem_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_mem,
-    .print = machine_mem_print,
-    .subscr = machine_mem_subscr,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_mem_type, MP_QSTR_mem, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, machine_mem_print,
+    subscr, machine_mem_subscr
+    );
 
 const machine_mem_obj_t machine_mem8_obj = {{&machine_mem_type}, 1};
 const machine_mem_obj_t machine_mem16_obj = {{&machine_mem_type}, 2};
diff --git a/extmod/machine_pinbase.c b/extmod/machine_pinbase.c
index 070c5cde9d3ac..1a0a5c0a4fb87 100644
--- a/extmod/machine_pinbase.c
+++ b/extmod/machine_pinbase.c
@@ -77,11 +77,9 @@ STATIC const mp_pin_p_t pinbase_pin_p = {
     .ioctl = pinbase_ioctl,
 };
 
-const mp_obj_type_t machine_pinbase_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_PinBase,
-    .make_new = pinbase_make_new,
-    .protocol = &pinbase_pin_p,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pinbase_type, MP_QSTR_PinBase, MP_TYPE_FLAG_NONE, pinbase_make_new,
+    protocol, &pinbase_pin_p
+    );
 
 #endif // MICROPY_PY_MACHINE
diff --git a/extmod/machine_pwm.c b/extmod/machine_pwm.c
index ddf49c1358a5d..8f243df8603af 100644
--- a/extmod/machine_pwm.c
+++ b/extmod/machine_pwm.c
@@ -132,12 +132,10 @@ STATIC const mp_rom_map_elem_t machine_pwm_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_pwm_locals_dict, machine_pwm_locals_dict_table);
 
-const mp_obj_type_t machine_pwm_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_PWM,
-    .print = mp_machine_pwm_print,
-    .make_new = mp_machine_pwm_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_pwm_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pwm_type, MP_QSTR_PWM, MP_TYPE_FLAG_NONE, mp_machine_pwm_make_new,
+    print, mp_machine_pwm_print,
+    locals_dict, &machine_pwm_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_PWM
diff --git a/extmod/machine_signal.c b/extmod/machine_signal.c
index f112ddc57c827..f6373f36f096f 100644
--- a/extmod/machine_signal.c
+++ b/extmod/machine_signal.c
@@ -51,7 +51,7 @@ STATIC mp_obj_t signal_make_new(const mp_obj_type_t *type, size_t n_args, size_t
 
     if (n_args > 0 && mp_obj_is_obj(args[0])) {
         mp_obj_base_t *pin_base = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
-        pin_p = (mp_pin_p_t *)pin_base->type->protocol;
+        pin_p = (mp_pin_p_t *)MP_OBJ_TYPE_GET_SLOT_OR_NULL(pin_base->type, protocol);
     }
 
     if (pin_p == NULL) {
@@ -173,13 +173,11 @@ STATIC const mp_pin_p_t signal_pin_p = {
     .ioctl = signal_ioctl,
 };
 
-const mp_obj_type_t machine_signal_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Signal,
-    .make_new = signal_make_new,
-    .call = signal_call,
-    .protocol = &signal_pin_p,
-    .locals_dict = (void *)&signal_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_signal_type, MP_QSTR_Signal, MP_TYPE_FLAG_NONE, signal_make_new,
+    call, signal_call,
+    protocol, &signal_pin_p,
+    locals_dict, (void *)&signal_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE
diff --git a/extmod/machine_spi.c b/extmod/machine_spi.c
index ae5e6677d265f..749aad4d62af5 100644
--- a/extmod/machine_spi.c
+++ b/extmod/machine_spi.c
@@ -43,7 +43,7 @@
 
 STATIC mp_obj_t machine_spi_init(size_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
     mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(args[0]);
-    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)s->type->protocol;
+    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)MP_OBJ_TYPE_GET_SLOT(s->type, protocol);
     spi_p->init(s, n_args - 1, args + 1, kw_args);
     return mp_const_none;
 }
@@ -51,7 +51,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_KW(machine_spi_init_obj, 1, machine_spi_init);
 
 STATIC mp_obj_t machine_spi_deinit(mp_obj_t self) {
     mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(self);
-    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)s->type->protocol;
+    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)MP_OBJ_TYPE_GET_SLOT(s->type, protocol);
     if (spi_p->deinit != NULL) {
         spi_p->deinit(s);
     }
@@ -61,7 +61,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(machine_spi_deinit_obj, machine_spi_deinit);
 
 STATIC void mp_machine_spi_transfer(mp_obj_t self, size_t len, const void *src, void *dest) {
     mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(self);
-    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)s->type->protocol;
+    mp_machine_spi_p_t *spi_p = (mp_machine_spi_p_t *)MP_OBJ_TYPE_GET_SLOT(s->type, protocol);
     spi_p->transfer(s, len, src, dest);
 }
 
@@ -252,13 +252,11 @@ const mp_machine_spi_p_t mp_machine_soft_spi_p = {
     .transfer = mp_machine_soft_spi_transfer,
 };
 
-const mp_obj_type_t mp_machine_soft_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SoftSPI,
-    .print = mp_machine_soft_spi_print,
-    .make_new = mp_machine_soft_spi_make_new,
-    .protocol = &mp_machine_soft_spi_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_machine_soft_spi_type, MP_QSTR_SoftSPI, MP_TYPE_FLAG_NONE, mp_machine_soft_spi_make_new,
+    print, mp_machine_soft_spi_print,
+    protocol, &mp_machine_soft_spi_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_spi_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_SOFTSPI
diff --git a/extmod/modbluetooth.c b/extmod/modbluetooth.c
index c4b9675cef530..153f0b91cef25 100644
--- a/extmod/modbluetooth.c
+++ b/extmod/modbluetooth.c
@@ -240,16 +240,13 @@ STATIC void ringbuf_get_uuid(ringbuf_t *ringbuf, mp_obj_bluetooth_uuid_t *uuid)
 
 #endif // !MICROPY_PY_BLUETOOTH_USE_SYNC_EVENTS
 
-const mp_obj_type_t mp_type_bluetooth_uuid = {
-    { &mp_type_type },
-    .name = MP_QSTR_UUID,
-    .make_new = bluetooth_uuid_make_new,
-    .unary_op = bluetooth_uuid_unary_op,
-    .binary_op = bluetooth_uuid_binary_op,
-    .locals_dict = NULL,
-    .print = bluetooth_uuid_print,
-    .buffer_p = { .get_buffer = bluetooth_uuid_get_buffer },
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_bluetooth_uuid, MP_QSTR_UUID, MP_TYPE_FLAG_NONE, bluetooth_uuid_make_new,
+    unary_op, bluetooth_uuid_unary_op,
+    binary_op, bluetooth_uuid_binary_op,
+    print, bluetooth_uuid_print,
+    buffer, bluetooth_uuid_get_buffer
+    );
 
 // ----------------------------------------------------------------------------
 // Bluetooth object: General
@@ -978,12 +975,10 @@ STATIC const mp_rom_map_elem_t bluetooth_ble_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(bluetooth_ble_locals_dict, bluetooth_ble_locals_dict_table);
 
-STATIC const mp_obj_type_t mp_type_bluetooth_ble = {
-    { &mp_type_type },
-    .name = MP_QSTR_BLE,
-    .make_new = bluetooth_ble_make_new,
-    .locals_dict = (void *)&bluetooth_ble_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_bluetooth_ble, MP_QSTR_BLE, MP_TYPE_FLAG_NONE, bluetooth_ble_make_new,
+    locals_dict, (void *)&bluetooth_ble_locals_dict
+    );
 
 STATIC const mp_rom_map_elem_t mp_module_bluetooth_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ubluetooth) },
diff --git a/extmod/modbtree.c b/extmod/modbtree.c
index 2dd3a89b89fef..9e88aa9c2c35c 100644
--- a/extmod/modbtree.c
+++ b/extmod/modbtree.c
@@ -68,7 +68,7 @@ void __dbpanic(DB *db) {
 
 STATIC mp_obj_btree_t *btree_new(DB *db, mp_obj_t stream) {
     mp_obj_btree_t *o = m_new_obj(mp_obj_btree_t);
-    o->base.type = &btree_type;
+    o->base.type = (mp_obj_type_t *)&btree_type;
     o->stream = stream;
     o->db = db;
     o->start_key = mp_const_none;
@@ -313,17 +313,16 @@ STATIC const mp_rom_map_elem_t btree_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(btree_locals_dict, btree_locals_dict_table);
 
-STATIC const mp_obj_type_t btree_type = {
-    { &mp_type_type },
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    btree_type, MP_QSTR_btree, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
     // Save on qstr's, reuse same as for module
-    .name = MP_QSTR_btree,
-    .print = btree_print,
-    .getiter = btree_getiter,
-    .iternext = btree_iternext,
-    .binary_op = btree_binary_op,
-    .subscr = btree_subscr,
-    .locals_dict = (void *)&btree_locals_dict,
-};
+    print, btree_print,
+    getiter, btree_getiter,
+    iternext, btree_iternext,
+    binary_op, btree_binary_op,
+    subscr, btree_subscr,
+    locals_dict, (void *)&btree_locals_dict
+    );
 #endif
 
 STATIC const FILEVTABLE btree_stream_fvtable = {
diff --git a/extmod/modframebuf.c b/extmod/modframebuf.c
index 454624dda8cb7..847c5450b165d 100644
--- a/extmod/modframebuf.c
+++ b/extmod/modframebuf.c
@@ -617,19 +617,17 @@ STATIC const mp_rom_map_elem_t framebuf_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(framebuf_locals_dict, framebuf_locals_dict_table);
 
-STATIC const mp_obj_type_t mp_type_framebuf = {
-    { &mp_type_type },
-    .name = MP_QSTR_FrameBuffer,
-    .make_new = framebuf_make_new,
-    .buffer_p = { .get_buffer = framebuf_get_buffer },
-    .locals_dict = (mp_obj_dict_t *)&framebuf_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_framebuf, MP_QSTR_FrameBuffer, MP_TYPE_FLAG_NONE, framebuf_make_new,
+    buffer, framebuf_get_buffer,
+    locals_dict, (mp_obj_dict_t *)&framebuf_locals_dict
+    );
 #endif
 
 // this factory function is provided for backwards compatibility with old FrameBuffer1 class
 STATIC mp_obj_t legacy_framebuffer1(size_t n_args, const mp_obj_t *args) {
     mp_obj_framebuf_t *o = m_new_obj(mp_obj_framebuf_t);
-    o->base.type = &mp_type_framebuf;
+    o->base.type = (mp_obj_type_t *)&mp_type_framebuf;
 
     mp_buffer_info_t bufinfo;
     mp_get_buffer_raise(args[0], &bufinfo, MP_BUFFER_WRITE);
diff --git a/extmod/modlwip.c b/extmod/modlwip.c
index 4d4ffc1e0787d..b54f665f5d5ec 100644
--- a/extmod/modlwip.c
+++ b/extmod/modlwip.c
@@ -174,12 +174,10 @@ STATIC const mp_rom_map_elem_t lwip_slip_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(lwip_slip_locals_dict, lwip_slip_locals_dict_table);
 
-STATIC const mp_obj_type_t lwip_slip_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_slip,
-    .make_new = lwip_slip_make_new,
-    .locals_dict = (mp_obj_dict_t *)&lwip_slip_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    lwip_slip_type, MP_QSTR_slip, MP_TYPE_FLAG_NONE, lwip_slip_make_new,
+    locals_dict, (mp_obj_dict_t *)&lwip_slip_locals_dict
+    );
 
 #endif // MICROPY_PY_LWIP_SLIP
 
@@ -1585,14 +1583,12 @@ STATIC const mp_stream_p_t lwip_socket_stream_p = {
     .ioctl = lwip_socket_ioctl,
 };
 
-STATIC const mp_obj_type_t lwip_socket_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_socket,
-    .print = lwip_socket_print,
-    .make_new = lwip_socket_make_new,
-    .protocol = &lwip_socket_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&lwip_socket_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    lwip_socket_type, MP_QSTR_socket, MP_TYPE_FLAG_NONE, lwip_socket_make_new,
+    print, lwip_socket_print,
+    protocol, &lwip_socket_stream_p,
+    locals_dict, (mp_obj_dict_t *)&lwip_socket_locals_dict
+    );
 
 /******************************************************************************/
 // Support functions for memory protection. lwIP has its own memory management
diff --git a/extmod/modnetwork.h b/extmod/modnetwork.h
index b95760897aa10..d3906bc2a6136 100644
--- a/extmod/modnetwork.h
+++ b/extmod/modnetwork.h
@@ -56,7 +56,11 @@ mp_obj_t mod_network_nic_ifconfig(struct netif *netif, size_t n_args, const mp_o
 struct _mod_network_socket_obj_t;
 
 typedef struct _mod_network_nic_type_t {
-    mp_obj_type_t base;
+    union {
+        mp_obj_type_t base;
+        // Ensure that this struct is big enough to hold any type size.
+        mp_obj_full_type_t _alloc;
+    };
 
     // API for non-socket operations
     int (*gethostbyname)(mp_obj_t nic, const char *name, mp_uint_t len, uint8_t *ip_out);
diff --git a/extmod/moduasyncio.c b/extmod/moduasyncio.c
index b0921b6eb13fe..8c94247145275 100644
--- a/extmod/moduasyncio.c
+++ b/extmod/moduasyncio.c
@@ -146,12 +146,10 @@ STATIC const mp_rom_map_elem_t task_queue_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(task_queue_locals_dict, task_queue_locals_dict_table);
 
-STATIC const mp_obj_type_t task_queue_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_TaskQueue,
-    .make_new = task_queue_make_new,
-    .locals_dict = (mp_obj_dict_t *)&task_queue_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    task_queue_type, MP_QSTR_TaskQueue, MP_TYPE_FLAG_NONE, task_queue_make_new,
+    locals_dict, (mp_obj_dict_t *)&task_queue_locals_dict
+    );
 
 /******************************************************************************/
 // Task class
@@ -288,14 +286,12 @@ STATIC mp_obj_t task_iternext(mp_obj_t self_in) {
     return mp_const_none;
 }
 
-STATIC const mp_obj_type_t task_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Task,
-    .make_new = task_make_new,
-    .attr = task_attr,
-    .getiter = task_getiter,
-    .iternext = task_iternext,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    task_type, MP_QSTR_Task, MP_TYPE_FLAG_NONE, task_make_new,
+    attr, task_attr,
+    getiter, task_getiter,
+    iternext, task_iternext
+    );
 
 /******************************************************************************/
 // C-level uasyncio module
diff --git a/extmod/moducryptolib.c b/extmod/moducryptolib.c
index 6c89d6d9fe81c..3adc9674fcb1c 100644
--- a/extmod/moducryptolib.c
+++ b/extmod/moducryptolib.c
@@ -349,12 +349,10 @@ STATIC const mp_rom_map_elem_t ucryptolib_aes_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(ucryptolib_aes_locals_dict, ucryptolib_aes_locals_dict_table);
 
-STATIC const mp_obj_type_t ucryptolib_aes_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_aes,
-    .make_new = ucryptolib_aes_make_new,
-    .locals_dict = (void *)&ucryptolib_aes_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    ucryptolib_aes_type, MP_QSTR_aes, MP_TYPE_FLAG_NONE, ucryptolib_aes_make_new,
+    locals_dict, (void *)&ucryptolib_aes_locals_dict
+    );
 
 STATIC const mp_rom_map_elem_t mp_module_ucryptolib_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ucryptolib) },
diff --git a/extmod/moductypes.c b/extmod/moductypes.c
index 58f0adfa4ba34..ca32c649943e4 100644
--- a/extmod/moductypes.c
+++ b/extmod/moductypes.c
@@ -639,16 +639,14 @@ STATIC mp_obj_t uctypes_struct_bytes_at(mp_obj_t ptr, mp_obj_t size) {
 }
 MP_DEFINE_CONST_FUN_OBJ_2(uctypes_struct_bytes_at_obj, uctypes_struct_bytes_at);
 
-STATIC const mp_obj_type_t uctypes_struct_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_struct,
-    .print = uctypes_struct_print,
-    .make_new = uctypes_struct_make_new,
-    .attr = uctypes_struct_attr,
-    .subscr = uctypes_struct_subscr,
-    .unary_op = uctypes_struct_unary_op,
-    .buffer_p = { .get_buffer = uctypes_get_buffer },
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    uctypes_struct_type, MP_QSTR_struct, MP_TYPE_FLAG_NONE, uctypes_struct_make_new,
+    print, uctypes_struct_print,
+    attr, uctypes_struct_attr,
+    subscr, uctypes_struct_subscr,
+    unary_op, uctypes_struct_unary_op,
+    buffer, uctypes_get_buffer
+    );
 
 STATIC const mp_rom_map_elem_t mp_module_uctypes_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uctypes) },
diff --git a/extmod/moduhashlib.c b/extmod/moduhashlib.c
index e97e8cb75d625..6e17f18cfbdf9 100644
--- a/extmod/moduhashlib.c
+++ b/extmod/moduhashlib.c
@@ -159,12 +159,10 @@ STATIC const mp_rom_map_elem_t uhashlib_sha256_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(uhashlib_sha256_locals_dict, uhashlib_sha256_locals_dict_table);
 
-STATIC const mp_obj_type_t uhashlib_sha256_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_sha256,
-    .make_new = uhashlib_sha256_make_new,
-    .locals_dict = (void *)&uhashlib_sha256_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    uhashlib_sha256_type, MP_QSTR_sha256, MP_TYPE_FLAG_NONE, uhashlib_sha256_make_new,
+    locals_dict, (void *)&uhashlib_sha256_locals_dict
+    );
 #endif
 
 #if MICROPY_PY_UHASHLIB_SHA1
@@ -254,12 +252,10 @@ STATIC const mp_rom_map_elem_t uhashlib_sha1_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(uhashlib_sha1_locals_dict, uhashlib_sha1_locals_dict_table);
 
-STATIC const mp_obj_type_t uhashlib_sha1_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_sha1,
-    .make_new = uhashlib_sha1_make_new,
-    .locals_dict = (void *)&uhashlib_sha1_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    uhashlib_sha1_type, MP_QSTR_sha1, MP_TYPE_FLAG_NONE, uhashlib_sha1_make_new,
+    locals_dict, (void *)&uhashlib_sha1_locals_dict
+    );
 #endif
 
 #if MICROPY_PY_UHASHLIB_MD5
@@ -349,12 +345,10 @@ STATIC const mp_rom_map_elem_t uhashlib_md5_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(uhashlib_md5_locals_dict, uhashlib_md5_locals_dict_table);
 
-STATIC const mp_obj_type_t uhashlib_md5_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_md5,
-    .make_new = uhashlib_md5_make_new,
-    .locals_dict = (void *)&uhashlib_md5_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    uhashlib_md5_type, MP_QSTR_md5, MP_TYPE_FLAG_NONE, uhashlib_md5_make_new,
+    locals_dict, (void *)&uhashlib_md5_locals_dict
+    );
 #endif // MICROPY_PY_UHASHLIB_MD5
 
 STATIC const mp_rom_map_elem_t mp_module_uhashlib_globals_table[] = {
diff --git a/extmod/modure.c b/extmod/modure.c
index d9e5451eb58ba..2932569288610 100644
--- a/extmod/modure.c
+++ b/extmod/modure.c
@@ -163,12 +163,11 @@ STATIC const mp_rom_map_elem_t match_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(match_locals_dict, match_locals_dict_table);
 
-STATIC const mp_obj_type_t match_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_match,
-    .print = match_print,
-    .locals_dict = (void *)&match_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    match_type, MP_QSTR_match, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, match_print,
+    locals_dict, (void *)&match_locals_dict
+    );
 #endif
 
 STATIC void re_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
@@ -180,7 +179,7 @@ STATIC void re_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t
 STATIC mp_obj_t ure_exec(bool is_anchored, uint n_args, const mp_obj_t *args) {
     (void)n_args;
     mp_obj_re_t *self;
-    if (mp_obj_is_type(args[0], &re_type)) {
+    if (mp_obj_is_type(args[0], (mp_obj_type_t *)&re_type)) {
         self = MP_OBJ_TO_PTR(args[0]);
     } else {
         self = MP_OBJ_TO_PTR(mod_re_compile(1, args));
@@ -199,7 +198,7 @@ STATIC mp_obj_t ure_exec(bool is_anchored, uint n_args, const mp_obj_t *args) {
         return mp_const_none;
     }
 
-    match->base.type = &match_type;
+    match->base.type = (mp_obj_type_t *)&match_type;
     match->num_matches = caps_num / 2; // caps_num counts start and end pointers
     match->str = args[1];
     return MP_OBJ_FROM_PTR(match);
@@ -264,7 +263,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(re_split_obj, 2, 3, re_split);
 
 STATIC mp_obj_t re_sub_helper(size_t n_args, const mp_obj_t *args) {
     mp_obj_re_t *self;
-    if (mp_obj_is_type(args[0], &re_type)) {
+    if (mp_obj_is_type(args[0], (mp_obj_type_t *)&re_type)) {
         self = MP_OBJ_TO_PTR(args[0]);
     } else {
         self = MP_OBJ_TO_PTR(mod_re_compile(1, args));
@@ -287,7 +286,7 @@ STATIC mp_obj_t re_sub_helper(size_t n_args, const mp_obj_t *args) {
     vstr_t vstr_return;
     vstr_return.buf = NULL; // We'll init the vstr after the first match
     mp_obj_match_t *match = mp_local_alloc(sizeof(mp_obj_match_t) + caps_num * sizeof(char *));
-    match->base.type = &match_type;
+    match->base.type = (mp_obj_type_t *)&match_type;
     match->num_matches = caps_num / 2; // caps_num counts start and end pointers
     match->str = where;
 
@@ -391,12 +390,11 @@ STATIC const mp_rom_map_elem_t re_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(re_locals_dict, re_locals_dict_table);
 
-STATIC const mp_obj_type_t re_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ure,
-    .print = re_print,
-    .locals_dict = (void *)&re_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    re_type, MP_QSTR_ure, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, re_print,
+    locals_dict, (void *)&re_locals_dict
+    );
 #endif
 
 STATIC mp_obj_t mod_re_compile(size_t n_args, const mp_obj_t *args) {
@@ -407,7 +405,7 @@ STATIC mp_obj_t mod_re_compile(size_t n_args, const mp_obj_t *args) {
         goto error;
     }
     mp_obj_re_t *o = m_new_obj_var(mp_obj_re_t, char, size);
-    o->base.type = &re_type;
+    o->base.type = (mp_obj_type_t *)&re_type;
     #if MICROPY_PY_URE_DEBUG
     int flags = 0;
     if (n_args > 1) {
diff --git a/extmod/moduselect.c b/extmod/moduselect.c
index cf47f02afefa0..cf7653dedbad6 100644
--- a/extmod/moduselect.c
+++ b/extmod/moduselect.c
@@ -336,13 +336,12 @@ STATIC const mp_rom_map_elem_t poll_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(poll_locals_dict, poll_locals_dict_table);
 
-STATIC const mp_obj_type_t mp_type_poll = {
-    { &mp_type_type },
-    .name = MP_QSTR_poll,
-    .getiter = mp_identity_getiter,
-    .iternext = poll_iternext,
-    .locals_dict = (void *)&poll_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_poll, MP_QSTR_poll, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, poll_iternext,
+    locals_dict, (void *)&poll_locals_dict
+    );
 
 // poll()
 STATIC mp_obj_t select_poll(void) {
diff --git a/extmod/modusocket.c b/extmod/modusocket.c
index bd11e70c1e9aa..80a9363adee1e 100644
--- a/extmod/modusocket.c
+++ b/extmod/modusocket.c
@@ -466,13 +466,11 @@ STATIC const mp_stream_p_t socket_stream_p = {
     .is_text = false,
 };
 
-STATIC const mp_obj_type_t socket_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_socket,
-    .make_new = socket_make_new,
-    .protocol = &socket_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&socket_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    socket_type, MP_QSTR_socket, MP_TYPE_FLAG_NONE, socket_make_new,
+    protocol, &socket_stream_p,
+    locals_dict, (mp_obj_dict_t *)&socket_locals_dict
+    );
 
 /******************************************************************************/
 // usocket module
diff --git a/extmod/modussl_axtls.c b/extmod/modussl_axtls.c
index 9d5934206749a..b2112aec59f34 100644
--- a/extmod/modussl_axtls.c
+++ b/extmod/modussl_axtls.c
@@ -314,16 +314,15 @@ STATIC const mp_stream_p_t ussl_socket_stream_p = {
     .ioctl = ussl_socket_ioctl,
 };
 
-STATIC const mp_obj_type_t ussl_socket_type = {
-    { &mp_type_type },
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    ussl_socket_type, MP_QSTR_ussl, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
     // Save on qstr's, reuse same as for module
-    .name = MP_QSTR_ussl,
-    .print = ussl_socket_print,
-    .getiter = NULL,
-    .iternext = NULL,
-    .protocol = &ussl_socket_stream_p,
-    .locals_dict = (void *)&ussl_socket_locals_dict,
-};
+    print, ussl_socket_print,
+    getiter, NULL,
+    iternext, NULL,
+    protocol, &ussl_socket_stream_p,
+    locals_dict, (void *)&ussl_socket_locals_dict
+    );
 
 STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     // TODO: Implement more args
diff --git a/extmod/modussl_mbedtls.c b/extmod/modussl_mbedtls.c
index 277af37c7cfd6..438c7d0a4612d 100644
--- a/extmod/modussl_mbedtls.c
+++ b/extmod/modussl_mbedtls.c
@@ -374,16 +374,15 @@ STATIC const mp_stream_p_t ussl_socket_stream_p = {
     .ioctl = socket_ioctl,
 };
 
-STATIC const mp_obj_type_t ussl_socket_type = {
-    { &mp_type_type },
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    ussl_socket_type, MP_QSTR_ussl, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
     // Save on qstr's, reuse same as for module
-    .name = MP_QSTR_ussl,
-    .print = socket_print,
-    .getiter = NULL,
-    .iternext = NULL,
-    .protocol = &ussl_socket_stream_p,
-    .locals_dict = (void *)&ussl_socket_locals_dict,
-};
+    print, socket_print,
+    getiter, NULL,
+    iternext, NULL,
+    protocol, &ussl_socket_stream_p,
+    locals_dict, (void *)&ussl_socket_locals_dict
+    );
 
 STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     // TODO: Implement more args
diff --git a/extmod/modutimeq.c b/extmod/modutimeq.c
index c7467f3bf14fc..bd8c3ce813763 100644
--- a/extmod/modutimeq.c
+++ b/extmod/modutimeq.c
@@ -210,13 +210,11 @@ STATIC const mp_rom_map_elem_t utimeq_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(utimeq_locals_dict, utimeq_locals_dict_table);
 
-STATIC const mp_obj_type_t utimeq_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_utimeq,
-    .make_new = utimeq_make_new,
-    .unary_op = utimeq_unary_op,
-    .locals_dict = (void *)&utimeq_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    utimeq_type, MP_QSTR_utimeq, MP_TYPE_FLAG_NONE, utimeq_make_new,
+    unary_op, utimeq_unary_op,
+    locals_dict, (void *)&utimeq_locals_dict
+    );
 
 STATIC const mp_rom_map_elem_t mp_module_utimeq_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_utimeq) },
diff --git a/extmod/moduwebsocket.c b/extmod/moduwebsocket.c
index 34b520f33706a..d8206b20840c0 100644
--- a/extmod/moduwebsocket.c
+++ b/extmod/moduwebsocket.c
@@ -291,13 +291,11 @@ STATIC const mp_stream_p_t websocket_stream_p = {
     .ioctl = websocket_ioctl,
 };
 
-STATIC const mp_obj_type_t websocket_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_websocket,
-    .make_new = websocket_make_new,
-    .protocol = &websocket_stream_p,
-    .locals_dict = (void *)&websocket_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    websocket_type, MP_QSTR_websocket, MP_TYPE_FLAG_NONE, websocket_make_new,
+    protocol, &websocket_stream_p,
+    locals_dict, (void *)&websocket_locals_dict
+    );
 
 STATIC const mp_rom_map_elem_t uwebsocket_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uwebsocket) },
diff --git a/extmod/moduzlib.c b/extmod/moduzlib.c
index a6874fb4e3e59..f6e351586eaac 100644
--- a/extmod/moduzlib.c
+++ b/extmod/moduzlib.c
@@ -141,13 +141,11 @@ STATIC const mp_stream_p_t decompio_stream_p = {
 };
 
 #if !MICROPY_ENABLE_DYNRUNTIME
-STATIC const mp_obj_type_t decompio_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_DecompIO,
-    .make_new = decompio_make_new,
-    .protocol = &decompio_stream_p,
-    .locals_dict = (void *)&decompio_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    decompio_type, MP_QSTR_DecompIO, MP_TYPE_FLAG_NONE, decompio_make_new,
+    protocol, &decompio_stream_p,
+    locals_dict, (void *)&decompio_locals_dict
+    );
 #endif
 
 STATIC mp_obj_t mod_uzlib_decompress(size_t n_args, const mp_obj_t *args) {
diff --git a/extmod/modwebrepl.c b/extmod/modwebrepl.c
index a8430bafb3c8e..a503116710a1c 100644
--- a/extmod/modwebrepl.c
+++ b/extmod/modwebrepl.c
@@ -343,13 +343,11 @@ STATIC const mp_stream_p_t webrepl_stream_p = {
     .ioctl = webrepl_ioctl,
 };
 
-STATIC const mp_obj_type_t webrepl_type = {
-    { &mp_type_type },
-    .name = MP_QSTR__webrepl,
-    .make_new = webrepl_make_new,
-    .protocol = &webrepl_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&webrepl_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    webrepl_type, MP_QSTR__webrepl, MP_TYPE_FLAG_NONE, webrepl_make_new,
+    protocol, &webrepl_stream_p,
+    locals_dict, (mp_obj_dict_t *)&webrepl_locals_dict
+    );
 
 STATIC const mp_rom_map_elem_t webrepl_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__webrepl) },
diff --git a/extmod/network_cyw43.c b/extmod/network_cyw43.c
index d2383c7187358..c8f391fd53a35 100644
--- a/extmod/network_cyw43.c
+++ b/extmod/network_cyw43.c
@@ -449,12 +449,10 @@ STATIC const mp_rom_map_elem_t network_cyw43_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(network_cyw43_locals_dict, network_cyw43_locals_dict_table);
 
-const mp_obj_type_t mp_network_cyw43_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_CYW43,
-    .print = network_cyw43_print,
-    .make_new = network_cyw43_make_new,
-    .locals_dict = (mp_obj_dict_t *)&network_cyw43_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_network_cyw43_type, MP_QSTR_CYW43, MP_TYPE_FLAG_NONE, network_cyw43_make_new,
+    print, network_cyw43_print,
+    locals_dict, (mp_obj_dict_t *)&network_cyw43_locals_dict
+    );
 
 #endif // MICROPY_PY_NETWORK_CYW43
diff --git a/extmod/vfs.c b/extmod/vfs.c
index 6dcdcfa22d3e6..8133aae3a27f6 100644
--- a/extmod/vfs.c
+++ b/extmod/vfs.c
@@ -130,8 +130,9 @@ mp_import_stat_t mp_vfs_import_stat(const char *path) {
     }
 
     // If the mounted object has the VFS protocol, call its import_stat helper
-    const mp_vfs_proto_t *proto = mp_obj_get_type(vfs->obj)->protocol;
-    if (proto != NULL) {
+    const mp_obj_type_t *type = mp_obj_get_type(vfs->obj);
+    if (MP_OBJ_TYPE_HAS_SLOT(type, protocol)) {
+        const mp_vfs_proto_t *proto = MP_OBJ_TYPE_GET_SLOT(type, protocol);
         return proto->import_stat(MP_OBJ_TO_PTR(vfs->obj), path_out);
     }
 
diff --git a/extmod/vfs_fat.c b/extmod/vfs_fat.c
index 41284500b4600..ea3e5d2118951 100644
--- a/extmod/vfs_fat.c
+++ b/extmod/vfs_fat.c
@@ -419,13 +419,10 @@ STATIC const mp_vfs_proto_t fat_vfs_proto = {
     .import_stat = fat_vfs_import_stat,
 };
 
-const mp_obj_type_t mp_fat_vfs_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_VfsFat,
-    .make_new = fat_vfs_make_new,
-    .protocol = &fat_vfs_proto,
-    .locals_dict = (mp_obj_dict_t *)&fat_vfs_locals_dict,
-
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_fat_vfs_type, MP_QSTR_VfsFat, MP_TYPE_FLAG_NONE, fat_vfs_make_new,
+    protocol, &fat_vfs_proto,
+    locals_dict, (mp_obj_dict_t *)&fat_vfs_locals_dict
+    );
 
 #endif // MICROPY_VFS_FAT
diff --git a/extmod/vfs_fat_file.c b/extmod/vfs_fat_file.c
index 537101d00f406..fea85de1677ee 100644
--- a/extmod/vfs_fat_file.c
+++ b/extmod/vfs_fat_file.c
@@ -243,16 +243,14 @@ STATIC const mp_stream_p_t vfs_fat_fileio_stream_p = {
     .ioctl = file_obj_ioctl,
 };
 
-const mp_obj_type_t mp_type_vfs_fat_fileio = {
-    { &mp_type_type },
-    .name = MP_QSTR_FileIO,
-    .print = file_obj_print,
-    .make_new = file_obj_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &vfs_fat_fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&vfs_fat_rawfile_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_vfs_fat_fileio, MP_QSTR_FileIO, MP_TYPE_FLAG_NONE, file_obj_make_new,
+    print, file_obj_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &vfs_fat_fileio_stream_p,
+    locals_dict, (mp_obj_dict_t *)&vfs_fat_rawfile_locals_dict
+    );
 #endif
 
 STATIC const mp_stream_p_t vfs_fat_textio_stream_p = {
@@ -262,16 +260,14 @@ STATIC const mp_stream_p_t vfs_fat_textio_stream_p = {
     .is_text = true,
 };
 
-const mp_obj_type_t mp_type_vfs_fat_textio = {
-    { &mp_type_type },
-    .name = MP_QSTR_TextIOWrapper,
-    .print = file_obj_print,
-    .make_new = file_obj_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &vfs_fat_textio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&vfs_fat_rawfile_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_vfs_fat_textio, MP_QSTR_TextIOWrapper, MP_TYPE_FLAG_NONE, file_obj_make_new,
+    print, file_obj_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &vfs_fat_textio_stream_p,
+    locals_dict, (mp_obj_dict_t *)&vfs_fat_rawfile_locals_dict
+    );
 
 // Factory function for I/O stream classes
 STATIC mp_obj_t fatfs_builtin_open_self(mp_obj_t self_in, mp_obj_t path, mp_obj_t mode) {
diff --git a/extmod/vfs_lfsx.c b/extmod/vfs_lfsx.c
index e1324f82c73fd..601c3bc298912 100644
--- a/extmod/vfs_lfsx.c
+++ b/extmod/vfs_lfsx.c
@@ -482,14 +482,14 @@ STATIC const mp_vfs_proto_t MP_VFS_LFSx(proto) = {
     .import_stat = MP_VFS_LFSx(import_stat),
 };
 
-const mp_obj_type_t MP_TYPE_VFS_LFSx = {
-    { &mp_type_type },
+MP_DEFINE_CONST_OBJ_TYPE(
+    MP_TYPE_VFS_LFSx,
     #if LFS_BUILD_VERSION == 1
-    .name = MP_QSTR_VfsLfs1,
+    MP_QSTR_VfsLfs1,
     #else
-    .name = MP_QSTR_VfsLfs2,
+    MP_QSTR_VfsLfs2,
     #endif
-    .make_new = MP_VFS_LFSx(make_new),
-    .protocol = &MP_VFS_LFSx(proto),
-    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(locals_dict),
-};
+    MP_TYPE_FLAG_NONE, MP_VFS_LFSx(make_new),
+    protocol, &MP_VFS_LFSx(proto),
+    locals_dict, (mp_obj_dict_t *)&MP_VFS_LFSx(locals_dict)
+    );
diff --git a/extmod/vfs_lfsx_file.c b/extmod/vfs_lfsx_file.c
index bc1a37b90bdb8..bbe541a52bcec 100644
--- a/extmod/vfs_lfsx_file.c
+++ b/extmod/vfs_lfsx_file.c
@@ -223,15 +223,14 @@ STATIC const mp_stream_p_t MP_VFS_LFSx(fileio_stream_p) = {
     .ioctl = MP_VFS_LFSx(file_ioctl),
 };
 
-const mp_obj_type_t MP_TYPE_VFS_LFSx_(_fileio) = {
-    { &mp_type_type },
-    .name = MP_QSTR_FileIO,
-    .print = MP_VFS_LFSx(file_print),
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &MP_VFS_LFSx(fileio_stream_p),
-    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict),
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    MP_TYPE_VFS_LFSx_(_fileio), MP_QSTR_FileIO, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, MP_VFS_LFSx(file_print),
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &MP_VFS_LFSx(fileio_stream_p),
+    locals_dict, (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict)
+    );
 #endif
 
 STATIC const mp_stream_p_t MP_VFS_LFSx(textio_stream_p) = {
@@ -241,12 +240,11 @@ STATIC const mp_stream_p_t MP_VFS_LFSx(textio_stream_p) = {
     .is_text = true,
 };
 
-const mp_obj_type_t MP_TYPE_VFS_LFSx_(_textio) = {
-    { &mp_type_type },
-    .name = MP_QSTR_TextIOWrapper,
-    .print = MP_VFS_LFSx(file_print),
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &MP_VFS_LFSx(textio_stream_p),
-    .locals_dict = (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict),
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    MP_TYPE_VFS_LFSx_(_textio), MP_QSTR_TextIOWrapper, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, MP_VFS_LFSx(file_print),
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &MP_VFS_LFSx(textio_stream_p),
+    locals_dict, (mp_obj_dict_t *)&MP_VFS_LFSx(file_locals_dict)
+    );
diff --git a/extmod/vfs_posix.c b/extmod/vfs_posix.c
index 5dcc9c03ec826..a951fbc080da1 100644
--- a/extmod/vfs_posix.c
+++ b/extmod/vfs_posix.c
@@ -383,12 +383,10 @@ STATIC const mp_vfs_proto_t vfs_posix_proto = {
     .import_stat = mp_vfs_posix_import_stat,
 };
 
-const mp_obj_type_t mp_type_vfs_posix = {
-    { &mp_type_type },
-    .name = MP_QSTR_VfsPosix,
-    .make_new = vfs_posix_make_new,
-    .protocol = &vfs_posix_proto,
-    .locals_dict = (mp_obj_dict_t *)&vfs_posix_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_vfs_posix, MP_QSTR_VfsPosix, MP_TYPE_FLAG_NONE, vfs_posix_make_new,
+    protocol, &vfs_posix_proto,
+    locals_dict, (mp_obj_dict_t *)&vfs_posix_locals_dict
+    );
 
 #endif // MICROPY_VFS_POSIX
diff --git a/extmod/vfs_posix_file.c b/extmod/vfs_posix_file.c
index 837c5489b0e14..cb65f1671ff95 100644
--- a/extmod/vfs_posix_file.c
+++ b/extmod/vfs_posix_file.c
@@ -264,16 +264,14 @@ STATIC const mp_stream_p_t vfs_posix_fileio_stream_p = {
     .ioctl = vfs_posix_file_ioctl,
 };
 
-const mp_obj_type_t mp_type_vfs_posix_fileio = {
-    { &mp_type_type },
-    .name = MP_QSTR_FileIO,
-    .print = vfs_posix_file_print,
-    .make_new = vfs_posix_file_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &vfs_posix_fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&vfs_posix_rawfile_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_vfs_posix_fileio, MP_QSTR_FileIO, MP_TYPE_FLAG_NONE, vfs_posix_file_make_new,
+    print, vfs_posix_file_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &vfs_posix_fileio_stream_p,
+    locals_dict, (mp_obj_dict_t *)&vfs_posix_rawfile_locals_dict
+    );
 #endif
 
 STATIC const mp_stream_p_t vfs_posix_textio_stream_p = {
@@ -283,16 +281,14 @@ STATIC const mp_stream_p_t vfs_posix_textio_stream_p = {
     .is_text = true,
 };
 
-const mp_obj_type_t mp_type_vfs_posix_textio = {
-    { &mp_type_type },
-    .name = MP_QSTR_TextIOWrapper,
-    .print = vfs_posix_file_print,
-    .make_new = vfs_posix_file_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &vfs_posix_textio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&vfs_posix_rawfile_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_vfs_posix_textio, MP_QSTR_TextIOWrapper, MP_TYPE_FLAG_NONE, vfs_posix_file_make_new,
+    print, vfs_posix_file_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &vfs_posix_textio_stream_p,
+    locals_dict, (mp_obj_dict_t *)&vfs_posix_rawfile_locals_dict
+    );
 
 const mp_obj_vfs_posix_file_t mp_sys_stdin_obj = {{&mp_type_textio}, STDIN_FILENO};
 const mp_obj_vfs_posix_file_t mp_sys_stdout_obj = {{&mp_type_textio}, STDOUT_FILENO};
diff --git a/extmod/virtpin.c b/extmod/virtpin.c
index 71a11232d4339..cd0b9f92f830e 100644
--- a/extmod/virtpin.c
+++ b/extmod/virtpin.c
@@ -28,12 +28,12 @@
 
 int mp_virtual_pin_read(mp_obj_t pin) {
     mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(pin);
-    mp_pin_p_t *pin_p = (mp_pin_p_t *)s->type->protocol;
+    mp_pin_p_t *pin_p = (mp_pin_p_t *)MP_OBJ_TYPE_GET_SLOT(s->type, protocol);
     return pin_p->ioctl(pin, MP_PIN_READ, 0, NULL);
 }
 
 void mp_virtual_pin_write(mp_obj_t pin, int value) {
     mp_obj_base_t *s = (mp_obj_base_t *)MP_OBJ_TO_PTR(pin);
-    mp_pin_p_t *pin_p = (mp_pin_p_t *)s->type->protocol;
+    mp_pin_p_t *pin_p = (mp_pin_p_t *)MP_OBJ_TYPE_GET_SLOT(s->type, protocol);
     pin_p->ioctl(pin, MP_PIN_WRITE, value, NULL);
 }
diff --git a/mpy-cross/Makefile b/mpy-cross/Makefile
index 2189dff9058ea..a3271729ff985 100644
--- a/mpy-cross/Makefile
+++ b/mpy-cross/Makefile
@@ -18,7 +18,7 @@ INC += -I$(TOP)
 
 # compiler settings
 CWARN = -Wall -Werror
-CWARN += -Wextra -Wno-unused-parameter -Wpointer-arith
+CWARN += -Wextra -Wno-unused-parameter -Wpointer-arith -Wno-missing-field-initializers
 CFLAGS = $(INC) $(CWARN) -std=gnu99 $(CFLAGS_MOD) $(COPT) $(CFLAGS_EXTRA)
 CFLAGS += -fdata-sections -ffunction-sections -fno-asynchronous-unwind-tables
 
diff --git a/ports/cc3200/misc/mpirq.c b/ports/cc3200/misc/mpirq.c
index a4144def5a724..bf7cf6195afbb 100644
--- a/ports/cc3200/misc/mpirq.c
+++ b/ports/cc3200/misc/mpirq.c
@@ -191,10 +191,9 @@ STATIC const mp_rom_map_elem_t mp_irq_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(mp_irq_locals_dict, mp_irq_locals_dict_table);
 
-const mp_obj_type_t mp_irq_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_irq,
-    .call = mp_irq_call,
-    .locals_dict = (mp_obj_t)&mp_irq_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_irq_type, MP_QSTR_irq, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    call, mp_irq_call,
+    locals_dict, (mp_obj_t)&mp_irq_locals_dict
+    );
 
diff --git a/ports/cc3200/mods/modnetwork.c b/ports/cc3200/mods/modnetwork.c
index e8a70e0a84dad..a4fd6d6f08b84 100644
--- a/ports/cc3200/mods/modnetwork.c
+++ b/ports/cc3200/mods/modnetwork.c
@@ -169,10 +169,8 @@ STATIC const mp_rom_map_elem_t network_server_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(network_server_locals_dict, network_server_locals_dict_table);
 
-STATIC const mp_obj_type_t network_server_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Server,
-    .make_new = network_server_make_new,
-    .locals_dict = (mp_obj_t)&network_server_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    network_server_type, MP_QSTR_Server, MP_TYPE_FLAG_NONE, network_server_make_new,
+    locals_dict, (mp_obj_t)&network_server_locals_dict
+    );
 #endif
diff --git a/ports/cc3200/mods/modnetwork.h b/ports/cc3200/mods/modnetwork.h
index 6ec90a2bac189..f41e11add135c 100644
--- a/ports/cc3200/mods/modnetwork.h
+++ b/ports/cc3200/mods/modnetwork.h
@@ -36,7 +36,11 @@
  DEFINE TYPES
  ******************************************************************************/
 typedef struct _mod_network_nic_type_t {
-    mp_obj_type_t base;
+    union {
+        mp_obj_type_t base;
+        // Ensure that this struct is big enough to hold any type size.
+        mp_obj_full_type_t _alloc;
+    };
 } mod_network_nic_type_t;
 
 typedef struct _mod_network_socket_base_t {
diff --git a/ports/cc3200/mods/moduhashlib.c b/ports/cc3200/mods/moduhashlib.c
index fc11569b7f988..6c05c7b4e6797 100644
--- a/ports/cc3200/mods/moduhashlib.c
+++ b/ports/cc3200/mods/moduhashlib.c
@@ -177,19 +177,15 @@ STATIC MP_DEFINE_CONST_DICT(hash_locals_dict, hash_locals_dict_table);
 //    .locals_dict = (mp_obj_t)&hash_locals_dict,
 //};
 
-STATIC const mp_obj_type_t sha1_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_sha1,
-    .make_new = hash_make_new,
-    .locals_dict = (mp_obj_t)&hash_locals_dict,
-};
-
-STATIC const mp_obj_type_t sha256_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_sha256,
-    .make_new = hash_make_new,
-    .locals_dict = (mp_obj_t)&hash_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    sha1_type, MP_QSTR_sha1, MP_TYPE_FLAG_NONE, hash_make_new,
+    locals_dict, (mp_obj_t)&hash_locals_dict
+    );
+
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    sha256_type, MP_QSTR_sha256, MP_TYPE_FLAG_NONE, hash_make_new,
+    locals_dict, (mp_obj_t)&hash_locals_dict
+    );
 
 STATIC const mp_rom_map_elem_t mp_module_hashlib_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__),    MP_ROM_QSTR(MP_QSTR_uhashlib) },
diff --git a/ports/cc3200/mods/modusocket.c b/ports/cc3200/mods/modusocket.c
index 99b78c88372d3..2f24e4167c00a 100644
--- a/ports/cc3200/mods/modusocket.c
+++ b/ports/cc3200/mods/modusocket.c
@@ -759,13 +759,11 @@ const mp_stream_p_t socket_stream_p = {
     .is_text = false,
 };
 
-STATIC const mp_obj_type_t socket_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_socket,
-    .make_new = socket_make_new,
-    .protocol = &socket_stream_p,
-    .locals_dict = (mp_obj_t)&socket_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    socket_type, MP_QSTR_socket, MP_TYPE_FLAG_NONE, socket_make_new,
+    protocol, &socket_stream_p,
+    locals_dict, (mp_obj_t)&socket_locals_dict
+    );
 
 /******************************************************************************/
 // usocket module
diff --git a/ports/cc3200/mods/modussl.c b/ports/cc3200/mods/modussl.c
index 09a1a3185700c..bf0d02774ea43 100644
--- a/ports/cc3200/mods/modussl.c
+++ b/ports/cc3200/mods/modussl.c
@@ -60,14 +60,13 @@ STATIC const mp_obj_type_t ssl_socket_type;
 
 // ssl sockets inherit from normal socket, so we take its
 // locals and stream methods
-STATIC const mp_obj_type_t ssl_socket_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ussl,
-    .getiter = NULL,
-    .iternext = NULL,
-    .protocol = &socket_stream_p,
-    .locals_dict = (mp_obj_t)&socket_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    ssl_socket_type, MP_QSTR_ussl, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    getiter, NULL,
+    iternext, NULL,
+    protocol, &socket_stream_p,
+    locals_dict, (mp_obj_t)&socket_locals_dict
+    );
 
 STATIC mp_obj_t mod_ssl_wrap_socket(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
     STATIC const mp_arg_t allowed_args[] = {
diff --git a/ports/cc3200/mods/modwlan.c b/ports/cc3200/mods/modwlan.c
index 920079b589ae6..fe84c7ad94c87 100644
--- a/ports/cc3200/mods/modwlan.c
+++ b/ports/cc3200/mods/modwlan.c
@@ -1285,13 +1285,13 @@ STATIC const mp_rom_map_elem_t wlan_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(wlan_locals_dict, wlan_locals_dict_table);
 
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mod_network_nic_type_wlan_base, MP_QSTR_WLAN, MP_TYPE_FLAG_NONE, wlan_make_new,
+    locals_dict, (mp_obj_t)&wlan_locals_dict
+    );
+
 const mod_network_nic_type_t mod_network_nic_type_wlan = {
-    .base = {
-        { &mp_type_type },
-        .name = MP_QSTR_WLAN,
-        .make_new = wlan_make_new,
-        .locals_dict = (mp_obj_t)&wlan_locals_dict,
-    },
+    .base = mod_network_nic_type_wlan_base,
 };
 
 STATIC const mp_irq_methods_t wlan_irq_methods = {
diff --git a/ports/cc3200/mods/pybadc.c b/ports/cc3200/mods/pybadc.c
index fbdd393cd2ecc..e96e228275bfd 100644
--- a/ports/cc3200/mods/pybadc.c
+++ b/ports/cc3200/mods/pybadc.c
@@ -233,13 +233,11 @@ STATIC const mp_rom_map_elem_t adc_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(adc_locals_dict, adc_locals_dict_table);
 
-const mp_obj_type_t pyb_adc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADC,
-    .print = adc_print,
-    .make_new = adc_make_new,
-    .locals_dict = (mp_obj_t)&adc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_adc_type, MP_QSTR_ADC, MP_TYPE_FLAG_NONE, adc_make_new,
+    print, adc_print,
+    locals_dict, (mp_obj_t)&adc_locals_dict
+    );
 
 STATIC void adc_channel_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     pyb_adc_channel_obj_t *self = self_in;
@@ -300,10 +298,9 @@ STATIC const mp_rom_map_elem_t adc_channel_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(adc_channel_locals_dict, adc_channel_locals_dict_table);
 
-STATIC const mp_obj_type_t pyb_adc_channel_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADCChannel,
-    .print = adc_channel_print,
-    .call = adc_channel_call,
-    .locals_dict = (mp_obj_t)&adc_channel_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_adc_channel_type, MP_QSTR_ADCChannel, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, adc_channel_print,
+    call, adc_channel_call,
+    locals_dict, (mp_obj_t)&adc_channel_locals_dict
+    );
diff --git a/ports/cc3200/mods/pybflash.c b/ports/cc3200/mods/pybflash.c
index 9d534608becce..2c91b9d89c386 100644
--- a/ports/cc3200/mods/pybflash.c
+++ b/ports/cc3200/mods/pybflash.c
@@ -84,12 +84,10 @@ STATIC const mp_rom_map_elem_t pyb_flash_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_flash_locals_dict, pyb_flash_locals_dict_table);
 
-const mp_obj_type_t pyb_flash_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Flash,
-    .make_new = pyb_flash_make_new,
-    .locals_dict = (mp_obj_t)&pyb_flash_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_flash_type, MP_QSTR_Flash, MP_TYPE_FLAG_NONE, pyb_flash_make_new,
+    locals_dict, (mp_obj_t)&pyb_flash_locals_dict
+    );
 
 void pyb_flash_init_vfs(fs_user_mount_t *vfs) {
     vfs->base.type = &mp_fat_vfs_type;
diff --git a/ports/cc3200/mods/pybi2c.c b/ports/cc3200/mods/pybi2c.c
index 5310176091a96..faf4ee4d4ff25 100644
--- a/ports/cc3200/mods/pybi2c.c
+++ b/ports/cc3200/mods/pybi2c.c
@@ -521,10 +521,8 @@ STATIC const mp_rom_map_elem_t pyb_i2c_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_i2c_locals_dict, pyb_i2c_locals_dict_table);
 
-const mp_obj_type_t pyb_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2C,
-    .print = pyb_i2c_print,
-    .make_new = pyb_i2c_make_new,
-    .locals_dict = (mp_obj_t)&pyb_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_i2c_type, MP_QSTR_I2C, MP_TYPE_FLAG_NONE, pyb_i2c_make_new,
+    print, pyb_i2c_print,
+    locals_dict, (mp_obj_t)&pyb_i2c_locals_dict
+    );
diff --git a/ports/cc3200/mods/pybpin.c b/ports/cc3200/mods/pybpin.c
index fd2f032e8d7ce..0b8bbefbbaa4e 100644
--- a/ports/cc3200/mods/pybpin.c
+++ b/ports/cc3200/mods/pybpin.c
@@ -931,14 +931,12 @@ STATIC const mp_rom_map_elem_t pin_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pin_locals_dict, pin_locals_dict_table);
 
-const mp_obj_type_t pin_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Pin,
-    .print = pin_print,
-    .make_new = pin_make_new,
-    .call = pin_call,
-    .locals_dict = (mp_obj_t)&pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, pin_make_new,
+    print, pin_print,
+    call, pin_call,
+    locals_dict, (mp_obj_t)&pin_locals_dict
+    );
 
 STATIC const mp_irq_methods_t pin_irq_methods = {
     .init = pin_irq,
@@ -952,10 +950,9 @@ STATIC void pin_named_pins_obj_print(const mp_print_t *print, mp_obj_t self_in,
     mp_printf(print, "<Pin.%q>", self->name);
 }
 
-const mp_obj_type_t pin_board_pins_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_board,
-    .print = pin_named_pins_obj_print,
-    .locals_dict = (mp_obj_t)&pin_board_pins_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_board_pins_obj_type, MP_QSTR_board, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, pin_named_pins_obj_print,
+    locals_dict, (mp_obj_t)&pin_board_pins_locals_dict
+    );
 
diff --git a/ports/cc3200/mods/pybrtc.c b/ports/cc3200/mods/pybrtc.c
index 6c1918831c8c2..10c372a474db8 100644
--- a/ports/cc3200/mods/pybrtc.c
+++ b/ports/cc3200/mods/pybrtc.c
@@ -469,12 +469,10 @@ STATIC const mp_rom_map_elem_t pyb_rtc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_rtc_locals_dict, pyb_rtc_locals_dict_table);
 
-const mp_obj_type_t pyb_rtc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_RTC,
-    .make_new = pyb_rtc_make_new,
-    .locals_dict = (mp_obj_t)&pyb_rtc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_rtc_type, MP_QSTR_RTC, MP_TYPE_FLAG_NONE, pyb_rtc_make_new,
+    locals_dict, (mp_obj_t)&pyb_rtc_locals_dict
+    );
 
 STATIC const mp_irq_methods_t pyb_rtc_irq_methods = {
     .init = pyb_rtc_irq,
diff --git a/ports/cc3200/mods/pybsd.c b/ports/cc3200/mods/pybsd.c
index 817127634d898..e276e988ff0b6 100644
--- a/ports/cc3200/mods/pybsd.c
+++ b/ports/cc3200/mods/pybsd.c
@@ -212,9 +212,7 @@ STATIC const mp_rom_map_elem_t pyb_sd_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_sd_locals_dict, pyb_sd_locals_dict_table);
 
-const mp_obj_type_t pyb_sd_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SD,
-    .make_new = pyb_sd_make_new,
-    .locals_dict = (mp_obj_t)&pyb_sd_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_sd_type, MP_QSTR_SD, MP_TYPE_FLAG_NONE, pyb_sd_make_new,
+    locals_dict, (mp_obj_t)&pyb_sd_locals_dict
+    );
diff --git a/ports/cc3200/mods/pybsleep.c b/ports/cc3200/mods/pybsleep.c
index da2eeff80fa24..ff2951cd33b56 100644
--- a/ports/cc3200/mods/pybsleep.c
+++ b/ports/cc3200/mods/pybsleep.c
@@ -125,10 +125,9 @@ STATIC pybsleep_data_t   pybsleep_data = {NULL, NULL, NULL};
 volatile arm_cm4_core_regs_t vault_arm_registers;
 STATIC pybsleep_reset_cause_t pybsleep_reset_cause = PYB_SLP_PWRON_RESET;
 STATIC pybsleep_wake_reason_t pybsleep_wake_reason = PYB_SLP_WAKED_PWRON;
-STATIC const mp_obj_type_t pyb_sleep_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_sleep,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_sleep_type, MP_QSTR_sleep, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW
+    );
 
 /******************************************************************************
  DECLARE PRIVATE FUNCTIONS
diff --git a/ports/cc3200/mods/pybspi.c b/ports/cc3200/mods/pybspi.c
index 61b1a6bd11eeb..1d0bf8d3d693e 100644
--- a/ports/cc3200/mods/pybspi.c
+++ b/ports/cc3200/mods/pybspi.c
@@ -377,10 +377,8 @@ STATIC const mp_rom_map_elem_t pyb_spi_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_spi_locals_dict, pyb_spi_locals_dict_table);
 
-const mp_obj_type_t pyb_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SPI,
-    .print = pyb_spi_print,
-    .make_new = pyb_spi_make_new,
-    .locals_dict = (mp_obj_t)&pyb_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_spi_type, MP_QSTR_SPI, MP_TYPE_FLAG_NONE, pyb_spi_make_new,
+    print, pyb_spi_print,
+    locals_dict, (mp_obj_t)&pyb_spi_locals_dict
+    );
diff --git a/ports/cc3200/mods/pybtimer.c b/ports/cc3200/mods/pybtimer.c
index b5cf594d74e82..24dd7e9fea9af 100644
--- a/ports/cc3200/mods/pybtimer.c
+++ b/ports/cc3200/mods/pybtimer.c
@@ -460,13 +460,11 @@ STATIC const mp_rom_map_elem_t pyb_timer_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_timer_locals_dict, pyb_timer_locals_dict_table);
 
-const mp_obj_type_t pyb_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = pyb_timer_print,
-    .make_new = pyb_timer_make_new,
-    .locals_dict = (mp_obj_t)&pyb_timer_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, pyb_timer_make_new,
+    print, pyb_timer_print,
+    locals_dict, (mp_obj_t)&pyb_timer_locals_dict
+    );
 
 STATIC const mp_irq_methods_t pyb_timer_channel_irq_methods = {
     .init = pyb_timer_channel_irq,
@@ -722,10 +720,9 @@ STATIC const mp_rom_map_elem_t pyb_timer_channel_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_timer_channel_locals_dict, pyb_timer_channel_locals_dict_table);
 
-STATIC const mp_obj_type_t pyb_timer_channel_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_TimerChannel,
-    .print = pyb_timer_channel_print,
-    .locals_dict = (mp_obj_t)&pyb_timer_channel_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_timer_channel_type, MP_QSTR_TimerChannel, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, pyb_timer_channel_print,
+    locals_dict, (mp_obj_t)&pyb_timer_channel_locals_dict
+    );
 
diff --git a/ports/cc3200/mods/pybuart.c b/ports/cc3200/mods/pybuart.c
index b8e8cbb682fab..26a76ea10ab58 100644
--- a/ports/cc3200/mods/pybuart.c
+++ b/ports/cc3200/mods/pybuart.c
@@ -656,13 +656,11 @@ STATIC const mp_irq_methods_t uart_irq_methods = {
     .flags = uart_irq_flags
 };
 
-const mp_obj_type_t pyb_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = pyb_uart_print,
-    .make_new = pyb_uart_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_t)&pyb_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, pyb_uart_make_new,
+    print, pyb_uart_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &uart_stream_p,
+    locals_dict, (mp_obj_t)&pyb_uart_locals_dict
+    );
diff --git a/ports/cc3200/mods/pybwdt.c b/ports/cc3200/mods/pybwdt.c
index 8db096d6b5fcb..7a15bad244617 100644
--- a/ports/cc3200/mods/pybwdt.c
+++ b/ports/cc3200/mods/pybwdt.c
@@ -150,10 +150,8 @@ STATIC const mp_rom_map_elem_t pybwdt_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pybwdt_locals_dict, pybwdt_locals_dict_table);
 
-const mp_obj_type_t pyb_wdt_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_WDT,
-    .make_new = pyb_wdt_make_new,
-    .locals_dict = (mp_obj_t)&pybwdt_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_wdt_type, MP_QSTR_WDT, MP_TYPE_FLAG_NONE, pyb_wdt_make_new,
+    locals_dict, (mp_obj_t)&pybwdt_locals_dict
+    );
 
diff --git a/ports/esp32/esp32_nvs.c b/ports/esp32/esp32_nvs.c
index d13151d3ce774..36548c4f70751 100644
--- a/ports/esp32/esp32_nvs.c
+++ b/ports/esp32/esp32_nvs.c
@@ -142,10 +142,8 @@ STATIC const mp_rom_map_elem_t esp32_nvs_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(esp32_nvs_locals_dict, esp32_nvs_locals_dict_table);
 
-const mp_obj_type_t esp32_nvs_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_NVS,
-    .print = esp32_nvs_print,
-    .make_new = esp32_nvs_make_new,
-    .locals_dict = (mp_obj_dict_t *)&esp32_nvs_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    esp32_nvs_type, MP_QSTR_NVS, MP_TYPE_FLAG_NONE, esp32_nvs_make_new,
+    print, esp32_nvs_print,
+    locals_dict, (mp_obj_dict_t *)&esp32_nvs_locals_dict
+    );
diff --git a/ports/esp32/esp32_partition.c b/ports/esp32/esp32_partition.c
index b779cb18c6129..910366cb22c00 100644
--- a/ports/esp32/esp32_partition.c
+++ b/ports/esp32/esp32_partition.c
@@ -285,10 +285,8 @@ STATIC const mp_rom_map_elem_t esp32_partition_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(esp32_partition_locals_dict, esp32_partition_locals_dict_table);
 
-const mp_obj_type_t esp32_partition_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Partition,
-    .print = esp32_partition_print,
-    .make_new = esp32_partition_make_new,
-    .locals_dict = (mp_obj_dict_t *)&esp32_partition_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    esp32_partition_type, MP_QSTR_Partition, MP_TYPE_FLAG_NONE, esp32_partition_make_new,
+    print, esp32_partition_print,
+    locals_dict, (mp_obj_dict_t *)&esp32_partition_locals_dict
+    );
diff --git a/ports/esp32/esp32_rmt.c b/ports/esp32/esp32_rmt.c
index ac897e33368a3..3b72dfe2ed5b2 100644
--- a/ports/esp32/esp32_rmt.c
+++ b/ports/esp32/esp32_rmt.c
@@ -372,10 +372,8 @@ STATIC const mp_rom_map_elem_t esp32_rmt_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(esp32_rmt_locals_dict, esp32_rmt_locals_dict_table);
 
-const mp_obj_type_t esp32_rmt_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_RMT,
-    .print = esp32_rmt_print,
-    .make_new = esp32_rmt_make_new,
-    .locals_dict = (mp_obj_dict_t *)&esp32_rmt_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    esp32_rmt_type, MP_QSTR_RMT, MP_TYPE_FLAG_NONE, esp32_rmt_make_new,
+    print, esp32_rmt_print,
+    locals_dict, (mp_obj_dict_t *)&esp32_rmt_locals_dict
+    );
diff --git a/ports/esp32/esp32_ulp.c b/ports/esp32/esp32_ulp.c
index 8e4ce9c5a41b9..afe2ea7e41cea 100644
--- a/ports/esp32/esp32_ulp.c
+++ b/ports/esp32/esp32_ulp.c
@@ -91,11 +91,9 @@ STATIC const mp_rom_map_elem_t esp32_ulp_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(esp32_ulp_locals_dict, esp32_ulp_locals_dict_table);
 
-const mp_obj_type_t esp32_ulp_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ULP,
-    .make_new = esp32_ulp_make_new,
-    .locals_dict = (mp_obj_t)&esp32_ulp_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    esp32_ulp_type, MP_QSTR_ULP, MP_TYPE_FLAG_NONE, esp32_ulp_make_new,
+    locals_dict, (mp_obj_t)&esp32_ulp_locals_dict
+    );
 
 #endif // CONFIG_IDF_TARGET_ESP32
diff --git a/ports/esp32/machine_adc.c b/ports/esp32/machine_adc.c
index cb45aab33910c..c4d0df47588cf 100644
--- a/ports/esp32/machine_adc.c
+++ b/ports/esp32/machine_adc.c
@@ -256,10 +256,8 @@ STATIC const mp_rom_map_elem_t madc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(madc_locals_dict, madc_locals_dict_table);
 
-const mp_obj_type_t machine_adc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADC,
-    .print = madc_print,
-    .make_new = madc_make_new,
-    .locals_dict = (mp_obj_t)&madc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_adc_type, MP_QSTR_ADC, MP_TYPE_FLAG_NONE, madc_make_new,
+    print, madc_print,
+    locals_dict, (mp_obj_t)&madc_locals_dict
+    );
diff --git a/ports/esp32/machine_adcblock.c b/ports/esp32/machine_adcblock.c
index 06c215f8ae73d..2b6003448a6e2 100644
--- a/ports/esp32/machine_adcblock.c
+++ b/ports/esp32/machine_adcblock.c
@@ -194,10 +194,8 @@ STATIC const mp_rom_map_elem_t madcblock_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(madcblock_locals_dict, madcblock_locals_dict_table);
 
-const mp_obj_type_t machine_adcblock_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADCBlock,
-    .print = madcblock_print,
-    .make_new = madcblock_make_new,
-    .locals_dict = (mp_obj_t)&madcblock_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_adcblock_type, MP_QSTR_ADCBlock, MP_TYPE_FLAG_NONE, madcblock_make_new,
+    print, madcblock_print,
+    locals_dict, (mp_obj_dict_t *)&madcblock_locals_dict
+    );
diff --git a/ports/esp32/machine_dac.c b/ports/esp32/machine_dac.c
index 35826d4a99a8b..9c9c492e28f02 100644
--- a/ports/esp32/machine_dac.c
+++ b/ports/esp32/machine_dac.c
@@ -104,12 +104,10 @@ STATIC const mp_rom_map_elem_t mdac_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(mdac_locals_dict, mdac_locals_dict_table);
 
-const mp_obj_type_t machine_dac_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_DAC,
-    .print = mdac_print,
-    .make_new = mdac_make_new,
-    .locals_dict = (mp_obj_t)&mdac_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_dac_type, MP_QSTR_DAC, MP_TYPE_FLAG_NONE, mdac_make_new,
+    print, mdac_print,
+    locals_dict, (mp_obj_t)&mdac_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_DAC
diff --git a/ports/esp32/machine_hw_spi.c b/ports/esp32/machine_hw_spi.c
index 3e720adb1a5e2..2508d4365d8d7 100644
--- a/ports/esp32/machine_hw_spi.c
+++ b/ports/esp32/machine_hw_spi.c
@@ -545,11 +545,9 @@ STATIC const mp_machine_spi_p_t machine_hw_spi_p = {
     .transfer = machine_hw_spi_transfer,
 };
 
-const mp_obj_type_t machine_hw_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SPI,
-    .print = machine_hw_spi_print,
-    .make_new = machine_hw_spi_make_new,
-    .protocol = &machine_hw_spi_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hw_spi_type, MP_QSTR_SPI, MP_TYPE_FLAG_NONE, machine_hw_spi_make_new,
+    print, machine_hw_spi_print,
+    protocol, &machine_hw_spi_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_spi_locals_dict
+    );
diff --git a/ports/esp32/machine_i2c.c b/ports/esp32/machine_i2c.c
index d9003f45b5bed..d2e2fca8db76f 100644
--- a/ports/esp32/machine_i2c.c
+++ b/ports/esp32/machine_i2c.c
@@ -181,11 +181,9 @@ STATIC const mp_machine_i2c_p_t machine_hw_i2c_p = {
     .transfer = machine_hw_i2c_transfer,
 };
 
-const mp_obj_type_t machine_hw_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2C,
-    .print = machine_hw_i2c_print,
-    .make_new = machine_hw_i2c_make_new,
-    .protocol = &machine_hw_i2c_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hw_i2c_type, MP_QSTR_I2C, MP_TYPE_FLAG_NONE, machine_hw_i2c_make_new,
+    print, machine_hw_i2c_print,
+    protocol, &machine_hw_i2c_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_i2c_locals_dict
+    );
diff --git a/ports/esp32/machine_i2s.c b/ports/esp32/machine_i2s.c
index 108caf677b0eb..ff7700e45747f 100644
--- a/ports/esp32/machine_i2s.c
+++ b/ports/esp32/machine_i2s.c
@@ -830,15 +830,13 @@ STATIC const mp_stream_p_t i2s_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_i2s_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2S,
-    .print = machine_i2s_print,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &i2s_stream_p,
-    .make_new = machine_i2s_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_i2s_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_i2s_type, MP_QSTR_I2S, MP_TYPE_FLAG_NONE, machine_i2s_make_new,
+    print, machine_i2s_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &i2s_stream_p,
+    locals_dict, (mp_obj_dict_t *)&machine_i2s_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_I2S
diff --git a/ports/esp32/machine_pin.c b/ports/esp32/machine_pin.c
index edfa4d5cae183..c9f4b6821978e 100644
--- a/ports/esp32/machine_pin.c
+++ b/ports/esp32/machine_pin.c
@@ -529,15 +529,13 @@ STATIC const mp_pin_p_t pin_pin_p = {
     .ioctl = pin_ioctl,
 };
 
-const mp_obj_type_t machine_pin_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Pin,
-    .print = machine_pin_print,
-    .make_new = mp_pin_make_new,
-    .call = machine_pin_call,
-    .protocol = &pin_pin_p,
-    .locals_dict = (mp_obj_t)&machine_pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, mp_pin_make_new,
+    print, machine_pin_print,
+    call, machine_pin_call,
+    protocol, &pin_pin_p,
+    locals_dict, (mp_obj_t)&machine_pin_locals_dict
+    );
 
 /******************************************************************************/
 // Pin IRQ object
@@ -723,9 +721,8 @@ STATIC const mp_rom_map_elem_t machine_pin_irq_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_pin_irq_locals_dict, machine_pin_irq_locals_dict_table);
 
-STATIC const mp_obj_type_t machine_pin_irq_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_IRQ,
-    .call = machine_pin_irq_call,
-    .locals_dict = (mp_obj_dict_t *)&machine_pin_irq_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_irq_type, MP_QSTR_IRQ, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    call, machine_pin_irq_call,
+    locals_dict, (mp_obj_dict_t *)&machine_pin_irq_locals_dict
+    );
diff --git a/ports/esp32/machine_rtc.c b/ports/esp32/machine_rtc.c
index 72d7b5c8280aa..dd386af30c55d 100644
--- a/ports/esp32/machine_rtc.c
+++ b/ports/esp32/machine_rtc.c
@@ -173,9 +173,7 @@ STATIC const mp_rom_map_elem_t machine_rtc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_rtc_locals_dict, machine_rtc_locals_dict_table);
 
-const mp_obj_type_t machine_rtc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_RTC,
-    .make_new = machine_rtc_make_new,
-    .locals_dict = (mp_obj_t)&machine_rtc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_rtc_type, MP_QSTR_RTC, MP_TYPE_FLAG_NONE, machine_rtc_make_new,
+    locals_dict, (mp_obj_t)&machine_rtc_locals_dict
+    );
diff --git a/ports/esp32/machine_sdcard.c b/ports/esp32/machine_sdcard.c
index 82c2e6cd4e320..3414644feca65 100644
--- a/ports/esp32/machine_sdcard.c
+++ b/ports/esp32/machine_sdcard.c
@@ -395,11 +395,9 @@ STATIC const mp_rom_map_elem_t machine_sdcard_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(machine_sdcard_locals_dict, machine_sdcard_locals_dict_table);
 
-const mp_obj_type_t machine_sdcard_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SDCard,
-    .make_new = machine_sdcard_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_sdcard_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_sdcard_type, MP_QSTR_SDCard, MP_TYPE_FLAG_NONE, machine_sdcard_make_new,
+    locals_dict, (mp_obj_dict_t *)&machine_sdcard_locals_dict
+    );
 
 #endif // MICROPY_HW_ENABLE_SDCARD
diff --git a/ports/esp32/machine_timer.c b/ports/esp32/machine_timer.c
index ea8b5965d873a..2284c8cc247e6 100644
--- a/ports/esp32/machine_timer.c
+++ b/ports/esp32/machine_timer.c
@@ -266,10 +266,8 @@ STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
 
-const mp_obj_type_t machine_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = machine_timer_print,
-    .make_new = machine_timer_make_new,
-    .locals_dict = (mp_obj_t)&machine_timer_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, machine_timer_make_new,
+    print, machine_timer_print,
+    locals_dict, (mp_obj_t)&machine_timer_locals_dict
+    );
diff --git a/ports/esp32/machine_touchpad.c b/ports/esp32/machine_touchpad.c
index 168ac16d0eef6..fa6b746427514 100644
--- a/ports/esp32/machine_touchpad.c
+++ b/ports/esp32/machine_touchpad.c
@@ -134,11 +134,9 @@ STATIC const mp_rom_map_elem_t mtp_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(mtp_locals_dict, mtp_locals_dict_table);
 
-const mp_obj_type_t machine_touchpad_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_TouchPad,
-    .make_new = mtp_make_new,
-    .locals_dict = (mp_obj_t)&mtp_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_touchpad_type, MP_QSTR_TouchPad, MP_TYPE_FLAG_NONE, mtp_make_new,
+    locals_dict, (mp_obj_t)&mtp_locals_dict
+    );
 
 #endif // CONFIG_IDF_TARGET_ESP32
diff --git a/ports/esp32/machine_uart.c b/ports/esp32/machine_uart.c
index 396455666f621..030751fbddc82 100644
--- a/ports/esp32/machine_uart.c
+++ b/ports/esp32/machine_uart.c
@@ -509,13 +509,11 @@ STATIC const mp_stream_p_t uart_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = machine_uart_print,
-    .make_new = machine_uart_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&machine_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, machine_uart_make_new,
+    print, machine_uart_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &uart_stream_p,
+    locals_dict, (mp_obj_dict_t *)&machine_uart_locals_dict
+    );
diff --git a/ports/esp32/machine_wdt.c b/ports/esp32/machine_wdt.c
index f0ec6928e05df..6f0c9b65e649f 100644
--- a/ports/esp32/machine_wdt.c
+++ b/ports/esp32/machine_wdt.c
@@ -83,9 +83,7 @@ STATIC const mp_rom_map_elem_t machine_wdt_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_wdt_locals_dict, machine_wdt_locals_dict_table);
 
-const mp_obj_type_t machine_wdt_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_WDT,
-    .make_new = machine_wdt_make_new,
-    .locals_dict = (mp_obj_t)&machine_wdt_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_wdt_type, MP_QSTR_WDT, MP_TYPE_FLAG_NONE, machine_wdt_make_new,
+    locals_dict, (mp_obj_t)&machine_wdt_locals_dict
+    );
diff --git a/ports/esp32/modsocket.c b/ports/esp32/modsocket.c
index 9d4bfb37c45ab..05b65a409567f 100644
--- a/ports/esp32/modsocket.c
+++ b/ports/esp32/modsocket.c
@@ -785,13 +785,11 @@ STATIC const mp_stream_p_t socket_stream_p = {
     .ioctl = socket_stream_ioctl
 };
 
-STATIC const mp_obj_type_t socket_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_socket,
-    .make_new = socket_make_new,
-    .protocol = &socket_stream_p,
-    .locals_dict = (mp_obj_t)&socket_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    socket_type, MP_QSTR_socket, MP_TYPE_FLAG_NONE, socket_make_new,
+    protocol, &socket_stream_p,
+    locals_dict, (mp_obj_t)&socket_locals_dict
+    );
 
 STATIC mp_obj_t esp_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
     // TODO support additional args beyond the first two
diff --git a/ports/esp32/network_lan.c b/ports/esp32/network_lan.c
index f302d70fec1d5..7e63e0be41e5e 100644
--- a/ports/esp32/network_lan.c
+++ b/ports/esp32/network_lan.c
@@ -302,10 +302,9 @@ STATIC const mp_rom_map_elem_t lan_if_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(lan_if_locals_dict, lan_if_locals_dict_table);
 
-const mp_obj_type_t lan_if_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LAN,
-    .locals_dict = (mp_obj_dict_t *)&lan_if_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    lan_if_type, MP_QSTR_LAN, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t *)&lan_if_locals_dict
+    );
 
 #endif
diff --git a/ports/esp32/network_ppp.c b/ports/esp32/network_ppp.c
index d74283c19cf63..d736e497200f3 100644
--- a/ports/esp32/network_ppp.c
+++ b/ports/esp32/network_ppp.c
@@ -278,8 +278,7 @@ STATIC const mp_rom_map_elem_t ppp_if_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(ppp_if_locals_dict, ppp_if_locals_dict_table);
 
-const mp_obj_type_t ppp_if_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_PPP,
-    .locals_dict = (mp_obj_dict_t *)&ppp_if_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ppp_if_type, MP_QSTR_PPP, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t *)&ppp_if_locals_dict
+    );
diff --git a/ports/esp32/network_wlan.c b/ports/esp32/network_wlan.c
index 8702ca7704598..a2d146117573b 100644
--- a/ports/esp32/network_wlan.c
+++ b/ports/esp32/network_wlan.c
@@ -47,9 +47,8 @@
 #error WIFI_MODE_STA and WIFI_MODE_AP are supposed to be bitfields!
 #endif
 
-STATIC const mp_obj_type_t wlan_if_type;
-STATIC const wlan_if_obj_t wlan_sta_obj = {{&wlan_if_type}, WIFI_IF_STA};
-STATIC const wlan_if_obj_t wlan_ap_obj = {{&wlan_if_type}, WIFI_IF_AP};
+STATIC const wlan_if_obj_t wlan_sta_obj;
+STATIC const wlan_if_obj_t wlan_ap_obj;
 
 // Set to "true" if esp_wifi_start() was called
 static bool wifi_started = false;
@@ -565,10 +564,12 @@ STATIC const mp_rom_map_elem_t wlan_if_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(wlan_if_locals_dict, wlan_if_locals_dict_table);
 
-STATIC const mp_obj_type_t wlan_if_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_WLAN,
-    .locals_dict = (mp_obj_t)&wlan_if_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    wlan_if_type, MP_QSTR_WLAN, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t *)&wlan_if_locals_dict
+    );
+
+STATIC const wlan_if_obj_t wlan_sta_obj = {{&wlan_if_type}, WIFI_IF_STA};
+STATIC const wlan_if_obj_t wlan_ap_obj = {{&wlan_if_type}, WIFI_IF_AP};
 
 #endif // MICROPY_PY_NETWORK_WLAN
diff --git a/ports/esp8266/machine_adc.c b/ports/esp8266/machine_adc.c
index 471e14d8dfbed..f99d75dbf391b 100644
--- a/ports/esp8266/machine_adc.c
+++ b/ports/esp8266/machine_adc.c
@@ -89,10 +89,8 @@ STATIC const mp_rom_map_elem_t machine_adc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_adc_locals_dict, machine_adc_locals_dict_table);
 
-const mp_obj_type_t machine_adc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADC,
-    .print = machine_adc_print,
-    .make_new = machine_adc_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_adc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_adc_type, MP_QSTR_ADC, MP_TYPE_FLAG_NONE, machine_adc_make_new,
+    print, machine_adc_print,
+    locals_dict, (mp_obj_dict_t *)&machine_adc_locals_dict
+    );
diff --git a/ports/esp8266/machine_hspi.c b/ports/esp8266/machine_hspi.c
index ff3ba17255358..dbe3101471ae3 100644
--- a/ports/esp8266/machine_hspi.c
+++ b/ports/esp8266/machine_hspi.c
@@ -176,13 +176,11 @@ STATIC const mp_machine_spi_p_t machine_hspi_p = {
     .transfer = machine_hspi_transfer,
 };
 
-const mp_obj_type_t machine_hspi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_HSPI,
-    .print = machine_hspi_print,
-    .make_new = machine_hspi_make_new,
-    .protocol = &machine_hspi_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hspi_type, MP_QSTR_HSPI, MP_TYPE_FLAG_NONE, machine_hspi_make_new,
+    print, machine_hspi_print,
+    protocol, &machine_hspi_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_spi_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_SPI
diff --git a/ports/esp8266/machine_pin.c b/ports/esp8266/machine_pin.c
index 419ee87a7332b..f32f61e561c42 100644
--- a/ports/esp8266/machine_pin.c
+++ b/ports/esp8266/machine_pin.c
@@ -450,15 +450,13 @@ STATIC const mp_pin_p_t pin_pin_p = {
     .ioctl = pin_ioctl,
 };
 
-const mp_obj_type_t pyb_pin_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Pin,
-    .print = pyb_pin_print,
-    .make_new = mp_pin_make_new,
-    .call = pyb_pin_call,
-    .protocol = &pin_pin_p,
-    .locals_dict = (mp_obj_dict_t *)&pyb_pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, mp_pin_make_new,
+    print, pyb_pin_print,
+    call, pyb_pin_call,
+    protocol, &pin_pin_p,
+    locals_dict, (mp_obj_dict_t *)&pyb_pin_locals_dict
+    );
 
 /******************************************************************************/
 // Pin IRQ object
@@ -509,9 +507,8 @@ STATIC const mp_rom_map_elem_t pin_irq_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pin_irq_locals_dict, pin_irq_locals_dict_table);
 
-STATIC const mp_obj_type_t pin_irq_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_IRQ,
-    .call = pin_irq_call,
-    .locals_dict = (mp_obj_dict_t *)&pin_irq_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    pin_irq_type, MP_QSTR_IRQ, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    call, pin_irq_call,
+    locals_dict, (mp_obj_dict_t *)&pin_irq_locals_dict
+    );
diff --git a/ports/esp8266/machine_rtc.c b/ports/esp8266/machine_rtc.c
index 38049ce724939..b966f59af386a 100644
--- a/ports/esp8266/machine_rtc.c
+++ b/ports/esp8266/machine_rtc.c
@@ -262,9 +262,7 @@ STATIC const mp_rom_map_elem_t pyb_rtc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_rtc_locals_dict, pyb_rtc_locals_dict_table);
 
-const mp_obj_type_t pyb_rtc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_RTC,
-    .make_new = pyb_rtc_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_rtc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_rtc_type, MP_QSTR_RTC, MP_TYPE_FLAG_NONE, pyb_rtc_make_new,
+    locals_dict, (mp_obj_dict_t *)&pyb_rtc_locals_dict
+    );
diff --git a/ports/esp8266/machine_uart.c b/ports/esp8266/machine_uart.c
index a8ea5e38d3154..efd240e08f9b8 100644
--- a/ports/esp8266/machine_uart.c
+++ b/ports/esp8266/machine_uart.c
@@ -320,13 +320,11 @@ STATIC const mp_stream_p_t uart_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t pyb_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = pyb_uart_print,
-    .make_new = pyb_uart_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&pyb_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, pyb_uart_make_new,
+    print, pyb_uart_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &uart_stream_p,
+    locals_dict, (mp_obj_dict_t *)&pyb_uart_locals_dict
+    );
diff --git a/ports/esp8266/machine_wdt.c b/ports/esp8266/machine_wdt.c
index b64830e7d6733..5ac9d53bfc0db 100644
--- a/ports/esp8266/machine_wdt.c
+++ b/ports/esp8266/machine_wdt.c
@@ -77,9 +77,7 @@ STATIC const mp_rom_map_elem_t machine_wdt_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_wdt_locals_dict, machine_wdt_locals_dict_table);
 
-const mp_obj_type_t esp_wdt_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_WDT,
-    .make_new = machine_wdt_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_wdt_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    esp_wdt_type, MP_QSTR_WDT, MP_TYPE_FLAG_NONE, machine_wdt_make_new,
+    locals_dict, (mp_obj_dict_t *)&machine_wdt_locals_dict
+    );
diff --git a/ports/esp8266/modmachine.c b/ports/esp8266/modmachine.c
index 39a890f56f172..db4ca0594f9d6 100644
--- a/ports/esp8266/modmachine.c
+++ b/ports/esp8266/modmachine.c
@@ -338,13 +338,11 @@ STATIC const mp_rom_map_elem_t esp_timer_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(esp_timer_locals_dict, esp_timer_locals_dict_table);
 
-const mp_obj_type_t esp_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = esp_timer_print,
-    .make_new = esp_timer_make_new,
-    .locals_dict = (mp_obj_dict_t *)&esp_timer_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    esp_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, esp_timer_make_new,
+    print, esp_timer_print,
+    locals_dict, (mp_obj_dict_t *)&esp_timer_locals_dict
+    );
 
 // this bit is unused in the Xtensa PS register
 #define ETS_LOOP_ITER_BIT (12)
diff --git a/ports/esp8266/modnetwork.c b/ports/esp8266/modnetwork.c
index 6988e09bd12af..e7d384df54020 100644
--- a/ports/esp8266/modnetwork.c
+++ b/ports/esp8266/modnetwork.c
@@ -495,11 +495,10 @@ STATIC const mp_rom_map_elem_t wlan_if_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(wlan_if_locals_dict, wlan_if_locals_dict_table);
 
-const mp_obj_type_t wlan_if_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_WLAN,
-    .locals_dict = (mp_obj_dict_t *)&wlan_if_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    wlan_if_type, MP_QSTR_WLAN, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t *)&wlan_if_locals_dict
+    );
 
 STATIC mp_obj_t esp_phy_mode(size_t n_args, const mp_obj_t *args) {
     if (n_args == 0) {
diff --git a/ports/mimxrt/machine_adc.c b/ports/mimxrt/machine_adc.c
index 8bf5e7b9a8adb..bf155750ad464 100644
--- a/ports/mimxrt/machine_adc.c
+++ b/ports/mimxrt/machine_adc.c
@@ -118,13 +118,11 @@ STATIC const mp_rom_map_elem_t adc_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(adc_locals_dict, adc_locals_dict_table);
 
-const mp_obj_type_t machine_adc_type = {
-    {&mp_type_type},
-    .name = MP_QSTR_ADC,
-    .print = adc_obj_print,
-    .make_new = adc_obj_make_new,
-    .locals_dict = (mp_obj_dict_t *)&adc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_adc_type, MP_QSTR_ADC, MP_TYPE_FLAG_NONE, adc_obj_make_new,
+    print, adc_obj_print,
+    locals_dict, (mp_obj_dict_t *)&adc_locals_dict
+    );
 
 void machine_adc_init(void) {
     for (int i = 1; i < sizeof(adc_bases) / sizeof(ADC_Type *); ++i) {
diff --git a/ports/mimxrt/machine_i2c.c b/ports/mimxrt/machine_i2c.c
index c64f46ff1b496..f890c7f6f9241 100644
--- a/ports/mimxrt/machine_i2c.c
+++ b/ports/mimxrt/machine_i2c.c
@@ -206,11 +206,9 @@ STATIC const mp_machine_i2c_p_t machine_i2c_p = {
     .transfer_single = machine_i2c_transfer_single,
 };
 
-const mp_obj_type_t machine_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2C,
-    .print = machine_i2c_print,
-    .make_new = machine_i2c_make_new,
-    .protocol = &machine_i2c_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_i2c_type, MP_QSTR_I2C, MP_TYPE_FLAG_NONE, machine_i2c_make_new,
+    print, machine_i2c_print,
+    protocol, &machine_i2c_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_i2c_locals_dict
+    );
diff --git a/ports/mimxrt/machine_i2s.c b/ports/mimxrt/machine_i2s.c
index a41dfe94f13f1..01297519858d6 100644
--- a/ports/mimxrt/machine_i2s.c
+++ b/ports/mimxrt/machine_i2s.c
@@ -1214,15 +1214,13 @@ STATIC const mp_stream_p_t i2s_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_i2s_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2S,
-    .print = machine_i2s_print,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &i2s_stream_p,
-    .make_new = machine_i2s_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_i2s_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_i2s_type, MP_QSTR_I2S, MP_TYPE_FLAG_NONE, machine_i2s_make_new,
+    print, machine_i2s_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &i2s_stream_p,
+    locals_dict, (mp_obj_dict_t *)&machine_i2s_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_I2S
diff --git a/ports/mimxrt/machine_led.c b/ports/mimxrt/machine_led.c
index 4082eb34bbbfb..5dd405d00e40a 100644
--- a/ports/mimxrt/machine_led.c
+++ b/ports/mimxrt/machine_led.c
@@ -80,12 +80,10 @@ STATIC const mp_rom_map_elem_t led_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(led_locals_dict, led_locals_dict_table);
 
-const mp_obj_type_t machine_led_type = {
-    {&mp_type_type},
-    .name = MP_QSTR_LED,
-    .print = led_obj_print,
-    .make_new = led_obj_make_new,
-    .locals_dict = (mp_obj_dict_t *)&led_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_led_type, MP_QSTR_LED, MP_TYPE_FLAG_NONE, led_obj_make_new,
+    print, led_obj_print,
+    locals_dict, (mp_obj_dict_t *)&led_locals_dict
+    );
 
 #endif
diff --git a/ports/mimxrt/machine_pin.c b/ports/mimxrt/machine_pin.c
index 2424088f02efb..a90f56aacfdb8 100644
--- a/ports/mimxrt/machine_pin.c
+++ b/ports/mimxrt/machine_pin.c
@@ -58,17 +58,15 @@ enum {
 };
 
 // Pin mapping dictionaries
-const mp_obj_type_t machine_pin_cpu_pins_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_cpu,
-    .locals_dict = (mp_obj_t)&machine_pin_cpu_pins_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_cpu_pins_obj_type, MP_QSTR_cpu, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_t)&machine_pin_cpu_pins_locals_dict
+    );
 
-const mp_obj_type_t machine_pin_board_pins_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_board,
-    .locals_dict = (mp_obj_t)&machine_pin_board_pins_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_board_pins_obj_type, MP_QSTR_board, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_t)&machine_pin_board_pins_locals_dict
+    );
 
 STATIC const mp_irq_methods_t machine_pin_irq_methods;
 
@@ -396,7 +394,6 @@ STATIC const mp_rom_map_elem_t machine_pin_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_pin_locals_dict, machine_pin_locals_dict_table);
 
-
 STATIC mp_uint_t machine_pin_ioctl(mp_obj_t self_in, mp_uint_t request, uintptr_t arg, int *errcode) {
     (void)errcode;
     machine_pin_obj_t *self = self_in;
@@ -417,24 +414,20 @@ STATIC const mp_pin_p_t machine_pin_obj_protocol = {
     .ioctl = machine_pin_ioctl,
 };
 
-const mp_obj_type_t machine_pin_type = {
-    {&mp_type_type},
-    .name = MP_QSTR_Pin,
-    .print = machine_pin_obj_print,
-    .call = machine_pin_obj_call,
-    .make_new = mp_pin_make_new,
-    .protocol = &machine_pin_obj_protocol,
-    .locals_dict = (mp_obj_dict_t *)&machine_pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, mp_pin_make_new,
+    print, machine_pin_obj_print,
+    call, machine_pin_obj_call,
+    protocol, &machine_pin_obj_protocol,
+    locals_dict, (mp_obj_dict_t *)&machine_pin_locals_dict
+    );
 
 // FIXME: Create actual pin_af type!!!
-const mp_obj_type_t machine_pin_af_type = {
-    {&mp_type_type},
-    .name = MP_QSTR_PinAF,
-    .print = machine_pin_obj_print,
-    .make_new = mp_pin_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_af_type, MP_QSTR_PinAF, MP_TYPE_FLAG_NONE, mp_pin_make_new,
+    print, machine_pin_obj_print,
+    locals_dict, (mp_obj_dict_t *)&machine_pin_locals_dict
+    );
 
 STATIC mp_uint_t machine_pin_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
     machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
diff --git a/ports/mimxrt/machine_rtc.c b/ports/mimxrt/machine_rtc.c
index e0d33554b5594..daee9dcc1884b 100644
--- a/ports/mimxrt/machine_rtc.c
+++ b/ports/mimxrt/machine_rtc.c
@@ -166,9 +166,7 @@ STATIC const mp_rom_map_elem_t machine_rtc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_rtc_locals_dict, machine_rtc_locals_dict_table);
 
-const mp_obj_type_t machine_rtc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_RTC,
-    .make_new = machine_rtc_make_new,
-    .locals_dict = (mp_obj_t)&machine_rtc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_rtc_type, MP_QSTR_RTC, MP_TYPE_FLAG_NONE, machine_rtc_make_new,
+    locals_dict, (mp_obj_t)&machine_rtc_locals_dict
+    );
diff --git a/ports/mimxrt/machine_sdcard.c b/ports/mimxrt/machine_sdcard.c
index 4a92aae00cefa..e8d3a6bb321db 100644
--- a/ports/mimxrt/machine_sdcard.c
+++ b/ports/mimxrt/machine_sdcard.c
@@ -208,12 +208,10 @@ STATIC const mp_rom_map_elem_t sdcard_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(sdcard_locals_dict, sdcard_locals_dict_table);
 
-const mp_obj_type_t machine_sdcard_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SDCard,
-    .make_new = sdcard_obj_make_new,
-    .locals_dict = (mp_obj_dict_t *)&sdcard_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_sdcard_type, MP_QSTR_SDCard, MP_TYPE_FLAG_NONE, sdcard_obj_make_new,
+    locals_dict, (mp_obj_dict_t *)&sdcard_locals_dict
+    );
 
 void machine_sdcard_init0(void) {
     return;
diff --git a/ports/mimxrt/machine_spi.c b/ports/mimxrt/machine_spi.c
index 2235732790888..a850ec94fded7 100644
--- a/ports/mimxrt/machine_spi.c
+++ b/ports/mimxrt/machine_spi.c
@@ -347,11 +347,9 @@ STATIC const mp_machine_spi_p_t machine_spi_p = {
     .transfer = machine_spi_transfer,
 };
 
-const mp_obj_type_t machine_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SPI,
-    .print = machine_spi_print,
-    .make_new = machine_spi_make_new,
-    .protocol = &machine_spi_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_spi_type, MP_QSTR_SPI, MP_TYPE_FLAG_NONE, machine_spi_make_new,
+    print, machine_spi_print,
+    protocol, &machine_spi_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_spi_locals_dict
+    );
diff --git a/ports/mimxrt/machine_timer.c b/ports/mimxrt/machine_timer.c
index 334a020c15cc1..7220b8e01ec8a 100644
--- a/ports/mimxrt/machine_timer.c
+++ b/ports/mimxrt/machine_timer.c
@@ -211,10 +211,8 @@ STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
 
-const mp_obj_type_t machine_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = machine_timer_print,
-    .make_new = machine_timer_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_timer_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, machine_timer_make_new,
+    print, machine_timer_print,
+    locals_dict, (mp_obj_dict_t *)&machine_timer_locals_dict
+    );
diff --git a/ports/mimxrt/machine_uart.c b/ports/mimxrt/machine_uart.c
index d413778c8c03f..ff995d5ee8f11 100644
--- a/ports/mimxrt/machine_uart.c
+++ b/ports/mimxrt/machine_uart.c
@@ -459,13 +459,11 @@ STATIC const mp_stream_p_t uart_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = machine_uart_print,
-    .make_new = machine_uart_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&machine_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, machine_uart_make_new,
+    print, machine_uart_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &uart_stream_p,
+    locals_dict, (mp_obj_dict_t *)&machine_uart_locals_dict
+    );
diff --git a/ports/mimxrt/machine_wdt.c b/ports/mimxrt/machine_wdt.c
index d09c464f69a3c..b04fba9851cd8 100644
--- a/ports/mimxrt/machine_wdt.c
+++ b/ports/mimxrt/machine_wdt.c
@@ -99,9 +99,7 @@ STATIC const mp_rom_map_elem_t machine_wdt_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_wdt_locals_dict, machine_wdt_locals_dict_table);
 
-const mp_obj_type_t machine_wdt_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_WDT,
-    .make_new = machine_wdt_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_wdt_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_wdt_type, MP_QSTR_WDT, MP_TYPE_FLAG_NONE, machine_wdt_make_new,
+    locals_dict, (mp_obj_dict_t *)&machine_wdt_locals_dict
+    );
diff --git a/ports/mimxrt/mimxrt_flash.c b/ports/mimxrt/mimxrt_flash.c
index 27ab987ed17f2..c1a5c529c6792 100644
--- a/ports/mimxrt/mimxrt_flash.c
+++ b/ports/mimxrt/mimxrt_flash.c
@@ -215,9 +215,7 @@ STATIC const mp_rom_map_elem_t mimxrt_flash_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(mimxrt_flash_locals_dict, mimxrt_flash_locals_dict_table);
 
-const mp_obj_type_t mimxrt_flash_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Flash,
-    .make_new = mimxrt_flash_make_new,
-    .locals_dict = (mp_obj_dict_t *)&mimxrt_flash_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mimxrt_flash_type, MP_QSTR_Flash, MP_TYPE_FLAG_NONE, mimxrt_flash_make_new,
+    locals_dict, (mp_obj_dict_t *)&mimxrt_flash_locals_dict
+    );
diff --git a/ports/mimxrt/network_lan.c b/ports/mimxrt/network_lan.c
index 5517b54bd02f5..f1953eb63f88a 100644
--- a/ports/mimxrt/network_lan.c
+++ b/ports/mimxrt/network_lan.c
@@ -220,12 +220,11 @@ STATIC const mp_rom_map_elem_t network_lan_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(network_lan_locals_dict, network_lan_locals_dict_table);
 
-const mp_obj_type_t network_lan_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LAN,
-    .print = network_lan_print,
-    .make_new = network_lan_make_new,
-    .locals_dict = (mp_obj_dict_t *)&network_lan_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    network_lan_type, MP_QSTR_LAN, MP_TYPE_FLAG_NONE, network_lan_make_new,
+    print, network_lan_print,
+    locals_dict, (mp_obj_dict_t *)&network_lan_locals_dict
+    );
+
 
 #endif // defined(MICROPY_HW_ETH_MDC)
diff --git a/ports/nrf/boards/microbit/modules/iters.c b/ports/nrf/boards/microbit/modules/iters.c
index 2c675ffe81b48..72b73b2b8c75d 100644
--- a/ports/nrf/boards/microbit/modules/iters.c
+++ b/ports/nrf/boards/microbit/modules/iters.c
@@ -43,21 +43,11 @@ static mp_obj_t microbit_repeat_iter_next(mp_obj_t iter_in) {
     return mp_obj_subscr(iter->iterable, MP_OBJ_NEW_SMALL_INT(iter->index), MP_OBJ_SENTINEL);
 }
 
-const mp_obj_type_t microbit_repeat_iterator_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .print = NULL,
-    .make_new = NULL,
-    .call = NULL,
-    .unary_op = NULL,
-    .binary_op = NULL,
-    .attr = NULL,
-    .subscr = NULL,
-    .getiter = mp_identity_getiter,
-    .iternext = microbit_repeat_iter_next,
-    .buffer_p = {NULL},
-    MP_OBJ_NULL
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    microbit_repeat_iterator_type, MP_QSTR_iterator, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, microbit_repeat_iter_next
+    );
 
 mp_obj_t microbit_repeat_iterator(mp_obj_t iterable) {
     repeat_iterator_t *result = m_new_obj(repeat_iterator_t);
diff --git a/ports/nrf/boards/microbit/modules/microbitdisplay.c b/ports/nrf/boards/microbit/modules/microbitdisplay.c
index a0508886d796c..827254a995049 100644
--- a/ports/nrf/boards/microbit/modules/microbitdisplay.c
+++ b/ports/nrf/boards/microbit/modules/microbitdisplay.c
@@ -542,21 +542,10 @@ STATIC const mp_rom_map_elem_t microbit_display_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(microbit_display_locals_dict, microbit_display_locals_dict_table);
 
-const mp_obj_type_t microbit_display_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_MicroBitDisplay,
-    .print = NULL,
-    .make_new = NULL,
-    .call = NULL,
-    .unary_op = NULL,
-    .binary_op = NULL,
-    .attr = NULL,
-    .subscr = NULL,
-    .getiter = NULL,
-    .iternext = NULL,
-    .buffer_p = {NULL},
-    .locals_dict = (mp_obj_dict_t*)&microbit_display_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    microbit_display_type, MP_QSTR_MicroBitDisplay, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t*)&microbit_display_locals_dict
+    );
 
 microbit_display_obj_t microbit_display_obj = {
     {&microbit_display_type},
diff --git a/ports/nrf/boards/microbit/modules/microbitimage.c b/ports/nrf/boards/microbit/modules/microbitimage.c
index d697a9081f9aa..dcbd7e3ad0e9c 100644
--- a/ports/nrf/boards/microbit/modules/microbitimage.c
+++ b/ports/nrf/boards/microbit/modules/microbitimage.c
@@ -679,21 +679,12 @@ STATIC mp_obj_t image_binary_op(mp_binary_op_t op, mp_obj_t lhs_in, mp_obj_t rhs
 }
 
 
-const mp_obj_type_t microbit_image_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_MicroBitImage,
-    .print = microbit_image_print,
-    .make_new = microbit_image_make_new,
-    .call = NULL,
-    .unary_op = NULL,
-    .binary_op = image_binary_op,
-    .attr = NULL,
-    .subscr = NULL,
-    .getiter = NULL,
-    .iternext = NULL,
-    .buffer_p = {NULL},
-    .locals_dict = (mp_obj_dict_t*)&microbit_image_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    microbit_image_type, MP_QSTR_MicroBitImage, MP_TYPE_FLAG_NONE, microbit_image_make_new,
+    print, microbit_image_print,
+    binary_op, image_binary_op,
+    locals_dict, (mp_obj_dict_t*)&microbit_image_locals_dict
+    );
 
 typedef struct _scrolling_string_t {
     mp_obj_base_t base;
@@ -830,37 +821,16 @@ STATIC mp_obj_t microbit_scrolling_string_iter_next(mp_obj_t o_in) {
     return iter->img;
 }
 
-const mp_obj_type_t microbit_scrolling_string_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ScrollingString,
-    .print = NULL,
-    .make_new = NULL,
-    .call = NULL,
-    .unary_op = NULL,
-    .binary_op = NULL,
-    .attr = NULL,
-    .subscr = NULL,
-    .getiter = get_microbit_scrolling_string_iter,
-    .iternext = NULL,
-    .buffer_p = {NULL},
-    .locals_dict = NULL,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    microbit_scrolling_string_type, MP_QSTR_ScrollingString, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    getiter, get_microbit_scrolling_string_iter
+    );
 
-const mp_obj_type_t microbit_scrolling_string_iterator_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .print = NULL,
-    .make_new = NULL,
-    .call = NULL,
-    .unary_op = NULL,
-    .binary_op = NULL,
-    .attr = NULL,
-    .subscr = NULL,
-    .getiter = mp_identity_getiter,
-    .iternext = microbit_scrolling_string_iter_next,
-    .buffer_p = {NULL},
-    .locals_dict = NULL,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    microbit_scrolling_string_iterator_type, MP_QSTR_iterator, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, microbit_scrolling_string_iter_next
+    );
 
 /** Facade types to present a string as a sequence of images.
  * These are necessary to avoid allocation during iteration,
@@ -898,21 +868,12 @@ static mp_obj_t facade_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
 
 static mp_obj_t microbit_facade_iterator(mp_obj_t iterable_in, mp_obj_iter_buf_t *iter_buf);
 
-const mp_obj_type_t string_image_facade_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Facade,
-    .print = NULL,
-    .make_new = NULL,
-    .call = NULL,
-    .unary_op = facade_unary_op,
-    .binary_op = NULL,
-    .attr = NULL,
-    .subscr = string_image_facade_subscr,
-    .getiter = microbit_facade_iterator,
-    .iternext = NULL,
-    .buffer_p = {NULL},
-    NULL
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    string_image_facade_type, MP_QSTR_Facade, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    unary_op, facade_unary_op,
+    subscr, string_image_facade_subscr,
+    getiter, microbit_facade_iterator
+    );
 
 
 typedef struct _facade_iterator_t {
@@ -942,21 +903,11 @@ static mp_obj_t microbit_facade_iter_next(mp_obj_t iter_in) {
     return iter->image;
 }
 
-const mp_obj_type_t microbit_facade_iterator_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_iterator,
-    .print = NULL,
-    .make_new = NULL,
-    .call = NULL,
-    .unary_op = NULL,
-    .binary_op = NULL,
-    .attr = NULL,
-    .subscr = NULL,
-    .getiter = mp_identity_getiter,
-    .iternext = microbit_facade_iter_next,
-    .buffer_p = {NULL},
-    NULL
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    microbit_facade_iterator_type, MP_QSTR_iterator, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, microbit_facade_iter_next
+    );
 
 mp_obj_t microbit_facade_iterator(mp_obj_t iterable_in, mp_obj_iter_buf_t *iter_buf) {
     (void)iter_buf;
diff --git a/ports/nrf/modules/board/led.c b/ports/nrf/modules/board/led.c
index cbfc330d63309..3d4f8e4df9e16 100644
--- a/ports/nrf/modules/board/led.c
+++ b/ports/nrf/modules/board/led.c
@@ -194,13 +194,11 @@ STATIC const mp_rom_map_elem_t led_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(led_locals_dict, led_locals_dict_table);
 
-const mp_obj_type_t board_led_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LED,
-    .print = led_obj_print,
-    .make_new = led_obj_make_new,
-    .locals_dict = (mp_obj_dict_t*)&led_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    board_led_type, MP_QSTR_LED, MP_TYPE_FLAG_NONE, led_obj_make_new,
+    print, led_obj_print,
+    locals_dict, (mp_obj_dict_t*)&led_locals_dict
+    );
 
 #else
 // For boards with no LEDs, we leave an empty function here so that we don't
diff --git a/ports/nrf/modules/machine/adc.c b/ports/nrf/modules/machine/adc.c
index 54870d2c18ee8..68a3157729a7e 100644
--- a/ports/nrf/modules/machine/adc.c
+++ b/ports/nrf/modules/machine/adc.c
@@ -294,12 +294,10 @@ STATIC const mp_rom_map_elem_t machine_adc_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(machine_adc_locals_dict, machine_adc_locals_dict_table);
 
-const mp_obj_type_t machine_adc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADC,
-    .make_new = machine_adc_make_new,
-    .locals_dict = (mp_obj_dict_t*)&machine_adc_locals_dict,
-    .print = machine_adc_print,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_adc_type, MP_QSTR_ADC, MP_TYPE_FLAG_NONE, machine_adc_make_new,
+    locals_dict, (mp_obj_dict_t*)&machine_adc_locals_dict,
+    print, machine_adc_print
+    );
 
 #endif // MICROPY_PY_MACHINE_ADC
diff --git a/ports/nrf/modules/machine/i2c.c b/ports/nrf/modules/machine/i2c.c
index aac9320873207..846e732fc07df 100644
--- a/ports/nrf/modules/machine/i2c.c
+++ b/ports/nrf/modules/machine/i2c.c
@@ -161,13 +161,11 @@ STATIC const mp_machine_i2c_p_t machine_hard_i2c_p = {
     .transfer_single = machine_hard_i2c_transfer_single,
 };
 
-const mp_obj_type_t machine_hard_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2C,
-    .print = machine_hard_i2c_print,
-    .make_new = machine_hard_i2c_make_new,
-    .protocol = &machine_hard_i2c_p,
-    .locals_dict = (mp_obj_dict_t*)&mp_machine_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hard_i2c_type, MP_QSTR_I2C, MP_TYPE_FLAG_NONE, machine_hard_i2c_make_new,
+    print, machine_hard_i2c_print,
+    protocol, &machine_hard_i2c_p,
+    locals_dict, (mp_obj_dict_t*)&mp_machine_i2c_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_I2C
diff --git a/ports/nrf/modules/machine/pin.c b/ports/nrf/modules/machine/pin.c
index 170caf6dde4c6..7faf2ef444329 100644
--- a/ports/nrf/modules/machine/pin.c
+++ b/ports/nrf/modules/machine/pin.c
@@ -590,14 +590,12 @@ STATIC const mp_rom_map_elem_t pin_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pin_locals_dict, pin_locals_dict_table);
 
-const mp_obj_type_t pin_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Pin,
-    .print = pin_print,
-    .make_new = pin_make_new,
-    .call = pin_call,
-    .locals_dict = (mp_obj_dict_t*)&pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, pin_make_new,
+    print, pin_print,
+    call, pin_call,
+    locals_dict, (mp_obj_dict_t*)&pin_locals_dict
+    );
 
 /// \moduleref machine
 /// \class PinAF - Pin Alternate Functions
@@ -665,9 +663,8 @@ STATIC const mp_rom_map_elem_t pin_af_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pin_af_locals_dict, pin_af_locals_dict_table);
 
-const mp_obj_type_t pin_af_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_PinAF,
-    .print = pin_af_obj_print,
-    .locals_dict = (mp_obj_dict_t*)&pin_af_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_af_type, MP_QSTR_PinAF, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, pin_af_obj_print,
+    locals_dict, (mp_obj_dict_t*)&pin_af_locals_dict
+    );
diff --git a/ports/nrf/modules/machine/pwm.c b/ports/nrf/modules/machine/pwm.c
index a750285841e24..4cb4d68d7a9cb 100644
--- a/ports/nrf/modules/machine/pwm.c
+++ b/ports/nrf/modules/machine/pwm.c
@@ -339,12 +339,10 @@ STATIC mp_obj_t machine_hard_pwm_freq(mp_obj_t self_in, mp_arg_val_t *args) {
     return mp_const_none;
 }
 
-const mp_obj_type_t machine_hard_pwm_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_PWM,
-    .print = machine_pwm_print,
-    .make_new = machine_pwm_make_new,
-    .locals_dict = (mp_obj_dict_t*)&machine_pwm_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hard_pwm_type, MP_QSTR_PWM, MP_TYPE_FLAG_NONE, machine_pwm_make_new,
+    print, machine_pwm_print,
+    locals_dict, (mp_obj_dict_t*)&machine_pwm_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_HW_PWM
diff --git a/ports/nrf/modules/machine/rtcounter.c b/ports/nrf/modules/machine/rtcounter.c
index c9f907774e6a3..35d40a2b3d1b9 100644
--- a/ports/nrf/modules/machine/rtcounter.c
+++ b/ports/nrf/modules/machine/rtcounter.c
@@ -262,12 +262,10 @@ STATIC const mp_rom_map_elem_t machine_rtc_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(machine_rtc_locals_dict, machine_rtc_locals_dict_table);
 
-const mp_obj_type_t machine_rtcounter_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_RTCounter,
-    .print = rtc_print,
-    .make_new = machine_rtc_make_new,
-    .locals_dict = (mp_obj_dict_t*)&machine_rtc_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_rtcounter_type, MP_QSTR_RTCounter, MP_TYPE_FLAG_NONE, machine_rtc_make_new,
+    print, rtc_print,
+    locals_dict, (mp_obj_dict_t*)&machine_rtc_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_RTCOUNTER
diff --git a/ports/nrf/modules/machine/spi.c b/ports/nrf/modules/machine/spi.c
index 880d946a29f95..89bc99addc5ea 100644
--- a/ports/nrf/modules/machine/spi.c
+++ b/ports/nrf/modules/machine/spi.c
@@ -427,13 +427,11 @@ STATIC const mp_machine_spi_p_t machine_hard_spi_p = {
     .transfer = machine_hard_spi_transfer,
 };
 
-const mp_obj_type_t machine_hard_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SPI,
-    .print = machine_hard_spi_print,
-    .make_new = machine_spi_make_new,
-    .protocol = &machine_hard_spi_p,
-    .locals_dict = (mp_obj_dict_t*)&machine_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hard_spi_type, MP_QSTR_SPI, MP_TYPE_FLAG_NONE, machine_spi_make_new,
+    print, machine_hard_spi_print,
+    protocol, &machine_hard_spi_p,
+    locals_dict, (mp_obj_dict_t*)&machine_spi_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_HW_SPI
diff --git a/ports/nrf/modules/machine/temp.c b/ports/nrf/modules/machine/temp.c
index 82b02d09e9232..52c8db6b119b2 100644
--- a/ports/nrf/modules/machine/temp.c
+++ b/ports/nrf/modules/machine/temp.c
@@ -114,12 +114,10 @@ STATIC const mp_rom_map_elem_t machine_temp_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(machine_temp_locals_dict, machine_temp_locals_dict_table);
 
-const mp_obj_type_t machine_temp_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Temp,
-    .make_new = machine_temp_make_new,
-    .locals_dict = (mp_obj_dict_t*)&machine_temp_locals_dict,
-    .print = machine_temp_print,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_temp_type, MP_QSTR_Temp, MP_TYPE_FLAG_NONE, machine_temp_make_new,
+    locals_dict, (mp_obj_dict_t*)&machine_temp_locals_dict,
+    print, machine_temp_print
+    );
 
 #endif // MICROPY_PY_MACHINE_TEMP
diff --git a/ports/nrf/modules/machine/timer.c b/ports/nrf/modules/machine/timer.c
index c99713ef52c5d..47f597cb0e489 100644
--- a/ports/nrf/modules/machine/timer.c
+++ b/ports/nrf/modules/machine/timer.c
@@ -234,12 +234,10 @@ STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
 
-const mp_obj_type_t machine_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = timer_print,
-    .make_new = machine_timer_make_new,
-    .locals_dict = (mp_obj_dict_t*)&machine_timer_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, machine_timer_make_new,
+    print, timer_print,
+    locals_dict, (mp_obj_dict_t*)&machine_timer_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_TIMER
diff --git a/ports/nrf/modules/machine/uart.c b/ports/nrf/modules/machine/uart.c
index 2cc421aa1f333..fe6002a4c6674 100644
--- a/ports/nrf/modules/machine/uart.c
+++ b/ports/nrf/modules/machine/uart.c
@@ -355,15 +355,13 @@ STATIC const mp_stream_p_t uart_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_hard_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = machine_hard_uart_print,
-    .make_new = machine_hard_uart_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&machine_hard_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hard_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, machine_hard_uart_make_new,
+    print, machine_hard_uart_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &uart_stream_p,
+    locals_dict, (mp_obj_dict_t*)&machine_hard_uart_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_UART
diff --git a/ports/nrf/modules/nrf/flashbdev.c b/ports/nrf/modules/nrf/flashbdev.c
index 7a1296c5d19f6..41abc1dea507c 100644
--- a/ports/nrf/modules/nrf/flashbdev.c
+++ b/ports/nrf/modules/nrf/flashbdev.c
@@ -184,13 +184,11 @@ STATIC mp_obj_t nrf_flashbdev_make_new(const mp_obj_type_t *type, size_t n_args,
     return MP_OBJ_FROM_PTR(self);
 }
 
-const mp_obj_type_t nrf_flashbdev_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Flash,
-    .print = nrf_flashbdev_print,
-    .make_new = nrf_flashbdev_make_new,
-    .locals_dict = (mp_obj_dict_t *)&nrf_flashbdev_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    nrf_flashbdev_type, MP_QSTR_Flash, MP_TYPE_FLAG_NONE, nrf_flashbdev_make_new,
+    print, nrf_flashbdev_print,
+    locals_dict, (mp_obj_dict_t *)&nrf_flashbdev_locals_dict
+    );
 
 void flashbdev_init(void) {
     // Set start to first aligned page from _fs_start.
diff --git a/ports/nrf/modules/ubluepy/ubluepy_characteristic.c b/ports/nrf/modules/ubluepy/ubluepy_characteristic.c
index 9adafaa64efdf..580af53eac1f3 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_characteristic.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_characteristic.c
@@ -210,12 +210,10 @@ STATIC const mp_rom_map_elem_t ubluepy_characteristic_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_characteristic_locals_dict, ubluepy_characteristic_locals_dict_table);
 
-const mp_obj_type_t ubluepy_characteristic_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Characteristic,
-    .print = ubluepy_characteristic_print,
-    .make_new = ubluepy_characteristic_make_new,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_characteristic_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_characteristic_type, MP_QSTR_Characteristic, MP_TYPE_FLAG_NONE, ubluepy_characteristic_make_new,
+    print, ubluepy_characteristic_print,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_characteristic_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL
diff --git a/ports/nrf/modules/ubluepy/ubluepy_constants.c b/ports/nrf/modules/ubluepy/ubluepy_constants.c
index 14e433e6ebff3..86ce1770195db 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_constants.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_constants.c
@@ -69,11 +69,10 @@ STATIC const mp_rom_map_elem_t ubluepy_constants_ad_types_locals_dict_table[] =
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_constants_ad_types_locals_dict, ubluepy_constants_ad_types_locals_dict_table);
 
-const mp_obj_type_t ubluepy_constants_ad_types_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ad_types,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_constants_ad_types_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_constants_ad_types_type, MP_QSTR_ad_types, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_constants_ad_types_locals_dict
+    );
 
 STATIC const mp_rom_map_elem_t ubluepy_constants_locals_dict_table[] = {
     // GAP events
@@ -90,10 +89,9 @@ STATIC const mp_rom_map_elem_t ubluepy_constants_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_constants_locals_dict, ubluepy_constants_locals_dict_table);
 
-const mp_obj_type_t ubluepy_constants_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_constants,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_constants_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_constants_type, MP_QSTR_constants, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_constants_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY
diff --git a/ports/nrf/modules/ubluepy/ubluepy_delegate.c b/ports/nrf/modules/ubluepy/ubluepy_delegate.c
index 74ad52bbfa35b..9f1ec8aff7045 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_delegate.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_delegate.c
@@ -78,12 +78,10 @@ STATIC const mp_rom_map_elem_t ubluepy_delegate_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_delegate_locals_dict, ubluepy_delegate_locals_dict_table);
 
-const mp_obj_type_t ubluepy_delegate_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_DefaultDelegate,
-    .print = ubluepy_delegate_print,
-    .make_new = ubluepy_delegate_make_new,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_delegate_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_delegate_type, MP_QSTR_DefaultDelegate, MP_TYPE_FLAG_NONE, ubluepy_delegate_make_new,
+    print, ubluepy_delegate_print,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_delegate_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL
diff --git a/ports/nrf/modules/ubluepy/ubluepy_descriptor.c b/ports/nrf/modules/ubluepy/ubluepy_descriptor.c
index b15301954d07e..0fe68e0f7bda6 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_descriptor.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_descriptor.c
@@ -71,12 +71,10 @@ STATIC const mp_rom_map_elem_t ubluepy_descriptor_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_descriptor_locals_dict, ubluepy_descriptor_locals_dict_table);
 
-const mp_obj_type_t ubluepy_descriptor_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Descriptor,
-    .print = ubluepy_descriptor_print,
-    .make_new = ubluepy_descriptor_make_new,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_descriptor_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_descriptor_type, MP_QSTR_Descriptor, MP_TYPE_FLAG_NONE, ubluepy_descriptor_make_new,
+    print, ubluepy_descriptor_print,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_descriptor_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY
diff --git a/ports/nrf/modules/ubluepy/ubluepy_peripheral.c b/ports/nrf/modules/ubluepy/ubluepy_peripheral.c
index 8f07daa2a3297..bfc8878a1df9f 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_peripheral.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_peripheral.c
@@ -487,12 +487,10 @@ STATIC const mp_rom_map_elem_t ubluepy_peripheral_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_peripheral_locals_dict, ubluepy_peripheral_locals_dict_table);
 
-const mp_obj_type_t ubluepy_peripheral_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Peripheral,
-    .print = ubluepy_peripheral_print,
-    .make_new = ubluepy_peripheral_make_new,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_peripheral_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_peripheral_type, MP_QSTR_Peripheral, MP_TYPE_FLAG_NONE, ubluepy_peripheral_make_new,
+    print, ubluepy_peripheral_print,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_peripheral_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY
diff --git a/ports/nrf/modules/ubluepy/ubluepy_scan_entry.c b/ports/nrf/modules/ubluepy/ubluepy_scan_entry.c
index 773070b08907f..c27ea1952516c 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_scan_entry.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_scan_entry.c
@@ -91,7 +91,7 @@ STATIC mp_obj_t scan_entry_get_scan_data(mp_obj_t self_in) {
 
         mp_obj_t description = mp_const_none;
 
-        mp_map_t *constant_map = mp_obj_dict_get_map(ubluepy_constants_ad_types_type.locals_dict);
+        mp_map_t *constant_map = mp_obj_dict_get_map(MP_OBJ_TYPE_GET_SLOT(&ubluepy_constants_ad_types_type, locals_dict));
         mp_map_elem_t *ad_types_table = MP_OBJ_TO_PTR(constant_map->table);
 
         uint16_t num_of_elements = constant_map->used;
@@ -136,11 +136,10 @@ STATIC const mp_rom_map_elem_t ubluepy_scan_entry_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_scan_entry_locals_dict, ubluepy_scan_entry_locals_dict_table);
 
-const mp_obj_type_t ubluepy_scan_entry_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ScanEntry,
-    .print = ubluepy_scan_entry_print,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_scan_entry_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_scan_entry_type, MP_QSTR_ScanEntry, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, ubluepy_scan_entry_print,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_scan_entry_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY_CENTRAL
diff --git a/ports/nrf/modules/ubluepy/ubluepy_scanner.c b/ports/nrf/modules/ubluepy/ubluepy_scanner.c
index f5c9a6dca8083..383b20ee9b4fb 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_scanner.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_scanner.c
@@ -116,12 +116,10 @@ STATIC const mp_rom_map_elem_t ubluepy_scanner_locals_dict_table[] = {
 STATIC MP_DEFINE_CONST_DICT(ubluepy_scanner_locals_dict, ubluepy_scanner_locals_dict_table);
 
 
-const mp_obj_type_t ubluepy_scanner_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Scanner,
-    .print = ubluepy_scanner_print,
-    .make_new = ubluepy_scanner_make_new,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_scanner_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_scanner_type, MP_QSTR_Scanner, MP_TYPE_FLAG_NONE, ubluepy_scanner_make_new,
+    print, ubluepy_scanner_print,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_scanner_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY_CENTRAL
diff --git a/ports/nrf/modules/ubluepy/ubluepy_service.c b/ports/nrf/modules/ubluepy/ubluepy_service.c
index 7b51ce3055eba..25c8501560a06 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_service.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_service.c
@@ -172,12 +172,10 @@ STATIC const mp_rom_map_elem_t ubluepy_service_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_service_locals_dict, ubluepy_service_locals_dict_table);
 
-const mp_obj_type_t ubluepy_service_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Service,
-    .print = ubluepy_service_print,
-    .make_new = ubluepy_service_make_new,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_service_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_service_type, MP_QSTR_Service, MP_TYPE_FLAG_NONE, ubluepy_service_make_new,
+    print, ubluepy_service_print,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_service_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY_PERIPHERAL || MICROPY_PY_UBLUEPY_CENTRAL
diff --git a/ports/nrf/modules/ubluepy/ubluepy_uuid.c b/ports/nrf/modules/ubluepy/ubluepy_uuid.c
index 7b4a09dba4aba..326bd08feec73 100644
--- a/ports/nrf/modules/ubluepy/ubluepy_uuid.c
+++ b/ports/nrf/modules/ubluepy/ubluepy_uuid.c
@@ -160,12 +160,10 @@ STATIC const mp_rom_map_elem_t ubluepy_uuid_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ubluepy_uuid_locals_dict, ubluepy_uuid_locals_dict_table);
 
-const mp_obj_type_t ubluepy_uuid_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UUID,
-    .print = ubluepy_uuid_print,
-    .make_new = ubluepy_uuid_make_new,
-    .locals_dict = (mp_obj_dict_t*)&ubluepy_uuid_locals_dict
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    ubluepy_uuid_type, MP_QSTR_UUID, MP_TYPE_FLAG_NONE, ubluepy_uuid_make_new,
+    print, ubluepy_uuid_print,
+    locals_dict, (mp_obj_dict_t*)&ubluepy_uuid_locals_dict
+    );
 
 #endif // MICROPY_PY_UBLUEPY
diff --git a/ports/nrf/modules/uos/microbitfs.c b/ports/nrf/modules/uos/microbitfs.c
index e8628f4945c20..ac9750c75d94d 100644
--- a/ports/nrf/modules/uos/microbitfs.c
+++ b/ports/nrf/modules/uos/microbitfs.c
@@ -632,12 +632,11 @@ STATIC const mp_stream_p_t textio_stream_p = {
     .is_text = true,
 };
 
-const mp_obj_type_t uos_mbfs_textio_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_TextIO,
-    .protocol = &textio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&uos_mbfs_file_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    uos_mbfs_textio_type, MP_QSTR_TextIO, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    protocol, &textio_stream_p,
+    locals_dict, (mp_obj_dict_t*)&uos_mbfs_file_locals_dict
+    );
 
 
 STATIC const mp_stream_p_t fileio_stream_p = {
@@ -645,12 +644,11 @@ STATIC const mp_stream_p_t fileio_stream_p = {
     .write = microbit_file_write,
 };
 
-const mp_obj_type_t uos_mbfs_fileio_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_FileIO,
-    .protocol = &fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t*)&uos_mbfs_file_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    uos_mbfs_fileio_type, MP_QSTR_FileIO, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    protocol, &fileio_stream_p,
+    locals_dict, (mp_obj_dict_t*)&uos_mbfs_file_locals_dict
+    );
 
 // From micro:bit fileobj.c
 mp_obj_t uos_mbfs_open(size_t n_args, const mp_obj_t *args) {
diff --git a/ports/nrf/pin_named_pins.c b/ports/nrf/pin_named_pins.c
index e1d8736b9cf23..52573773b8563 100644
--- a/ports/nrf/pin_named_pins.c
+++ b/ports/nrf/pin_named_pins.c
@@ -36,19 +36,17 @@ STATIC void pin_named_pins_obj_print(const mp_print_t *print, mp_obj_t self_in,
     mp_printf(print, "<Pin.%q>", self->name);
 }
 
-const mp_obj_type_t pin_cpu_pins_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_cpu,
-    .print = pin_named_pins_obj_print,
-    .locals_dict = (mp_obj_t)&pin_cpu_pins_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_cpu_pins_obj_type, MP_QSTR_cpu, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, pin_named_pins_obj_print,
+    locals_dict, (mp_obj_t)&pin_cpu_pins_locals_dict
+    );
 
-const mp_obj_type_t pin_board_pins_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_board,
-    .print = pin_named_pins_obj_print,
-    .locals_dict = (mp_obj_t)&pin_board_pins_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_board_pins_obj_type, MP_QSTR_board, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, pin_named_pins_obj_print,
+    locals_dict, (mp_obj_t)&pin_board_pins_locals_dict
+    );
 
 const pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) {
     mp_map_t *named_map = mp_obj_dict_get_map((mp_obj_t)named_pins);
diff --git a/ports/pic16bit/modpybled.c b/ports/pic16bit/modpybled.c
index 6adb2fda31265..320d081181f96 100644
--- a/ports/pic16bit/modpybled.c
+++ b/ports/pic16bit/modpybled.c
@@ -84,10 +84,8 @@ STATIC const mp_rom_map_elem_t pyb_led_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_led_locals_dict, pyb_led_locals_dict_table);
 
-const mp_obj_type_t pyb_led_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LED,
-    .print = pyb_led_print,
-    .make_new = pyb_led_make_new,
-    .locals_dict = (mp_obj_t)&pyb_led_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_led_type, MP_QSTR_LED, MP_TYPE_FLAG_NONE, pyb_led_make_new,
+    print, pyb_led_print,
+    locals_dict, (mp_obj_t)&pyb_led_locals_dict
+    );
diff --git a/ports/pic16bit/modpybswitch.c b/ports/pic16bit/modpybswitch.c
index 7b3d0f5f527bb..c2fc965255434 100644
--- a/ports/pic16bit/modpybswitch.c
+++ b/ports/pic16bit/modpybswitch.c
@@ -71,11 +71,9 @@ STATIC const mp_rom_map_elem_t pyb_switch_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_switch_locals_dict, pyb_switch_locals_dict_table);
 
-const mp_obj_type_t pyb_switch_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Switch,
-    .print = pyb_switch_print,
-    .make_new = pyb_switch_make_new,
-    .call = pyb_switch_call,
-    .locals_dict = (mp_obj_t)&pyb_switch_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_switch_type, MP_QSTR_Switch, MP_TYPE_FLAG_NONE, pyb_switch_make_new,
+    print, pyb_switch_print,
+    call, pyb_switch_call,
+    locals_dict, (mp_obj_t)&pyb_switch_locals_dict
+    );
diff --git a/ports/rp2/machine_adc.c b/ports/rp2/machine_adc.c
index f8925e5aa33a6..e092cb3c15bda 100644
--- a/ports/rp2/machine_adc.c
+++ b/ports/rp2/machine_adc.c
@@ -114,10 +114,8 @@ STATIC const mp_rom_map_elem_t machine_adc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_adc_locals_dict, machine_adc_locals_dict_table);
 
-const mp_obj_type_t machine_adc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADC,
-    .print = machine_adc_print,
-    .make_new = machine_adc_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_adc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_adc_type, MP_QSTR_ADC, MP_TYPE_FLAG_NONE, machine_adc_make_new,
+    print, machine_adc_print,
+    locals_dict, (mp_obj_dict_t *)&machine_adc_locals_dict
+    );
diff --git a/ports/rp2/machine_i2c.c b/ports/rp2/machine_i2c.c
index f785ad7dedf33..9fac76d58e3d9 100644
--- a/ports/rp2/machine_i2c.c
+++ b/ports/rp2/machine_i2c.c
@@ -166,11 +166,9 @@ STATIC const mp_machine_i2c_p_t machine_i2c_p = {
     .transfer_single = machine_i2c_transfer_single,
 };
 
-const mp_obj_type_t machine_hw_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2C,
-    .print = machine_i2c_print,
-    .make_new = machine_i2c_make_new,
-    .protocol = &machine_i2c_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hw_i2c_type, MP_QSTR_I2C, MP_TYPE_FLAG_NONE, machine_i2c_make_new,
+    print, machine_i2c_print,
+    protocol, &machine_i2c_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_i2c_locals_dict
+    );
diff --git a/ports/rp2/machine_i2s.c b/ports/rp2/machine_i2s.c
index ec64f72ec07f4..d0195e04efca5 100644
--- a/ports/rp2/machine_i2s.c
+++ b/ports/rp2/machine_i2s.c
@@ -1138,13 +1138,11 @@ STATIC const mp_stream_p_t i2s_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_i2s_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2S,
-    .print = machine_i2s_print,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &i2s_stream_p,
-    .make_new = machine_i2s_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_i2s_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_i2s_type, MP_QSTR_I2S, MP_TYPE_FLAG_NONE, machine_i2s_make_new,
+    print, machine_i2s_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &i2s_stream_p,
+    locals_dict, (mp_obj_dict_t *)&machine_i2s_locals_dict
+    );
diff --git a/ports/rp2/machine_pin.c b/ports/rp2/machine_pin.c
index aa3cad6ef0404..1d005e98af252 100644
--- a/ports/rp2/machine_pin.c
+++ b/ports/rp2/machine_pin.c
@@ -404,15 +404,13 @@ STATIC const mp_pin_p_t pin_pin_p = {
     .ioctl = pin_ioctl,
 };
 
-const mp_obj_type_t machine_pin_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Pin,
-    .print = machine_pin_print,
-    .make_new = mp_pin_make_new,
-    .call = machine_pin_call,
-    .protocol = &pin_pin_p,
-    .locals_dict = (mp_obj_t)&machine_pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, mp_pin_make_new,
+    print, machine_pin_print,
+    call, machine_pin_call,
+    protocol, &pin_pin_p,
+    locals_dict, (mp_obj_t)&machine_pin_locals_dict
+    );
 
 STATIC mp_uint_t machine_pin_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
     machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
diff --git a/ports/rp2/machine_rtc.c b/ports/rp2/machine_rtc.c
index 9d59124a66e1f..73bccecd2f679 100644
--- a/ports/rp2/machine_rtc.c
+++ b/ports/rp2/machine_rtc.c
@@ -115,9 +115,7 @@ STATIC const mp_rom_map_elem_t machine_rtc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_rtc_locals_dict, machine_rtc_locals_dict_table);
 
-const mp_obj_type_t machine_rtc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_RTC,
-    .make_new = machine_rtc_make_new,
-    .locals_dict = (mp_obj_t)&machine_rtc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_rtc_type, MP_QSTR_RTC, MP_TYPE_FLAG_NONE, machine_rtc_make_new,
+    locals_dict, (mp_obj_t)&machine_rtc_locals_dict
+    );
diff --git a/ports/rp2/machine_spi.c b/ports/rp2/machine_spi.c
index 332f44694548d..4b3bb43d888d0 100644
--- a/ports/rp2/machine_spi.c
+++ b/ports/rp2/machine_spi.c
@@ -274,11 +274,9 @@ STATIC const mp_machine_spi_p_t machine_spi_p = {
     .transfer = machine_spi_transfer,
 };
 
-const mp_obj_type_t machine_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SPI,
-    .print = machine_spi_print,
-    .make_new = machine_spi_make_new,
-    .protocol = &machine_spi_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_spi_type, MP_QSTR_SPI, MP_TYPE_FLAG_NONE, machine_spi_make_new,
+    print, machine_spi_print,
+    protocol, &machine_spi_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_spi_locals_dict
+    );
diff --git a/ports/rp2/machine_timer.c b/ports/rp2/machine_timer.c
index e7e8f02d5517c..9ccf554195fd3 100644
--- a/ports/rp2/machine_timer.c
+++ b/ports/rp2/machine_timer.c
@@ -156,10 +156,8 @@ STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
 
-const mp_obj_type_t machine_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = machine_timer_print,
-    .make_new = machine_timer_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_timer_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, machine_timer_make_new,
+    print, machine_timer_print,
+    locals_dict, (mp_obj_dict_t *)&machine_timer_locals_dict
+    );
diff --git a/ports/rp2/machine_uart.c b/ports/rp2/machine_uart.c
index fafa3c1b5678d..7584a54d70f46 100644
--- a/ports/rp2/machine_uart.c
+++ b/ports/rp2/machine_uart.c
@@ -552,13 +552,11 @@ STATIC const mp_stream_p_t uart_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = machine_uart_print,
-    .make_new = machine_uart_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&machine_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, machine_uart_make_new,
+    print, machine_uart_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &uart_stream_p,
+    locals_dict, (mp_obj_dict_t *)&machine_uart_locals_dict
+    );
diff --git a/ports/rp2/machine_wdt.c b/ports/rp2/machine_wdt.c
index 38e0597018d64..9a51aa42a0ee7 100644
--- a/ports/rp2/machine_wdt.c
+++ b/ports/rp2/machine_wdt.c
@@ -70,9 +70,7 @@ STATIC const mp_rom_map_elem_t machine_wdt_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_wdt_locals_dict, machine_wdt_locals_dict_table);
 
-const mp_obj_type_t machine_wdt_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_WDT,
-    .make_new = machine_wdt_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_wdt_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_wdt_type, MP_QSTR_WDT, MP_TYPE_FLAG_NONE, machine_wdt_make_new,
+    locals_dict, (mp_obj_dict_t *)&machine_wdt_locals_dict
+    );
diff --git a/ports/rp2/rp2_flash.c b/ports/rp2/rp2_flash.c
index 80bc1dc1df121..5457e14b19b64 100644
--- a/ports/rp2/rp2_flash.c
+++ b/ports/rp2/rp2_flash.c
@@ -150,9 +150,7 @@ STATIC const mp_rom_map_elem_t rp2_flash_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(rp2_flash_locals_dict, rp2_flash_locals_dict_table);
 
-const mp_obj_type_t rp2_flash_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Flash,
-    .make_new = rp2_flash_make_new,
-    .locals_dict = (mp_obj_dict_t *)&rp2_flash_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    rp2_flash_type, MP_QSTR_Flash, MP_TYPE_FLAG_NONE, rp2_flash_make_new,
+    locals_dict, (mp_obj_dict_t *)&rp2_flash_locals_dict
+    );
diff --git a/ports/rp2/rp2_pio.c b/ports/rp2/rp2_pio.c
index fe09ebe249e5f..843e587e0f3b5 100644
--- a/ports/rp2/rp2_pio.c
+++ b/ports/rp2/rp2_pio.c
@@ -371,13 +371,11 @@ STATIC const mp_rom_map_elem_t rp2_pio_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(rp2_pio_locals_dict, rp2_pio_locals_dict_table);
 
-const mp_obj_type_t rp2_pio_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_PIO,
-    .print = rp2_pio_print,
-    .make_new = rp2_pio_make_new,
-    .locals_dict = (mp_obj_dict_t *)&rp2_pio_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    rp2_pio_type, MP_QSTR_PIO, MP_TYPE_FLAG_NONE, rp2_pio_make_new,
+    print, rp2_pio_print,
+    locals_dict, (mp_obj_dict_t *)&rp2_pio_locals_dict
+    );
 
 STATIC mp_uint_t rp2_pio_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
     rp2_pio_obj_t *self = MP_OBJ_TO_PTR(self_in);
@@ -803,13 +801,11 @@ STATIC const mp_rom_map_elem_t rp2_state_machine_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(rp2_state_machine_locals_dict, rp2_state_machine_locals_dict_table);
 
-const mp_obj_type_t rp2_state_machine_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_StateMachine,
-    .print = rp2_state_machine_print,
-    .make_new = rp2_state_machine_make_new,
-    .locals_dict = (mp_obj_dict_t *)&rp2_state_machine_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    rp2_state_machine_type, MP_QSTR_StateMachine, MP_TYPE_FLAG_NONE, rp2_state_machine_make_new,
+    print, rp2_state_machine_print,
+    locals_dict, (mp_obj_dict_t *)&rp2_state_machine_locals_dict
+    );
 
 STATIC mp_uint_t rp2_state_machine_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
     rp2_state_machine_obj_t *self = MP_OBJ_TO_PTR(self_in);
diff --git a/ports/samd/machine_led.c b/ports/samd/machine_led.c
index f4dd1aeb3c65a..f02093c0b57f3 100644
--- a/ports/samd/machine_led.c
+++ b/ports/samd/machine_led.c
@@ -162,11 +162,9 @@ STATIC const mp_rom_map_elem_t machine_led_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_led_locals_dict, machine_led_locals_dict_table);
 
-const mp_obj_type_t machine_led_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LED,
-    .print = machine_led_print,
-    .make_new = mp_led_make_new,
-    .call = machine_led_call,
-    .locals_dict = (mp_obj_t)&machine_led_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_led_type, MP_QSTR_LED, MP_TYPE_FLAG_NONE, mp_led_make_new,
+    print, machine_led_print,
+    call, machine_led_call,
+    locals_dict, (mp_obj_t)&machine_led_locals_dict
+    );
diff --git a/ports/samd/machine_pin.c b/ports/samd/machine_pin.c
index 161a3ccddd2a4..d50f571ec8dd6 100644
--- a/ports/samd/machine_pin.c
+++ b/ports/samd/machine_pin.c
@@ -287,15 +287,13 @@ STATIC const mp_pin_p_t pin_pin_p = {
     .ioctl = pin_ioctl,
 };
 
-const mp_obj_type_t machine_pin_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Pin,
-    .print = machine_pin_print,
-    .make_new = mp_pin_make_new,
-    .call = machine_pin_call,
-    .protocol = &pin_pin_p,
-    .locals_dict = (mp_obj_t)&machine_pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, mp_pin_make_new,
+    print, machine_pin_print,
+    call, machine_pin_call,
+    protocol, &pin_pin_p,
+    locals_dict, (mp_obj_t)&machine_pin_locals_dict
+    );
 
 /*
 STATIC mp_uint_t machine_pin_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
diff --git a/ports/samd/samd_flash.c b/ports/samd/samd_flash.c
index 3bccf5577e2c8..547e7d64a0642 100644
--- a/ports/samd/samd_flash.c
+++ b/ports/samd/samd_flash.c
@@ -181,9 +181,7 @@ STATIC const mp_rom_map_elem_t samd_flash_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(samd_flash_locals_dict, samd_flash_locals_dict_table);
 
-const mp_obj_type_t samd_flash_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Flash,
-    .make_new = samd_flash_make_new,
-    .locals_dict = (mp_obj_dict_t *)&samd_flash_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    samd_flash_type, MP_QSTR_Flash, MP_TYPE_FLAG_NONE, samd_flash_make_new,
+    locals_dict, (mp_obj_dict_t *)&samd_flash_locals_dict
+    );
diff --git a/ports/stm32/accel.c b/ports/stm32/accel.c
index b07791a9a0b5a..2d67834278d06 100644
--- a/ports/stm32/accel.c
+++ b/ports/stm32/accel.c
@@ -281,11 +281,9 @@ STATIC const mp_rom_map_elem_t pyb_accel_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_accel_locals_dict, pyb_accel_locals_dict_table);
 
-const mp_obj_type_t pyb_accel_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Accel,
-    .make_new = pyb_accel_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_accel_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_accel_type, MP_QSTR_Accel, MP_TYPE_FLAG_NONE, pyb_accel_make_new,
+    locals_dict, (mp_obj_dict_t *)&pyb_accel_locals_dict
+    );
 
 #endif // MICROPY_HW_HAS_MMA7660 || MICROPY_HW_HAS_KXTJ3
diff --git a/ports/stm32/adc.c b/ports/stm32/adc.c
index c5ca6306e4088..bb088cecfa545 100644
--- a/ports/stm32/adc.c
+++ b/ports/stm32/adc.c
@@ -691,13 +691,11 @@ STATIC const mp_rom_map_elem_t adc_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(adc_locals_dict, adc_locals_dict_table);
 
-const mp_obj_type_t pyb_adc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADC,
-    .print = adc_print,
-    .make_new = adc_make_new,
-    .locals_dict = (mp_obj_dict_t *)&adc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_adc_type, MP_QSTR_ADC, MP_TYPE_FLAG_NONE, adc_make_new,
+    print, adc_print,
+    locals_dict, (mp_obj_dict_t *)&adc_locals_dict
+    );
 
 /******************************************************************************/
 /* adc all object                                                             */
@@ -897,11 +895,9 @@ STATIC const mp_rom_map_elem_t adc_all_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(adc_all_locals_dict, adc_all_locals_dict_table);
 
-const mp_obj_type_t pyb_adc_all_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADCAll,
-    .make_new = adc_all_make_new,
-    .locals_dict = (mp_obj_dict_t *)&adc_all_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_adc_all_type, MP_QSTR_ADCAll, MP_TYPE_FLAG_NONE, adc_all_make_new,
+    locals_dict, (mp_obj_dict_t *)&adc_all_locals_dict
+    );
 
 #endif // MICROPY_HW_ENABLE_ADC
diff --git a/ports/stm32/dac.c b/ports/stm32/dac.c
index b7fb0cbd708df..45ebfd0f2b6cd 100644
--- a/ports/stm32/dac.c
+++ b/ports/stm32/dac.c
@@ -502,12 +502,10 @@ STATIC const mp_rom_map_elem_t pyb_dac_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_dac_locals_dict, pyb_dac_locals_dict_table);
 
-const mp_obj_type_t pyb_dac_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_DAC,
-    .print = pyb_dac_print,
-    .make_new = pyb_dac_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_dac_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_dac_type, MP_QSTR_DAC, MP_TYPE_FLAG_NONE, pyb_dac_make_new,
+    print, pyb_dac_print,
+    locals_dict, (mp_obj_dict_t *)&pyb_dac_locals_dict
+    );
 
 #endif // MICROPY_HW_ENABLE_DAC
diff --git a/ports/stm32/extint.c b/ports/stm32/extint.c
index 55c9095f117e2..af44fb826dad4 100644
--- a/ports/stm32/extint.c
+++ b/ports/stm32/extint.c
@@ -633,13 +633,11 @@ STATIC const mp_rom_map_elem_t extint_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(extint_locals_dict, extint_locals_dict_table);
 
-const mp_obj_type_t extint_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ExtInt,
-    .print = extint_obj_print,
-    .make_new = extint_make_new,
-    .locals_dict = (mp_obj_dict_t *)&extint_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    extint_type, MP_QSTR_ExtInt, MP_TYPE_FLAG_NONE, extint_make_new,
+    print, extint_obj_print,
+    locals_dict, (mp_obj_dict_t *)&extint_locals_dict
+    );
 
 void extint_init0(void) {
     for (int i = 0; i < PYB_EXTI_NUM_VECTORS; i++) {
diff --git a/ports/stm32/lcd.c b/ports/stm32/lcd.c
index bfc9a0a5fd635..ef79a397342bb 100644
--- a/ports/stm32/lcd.c
+++ b/ports/stm32/lcd.c
@@ -526,11 +526,9 @@ STATIC const mp_rom_map_elem_t pyb_lcd_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_lcd_locals_dict, pyb_lcd_locals_dict_table);
 
-const mp_obj_type_t pyb_lcd_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LCD,
-    .make_new = pyb_lcd_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_lcd_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_lcd_type, MP_QSTR_LCD, MP_TYPE_FLAG_NONE, pyb_lcd_make_new,
+    locals_dict, (mp_obj_dict_t *)&pyb_lcd_locals_dict
+    );
 
 #endif // MICROPY_HW_HAS_LCD
diff --git a/ports/stm32/led.c b/ports/stm32/led.c
index 078327462ae15..f64a0d1cf46b0 100644
--- a/ports/stm32/led.c
+++ b/ports/stm32/led.c
@@ -381,13 +381,11 @@ STATIC const mp_rom_map_elem_t led_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(led_locals_dict, led_locals_dict_table);
 
-const mp_obj_type_t pyb_led_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LED,
-    .print = led_obj_print,
-    .make_new = led_obj_make_new,
-    .locals_dict = (mp_obj_dict_t *)&led_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_led_type, MP_QSTR_LED, MP_TYPE_FLAG_NONE, led_obj_make_new,
+    print, led_obj_print,
+    locals_dict, (mp_obj_dict_t *)&led_locals_dict
+    );
 
 #else
 // For boards with no LEDs, we leave an empty function here so that we don't
diff --git a/ports/stm32/machine_adc.c b/ports/stm32/machine_adc.c
index 819fd3414f68a..7f4418fe73d00 100644
--- a/ports/stm32/machine_adc.c
+++ b/ports/stm32/machine_adc.c
@@ -489,12 +489,10 @@ STATIC const mp_rom_map_elem_t machine_adc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_adc_locals_dict, machine_adc_locals_dict_table);
 
-const mp_obj_type_t machine_adc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ADC,
-    .print = machine_adc_print,
-    .make_new = machine_adc_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_adc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_adc_type, MP_QSTR_ADC, MP_TYPE_FLAG_NONE, machine_adc_make_new,
+    print, machine_adc_print,
+    locals_dict, (mp_obj_dict_t *)&machine_adc_locals_dict
+    );
 
 #endif
diff --git a/ports/stm32/machine_i2c.c b/ports/stm32/machine_i2c.c
index 0976c18c812ef..5bd9200eb1aec 100644
--- a/ports/stm32/machine_i2c.c
+++ b/ports/stm32/machine_i2c.c
@@ -236,13 +236,11 @@ STATIC const mp_machine_i2c_p_t machine_hard_i2c_p = {
     .transfer = machine_hard_i2c_transfer,
 };
 
-const mp_obj_type_t machine_hard_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2C,
-    .print = machine_hard_i2c_print,
-    .make_new = machine_hard_i2c_make_new,
-    .protocol = &machine_hard_i2c_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hard_i2c_type, MP_QSTR_I2C, MP_TYPE_FLAG_NONE, machine_hard_i2c_make_new,
+    print, machine_hard_i2c_print,
+    protocol, &machine_hard_i2c_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_i2c_locals_dict
+    );
 
 #endif // MICROPY_HW_ENABLE_HW_I2C
diff --git a/ports/stm32/machine_i2s.c b/ports/stm32/machine_i2s.c
index 2bb60a6a8664d..82fc41635aa2b 100644
--- a/ports/stm32/machine_i2s.c
+++ b/ports/stm32/machine_i2s.c
@@ -1115,15 +1115,13 @@ STATIC const mp_stream_p_t i2s_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_i2s_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2S,
-    .print = machine_i2s_print,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &i2s_stream_p,
-    .make_new = machine_i2s_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_i2s_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_i2s_type, MP_QSTR_I2S, MP_TYPE_FLAG_NONE, machine_i2s_make_new,
+    print, machine_i2s_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &i2s_stream_p,
+    locals_dict, (mp_obj_dict_t *)&machine_i2s_locals_dict
+    );
 
 #endif // MICROPY_HW_ENABLE_I2S
diff --git a/ports/stm32/machine_spi.c b/ports/stm32/machine_spi.c
index 37c026cefc33a..24bfc593bb9f9 100644
--- a/ports/stm32/machine_spi.c
+++ b/ports/stm32/machine_spi.c
@@ -135,11 +135,9 @@ STATIC const mp_machine_spi_p_t machine_hard_spi_p = {
     .transfer = machine_hard_spi_transfer,
 };
 
-const mp_obj_type_t machine_hard_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SPI,
-    .print = machine_hard_spi_print,
-    .make_new = machine_hard_spi_make_new,
-    .protocol = &machine_hard_spi_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hard_spi_type, MP_QSTR_SPI, MP_TYPE_FLAG_NONE, machine_hard_spi_make_new,
+    print, machine_hard_spi_print,
+    protocol, &machine_hard_spi_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_spi_locals_dict
+    );
diff --git a/ports/stm32/machine_timer.c b/ports/stm32/machine_timer.c
index c94532218773f..2f182ae01759b 100644
--- a/ports/stm32/machine_timer.c
+++ b/ports/stm32/machine_timer.c
@@ -136,10 +136,8 @@ STATIC const mp_rom_map_elem_t machine_timer_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(machine_timer_locals_dict, machine_timer_locals_dict_table);
 
-const mp_obj_type_t machine_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = machine_timer_print,
-    .make_new = machine_timer_make_new,
-    .locals_dict = (mp_obj_dict_t *)&machine_timer_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, machine_timer_make_new,
+    print, machine_timer_print,
+    locals_dict, (mp_obj_dict_t *)&machine_timer_locals_dict
+    );
diff --git a/ports/stm32/machine_uart.c b/ports/stm32/machine_uart.c
index 681939094b9ed..d4cf46ba86562 100644
--- a/ports/stm32/machine_uart.c
+++ b/ports/stm32/machine_uart.c
@@ -631,13 +631,11 @@ STATIC const mp_stream_p_t uart_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t pyb_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = pyb_uart_print,
-    .make_new = pyb_uart_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&pyb_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, pyb_uart_make_new,
+    print, pyb_uart_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &uart_stream_p,
+    locals_dict, (mp_obj_dict_t *)&pyb_uart_locals_dict
+    );
diff --git a/ports/stm32/modnwcc3k.c b/ports/stm32/modnwcc3k.c
index 952e535c2dbc6..443c74e0dc9d7 100644
--- a/ports/stm32/modnwcc3k.c
+++ b/ports/stm32/modnwcc3k.c
@@ -584,13 +584,13 @@ STATIC const mp_rom_map_elem_t cc3k_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(cc3k_locals_dict, cc3k_locals_dict_table);
 
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mod_network_nic_type_cc3k_base, MP_QSTR_CC3K, MP_TYPE_FLAG_NONE, cc3k_make_new,
+    locals_dict, (mp_obj_dict_t *)&cc3k_locals_dict
+    );
+
 const mod_network_nic_type_t mod_network_nic_type_cc3k = {
-    .base = {
-        { &mp_type_type },
-        .name = MP_QSTR_CC3K,
-        .make_new = cc3k_make_new,
-        .locals_dict = (mp_obj_dict_t *)&cc3k_locals_dict,
-    },
+    .base = mod_network_nic_type_cc3k_base,
     .gethostbyname = cc3k_gethostbyname,
     .socket = cc3k_socket_socket,
     .close = cc3k_socket_close,
diff --git a/ports/stm32/modnwwiznet5k.c b/ports/stm32/modnwwiznet5k.c
index f7adad3f317c6..12d33cabecbca 100644
--- a/ports/stm32/modnwwiznet5k.c
+++ b/ports/stm32/modnwwiznet5k.c
@@ -487,13 +487,13 @@ STATIC const mp_rom_map_elem_t wiznet5k_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(wiznet5k_locals_dict, wiznet5k_locals_dict_table);
 
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mod_network_nic_type_wiznet5k_base, MP_QSTR_WIZNET5K, MP_TYPE_FLAG_NONE, wiznet5k_make_new,
+    locals_dict, (mp_obj_dict_t *)&wiznet5k_locals_dict
+    );
+
 const mod_network_nic_type_t mod_network_nic_type_wiznet5k = {
-    .base = {
-        { &mp_type_type },
-        .name = MP_QSTR_WIZNET5K,
-        .make_new = wiznet5k_make_new,
-        .locals_dict = (mp_obj_dict_t *)&wiznet5k_locals_dict,
-    },
+    .base = mod_network_nic_type_wiznet5k_base,
     .gethostbyname = wiznet5k_gethostbyname,
     .socket = wiznet5k_socket_socket,
     .close = wiznet5k_socket_close,
diff --git a/ports/stm32/network_lan.c b/ports/stm32/network_lan.c
index f19916a1df091..5d0b80ac35ba0 100644
--- a/ports/stm32/network_lan.c
+++ b/ports/stm32/network_lan.c
@@ -158,12 +158,10 @@ STATIC const mp_rom_map_elem_t network_lan_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(network_lan_locals_dict, network_lan_locals_dict_table);
 
-const mp_obj_type_t network_lan_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LAN,
-    .print = network_lan_print,
-    .make_new = network_lan_make_new,
-    .locals_dict = (mp_obj_dict_t *)&network_lan_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    network_lan_type, MP_QSTR_LAN, MP_TYPE_FLAG_NONE, network_lan_make_new,
+    print, network_lan_print,
+    locals_dict, (mp_obj_dict_t *)&network_lan_locals_dict
+    );
 
 #endif // defined(MICROPY_HW_ETH_MDC)
diff --git a/ports/stm32/network_wiznet5k.c b/ports/stm32/network_wiznet5k.c
index a529191557ba9..42672b5a7918c 100644
--- a/ports/stm32/network_wiznet5k.c
+++ b/ports/stm32/network_wiznet5k.c
@@ -455,11 +455,9 @@ STATIC const mp_rom_map_elem_t wiznet5k_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(wiznet5k_locals_dict, wiznet5k_locals_dict_table);
 
-const mp_obj_type_t mod_network_nic_type_wiznet5k = {
-    { &mp_type_type },
-    .name = MP_QSTR_WIZNET5K,
-    .make_new = wiznet5k_make_new,
-    .locals_dict = (mp_obj_dict_t *)&wiznet5k_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mod_network_nic_type_wiznet5k, MP_QSTR_WIZNET5K, MP_TYPE_FLAG_NONE, wiznet5k_make_new,
+    locals_dict, (mp_obj_dict_t *)&wiznet5k_locals_dict
+    );
 
 #endif // MICROPY_PY_WIZNET5K && MICROPY_PY_LWIP
diff --git a/ports/stm32/pin.c b/ports/stm32/pin.c
index b490a09b7faa7..418996f9fa46d 100644
--- a/ports/stm32/pin.c
+++ b/ports/stm32/pin.c
@@ -592,15 +592,13 @@ STATIC const mp_pin_p_t pin_pin_p = {
     .ioctl = pin_ioctl,
 };
 
-const mp_obj_type_t pin_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Pin,
-    .print = pin_print,
-    .make_new = mp_pin_make_new,
-    .call = pin_call,
-    .protocol = &pin_pin_p,
-    .locals_dict = (mp_obj_dict_t *)&pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, mp_pin_make_new,
+    print, pin_print,
+    call, pin_call,
+    protocol, &pin_pin_p,
+    locals_dict, (mp_obj_dict_t *)&pin_locals_dict
+    );
 
 /// \moduleref pyb
 /// \class PinAF - Pin Alternate Functions
@@ -669,9 +667,8 @@ STATIC const mp_rom_map_elem_t pin_af_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pin_af_locals_dict, pin_af_locals_dict_table);
 
-const mp_obj_type_t pin_af_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_PinAF,
-    .print = pin_af_obj_print,
-    .locals_dict = (mp_obj_dict_t *)&pin_af_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_af_type, MP_QSTR_PinAF, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, pin_af_obj_print,
+    locals_dict, (mp_obj_dict_t *)&pin_af_locals_dict
+    );
diff --git a/ports/stm32/pin_named_pins.c b/ports/stm32/pin_named_pins.c
index 3a8e0f9fce9da..4a829bca81f83 100644
--- a/ports/stm32/pin_named_pins.c
+++ b/ports/stm32/pin_named_pins.c
@@ -31,17 +31,15 @@
 #include "py/mphal.h"
 #include "pin.h"
 
-const mp_obj_type_t pin_cpu_pins_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_cpu,
-    .locals_dict = (mp_obj_dict_t *)&pin_cpu_pins_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_cpu_pins_obj_type, MP_QSTR_cpu, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t *)&pin_cpu_pins_locals_dict
+    );
 
-const mp_obj_type_t pin_board_pins_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_board,
-    .locals_dict = (mp_obj_dict_t *)&pin_board_pins_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pin_board_pins_obj_type, MP_QSTR_board, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    locals_dict, (mp_obj_dict_t *)&pin_board_pins_locals_dict
+    );
 
 const pin_obj_t *pin_find_named_pin(const mp_obj_dict_t *named_pins, mp_obj_t name) {
     const mp_map_t *named_map = &named_pins->map;
diff --git a/ports/stm32/pyb_can.c b/ports/stm32/pyb_can.c
index aa2d83a64e582..9e11ba3307480 100644
--- a/ports/stm32/pyb_can.c
+++ b/ports/stm32/pyb_can.c
@@ -1073,13 +1073,11 @@ STATIC const mp_stream_p_t can_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t pyb_can_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_CAN,
-    .print = pyb_can_print,
-    .make_new = pyb_can_make_new,
-    .protocol = &can_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&pyb_can_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_can_type, MP_QSTR_CAN, MP_TYPE_FLAG_NONE, pyb_can_make_new,
+    print, pyb_can_print,
+    protocol, &can_stream_p,
+    locals_dict, (mp_obj_dict_t *)&pyb_can_locals_dict
+    );
 
 #endif // MICROPY_HW_ENABLE_CAN
diff --git a/ports/stm32/pyb_i2c.c b/ports/stm32/pyb_i2c.c
index 5cd7c0c8b06d0..ba3fd82c4a0bf 100644
--- a/ports/stm32/pyb_i2c.c
+++ b/ports/stm32/pyb_i2c.c
@@ -1084,12 +1084,10 @@ STATIC const mp_rom_map_elem_t pyb_i2c_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_i2c_locals_dict, pyb_i2c_locals_dict_table);
 
-const mp_obj_type_t pyb_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2C,
-    .print = pyb_i2c_print,
-    .make_new = pyb_i2c_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_i2c_type, MP_QSTR_I2C, MP_TYPE_FLAG_NONE, pyb_i2c_make_new,
+    print, pyb_i2c_print,
+    locals_dict, (mp_obj_dict_t *)&pyb_i2c_locals_dict
+    );
 
 #endif // MICROPY_PY_PYB_LEGACY && MICROPY_HW_ENABLE_HW_I2C
diff --git a/ports/stm32/pyb_spi.c b/ports/stm32/pyb_spi.c
index abb7ba41db0d1..0340b393aaf3c 100644
--- a/ports/stm32/pyb_spi.c
+++ b/ports/stm32/pyb_spi.c
@@ -350,11 +350,9 @@ STATIC const mp_machine_spi_p_t pyb_spi_p = {
     .transfer = spi_transfer_machine,
 };
 
-const mp_obj_type_t pyb_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SPI,
-    .print = pyb_spi_print,
-    .make_new = pyb_spi_make_new,
-    .protocol = &pyb_spi_p,
-    .locals_dict = (mp_obj_dict_t *)&pyb_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_spi_type, MP_QSTR_SPI, MP_TYPE_FLAG_NONE, pyb_spi_make_new,
+    print, pyb_spi_print,
+    protocol, &pyb_spi_p,
+    locals_dict, (mp_obj_dict_t *)&pyb_spi_locals_dict
+    );
diff --git a/ports/stm32/rtc.c b/ports/stm32/rtc.c
index e776f67bb9b09..d08670a1fc42d 100644
--- a/ports/stm32/rtc.c
+++ b/ports/stm32/rtc.c
@@ -831,9 +831,7 @@ STATIC const mp_rom_map_elem_t pyb_rtc_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_rtc_locals_dict, pyb_rtc_locals_dict_table);
 
-const mp_obj_type_t pyb_rtc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_RTC,
-    .make_new = pyb_rtc_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_rtc_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_rtc_type, MP_QSTR_RTC, MP_TYPE_FLAG_NONE, pyb_rtc_make_new,
+    locals_dict, (mp_obj_dict_t *)&pyb_rtc_locals_dict
+    );
diff --git a/ports/stm32/sdcard.c b/ports/stm32/sdcard.c
index 6f5892570baf2..2f3f39c3777a5 100644
--- a/ports/stm32/sdcard.c
+++ b/ports/stm32/sdcard.c
@@ -872,21 +872,17 @@ STATIC const mp_rom_map_elem_t pyb_sdcard_locals_dict_table[] = {
 STATIC MP_DEFINE_CONST_DICT(pyb_sdcard_locals_dict, pyb_sdcard_locals_dict_table);
 
 #if MICROPY_HW_ENABLE_SDCARD
-const mp_obj_type_t pyb_sdcard_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SDCard,
-    .make_new = pyb_sdcard_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_sdcard_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_sdcard_type, MP_QSTR_SDCard, MP_TYPE_FLAG_NONE, pyb_sdcard_make_new,
+    locals_dict, (mp_obj_dict_t *)&pyb_sdcard_locals_dict
+    );
 #endif
 
 #if MICROPY_HW_ENABLE_MMCARD
-const mp_obj_type_t pyb_mmcard_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_MMCard,
-    .make_new = pyb_mmcard_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_sdcard_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_mmcard_type, MP_QSTR_MMCard, MP_TYPE_FLAG_NONE, pyb_mmcard_make_new,
+    locals_dict, (mp_obj_dict_t *)&pyb_sdcard_locals_dict
+    );
 #endif
 
 void sdcard_init_vfs(fs_user_mount_t *vfs, int part) {
diff --git a/ports/stm32/servo.c b/ports/stm32/servo.c
index 17084224637ec..2c04026bee2c6 100644
--- a/ports/stm32/servo.c
+++ b/ports/stm32/servo.c
@@ -336,12 +336,10 @@ STATIC const mp_rom_map_elem_t pyb_servo_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_servo_locals_dict, pyb_servo_locals_dict_table);
 
-const mp_obj_type_t pyb_servo_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Servo,
-    .print = pyb_servo_print,
-    .make_new = pyb_servo_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_servo_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_servo_type, MP_QSTR_Servo, MP_TYPE_FLAG_NONE, pyb_servo_make_new,
+    print, pyb_servo_print,
+    locals_dict, (mp_obj_dict_t *)&pyb_servo_locals_dict
+    );
 
 #endif // MICROPY_HW_ENABLE_SERVO
diff --git a/ports/stm32/storage.c b/ports/stm32/storage.c
index fcc6d51b3d2a1..dd8bd0852fdd7 100644
--- a/ports/stm32/storage.c
+++ b/ports/stm32/storage.c
@@ -450,13 +450,11 @@ STATIC const mp_rom_map_elem_t pyb_flash_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_flash_locals_dict, pyb_flash_locals_dict_table);
 
-const mp_obj_type_t pyb_flash_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Flash,
-    .print = pyb_flash_print,
-    .make_new = pyb_flash_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_flash_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_flash_type, MP_QSTR_Flash, MP_TYPE_FLAG_NONE, pyb_flash_make_new,
+    print, pyb_flash_print,
+    locals_dict, (mp_obj_dict_t *)&pyb_flash_locals_dict
+    );
 
 void pyb_flash_init_vfs(fs_user_mount_t *vfs) {
     vfs->base.type = &mp_fat_vfs_type;
diff --git a/ports/stm32/timer.c b/ports/stm32/timer.c
index 12f0515d4e99f..f53adb2c8e180 100644
--- a/ports/stm32/timer.c
+++ b/ports/stm32/timer.c
@@ -1455,13 +1455,11 @@ STATIC const mp_rom_map_elem_t pyb_timer_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_timer_locals_dict, pyb_timer_locals_dict_table);
 
-const mp_obj_type_t pyb_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = pyb_timer_print,
-    .make_new = pyb_timer_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_timer_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, pyb_timer_make_new,
+    print, pyb_timer_print,
+    locals_dict, (mp_obj_dict_t *)&pyb_timer_locals_dict
+    );
 
 /// \moduleref pyb
 /// \class TimerChannel - setup a channel for a timer.
@@ -1591,12 +1589,11 @@ STATIC const mp_rom_map_elem_t pyb_timer_channel_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_timer_channel_locals_dict, pyb_timer_channel_locals_dict_table);
 
-STATIC const mp_obj_type_t pyb_timer_channel_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_TimerChannel,
-    .print = pyb_timer_channel_print,
-    .locals_dict = (mp_obj_dict_t *)&pyb_timer_channel_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_timer_channel_type, MP_QSTR_TimerChannel, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, pyb_timer_channel_print,
+    locals_dict, (mp_obj_dict_t *)&pyb_timer_channel_locals_dict
+    );
 
 STATIC void timer_handle_irq_channel(pyb_timer_obj_t *tim, uint8_t channel, mp_obj_t callback) {
     uint32_t irq_mask = TIMER_IRQ_MASK(channel);
diff --git a/ports/stm32/usb.c b/ports/stm32/usb.c
index 9a9600f89d6c8..b24205cc816af 100644
--- a/ports/stm32/usb.c
+++ b/ports/stm32/usb.c
@@ -918,16 +918,14 @@ STATIC const mp_stream_p_t pyb_usb_vcp_stream_p = {
     .ioctl = pyb_usb_vcp_ioctl,
 };
 
-const mp_obj_type_t pyb_usb_vcp_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_USB_VCP,
-    .print = pyb_usb_vcp_print,
-    .make_new = pyb_usb_vcp_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &pyb_usb_vcp_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&pyb_usb_vcp_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_usb_vcp_type, MP_QSTR_USB_VCP, MP_TYPE_FLAG_NONE, pyb_usb_vcp_make_new,
+    print, pyb_usb_vcp_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &pyb_usb_vcp_stream_p,
+    locals_dict, (mp_obj_dict_t *)&pyb_usb_vcp_locals_dict
+    );
 
 /******************************************************************************/
 // MicroPython bindings for USB HID
@@ -1059,13 +1057,11 @@ STATIC const mp_stream_p_t pyb_usb_hid_stream_p = {
     .ioctl = pyb_usb_hid_ioctl,
 };
 
-const mp_obj_type_t pyb_usb_hid_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_USB_HID,
-    .make_new = pyb_usb_hid_make_new,
-    .protocol = &pyb_usb_hid_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&pyb_usb_hid_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_usb_hid_type, MP_QSTR_USB_HID, MP_TYPE_FLAG_NONE, pyb_usb_hid_make_new,
+    protocol, &pyb_usb_hid_stream_p,
+    locals_dict, (mp_obj_dict_t *)&pyb_usb_hid_locals_dict
+    );
 
 #endif // MICROPY_HW_USB_HID
 
diff --git a/ports/stm32/usrsw.c b/ports/stm32/usrsw.c
index 596efba0530a7..eb77740ce2951 100644
--- a/ports/stm32/usrsw.c
+++ b/ports/stm32/usrsw.c
@@ -134,13 +134,11 @@ STATIC const mp_rom_map_elem_t pyb_switch_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_switch_locals_dict, pyb_switch_locals_dict_table);
 
-const mp_obj_type_t pyb_switch_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Switch,
-    .print = pyb_switch_print,
-    .make_new = pyb_switch_make_new,
-    .call = pyb_switch_call,
-    .locals_dict = (mp_obj_dict_t *)&pyb_switch_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_switch_type, MP_QSTR_Switch, MP_TYPE_FLAG_NONE, pyb_switch_make_new,
+    print, pyb_switch_print,
+    call, pyb_switch_call,
+    locals_dict, (mp_obj_dict_t *)&pyb_switch_locals_dict
+    );
 
 #endif // MICROPY_HW_HAS_SWITCH
diff --git a/ports/stm32/wdt.c b/ports/stm32/wdt.c
index d794607bc0a71..73b8b81cd00c7 100644
--- a/ports/stm32/wdt.c
+++ b/ports/stm32/wdt.c
@@ -102,9 +102,7 @@ STATIC const mp_rom_map_elem_t pyb_wdt_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_wdt_locals_dict, pyb_wdt_locals_dict_table);
 
-const mp_obj_type_t pyb_wdt_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_WDT,
-    .make_new = pyb_wdt_make_new,
-    .locals_dict = (mp_obj_dict_t *)&pyb_wdt_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_wdt_type, MP_QSTR_WDT, MP_TYPE_FLAG_NONE, pyb_wdt_make_new,
+    locals_dict, (mp_obj_dict_t *)&pyb_wdt_locals_dict
+    );
diff --git a/ports/teensy/led.c b/ports/teensy/led.c
index d79e63cf7102a..1f549015fd643 100644
--- a/ports/teensy/led.c
+++ b/ports/teensy/led.c
@@ -134,10 +134,8 @@ STATIC const mp_rom_map_elem_t led_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(led_locals_dict, led_locals_dict_table);
 
-const mp_obj_type_t pyb_led_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_LED,
-    .print = led_obj_print,
-    .make_new = led_obj_make_new,
-    .locals_dict = (mp_obj_t)&led_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_led_type, MP_QSTR_LED, MP_TYPE_FLAG_NONE, led_obj_make_new,
+    print, led_obj_print,
+    locals_dict, (mp_obj_t)&led_locals_dict
+    );
diff --git a/ports/teensy/timer.c b/ports/teensy/timer.c
index 68dc965eb8bc8..a31c6faa92a08 100644
--- a/ports/teensy/timer.c
+++ b/ports/teensy/timer.c
@@ -746,13 +746,11 @@ STATIC const mp_rom_map_elem_t pyb_timer_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_timer_locals_dict, pyb_timer_locals_dict_table);
 
-const mp_obj_type_t pyb_timer_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Timer,
-    .print = pyb_timer_print,
-    .make_new = pyb_timer_make_new,
-    .locals_dict = (mp_obj_t)&pyb_timer_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_timer_type, MP_QSTR_Timer, MP_TYPE_FLAG_NONE, pyb_timer_make_new,
+    print, pyb_timer_print,
+    locals_dict, (mp_obj_t)&pyb_timer_locals_dict
+    );
 
 /// \moduleref pyb
 /// \class TimerChannel - setup a channel for a timer.
@@ -889,12 +887,11 @@ STATIC const mp_rom_map_elem_t pyb_timer_channel_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(pyb_timer_channel_locals_dict, pyb_timer_channel_locals_dict_table);
 
-STATIC const mp_obj_type_t pyb_timer_channel_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_TimerChannel,
-    .print = pyb_timer_channel_print,
-    .locals_dict = (mp_obj_t)&pyb_timer_channel_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_timer_channel_type, MP_QSTR_TimerChannel, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, pyb_timer_channel_print,
+    locals_dict, (mp_obj_t)&pyb_timer_channel_locals_dict
+    );
 
 STATIC bool ftm_handle_irq_callback(pyb_timer_obj_t *self, mp_uint_t channel, mp_obj_t callback) {
     // execute callback if it's set
diff --git a/ports/teensy/uart.c b/ports/teensy/uart.c
index 6373047b004f6..19239fa007d8e 100644
--- a/ports/teensy/uart.c
+++ b/ports/teensy/uart.c
@@ -484,10 +484,8 @@ STATIC const mp_rom_map_elem_t pyb_uart_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(pyb_uart_locals_dict, pyb_uart_locals_dict_table);
 
-const mp_obj_type_t pyb_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = pyb_uart_print,
-    .make_new = pyb_uart_make_new,
-    .locals_dict = (mp_obj_t)&pyb_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    pyb_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, pyb_uart_make_new,
+    print, pyb_uart_print,
+    locals_dict, (mp_obj_t)&pyb_uart_locals_dict
+    );
diff --git a/ports/unix/Makefile b/ports/unix/Makefile
index d93cdf5d7f574..0d60bad4855a3 100644
--- a/ports/unix/Makefile
+++ b/ports/unix/Makefile
@@ -37,7 +37,7 @@ INC += -I$(BUILD)
 
 # compiler settings
 CWARN = -Wall -Werror
-CWARN += -Wextra -Wno-unused-parameter -Wpointer-arith -Wdouble-promotion -Wfloat-conversion
+CWARN += -Wextra -Wno-unused-parameter -Wpointer-arith -Wdouble-promotion -Wfloat-conversion -Wno-missing-field-initializers
 CFLAGS += $(INC) $(CWARN) -std=gnu99 -DUNIX $(CFLAGS_MOD) $(COPT) -I$(VARIANT_DIR) $(CFLAGS_EXTRA)
 
 # Debugging/Optimization
diff --git a/ports/unix/coverage.c b/ports/unix/coverage.c
index a855237200128..dcd4fa4c1d3eb 100644
--- a/ports/unix/coverage.c
+++ b/ports/unix/coverage.c
@@ -106,11 +106,11 @@ STATIC const mp_stream_p_t fileio_stream_p = {
     .ioctl = stest_ioctl,
 };
 
-STATIC const mp_obj_type_t mp_type_stest_fileio = {
-    { &mp_type_type },
-    .protocol = &fileio_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&rawfile_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_stest_fileio, MP_QSTR_stest_fileio, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    protocol, &fileio_stream_p,
+    locals_dict, (mp_obj_dict_t *)&rawfile_locals_dict
+    );
 
 // stream read returns non-blocking error
 STATIC mp_uint_t stest_read2(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
@@ -133,11 +133,11 @@ STATIC const mp_stream_p_t textio_stream_p2 = {
     .is_text = true,
 };
 
-STATIC const mp_obj_type_t mp_type_stest_textio2 = {
-    { &mp_type_type },
-    .protocol = &textio_stream_p2,
-    .locals_dict = (mp_obj_dict_t *)&rawfile_locals_dict2,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_stest_textio2, MP_QSTR_stest_textio2, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    protocol, &textio_stream_p2,
+    locals_dict, (mp_obj_dict_t *)&rawfile_locals_dict2
+    );
 
 // str/bytes objects without a valid hash
 STATIC const mp_obj_str_t str_no_hash_obj = {{&mp_type_str}, 0, 10, (const byte *)"0123456789"};
diff --git a/ports/unix/modffi.c b/ports/unix/modffi.c
index 0ff37a99f5be3..a128e7e2cb0d2 100644
--- a/ports/unix/modffi.c
+++ b/ports/unix/modffi.c
@@ -423,13 +423,11 @@ STATIC const mp_rom_map_elem_t ffimod_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ffimod_locals_dict, ffimod_locals_dict_table);
 
-STATIC const mp_obj_type_t ffimod_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ffimod,
-    .print = ffimod_print,
-    .make_new = ffimod_make_new,
-    .locals_dict = (mp_obj_dict_t *)&ffimod_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    ffimod_type, MP_QSTR_ffimod, MP_TYPE_FLAG_NONE, ffimod_make_new,
+    print, ffimod_print,
+    locals_dict, (mp_obj_dict_t *)&ffimod_locals_dict
+    );
 
 // FFI function
 
@@ -507,10 +505,10 @@ STATIC mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
         } else if (mp_obj_is_str(a)) {
             const char *s = mp_obj_str_get_str(a);
             values[i].ffi = (ffi_arg)(intptr_t)s;
-        } else if (((mp_obj_base_t *)MP_OBJ_TO_PTR(a))->type->buffer_p.get_buffer != NULL) {
+        } else if (MP_OBJ_TYPE_HAS_SLOT(((mp_obj_base_t *)MP_OBJ_TO_PTR(a))->type, buffer)) {
             mp_obj_base_t *o = (mp_obj_base_t *)MP_OBJ_TO_PTR(a);
             mp_buffer_info_t bufinfo;
-            int ret = o->type->buffer_p.get_buffer(MP_OBJ_FROM_PTR(o), &bufinfo, MP_BUFFER_READ); // TODO: MP_BUFFER_READ?
+            int ret = MP_OBJ_TYPE_GET_SLOT(o->type, buffer)(MP_OBJ_FROM_PTR(o), &bufinfo, MP_BUFFER_READ); // TODO: MP_BUFFER_READ?
             if (ret != 0) {
                 goto error;
             }
@@ -532,12 +530,11 @@ STATIC mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
     mp_raise_TypeError(MP_ERROR_TEXT("don't know how to pass object to native function"));
 }
 
-STATIC const mp_obj_type_t ffifunc_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ffifunc,
-    .print = ffifunc_print,
-    .call = ffifunc_call,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    ffifunc_type, MP_QSTR_ffifunc, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, ffifunc_print,
+    call, ffifunc_call
+    );
 
 // FFI callback for Python function
 
@@ -558,12 +555,11 @@ STATIC const mp_rom_map_elem_t fficallback_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(fficallback_locals_dict, fficallback_locals_dict_table);
 
-STATIC const mp_obj_type_t fficallback_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_fficallback,
-    .print = fficallback_print,
-    .locals_dict = (mp_obj_dict_t *)&fficallback_locals_dict
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    fficallback_type, MP_QSTR_fficallback, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, fficallback_print,
+    locals_dict, (mp_obj_dict_t *)&fficallback_locals_dict
+    );
 
 // FFI variable
 
@@ -594,21 +590,19 @@ STATIC const mp_rom_map_elem_t ffivar_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(ffivar_locals_dict, ffivar_locals_dict_table);
 
-STATIC const mp_obj_type_t ffivar_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_ffivar,
-    .print = ffivar_print,
-    .locals_dict = (mp_obj_dict_t *)&ffivar_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    ffivar_type, MP_QSTR_ffivar, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, ffivar_print,
+    locals_dict, (mp_obj_dict_t *)&ffivar_locals_dict
+    );
 
 // Generic opaque storage object (unused)
 
 /*
-STATIC const mp_obj_type_t opaque_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_opaqueval,
-//    .print = opaque_print,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    opaque_type, MP_QSTR_opaqueval, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    //    .print = opaque_print,
+    );
 */
 
 STATIC mp_obj_t mod_ffi_open(size_t n_args, const mp_obj_t *args) {
diff --git a/ports/unix/modjni.c b/ports/unix/modjni.c
index bd151050eae49..d8ef0cde46e8f 100644
--- a/ports/unix/modjni.c
+++ b/ports/unix/modjni.c
@@ -173,14 +173,13 @@ STATIC const mp_rom_map_elem_t jclass_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(jclass_locals_dict, jclass_locals_dict_table);
 
-STATIC const mp_obj_type_t jclass_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_jclass,
-    .print = jclass_print,
-    .attr = jclass_attr,
-    .call = jclass_call,
-    .locals_dict = (mp_obj_dict_t *)&jclass_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    jclass_type, MP_QSTR_jclass, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, jclass_print,
+    attr, jclass_attr,
+    call, jclass_call,
+    locals_dict, (mp_obj_dict_t *)&jclass_locals_dict
+    );
 
 STATIC mp_obj_t new_jclass(jclass jc) {
     mp_obj_jclass_t *o = m_new_obj(mp_obj_jclass_t);
@@ -321,16 +320,15 @@ STATIC mp_obj_t subscr_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
     return mp_obj_new_getitem_iter(dest, iter_buf);
 }
 
-STATIC const mp_obj_type_t jobject_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_jobject,
-    .print = jobject_print,
-    .unary_op = jobject_unary_op,
-    .attr = jobject_attr,
-    .subscr = jobject_subscr,
-    .getiter = subscr_getiter,
-//    .locals_dict = (mp_obj_dict_t*)&jobject_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    jobject_type, MP_QSTR_jobject, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, jobject_print,
+    unary_op, jobject_unary_op,
+    attr, jobject_attr,
+    subscr, jobject_subscr,
+    getiter, subscr_getiter,
+    //    .locals_dict = (mp_obj_dict_t*)&jobject_locals_dict,
+    );
 
 STATIC mp_obj_t new_jobject(jobject jo) {
     if (jo == NULL) {
@@ -569,14 +567,13 @@ STATIC mp_obj_t jmethod_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
     return call_method(self->obj, name, methods, false, n_args, args);
 }
 
-STATIC const mp_obj_type_t jmethod_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_jmethod,
-    .print = jmethod_print,
-    .call = jmethod_call,
-//    .attr = jobject_attr,
-//    .locals_dict = (mp_obj_dict_t*)&jobject_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    jmethod_type, MP_QSTR_jmethod, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, jmethod_print,
+    call, jmethod_call,
+    //    .attr = jobject_attr,
+    //    .locals_dict = (mp_obj_dict_t*)&jobject_locals_dict,
+    );
 
 #ifdef __ANDROID__
 #define LIBJVM_SO "libdvm.so"
diff --git a/ports/unix/moduselect.c b/ports/unix/moduselect.c
index a9390a146bd05..2d3abacf9430a 100644
--- a/ports/unix/moduselect.c
+++ b/ports/unix/moduselect.c
@@ -311,13 +311,12 @@ STATIC const mp_rom_map_elem_t poll_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(poll_locals_dict, poll_locals_dict_table);
 
-STATIC const mp_obj_type_t mp_type_poll = {
-    { &mp_type_type },
-    .name = MP_QSTR_poll,
-    .getiter = mp_identity_getiter,
-    .iternext = poll_iternext,
-    .locals_dict = (void *)&poll_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_poll, MP_QSTR_poll, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    getiter, mp_identity_getiter,
+    iternext, poll_iternext,
+    locals_dict, (void *)&poll_locals_dict
+    );
 
 STATIC mp_obj_t select_poll(size_t n_args, const mp_obj_t *args) {
     int alloc = 4;
diff --git a/ports/unix/modusocket.c b/ports/unix/modusocket.c
index a516ed9c24ef6..65874fe81f52b 100644
--- a/ports/unix/modusocket.c
+++ b/ports/unix/modusocket.c
@@ -515,16 +515,14 @@ STATIC const mp_stream_p_t usocket_stream_p = {
     .ioctl = socket_ioctl,
 };
 
-const mp_obj_type_t mp_type_socket = {
-    { &mp_type_type },
-    .name = MP_QSTR_socket,
-    .print = socket_print,
-    .make_new = socket_make_new,
-    .getiter = NULL,
-    .iternext = NULL,
-    .protocol = &usocket_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&usocket_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_socket, MP_QSTR_socket, MP_TYPE_FLAG_NONE, socket_make_new,
+    print, socket_print,
+    getiter, NULL,
+    iternext, NULL,
+    protocol, &usocket_stream_p,
+    locals_dict, (mp_obj_dict_t *)&usocket_locals_dict
+    );
 
 #define BINADDR_MAX_LEN sizeof(struct in6_addr)
 STATIC mp_obj_t mod_socket_inet_pton(mp_obj_t family_in, mp_obj_t addr_in) {
diff --git a/ports/zephyr/machine_i2c.c b/ports/zephyr/machine_i2c.c
index 810c3e5a9ea25..21d9948f075b2 100644
--- a/ports/zephyr/machine_i2c.c
+++ b/ports/zephyr/machine_i2c.c
@@ -128,13 +128,11 @@ STATIC const mp_machine_i2c_p_t machine_hard_i2c_p = {
     .transfer_single = machine_hard_i2c_transfer_single,
 };
 
-const mp_obj_type_t machine_hard_i2c_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_I2C,
-    .print = machine_hard_i2c_print,
-    .make_new = machine_hard_i2c_make_new,
-    .protocol = &machine_hard_i2c_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_i2c_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hard_i2c_type, MP_QSTR_I2C, MP_TYPE_FLAG_NONE, machine_hard_i2c_make_new,
+    print, machine_hard_i2c_print,
+    protocol, &machine_hard_i2c_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_i2c_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_I2C
diff --git a/ports/zephyr/machine_pin.c b/ports/zephyr/machine_pin.c
index f9da2433c03f9..200b97d432b0e 100644
--- a/ports/zephyr/machine_pin.c
+++ b/ports/zephyr/machine_pin.c
@@ -285,15 +285,13 @@ STATIC const mp_pin_p_t machine_pin_pin_p = {
     .ioctl = machine_pin_ioctl,
 };
 
-const mp_obj_type_t machine_pin_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Pin,
-    .print = machine_pin_print,
-    .make_new = mp_pin_make_new,
-    .call = machine_pin_call,
-    .protocol = &machine_pin_pin_p,
-    .locals_dict = (mp_obj_t)&machine_pin_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_pin_type, MP_QSTR_Pin, MP_TYPE_FLAG_NONE, mp_pin_make_new,
+    print, machine_pin_print,
+    call, machine_pin_call,
+    protocol, &machine_pin_pin_p,
+    locals_dict, (mp_obj_t)&machine_pin_locals_dict
+    );
 
 STATIC mp_uint_t machine_pin_irq_trigger(mp_obj_t self_in, mp_uint_t new_trigger) {
     machine_pin_obj_t *self = MP_OBJ_TO_PTR(self_in);
diff --git a/ports/zephyr/machine_spi.c b/ports/zephyr/machine_spi.c
index 2add7ff60b064..d0135d91912f7 100644
--- a/ports/zephyr/machine_spi.c
+++ b/ports/zephyr/machine_spi.c
@@ -199,13 +199,11 @@ STATIC const mp_machine_spi_p_t machine_hard_spi_p = {
     .transfer = machine_hard_spi_transfer,
 };
 
-const mp_obj_type_t machine_hard_spi_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_SPI,
-    .print = machine_hard_spi_print,
-    .make_new = machine_hard_spi_make_new,
-    .protocol = &machine_hard_spi_p,
-    .locals_dict = (mp_obj_dict_t *)&mp_machine_spi_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_hard_spi_type, MP_QSTR_SPI, MP_TYPE_FLAG_NONE, machine_hard_spi_make_new,
+    print, machine_hard_spi_print,
+    protocol, &machine_hard_spi_p,
+    locals_dict, (mp_obj_dict_t *)&mp_machine_spi_locals_dict
+    );
 
 #endif // MICROPY_PY_MACHINE_SPI
diff --git a/ports/zephyr/machine_uart.c b/ports/zephyr/machine_uart.c
index 23d7d59443729..ad88582b783dd 100644
--- a/ports/zephyr/machine_uart.c
+++ b/ports/zephyr/machine_uart.c
@@ -156,13 +156,11 @@ STATIC const mp_stream_p_t uart_stream_p = {
     .is_text = false,
 };
 
-const mp_obj_type_t machine_uart_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_UART,
-    .print = machine_uart_print,
-    .make_new = machine_uart_make_new,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &uart_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&machine_uart_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    machine_uart_type, MP_QSTR_UART, MP_TYPE_FLAG_NONE, machine_uart_make_new,
+    print, machine_uart_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &uart_stream_p,
+    locals_dict, (mp_obj_dict_t *)&machine_uart_locals_dict
+    );
diff --git a/ports/zephyr/modusocket.c b/ports/zephyr/modusocket.c
index 8f39347e37522..b9c3c7dd092c9 100644
--- a/ports/zephyr/modusocket.c
+++ b/ports/zephyr/modusocket.c
@@ -353,14 +353,12 @@ STATIC const mp_stream_p_t socket_stream_p = {
     .ioctl = sock_ioctl,
 };
 
-STATIC const mp_obj_type_t socket_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_socket,
-    .print = socket_print,
-    .make_new = socket_make_new,
-    .protocol = &socket_stream_p,
-    .locals_dict = (mp_obj_t)&socket_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    socket_type, MP_QSTR_socket, MP_TYPE_FLAG_NONE, socket_make_new,
+    print, socket_print,
+    protocol, &socket_stream_p,
+    locals_dict, (mp_obj_t)&socket_locals_dict
+    );
 
 //
 // getaddrinfo() implementation
diff --git a/ports/zephyr/modzsensor.c b/ports/zephyr/modzsensor.c
index 01f05aacd64a0..fc366af1b3af7 100644
--- a/ports/zephyr/modzsensor.c
+++ b/ports/zephyr/modzsensor.c
@@ -106,12 +106,10 @@ STATIC const mp_rom_map_elem_t sensor_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(sensor_locals_dict, sensor_locals_dict_table);
 
-STATIC const mp_obj_type_t sensor_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_Sensor,
-    .make_new = sensor_make_new,
-    .locals_dict = (void *)&sensor_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    sensor_type, MP_QSTR_Sensor, MP_TYPE_FLAG_NONE, sensor_make_new,
+    locals_dict, (void *)&sensor_locals_dict
+    );
 
 STATIC const mp_rom_map_elem_t mp_module_zsensor_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_zsensor) },
diff --git a/ports/zephyr/zephyr_storage.c b/ports/zephyr/zephyr_storage.c
index 5934f22813e62..6906885b6e759 100644
--- a/ports/zephyr/zephyr_storage.c
+++ b/ports/zephyr/zephyr_storage.c
@@ -129,13 +129,11 @@ STATIC const mp_rom_map_elem_t zephyr_disk_access_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(zephyr_disk_access_locals_dict, zephyr_disk_access_locals_dict_table);
 
-const mp_obj_type_t zephyr_disk_access_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_DiskAccess,
-    .print = zephyr_disk_access_print,
-    .make_new = zephyr_disk_access_make_new,
-    .locals_dict = (mp_obj_dict_t *)&zephyr_disk_access_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    zephyr_disk_access_type, MP_QSTR_DiskAccess, MP_TYPE_FLAG_NONE, zephyr_disk_access_make_new,
+    print, zephyr_disk_access_print,
+    locals_dict, (mp_obj_dict_t *)&zephyr_disk_access_locals_dict
+    );
 #endif // CONFIG_DISK_ACCESS
 
 #ifdef CONFIG_FLASH_MAP
@@ -251,11 +249,9 @@ STATIC const mp_rom_map_elem_t zephyr_flash_area_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(zephyr_flash_area_locals_dict, zephyr_flash_area_locals_dict_table);
 
-const mp_obj_type_t zephyr_flash_area_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_FlashArea,
-    .print = zephyr_flash_area_print,
-    .make_new = zephyr_flash_area_make_new,
-    .locals_dict = (mp_obj_dict_t *)&zephyr_flash_area_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    zephyr_flash_area_type, MP_QSTR_FlashArea, MP_TYPE_FLAG_NONE, zephyr_flash_area_make_new,
+    print, zephyr_flash_area_print,
+    locals_dict, (mp_obj_dict_t *)&zephyr_flash_area_locals_dict
+    );
 #endif // CONFIG_FLASH_MAP
diff --git a/py/builtinevex.c b/py/builtinevex.c
index 4e1c6a66d188f..1ca9b50354518 100644
--- a/py/builtinevex.c
+++ b/py/builtinevex.c
@@ -38,10 +38,9 @@ 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/builtinhelp.c b/py/builtinhelp.c
index 84d69caf35bed..e79f48e7c4507 100644
--- a/py/builtinhelp.c
+++ b/py/builtinhelp.c
@@ -143,8 +143,8 @@ STATIC void mp_help_print_obj(const mp_obj_t obj) {
         if (type == &mp_type_type) {
             type = MP_OBJ_TO_PTR(obj);
         }
-        if (type->locals_dict != NULL) {
-            map = &type->locals_dict->map;
+        if (MP_OBJ_TYPE_HAS_SLOT(type, locals_dict)) {
+            map = &MP_OBJ_TYPE_GET_SLOT(type, locals_dict)->map;
         }
     }
     if (map != NULL) {
diff --git a/py/dynruntime.h b/py/dynruntime.h
index b9dca60d1389d..3d32ccdb6d8e9 100644
--- a/py/dynruntime.h
+++ b/py/dynruntime.h
@@ -139,7 +139,7 @@ static inline mp_obj_t mp_obj_cast_to_native_base_dyn(mp_obj_t self_in, mp_const
 
     if (MP_OBJ_FROM_PTR(self_type) == native_type) {
         return self_in;
-    } else if (self_type->parent != native_type) {
+    } else if (MP_OBJ_TYPE_GET_SLOT_OR_NULL(self_type, parent) != native_type) {
         // The self_in object is not a direct descendant of native_type, so fail the cast.
         // This is a very simple version of mp_obj_is_subclass_fast that could be improved.
         return MP_OBJ_NULL;
diff --git a/py/modbuiltins.c b/py/modbuiltins.c
index 26a84f57b3d55..1824c8aeb29f2 100644
--- a/py/modbuiltins.c
+++ b/py/modbuiltins.c
@@ -455,7 +455,7 @@ STATIC mp_obj_t mp_builtin___repl_print__(mp_obj_t o) {
         #if MICROPY_CAN_OVERRIDE_BUILTINS
         // Set "_" special variable
         mp_obj_t dest[2] = {MP_OBJ_SENTINEL, o};
-        mp_type_module.attr(MP_OBJ_FROM_PTR(&mp_module_builtins), MP_QSTR__, dest);
+        MP_OBJ_TYPE_GET_SLOT(&mp_type_module, attr)(MP_OBJ_FROM_PTR(&mp_module_builtins), MP_QSTR__, dest);
         #endif
     }
     return mp_const_none;
diff --git a/py/modio.c b/py/modio.c
index e79d59e4e5555..146ed38e07fb4 100644
--- a/py/modio.c
+++ b/py/modio.c
@@ -100,12 +100,10 @@ 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
 
@@ -195,13 +193,11 @@ 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 29b765493ac3d..616c5aea3c99e 100644
--- a/py/modthread.c
+++ b/py/modthread.c
@@ -117,11 +117,10 @@ 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/mpconfig.h b/py/mpconfig.h
index c308c31bda562..9fd46ffc19031 100644
--- a/py/mpconfig.h
+++ b/py/mpconfig.h
@@ -145,6 +145,14 @@
 #define MICROPY_OBJ_IMMEDIATE_OBJS (MICROPY_OBJ_REPR != MICROPY_OBJ_REPR_D)
 #endif
 
+#define MICROPY_OBJ_TYPE_REPR_FULL (0)
+#define MICROPY_OBJ_TYPE_REPR_SLOT_INDEX (1)
+#define MICROPY_OBJ_TYPE_REPR_SPLIT (2)
+
+#ifndef MICROPY_OBJ_TYPE_REPR
+#define MICROPY_OBJ_TYPE_REPR (MICROPY_OBJ_TYPE_REPR_SLOT_INDEX)
+#endif
+
 /*****************************************************************************/
 /* Memory allocation policy                                                  */
 
diff --git a/py/obj.c b/py/obj.c
index 5255e96553343..f859d00136fa6 100644
--- a/py/obj.c
+++ b/py/obj.c
@@ -109,8 +109,8 @@ void mp_obj_print_helper(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_t
     }
     #endif
     const mp_obj_type_t *type = mp_obj_get_type(o_in);
-    if (type->print != NULL) {
-        type->print((mp_print_t *)print, o_in, kind);
+    if (MP_OBJ_TYPE_HAS_SLOT(type, print)) {
+        MP_OBJ_TYPE_GET_SLOT(type, print)((mp_print_t *)print, o_in, kind);
     } else {
         mp_printf(print, "<%q>", type->name);
     }
@@ -163,8 +163,8 @@ bool mp_obj_is_true(mp_obj_t arg) {
         }
     } else {
         const mp_obj_type_t *type = mp_obj_get_type(arg);
-        if (type->unary_op != NULL) {
-            mp_obj_t result = type->unary_op(MP_UNARY_OP_BOOL, arg);
+        if (MP_OBJ_TYPE_HAS_SLOT(type, unary_op)) {
+            mp_obj_t result = MP_OBJ_TYPE_GET_SLOT(type, unary_op)(MP_UNARY_OP_BOOL, arg);
             if (result != MP_OBJ_NULL) {
                 return result == mp_const_true;
             }
@@ -182,7 +182,7 @@ bool mp_obj_is_true(mp_obj_t arg) {
 }
 
 bool mp_obj_is_callable(mp_obj_t o_in) {
-    const mp_call_fun_t call = mp_obj_get_type(o_in)->call;
+    const mp_call_fun_t call = MP_OBJ_TYPE_GET_SLOT_OR_NULL(mp_obj_get_type(o_in), call);
     if (call != mp_obj_instance_call) {
         return call != NULL;
     }
@@ -249,19 +249,19 @@ mp_obj_t mp_obj_equal_not_equal(mp_binary_op_t op, mp_obj_t o1, mp_obj_t o2) {
         const mp_obj_type_t *type = mp_obj_get_type(o1);
         // If a full equality test is not needed and the other object is a different
         // type then we don't need to bother trying the comparison.
-        if (type->binary_op != NULL &&
+        if (MP_OBJ_TYPE_HAS_SLOT(type, binary_op) &&
             ((type->flags & MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE) || mp_obj_get_type(o2) == type)) {
             // CPython is asymmetric: it will try __eq__ if there's no __ne__ but not the
             // other way around.  If the class doesn't need a full test we can skip __ne__.
             if (op == MP_BINARY_OP_NOT_EQUAL && (type->flags & MP_TYPE_FLAG_EQ_HAS_NEQ_TEST)) {
-                mp_obj_t r = type->binary_op(MP_BINARY_OP_NOT_EQUAL, o1, o2);
+                mp_obj_t r = MP_OBJ_TYPE_GET_SLOT(type, binary_op)(MP_BINARY_OP_NOT_EQUAL, o1, o2);
                 if (r != MP_OBJ_NULL) {
                     return r;
                 }
             }
 
             // Try calling __eq__.
-            mp_obj_t r = type->binary_op(MP_BINARY_OP_EQUAL, o1, o2);
+            mp_obj_t r = MP_OBJ_TYPE_GET_SLOT(type, binary_op)(MP_BINARY_OP_EQUAL, o1, o2);
             if (r != MP_OBJ_NULL) {
                 if (op == MP_BINARY_OP_EQUAL) {
                     return r;
@@ -523,8 +523,8 @@ mp_obj_t mp_obj_len_maybe(mp_obj_t o_in) {
         return MP_OBJ_NEW_SMALL_INT(l);
     } else {
         const mp_obj_type_t *type = mp_obj_get_type(o_in);
-        if (type->unary_op != NULL) {
-            return type->unary_op(MP_UNARY_OP_LEN, o_in);
+        if (MP_OBJ_TYPE_HAS_SLOT(type, unary_op)) {
+            return MP_OBJ_TYPE_GET_SLOT(type, unary_op)(MP_UNARY_OP_LEN, o_in);
         } else {
             return MP_OBJ_NULL;
         }
@@ -533,8 +533,8 @@ mp_obj_t mp_obj_len_maybe(mp_obj_t o_in) {
 
 mp_obj_t mp_obj_subscr(mp_obj_t base, mp_obj_t index, mp_obj_t value) {
     const mp_obj_type_t *type = mp_obj_get_type(base);
-    if (type->subscr != NULL) {
-        mp_obj_t ret = type->subscr(base, index, value);
+    if (MP_OBJ_TYPE_HAS_SLOT(type, subscr)) {
+        mp_obj_t ret = MP_OBJ_TYPE_GET_SLOT(type, subscr)(base, index, value);
         if (ret != MP_OBJ_NULL) {
             return ret;
         }
@@ -578,10 +578,10 @@ mp_obj_t mp_identity_getiter(mp_obj_t self, mp_obj_iter_buf_t *iter_buf) {
 
 bool mp_get_buffer(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags) {
     const mp_obj_type_t *type = mp_obj_get_type(obj);
-    if (type->buffer_p.get_buffer == NULL) {
+    if (!MP_OBJ_TYPE_HAS_SLOT(type, buffer)) {
         return false;
     }
-    int ret = type->buffer_p.get_buffer(obj, bufinfo, flags);
+    int ret = MP_OBJ_TYPE_GET_SLOT(type, buffer)(obj, bufinfo, flags);
     if (ret != 0) {
         return false;
     }
diff --git a/py/obj.h b/py/obj.h
index 08a35ee6f874b..d76684e659edd 100644
--- a/py/obj.h
+++ b/py/obj.h
@@ -503,6 +503,7 @@ typedef mp_obj_t (*mp_fun_kw_t)(size_t n, const mp_obj_t *, mp_map_t *);
 // operator and not the __ne__ operator.  If it's set then __ne__ may be implemented.
 // If MP_TYPE_FLAG_BINDS_SELF is set then the type as a method binds self as the first arg.
 // If MP_TYPE_FLAG_BUILTIN_FUN is set then the type is a built-in function type.
+#define MP_TYPE_FLAG_NONE (0x0000)
 #define MP_TYPE_FLAG_IS_SUBCLASSED (0x0001)
 #define MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS (0x0002)
 #define MP_TYPE_FLAG_EQ_NOT_REFLEXIVE (0x0004)
@@ -547,12 +548,27 @@ typedef struct _mp_buffer_info_t {
 #define MP_BUFFER_READ  (1)
 #define MP_BUFFER_WRITE (2)
 #define MP_BUFFER_RW (MP_BUFFER_READ | MP_BUFFER_WRITE)
-typedef struct _mp_buffer_p_t {
-    mp_int_t (*get_buffer)(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags);
-} mp_buffer_p_t;
+typedef mp_int_t (*mp_buffer_fun_t)(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags);
 bool mp_get_buffer(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags);
 void mp_get_buffer_raise(mp_obj_t obj, mp_buffer_info_t *bufinfo, mp_uint_t flags);
 
+#if MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SPLIT
+// These fields are split out from mp_obj_type_t.
+struct _mp_obj_type_ext_t {
+    mp_call_fun_t call;
+    mp_unary_op_fun_t unary_op;
+    mp_subscr_fun_t subscr;
+    mp_getiter_fun_t getiter;
+    mp_fun_1_t iternext;
+    mp_buffer_fun_t buffer;
+    const void *protocol;
+    mp_binary_op_fun_t binary_op;
+};
+#endif
+
+// In split/slots representations, this is a variable sized struct.
+// In order to use this as a member, or allocate dynamically, use the
+// mp_obj_full_type_t below (which must be kept in sync).
 struct _mp_obj_type_t {
     // A type is an object so must start with this entry, which points to mp_type_type.
     mp_obj_base_t base;
@@ -563,12 +579,13 @@ struct _mp_obj_type_t {
     // The name of this type, a qstr.
     uint16_t name;
 
-    // Corresponds to __repr__ and __str__ special methods.
-    mp_print_fun_t print;
-
     // Corresponds to __new__ and __init__ special methods, to make an instance of the type.
     mp_make_new_fun_t make_new;
 
+    #if MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_FULL
+    // Corresponds to __repr__ and __str__ special methods.
+    mp_print_fun_t print;
+
     // Corresponds to __call__ special method, ie T(...).
     mp_call_fun_t call;
 
@@ -608,7 +625,7 @@ struct _mp_obj_type_t {
     mp_fun_1_t iternext;
 
     // Implements the buffer protocol if supported by this type.
-    mp_buffer_p_t buffer_p;
+    mp_buffer_fun_t buffer;
 
     // One of disjoint protocols (interfaces), like mp_stream_p_t, etc.
     const void *protocol;
@@ -621,8 +638,215 @@ struct _mp_obj_type_t {
 
     // A dict mapping qstrs to objects local methods/constants/etc.
     struct _mp_obj_dict_t *locals_dict;
+
+    #elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SLOT_INDEX
+
+    // Ideally these would be only 4 bits, but the extra overhead of
+    // accessing them adds more code, and we also need to be able to
+    // take the address of them for mp_obj_class_lookup.
+    uint8_t slot_index_print;
+    uint8_t slot_index_call;
+    uint8_t slot_index_unary_op;
+    uint8_t slot_index_binary_op;
+    uint8_t slot_index_attr;
+    uint8_t slot_index_subscr;
+    uint8_t slot_index_getiter;
+    uint8_t slot_index_iternext;
+    uint8_t slot_index_buffer;
+    uint8_t slot_index_protocol;
+    uint8_t slot_index_parent;
+    uint8_t slot_index_locals_dict;
+
+    const void *slots[];
+
+    #elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SPLIT
+
+    mp_print_fun_t print;
+    mp_attr_fun_t attr;
+    const void *parent;
+    struct _mp_obj_dict_t *locals_dict;
+
+    struct _mp_obj_type_ext_t ext[];
+
+    #endif
 };
 
+// Non-variable sized version of mp_obj_type_t to be used as a member
+// in other structs or for dynamic allocation. The fields are exactly
+// as in mp_obj_type_t, but with a fixed size for the flexible array
+// members.
+typedef struct _mp_obj_full_type_t {
+    mp_obj_base_t base;
+    uint16_t flags;
+    uint16_t name;
+    mp_make_new_fun_t make_new;
+
+    #if MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_FULL
+
+    mp_print_fun_t print;
+    mp_call_fun_t call;
+    mp_unary_op_fun_t unary_op;
+    mp_binary_op_fun_t binary_op;
+    mp_attr_fun_t attr;
+    mp_subscr_fun_t subscr;
+    mp_getiter_fun_t getiter;
+    mp_fun_1_t iternext;
+    mp_buffer_fun_t buffer;
+    const void *protocol;
+    const void *parent;
+    struct _mp_obj_dict_t *locals_dict;
+
+    #elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SLOT_INDEX
+
+    uint8_t slot_index_print;
+    uint8_t slot_index_call;
+    uint8_t slot_index_unary_op;
+    uint8_t slot_index_binary_op;
+    uint8_t slot_index_attr;
+    uint8_t slot_index_subscr;
+    uint8_t slot_index_getiter;
+    uint8_t slot_index_iternext;
+    uint8_t slot_index_buffer;
+    uint8_t slot_index_protocol;
+    uint8_t slot_index_parent;
+    uint8_t slot_index_locals_dict;
+    const void *slots[12];
+
+    #elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SPLIT
+
+    mp_print_fun_t print;
+    mp_attr_fun_t attr;
+    const void *parent;
+    struct _mp_obj_dict_t *locals_dict;
+    struct _mp_obj_type_ext_t ext[1];
+
+    #endif
+} mp_obj_full_type_t;
+
+#define MP_TYPE_NULL_MAKE_NEW (NULL)
+
+#if MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_FULL
+
+#define _MP_DEFINE_CONST_OBJ_TYPE_0(_typename, _name, _flags, _make_new) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new }
+#define _MP_DEFINE_CONST_OBJ_TYPE_1(_typename, _name, _flags, _make_new, f1, v1) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_2(_typename, _name, _flags, _make_new, f1, v1, f2, v2) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_3(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_4(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_5(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_6(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_7(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_8(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_9(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8, .f9 = v9 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_10(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8, .f9 = v9, .f10 = v10 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_11(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10, f11, v11) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8, .f9 = v9, .f10 = v10, .f11 = v11 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_12(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10, f11, v11, f12, v12) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .f1 = v1, .f2 = v2, .f3 = v3, .f4 = v4, .f5 = v5, .f6 = v6, .f7 = v7, .f8 = v8, .f9 = v9, .f10 = v10, .f11 = v11, .f12 = v12 }
+
+// Always safe, checks if the type can and does have this slot.
+#define MP_OBJ_TYPE_HAS_SLOT(t, f) ((t)->f)
+// Requires you know that this type can have this slot.
+#define MP_OBJ_TYPE_GET_SLOT(t, f) ((t)->f)
+// Always safe, returns NULL if the type cannot have this slot.
+#define MP_OBJ_TYPE_GET_SLOT_OR_NULL(t, f) ((t)->f)
+#define MP_OBJ_TYPE_SET_SLOT(t, f, v, n) ((t)->f = v)
+#define MP_OBJ_TYPE_OFFSETOF_SLOT(f) (offsetof(mp_obj_type_t, f))
+#define MP_OBJ_TYPE_HAS_SLOT_BY_OFFSET(t, offset) (*(void **)((char *)(t) + (offset)) != NULL)
+
+#elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SLOT_INDEX
+
+#define _MP_OBJ_TYPE_SLOT_TYPE_print (mp_print_fun_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_call (mp_call_fun_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_unary_op (mp_unary_op_fun_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_binary_op (mp_binary_op_fun_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_attr (mp_attr_fun_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_subscr (mp_subscr_fun_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_getiter (mp_getiter_fun_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_iternext (mp_fun_1_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_buffer (mp_buffer_fun_t)
+#define _MP_OBJ_TYPE_SLOT_TYPE_protocol (const void *)
+#define _MP_OBJ_TYPE_SLOT_TYPE_parent (const void *)
+#define _MP_OBJ_TYPE_SLOT_TYPE_locals_dict (struct _mp_obj_dict_t *)
+
+#define _MP_DEFINE_CONST_OBJ_TYPE_0(_typename, _name, _flags, _make_new) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slots = {} }
+#define _MP_DEFINE_CONST_OBJ_TYPE_1(_typename, _name, _flags, _make_new, f1, v1) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slots = {v1, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_2(_typename, _name, _flags, _make_new, f1, v1, f2, v2) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slots = {v1, v2, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_3(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slots = {v1, v2, v3, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_4(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slots = {v1, v2, v3, v4, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_5(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slot_index_##f5 = 5, .slots = {v1, v2, v3, v4, v5, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_6(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slot_index_##f5 = 5, .slot_index_##f6 = 6, .slots = {v1, v2, v3, v4, v5, v6, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_7(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slot_index_##f5 = 5, .slot_index_##f6 = 6, .slot_index_##f7 = 7, .slots = {v1, v2, v3, v4, v5, v6, v7, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_8(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slot_index_##f5 = 5, .slot_index_##f6 = 6, .slot_index_##f7 = 7, .slot_index_##f8 = 8, .slots = {v1, v2, v3, v4, v5, v6, v7, v8, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_9(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slot_index_##f5 = 5, .slot_index_##f6 = 6, .slot_index_##f7 = 7, .slot_index_##f8 = 8, .slot_index_##f9 = 9, .slots = {v1, v2, v3, v4, v5, v6, v7, v8, v9, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_10(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slot_index_##f5 = 5, .slot_index_##f6 = 6, .slot_index_##f7 = 7, .slot_index_##f8 = 8, .slot_index_##f9 = 9, .slot_index_##f10 = 10, .slots = {v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_11(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10, f11, v11) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slot_index_##f5 = 5, .slot_index_##f6 = 6, .slot_index_##f7 = 7, .slot_index_##f8 = 8, .slot_index_##f9 = 9, .slot_index_##f10 = 10, .slot_index_##f11 = 11, .slots = {v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, } }
+#define _MP_DEFINE_CONST_OBJ_TYPE_12(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10, f11, v11, f12, v12) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new, .slot_index_##f1 = 1, .slot_index_##f2 = 2, .slot_index_##f3 = 3, .slot_index_##f4 = 4, .slot_index_##f5 = 5, .slot_index_##f6 = 6, .slot_index_##f7 = 7, .slot_index_##f8 = 8, .slot_index_##f9 = 9, .slot_index_##f10 = 10, .slot_index_##f11 = 11, .slot_index_##f12 = 12, .slots = {v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, } }
+
+#define MP_OBJ_TYPE_HAS_SLOT(t, f) ((t)->slot_index_##f)
+#define MP_OBJ_TYPE_GET_SLOT(t, f) (_MP_OBJ_TYPE_SLOT_TYPE_##f(t)->slots[(t)->slot_index_##f - 1])
+#define MP_OBJ_TYPE_GET_SLOT_OR_NULL(t, f) (_MP_OBJ_TYPE_SLOT_TYPE_##f(MP_OBJ_TYPE_HAS_SLOT(t, f) ? MP_OBJ_TYPE_GET_SLOT(t, f) : NULL))
+#define MP_OBJ_TYPE_SET_SLOT(t, f, v, n) ((t)->slot_index_##f = n, (t)->slots[(t)->slot_index_##f - 1] = (void *)v)
+#define MP_OBJ_TYPE_OFFSETOF_SLOT(f) (offsetof(mp_obj_type_t, slot_index_##f))
+// For everything except make_new, the offset is to the uint8_t index. For make_new, we need to check the pointer.
+#define MP_OBJ_TYPE_HAS_SLOT_BY_OFFSET(t, offset) (*(uint8_t *)((char *)(t) + (offset)) != 0 || (offset == offsetof(mp_obj_type_t, make_new) && t->make_new))
+
+#elif MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SPLIT
+
+#define MP_OBJ_TYPE_FLAG_EXTENDED (0x0080)
+
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_print (0)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_call (1)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_unary_op (1)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_binary_op (1)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_attr (0)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_subscr (1)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_getiter (1)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_iternext (1)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_buffer (1)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_protocol (1)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_parent (0)
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_locals_dict (0)
+
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_print print
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_call ext[0].call
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_unary_op ext[0].unary_op
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_binary_op ext[0].binary_op
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_attr attr
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_subscr ext[0].subscr
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_getiter ext[0].getiter
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_iternext ext[0].iternext
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_buffer ext[0].buffer
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_protocol ext[0].protocol
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_parent parent
+#define _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_locals_dict locals_dict
+
+#define _MP_DEFINE_CONST_OBJ_TYPE_0(_typename, _name, _flags, _make_new) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags, .make_new = _make_new }
+#define _MP_DEFINE_CONST_OBJ_TYPE_1(_typename, _name, _flags, _make_new, f1, v1) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1)*MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_2(_typename, _name, _flags, _make_new, f1, v1, f2, v2) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_3(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_4(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_5(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f5) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f5 = v5 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_6(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f5 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f6) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f5 = v5, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f6 = v6 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_7(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f5 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f6 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f7) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f5 = v5, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f6 = v6, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f7 = v7 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_8(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f5 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f6 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f7 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f8) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f5 = v5, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f6 = v6, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f7 = v7, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f8 = v8 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_9(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f5 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f6 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f7 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f8 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f9) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f5 = v5, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f6 = v6, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f7 = v7, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f8 = v8, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f9 = v9 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_10(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f5 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f6 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f7 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f8 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f9 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f10) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f5 = v5, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f6 = v6, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f7 = v7, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f8 = v8, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f9 = v9, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f10 = v10 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_11(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10, f11, v11) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f5 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f6 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f7 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f8 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f9 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f10 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f11) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f5 = v5, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f6 = v6, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f7 = v7, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f8 = v8, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f9 = v9, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f10 = v10, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f11 = v11 }
+#define _MP_DEFINE_CONST_OBJ_TYPE_12(_typename, _name, _flags, _make_new, f1, v1, f2, v2, f3, v3, f4, v4, f5, v5, f6, v6, f7, v7, f8, v8, f9, v9, f10, v10, f11, v11, f12, v12) const mp_obj_type_t _typename = { .base = { &mp_type_type }, .name = _name, .flags = _flags | (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f1 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f2 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f3 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f4 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f5 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f6 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f7 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f8 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f9 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f10 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f11 | _MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f12) * MP_OBJ_TYPE_FLAG_EXTENDED, .make_new = _make_new, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f1 = v1, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f2 = v2, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f3 = v3, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f4 = v4, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f5 = v5, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f6 = v6, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f7 = v7, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f8 = v8, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f9 = v9, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f10 = v10, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f11 = v11, ._MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f12 = v12 }
+
+#define MP_OBJ_TYPE_HAS_SLOT(t, f) (_MP_DEFINE_CONST_OBJ_TYPE_SLOT_IS_EXT_##f ? (((t)->flags & MP_OBJ_TYPE_FLAG_EXTENDED) ? (t)->_MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f : 0) : (t)->_MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f)
+#define MP_OBJ_TYPE_GET_SLOT(t, f) ((t)->_MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f)
+#define MP_OBJ_TYPE_GET_SLOT_OR_NULL(t, f) ((MP_OBJ_TYPE_HAS_SLOT(t, f) ? MP_OBJ_TYPE_GET_SLOT(t, f) : NULL))
+#define MP_OBJ_TYPE_SET_SLOT(t, f, v, n) ((t)->_MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f = v)
+#define MP_OBJ_TYPE_OFFSETOF_SLOT(f) (offsetof(mp_obj_type_t, _MP_DEFINE_CONST_OBJ_TYPE_SLOT_PATH_##f))
+#define MP_OBJ_TYPE_HAS_SLOT_BY_OFFSET(t, offset) (*(void **)((char *)(t) + (offset)) != NULL)
+
+#endif
+
+// Workaround for https://docs.microsoft.com/en-us/cpp/preprocessor/preprocessor-experimental-overview?view=msvc-160#macro-arguments-are-unpacked
+#define _MP_DEFINE_CONST_OBJ_TYPE_EXPAND(x) x
+
+#define _MP_DEFINE_CONST_OBJ_TYPE_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, N, ...) _MP_DEFINE_CONST_OBJ_TYPE_##N
+#define MP_DEFINE_CONST_OBJ_TYPE(...) _MP_DEFINE_CONST_OBJ_TYPE_EXPAND(_MP_DEFINE_CONST_OBJ_TYPE_IMPL(__VA_ARGS__, _INV, 12, _INV, 11, _INV, 10, _INV, 9, _INV, 8, _INV, 7, _INV, 6, _INV, 5, _INV, 4, _INV, 3, _INV, 2, _INV, 1, _INV, 0, _INV, _INV, _INV)(__VA_ARGS__))
+
 // Constant types, globally accessible
 extern const mp_obj_type_t mp_type_type;
 extern const mp_obj_type_t mp_type_object;
@@ -745,7 +969,7 @@ extern const struct _mp_obj_exception_t mp_const_GeneratorExit_obj;
 #endif
 #define mp_obj_is_int(o) (mp_obj_is_small_int(o) || mp_obj_is_type(o, &mp_type_int))
 #define mp_obj_is_str(o) (mp_obj_is_qstr(o) || mp_obj_is_type(o, &mp_type_str))
-#define mp_obj_is_str_or_bytes(o) (mp_obj_is_qstr(o) || (mp_obj_is_obj(o) && ((mp_obj_base_t *)MP_OBJ_TO_PTR(o))->type->binary_op == mp_obj_str_binary_op))
+#define mp_obj_is_str_or_bytes(o) (mp_obj_is_qstr(o) || (mp_obj_is_obj(o) && MP_OBJ_TYPE_GET_SLOT_OR_NULL(((mp_obj_base_t *)MP_OBJ_TO_PTR(o))->type, binary_op) == mp_obj_str_binary_op))
 #define mp_obj_is_dict_or_ordereddict(o) (mp_obj_is_obj(o) && ((mp_obj_base_t *)MP_OBJ_TO_PTR(o))->type->make_new == mp_obj_dict_make_new)
 #define mp_obj_is_fun(o) (mp_obj_is_obj(o) && (((mp_obj_base_t *)MP_OBJ_TO_PTR(o))->type->name == MP_QSTR_function))
 
diff --git a/py/objarray.c b/py/objarray.c
index 16a4d4aac7e25..cc70c5b6af91b 100644
--- a/py/objarray.c
+++ b/py/objarray.c
@@ -437,7 +437,7 @@ STATIC mp_obj_t array_subscr(mp_obj_t self_in, mp_obj_t index_in, mp_obj_t value
                 size_t src_len;
                 void *src_items;
                 size_t item_sz = mp_binary_get_size('@', o->typecode & TYPECODE_MASK, NULL);
-                if (mp_obj_is_obj(value) && ((mp_obj_base_t *)MP_OBJ_TO_PTR(value))->type->subscr == array_subscr) {
+                if (mp_obj_is_obj(value) && MP_OBJ_TYPE_GET_SLOT_OR_NULL(((mp_obj_base_t *)MP_OBJ_TO_PTR(value))->type, subscr) == array_subscr) {
                     // value is array, bytearray or memoryview
                     mp_obj_array_t *src_slice = MP_OBJ_TO_PTR(value);
                     if (item_sz != mp_binary_get_size('@', src_slice->typecode & TYPECODE_MASK, NULL)) {
@@ -577,51 +577,43 @@ STATIC MP_DEFINE_CONST_DICT(array_locals_dict, array_locals_dict_table);
 #endif
 
 #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 = { .get_buffer = array_get_buffer },
-    .locals_dict = (mp_obj_dict_t *)&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 *)&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_p = { .get_buffer = array_get_buffer },
-    .locals_dict = (mp_obj_dict_t *)&array_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 *)&array_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
-    .subscr = array_subscr,
-    .buffer_p = { .get_buffer = array_get_buffer },
-};
+    subscr, array_subscr,
+    buffer, array_get_buffer
+    );
 #endif
 
 /* unused
@@ -668,12 +660,11 @@ 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 3422d0146abb3..4941e86591b73 100644
--- a/py/objattrtuple.c
+++ b/py/objattrtuple.c
@@ -81,15 +81,15 @@ 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 23e023d8cbc15..43d8a37e983db 100644
--- a/py/objbool.c
+++ b/py/objbool.c
@@ -84,15 +84,13 @@ 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 a3e1d302d963f..60ffca13a8e8f 100644
--- a/py/objboundmeth.c
+++ b/py/objboundmeth.c
@@ -95,17 +95,16 @@ 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 = m_new_obj(mp_obj_bound_meth_t);
diff --git a/py/objcell.c b/py/objcell.c
index be2ae8cd9c769..1fc1031b3d79c 100644
--- a/py/objcell.c
+++ b/py/objcell.c
@@ -55,13 +55,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 = m_new_obj(mp_obj_cell_t);
diff --git a/py/objclosure.c b/py/objclosure.c
index 054b657896573..e529c04dad4a3 100644
--- a/py/objclosure.c
+++ b/py/objclosure.c
@@ -78,15 +78,13 @@ STATIC void closure_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kind_
 }
 #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,
-};
+    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 = m_new_obj_var(mp_obj_closure_t, mp_obj_t, n_closed_over);
diff --git a/py/objcomplex.c b/py/objcomplex.c
index f4c4aeffcb91d..ec9119ddc6e5b 100644
--- a/py/objcomplex.c
+++ b/py/objcomplex.c
@@ -150,16 +150,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 = m_new_obj(mp_obj_complex_t);
diff --git a/py/objdeque.c b/py/objdeque.c
index c95bdeee9e39c..74c71abe72f4e 100644
--- a/py/objdeque.c
+++ b/py/objdeque.c
@@ -156,12 +156,10 @@ 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 ed4376aa4f0ac..d6b084144cdc5 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -461,12 +461,11 @@ 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 +511,12 @@ 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 = m_new_obj(mp_obj_dict_view_t);
@@ -586,31 +584,27 @@ 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 d1de4add47ba8..48dbe5d47cd94 100644
--- a/py/objenumerate.c
+++ b/py/objenumerate.c
@@ -69,13 +69,11 @@ 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 dca287bb6ed12..a318bed6cb4e9 100644
--- a/py/objexcept.c
+++ b/py/objexcept.c
@@ -284,13 +284,11 @@ 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/objexcept.h b/py/objexcept.h
index 384456bb51a94..5d56d67d7314f 100644
--- a/py/objexcept.h
+++ b/py/objexcept.h
@@ -41,13 +41,10 @@ void mp_obj_exception_print(const mp_print_t *print, mp_obj_t o_in, mp_print_kin
 void mp_obj_exception_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest);
 
 #define MP_DEFINE_EXCEPTION(exc_name, base_name) \
-    const mp_obj_type_t mp_type_##exc_name = { \
-        { &mp_type_type }, \
-        .name = MP_QSTR_##exc_name, \
-        .print = mp_obj_exception_print, \
-        .make_new = mp_obj_exception_make_new, \
-        .attr = mp_obj_exception_attr, \
-        .parent = &mp_type_##base_name, \
-    };
+    MP_DEFINE_CONST_OBJ_TYPE(mp_type_##exc_name, MP_QSTR_##exc_name, MP_TYPE_FLAG_NONE, mp_obj_exception_make_new, \
+    print, mp_obj_exception_print, \
+    attr, mp_obj_exception_attr, \
+    parent, &mp_type_##base_name \
+    );
 
 #endif // MICROPY_INCLUDED_PY_OBJEXCEPT_H
diff --git a/py/objfilter.c b/py/objfilter.c
index 41b2a3bc5f227..44646bc4fbabb 100644
--- a/py/objfilter.c
+++ b/py/objfilter.c
@@ -61,12 +61,10 @@ 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 8ff2fa16c4c70..c7ca19bc3731e 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 3542cc0e3f0b8..51ecf6f86b0de 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                                                        */
@@ -363,19 +353,17 @@ 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;
@@ -419,13 +407,11 @@ 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,
-    .call = fun_native_call,
-    .unary_op = mp_generic_unary_op,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_fun_native, MP_QSTR_function, MP_TYPE_FLAG_BINDS_SELF, MP_TYPE_NULL_MAKE_NEW,
+    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));
@@ -527,13 +513,11 @@ 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 = m_new_obj(mp_obj_fun_asm_t);
diff --git a/py/objgenerator.c b/py/objgenerator.c
index 850de3fb68e5a..646000f0dc934 100644
--- a/py/objgenerator.c
+++ b/py/objgenerator.c
@@ -71,16 +71,14 @@ 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
@@ -126,16 +124,14 @@ 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
 
@@ -339,12 +335,11 @@ 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 31ed4a9228ce5..b82725b60d3f4 100644
--- a/py/objgetitemiter.c
+++ b/py/objgetitemiter.c
@@ -56,12 +56,11 @@ 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 5ff5e7de4b574..47d6aa0bcf6c1 100644
--- a/py/objint.c
+++ b/py/objint.c
@@ -457,12 +457,10 @@ 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 f431e273df0af..b6bd35e9058e6 100644
--- a/py/objlist.c
+++ b/py/objlist.c
@@ -452,17 +452,16 @@ 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 78c52c8925782..04b2ae2c250c8 100644
--- a/py/objmap.c
+++ b/py/objmap.c
@@ -64,10 +64,8 @@ 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 0cd10e61f08e8..1fb03d8c68031 100644
--- a/py/objmodule.c
+++ b/py/objmodule.c
@@ -125,12 +125,11 @@ 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
+    );
 
 #include "py/bc.h"
 mp_obj_t mp_obj_new_module(qstr module_name) {
diff --git a/py/objnamedtuple.c b/py/objnamedtuple.c
index 214cad2572d7d..3b8aa75247056 100644
--- a/py/objnamedtuple.c
+++ b/py/objnamedtuple.c
@@ -156,14 +156,14 @@ STATIC mp_obj_t mp_obj_new_namedtuple_type(qstr name, size_t n_fields, mp_obj_t
     o->base.base.type = &mp_type_type;
     o->base.flags = MP_TYPE_FLAG_EQ_CHECKS_OTHER_TYPE; // can match tuple
     o->base.name = name;
-    o->base.print = namedtuple_print;
     o->base.make_new = namedtuple_make_new;
-    o->base.unary_op = mp_obj_tuple_unary_op;
-    o->base.binary_op = mp_obj_tuple_binary_op;
-    o->base.attr = namedtuple_attr;
-    o->base.subscr = mp_obj_tuple_subscr;
-    o->base.getiter = mp_obj_tuple_getiter;
-    o->base.parent = &mp_type_tuple;
+    MP_OBJ_TYPE_SET_SLOT(&o->base, print, namedtuple_print, 1);
+    MP_OBJ_TYPE_SET_SLOT(&o->base, unary_op, mp_obj_tuple_unary_op, 2);
+    MP_OBJ_TYPE_SET_SLOT(&o->base, binary_op, mp_obj_tuple_binary_op, 3);
+    MP_OBJ_TYPE_SET_SLOT(&o->base, attr, namedtuple_attr, 4);
+    MP_OBJ_TYPE_SET_SLOT(&o->base, subscr, mp_obj_tuple_subscr, 5);
+    MP_OBJ_TYPE_SET_SLOT(&o->base, getiter, mp_obj_tuple_getiter, 6);
+    MP_OBJ_TYPE_SET_SLOT(&o->base, parent, &mp_type_tuple, 7);
     return MP_OBJ_FROM_PTR(o);
 }
 
diff --git a/py/objnamedtuple.h b/py/objnamedtuple.h
index d32af35afec43..9f23351d5a36c 100644
--- a/py/objnamedtuple.h
+++ b/py/objnamedtuple.h
@@ -29,7 +29,10 @@
 #include "py/objtuple.h"
 
 typedef struct _mp_obj_namedtuple_type_t {
-    mp_obj_type_t base;
+    // Must use the full-size version to avoid this being a variable sized member.
+    // This means that named tuples use slightly more RAM than necessary, but
+    // no worse than if we didn't have slots/split representation.
+    mp_obj_full_type_t base;
     size_t n_fields;
     qstr fields[];
 } mp_obj_namedtuple_type_t;
diff --git a/py/objnone.c b/py/objnone.c
index 271a8543f9718..b7b7155c4a291 100644
--- a/py/objnone.c
+++ b/py/objnone.c
@@ -43,12 +43,11 @@ 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 00082dfe08708..32d66ef2340fa 100644
--- a/py/objobject.c
+++ b/py/objobject.c
@@ -112,11 +112,9 @@ 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 01880bff9c1b9..025e9c03db05f 100644
--- a/py/objpolyiter.c
+++ b/py/objpolyiter.c
@@ -45,9 +45,8 @@ 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
+    );
diff --git a/py/objproperty.c b/py/objproperty.c
index 8d2c292c52d76..451e1b80088da 100644
--- a/py/objproperty.c
+++ b/py/objproperty.c
@@ -91,12 +91,10 @@ 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 1f028eb867a91..1e1385d324110 100644
--- a/py/objrange.c
+++ b/py/objrange.c
@@ -50,12 +50,11 @@ 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));
@@ -210,18 +209,16 @@ 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 4254668e751c8..a73edb0cac5d1 100644
--- a/py/objreversed.c
+++ b/py/objreversed.c
@@ -69,12 +69,10 @@ 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 d2508bfbf9e3f..ab851f74d4bc9 100644
--- a/py/objset.c
+++ b/py/objset.c
@@ -540,16 +540,14 @@ 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[] = {
@@ -565,17 +563,14 @@ 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 2b896305cff5b..4a099657d4be4 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 c65c30601be69..cc3a3b50fa350 100644
--- a/py/objslice.c
+++ b/py/objslice.c
@@ -92,16 +92,15 @@ 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 = m_new_obj(mp_obj_slice_t);
diff --git a/py/objstr.c b/py/objstr.c
index 321bb058dc09b..fab2726af4d8c 100644
--- a/py/objstr.c
+++ b/py/objstr.c
@@ -1993,31 +1993,27 @@ STATIC MP_DEFINE_CONST_DICT(str8_locals_dict, str8_locals_dict_table);
 #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_p = { .get_buffer = mp_obj_str_get_buffer },
-    .locals_dict = (mp_obj_dict_t *)&str8_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 *)&str8_locals_dict
+    );
 #endif
 
 // 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_p = { .get_buffer = mp_obj_str_get_buffer },
-    .locals_dict = (mp_obj_dict_t *)&str8_locals_dict,
-};
+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 *)&str8_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 ef942e74e8f99..6a487bbe1fc5e 100644
--- a/py/objstringio.c
+++ b/py/objstringio.c
@@ -245,16 +245,14 @@ 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 = {
@@ -263,16 +261,14 @@ 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 ed79ad68a93c6..e23d85a501296 100644
--- a/py/objstrunicode.c
+++ b/py/objstrunicode.c
@@ -267,18 +267,16 @@ STATIC const mp_rom_map_elem_t struni_locals_dict_table[] = {
 
 STATIC MP_DEFINE_CONST_DICT(struni_locals_dict, struni_locals_dict_table);
 
-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_p = { .get_buffer = mp_obj_str_get_buffer },
-    .locals_dict = (mp_obj_dict_t *)&struni_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 *)&struni_locals_dict
+    );
 
 /******************************************************************************/
 /* str iterator                                                               */
diff --git a/py/objtuple.c b/py/objtuple.c
index 67d7bc356f4ca..8dd6dd15d5f4a 100644
--- a/py/objtuple.c
+++ b/py/objtuple.c
@@ -32,7 +32,7 @@
 #include "py/runtime.h"
 
 // type check is done on getiter method to allow tuple, namedtuple, attrtuple
-#define mp_obj_is_tuple_compatible(o) (mp_obj_get_type(o)->getiter == mp_obj_tuple_getiter)
+#define mp_obj_is_tuple_compatible(o) (MP_OBJ_TYPE_GET_SLOT_OR_NULL(mp_obj_get_type(o), getiter) == mp_obj_tuple_getiter)
 
 /******************************************************************************/
 /* tuple                                                                      */
@@ -111,7 +111,7 @@ STATIC mp_obj_t tuple_cmp_helper(mp_uint_t op, mp_obj_t self_in, mp_obj_t anothe
     mp_check_self(mp_obj_is_tuple_compatible(self_in));
     const mp_obj_type_t *another_type = mp_obj_get_type(another_in);
     mp_obj_tuple_t *self = MP_OBJ_TO_PTR(self_in);
-    if (another_type->getiter != mp_obj_tuple_getiter) {
+    if (MP_OBJ_TYPE_GET_SLOT_OR_NULL(another_type, getiter) != mp_obj_tuple_getiter) {
         // Slow path for user subclasses
         another_in = mp_obj_cast_to_native_base(another_in, MP_OBJ_FROM_PTR(&mp_type_tuple));
         if (another_in == MP_OBJ_NULL) {
@@ -224,17 +224,15 @@ 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 e320adc8bb330..7d659f18e6b2e 100644
--- a/py/objtype.c
+++ b/py/objtype.c
@@ -59,13 +59,13 @@ STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_t
             // Native types don't have parents (at least not from our perspective) so end.
             *last_native_base = type;
             return count + 1;
-        } else if (type->parent == NULL) {
+        } else if (!MP_OBJ_TYPE_HAS_SLOT(type, parent)) {
             // No parents so end search here.
             return count;
         #if MICROPY_MULTIPLE_INHERITANCE
-        } else if (((mp_obj_base_t *)type->parent)->type == &mp_type_tuple) {
+        } else if (((mp_obj_base_t *)MP_OBJ_TYPE_GET_SLOT(type, parent))->type == &mp_type_tuple) {
             // Multiple parents, search through them all recursively.
-            const mp_obj_tuple_t *parent_tuple = type->parent;
+            const mp_obj_tuple_t *parent_tuple = MP_OBJ_TYPE_GET_SLOT(type, parent);
             const mp_obj_t *item = parent_tuple->items;
             const mp_obj_t *top = item + parent_tuple->len;
             for (; item < top; ++item) {
@@ -77,7 +77,7 @@ STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_t
         #endif
         } else {
             // A single parent, use iteration to continue the search.
-            type = type->parent;
+            type = MP_OBJ_TYPE_GET_SLOT(type, parent);
         }
     }
 }
@@ -119,7 +119,7 @@ mp_obj_instance_t *mp_obj_new_instance(const mp_obj_type_t *class, const mp_obj_
 // will keep lookup->dest[0]'s value (should be MP_OBJ_NULL on invocation) if attribute
 // is not found
 // will set lookup->dest[0] to MP_OBJ_SENTINEL if special method was found in a native
-// type base via slot id (as specified by lookup->meth_offset). As there can be only one
+// type base via slot id (as specified by lookup->slot_offset). As there can be only one
 // native base, it's known that it applies to instance->subobj[0]. In most cases, we also
 // don't need to know which type it was - because instance->subobj[0] is of that type.
 // The only exception is when object is not yet constructed, then we need to know base
@@ -128,7 +128,7 @@ mp_obj_instance_t *mp_obj_new_instance(const mp_obj_type_t *class, const mp_obj_
 struct class_lookup_data {
     mp_obj_instance_t *obj;
     qstr attr;
-    size_t meth_offset;
+    size_t slot_offset;
     mp_obj_t *dest;
     bool is_type;
 };
@@ -142,19 +142,19 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data *lookup, const mp_obj_t
         // This avoids extra method_name => slot lookup. On the other hand,
         // this should not be applied to class types, as will result in extra
         // lookup either.
-        if (lookup->meth_offset != 0 && mp_obj_is_native_type(type)) {
-            if (*(void **)((char *)type + lookup->meth_offset) != NULL) {
+        if (lookup->slot_offset != 0 && mp_obj_is_native_type(type)) {
+            if (MP_OBJ_TYPE_HAS_SLOT_BY_OFFSET(type, lookup->slot_offset)) {
                 DEBUG_printf("mp_obj_class_lookup: Matched special meth slot (off=%d) for %s\n",
-                    lookup->meth_offset, qstr_str(lookup->attr));
+                    lookup->slot_offset, qstr_str(lookup->attr));
                 lookup->dest[0] = MP_OBJ_SENTINEL;
                 return;
             }
         }
 
-        if (type->locals_dict != NULL) {
+        if (MP_OBJ_TYPE_HAS_SLOT(type, locals_dict)) {
             // search locals_dict (the set of methods/attributes)
-            assert(mp_obj_is_dict_or_ordereddict(MP_OBJ_FROM_PTR(type->locals_dict))); // MicroPython restriction, for now
-            mp_map_t *locals_map = &type->locals_dict->map;
+            assert(mp_obj_is_dict_or_ordereddict(MP_OBJ_FROM_PTR(MP_OBJ_TYPE_GET_SLOT(type, locals_dict)))); // MicroPython restriction, for now
+            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(lookup->attr), MP_MAP_LOOKUP);
             if (elem != NULL) {
                 if (lookup->is_type) {
@@ -198,12 +198,12 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data *lookup, const mp_obj_t
 
         // attribute not found, keep searching base classes
 
-        if (type->parent == NULL) {
+        if (!MP_OBJ_TYPE_HAS_SLOT(type, parent)) {
             DEBUG_printf("mp_obj_class_lookup: No more parents\n");
             return;
         #if MICROPY_MULTIPLE_INHERITANCE
-        } else if (((mp_obj_base_t *)type->parent)->type == &mp_type_tuple) {
-            const mp_obj_tuple_t *parent_tuple = type->parent;
+        } else if (((mp_obj_base_t *)MP_OBJ_TYPE_GET_SLOT(type, parent))->type == &mp_type_tuple) {
+            const mp_obj_tuple_t *parent_tuple = MP_OBJ_TYPE_GET_SLOT(type, parent);
             const mp_obj_t *item = parent_tuple->items;
             const mp_obj_t *top = item + parent_tuple->len - 1;
             for (; item < top; ++item) {
@@ -224,7 +224,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data *lookup, const mp_obj_t
             type = (mp_obj_type_t *)MP_OBJ_TO_PTR(*item);
         #endif
         } else {
-            type = type->parent;
+            type = MP_OBJ_TYPE_GET_SLOT(type, parent);
         }
         if (type == &mp_type_object) {
             // Not a "real" type
@@ -240,7 +240,7 @@ STATIC void instance_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
     struct class_lookup_data lookup = {
         .obj = self,
         .attr = meth,
-        .meth_offset = offsetof(mp_obj_type_t, print),
+        .slot_offset = MP_OBJ_TYPE_OFFSETOF_SLOT(print),
         .dest = member,
         .is_type = false,
     };
@@ -248,7 +248,7 @@ STATIC void instance_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
     if (member[0] == MP_OBJ_NULL && kind == PRINT_STR) {
         // If there's no __str__, fall back to __repr__
         lookup.attr = MP_QSTR___repr__;
-        lookup.meth_offset = 0;
+        lookup.slot_offset = 0;
         mp_obj_class_lookup(&lookup, self->base.type);
     }
 
@@ -283,7 +283,7 @@ mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size
     struct class_lookup_data lookup = {
         .obj = NULL,
         .attr = MP_QSTR___new__,
-        .meth_offset = offsetof(mp_obj_type_t, make_new),
+        .slot_offset = offsetof(mp_obj_type_t, make_new),
         .dest = init_fn,
         .is_type = false,
     };
@@ -333,7 +333,7 @@ mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size
     init_fn[0] = init_fn[1] = MP_OBJ_NULL;
     lookup.obj = o;
     lookup.attr = MP_QSTR___init__;
-    lookup.meth_offset = 0;
+    lookup.slot_offset = 0;
     mp_obj_class_lookup(&lookup, self);
     if (init_fn[0] != MP_OBJ_NULL) {
         mp_obj_t init_ret;
@@ -409,7 +409,7 @@ STATIC mp_obj_t instance_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
     struct class_lookup_data lookup = {
         .obj = self,
         .attr = op_name,
-        .meth_offset = offsetof(mp_obj_type_t, unary_op),
+        .slot_offset = MP_OBJ_TYPE_OFFSETOF_SLOT(unary_op),
         .dest = member,
         .is_type = false,
     };
@@ -537,7 +537,7 @@ retry:;
     struct class_lookup_data lookup = {
         .obj = lhs,
         .attr = op_name,
-        .meth_offset = offsetof(mp_obj_type_t, binary_op),
+        .slot_offset = MP_OBJ_TYPE_OFFSETOF_SLOT(binary_op),
         .dest = dest,
         .is_type = false,
     };
@@ -603,7 +603,7 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
     struct class_lookup_data lookup = {
         .obj = self,
         .attr = attr,
-        .meth_offset = 0,
+        .slot_offset = 0,
         .dest = dest,
         .is_type = false,
     };
@@ -688,7 +688,7 @@ STATIC bool mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t val
     struct class_lookup_data lookup = {
         .obj = self,
         .attr = attr,
-        .meth_offset = 0,
+        .slot_offset = 0,
         .dest = member,
         .is_type = false,
     };
@@ -810,7 +810,7 @@ STATIC mp_obj_t instance_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value
     mp_obj_t member[4] = {MP_OBJ_NULL, MP_OBJ_NULL, index, value};
     struct class_lookup_data lookup = {
         .obj = self,
-        .meth_offset = offsetof(mp_obj_type_t, subscr),
+        .slot_offset = MP_OBJ_TYPE_OFFSETOF_SLOT(subscr),
         .dest = member,
         .is_type = false,
     };
@@ -845,7 +845,7 @@ STATIC mp_obj_t mp_obj_instance_get_call(mp_obj_t self_in, mp_obj_t *member) {
     struct class_lookup_data lookup = {
         .obj = self,
         .attr = MP_QSTR___call__,
-        .meth_offset = offsetof(mp_obj_type_t, call),
+        .slot_offset = MP_OBJ_TYPE_OFFSETOF_SLOT(call),
         .dest = member,
         .is_type = false,
     };
@@ -884,7 +884,7 @@ mp_obj_t mp_obj_instance_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf)
     struct class_lookup_data lookup = {
         .obj = self,
         .attr = MP_QSTR___iter__,
-        .meth_offset = offsetof(mp_obj_type_t, getiter),
+        .slot_offset = MP_OBJ_TYPE_OFFSETOF_SLOT(getiter),
         .dest = member,
         .is_type = false,
     };
@@ -896,7 +896,7 @@ mp_obj_t mp_obj_instance_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf)
         if (iter_buf == NULL) {
             iter_buf = m_new_obj(mp_obj_iter_buf_t);
         }
-        return type->getiter(self->subobj[0], iter_buf);
+        return MP_OBJ_TYPE_GET_SLOT(type, getiter)(self->subobj[0], iter_buf);
     } else {
         return mp_call_method_n_kw(0, 0, member);
     }
@@ -908,14 +908,14 @@ STATIC mp_int_t instance_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo,
     struct class_lookup_data lookup = {
         .obj = self,
         .attr = MP_QSTR_, // don't actually look for a method
-        .meth_offset = offsetof(mp_obj_type_t, buffer_p.get_buffer),
+        .slot_offset = MP_OBJ_TYPE_OFFSETOF_SLOT(buffer),
         .dest = member,
         .is_type = false,
     };
     mp_obj_class_lookup(&lookup, self->base.type);
     if (member[0] == MP_OBJ_SENTINEL) {
         const mp_obj_type_t *type = mp_obj_get_type(self->subobj[0]);
-        return type->buffer_p.get_buffer(self->subobj[0], bufinfo, flags);
+        return MP_OBJ_TYPE_GET_SLOT(type, buffer)(self->subobj[0], bufinfo, flags);
     } else {
         return 1; // object does not support buffer protocol
     }
@@ -1016,7 +1016,7 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
         if (attr == MP_QSTR___dict__) {
             // Returns a read-only dict of the class attributes.
             // If the internal locals is not fixed, a copy will be created.
-            const mp_obj_dict_t *dict = self->locals_dict;
+            const mp_obj_dict_t *dict = MP_OBJ_TYPE_GET_SLOT_OR_NULL(self, locals_dict);
             if (!dict) {
                 dict = &mp_const_empty_dict_obj;
             }
@@ -1035,7 +1035,7 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
                 dest[0] = mp_const_empty_tuple;
                 return;
             }
-            mp_obj_t parent_obj = self->parent ? MP_OBJ_FROM_PTR(self->parent) : MP_OBJ_FROM_PTR(&mp_type_object);
+            mp_obj_t parent_obj = MP_OBJ_TYPE_HAS_SLOT(self, parent) ? MP_OBJ_FROM_PTR(MP_OBJ_TYPE_GET_SLOT(self, parent)) : MP_OBJ_FROM_PTR(&mp_type_object);
             #if MICROPY_MULTIPLE_INHERITANCE
             if (mp_obj_is_type(parent_obj, &mp_type_tuple)) {
                 dest[0] = parent_obj;
@@ -1049,7 +1049,7 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
         struct class_lookup_data lookup = {
             .obj = (mp_obj_instance_t *)self,
             .attr = attr,
-            .meth_offset = 0,
+            .slot_offset = 0,
             .dest = dest,
             .is_type = true,
         };
@@ -1057,9 +1057,9 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     } else {
         // delete/store attribute
 
-        if (self->locals_dict != NULL) {
-            assert(mp_obj_is_dict_or_ordereddict(MP_OBJ_FROM_PTR(self->locals_dict))); // MicroPython restriction, for now
-            mp_map_t *locals_map = &self->locals_dict->map;
+        if (MP_OBJ_TYPE_HAS_SLOT(self, locals_dict)) {
+            assert(mp_obj_is_dict_or_ordereddict(MP_OBJ_FROM_PTR(MP_OBJ_TYPE_GET_SLOT(self, locals_dict)))); // MicroPython restriction, for now
+            mp_map_t *locals_map = &MP_OBJ_TYPE_GET_SLOT(self, locals_dict)->map;
             if (locals_map->is_fixed) {
                 // can't apply delete/store to a fixed map
                 return;
@@ -1093,15 +1093,13 @@ 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
@@ -1142,47 +1140,55 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
         #endif
     }
 
-    mp_obj_type_t *o = m_new0(mp_obj_type_t, 1);
+    // Allocate a full-sized mp_obj_full_type_t instance (i.e. all slots / extended fields).
+    // Given that Python types use almost all the slots anyway, this doesn't cost anything
+    // extra.
+    mp_obj_type_t *o = (mp_obj_type_t *)m_new0(mp_obj_full_type_t, 1);
     o->base.type = &mp_type_type;
-    o->flags = base_flags;
+    o->flags = base_flags
+        #if MICROPY_OBJ_TYPE_REPR == MICROPY_OBJ_TYPE_REPR_SPLIT
+        | MP_OBJ_TYPE_FLAG_EXTENDED
+        #endif
+    ;
     o->name = name;
-    o->print = instance_print;
     o->make_new = mp_obj_instance_make_new;
-    o->call = mp_obj_instance_call;
-    o->unary_op = instance_unary_op;
-    o->binary_op = instance_binary_op;
-    o->attr = mp_obj_instance_attr;
-    o->subscr = instance_subscr;
-    o->getiter = mp_obj_instance_getiter;
-    // o->iternext = ; not implemented
-    o->buffer_p.get_buffer = instance_get_buffer;
+    MP_OBJ_TYPE_SET_SLOT(o, print, instance_print, 1);
+    MP_OBJ_TYPE_SET_SLOT(o, call, mp_obj_instance_call, 2);
+    MP_OBJ_TYPE_SET_SLOT(o, unary_op, instance_unary_op, 3);
+    MP_OBJ_TYPE_SET_SLOT(o, binary_op, instance_binary_op, 4);
+    MP_OBJ_TYPE_SET_SLOT(o, attr, mp_obj_instance_attr, 5);
+    MP_OBJ_TYPE_SET_SLOT(o, subscr, instance_subscr, 6);
+    MP_OBJ_TYPE_SET_SLOT(o, getiter, mp_obj_instance_getiter, 7);
+    // MP_OBJ_TYPE_SET_SLOT(o, iternext, not implemented)
+    MP_OBJ_TYPE_SET_SLOT(o, buffer, instance_get_buffer, 8);
 
     if (bases_len > 0) {
         // Inherit protocol from a base class. This allows to define an
         // abstract base class which would translate C-level protocol to
         // Python method calls, and any subclass inheriting from it will
         // support this feature.
-        o->protocol = ((mp_obj_type_t *)MP_OBJ_TO_PTR(bases_items[0]))->protocol;
+        MP_OBJ_TYPE_SET_SLOT(o, protocol, MP_OBJ_TYPE_GET_SLOT_OR_NULL(((mp_obj_type_t *)MP_OBJ_TO_PTR(bases_items[0])), protocol), 9);
 
         if (bases_len >= 2) {
             #if MICROPY_MULTIPLE_INHERITANCE
-            o->parent = MP_OBJ_TO_PTR(bases_tuple);
+            MP_OBJ_TYPE_SET_SLOT(o, parent, MP_OBJ_TO_PTR(bases_tuple), 10);
             #else
             mp_raise_NotImplementedError(MP_ERROR_TEXT("multiple inheritance not supported"));
             #endif
         } else {
-            o->parent = MP_OBJ_TO_PTR(bases_items[0]);
+            MP_OBJ_TYPE_SET_SLOT(o, parent, MP_OBJ_TO_PTR(bases_items[0]), 10);
         }
     }
 
-    o->locals_dict = MP_OBJ_TO_PTR(locals_dict);
+    mp_obj_dict_t *locals_ptr = MP_OBJ_TO_PTR(locals_dict);
+    MP_OBJ_TYPE_SET_SLOT(o, locals_dict, locals_ptr, 11);
 
     #if ENABLE_SPECIAL_ACCESSORS
     // Check if the class has any special accessor methods
     if (!(o->flags & MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
-        for (size_t i = 0; i < o->locals_dict->map.alloc; i++) {
-            if (mp_map_slot_is_filled(&o->locals_dict->map, i)) {
-                const mp_map_elem_t *elem = &o->locals_dict->map.table[i];
+        for (size_t i = 0; i < locals_ptr->map.alloc; i++) {
+            if (mp_map_slot_is_filled(&locals_ptr->map, i)) {
+                const mp_map_elem_t *elem = &locals_ptr->map.table[i];
                 if (check_for_special_accessors(elem->key, elem->value)) {
                     o->flags |= MP_TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
                     break;
@@ -1198,7 +1204,7 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
         mp_raise_TypeError(MP_ERROR_TEXT("multiple bases have instance lay-out conflict"));
     }
 
-    mp_map_t *locals_map = &o->locals_dict->map;
+    mp_map_t *locals_map = &MP_OBJ_TYPE_GET_SLOT(o, locals_dict)->map;
     mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(MP_QSTR___new__), MP_MAP_LOOKUP);
     if (elem != NULL) {
         // __new__ slot exists; check if it is a function
@@ -1259,21 +1265,21 @@ STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     struct class_lookup_data lookup = {
         .obj = MP_OBJ_TO_PTR(self->obj),
         .attr = attr,
-        .meth_offset = 0,
+        .slot_offset = 0,
         .dest = dest,
         .is_type = false,
     };
 
-    // Allow a call super().__init__() to reach any native base classes
+    // Allow a call super().__init__() to reach any native base classes.
     if (attr == MP_QSTR___init__) {
-        lookup.meth_offset = offsetof(mp_obj_type_t, make_new);
+        lookup.slot_offset = offsetof(mp_obj_type_t, make_new);
     }
 
-    if (type->parent == NULL) {
+    if (!MP_OBJ_TYPE_HAS_SLOT(type, parent)) {
         // no parents, do nothing
     #if MICROPY_MULTIPLE_INHERITANCE
-    } else if (((mp_obj_base_t *)type->parent)->type == &mp_type_tuple) {
-        const mp_obj_tuple_t *parent_tuple = type->parent;
+    } else if (((mp_obj_base_t *)MP_OBJ_TYPE_GET_SLOT(type, parent))->type == &mp_type_tuple) {
+        const mp_obj_tuple_t *parent_tuple = MP_OBJ_TYPE_GET_SLOT(type, parent);
         size_t len = parent_tuple->len;
         const mp_obj_t *items = parent_tuple->items;
         for (size_t i = 0; i < len; i++) {
@@ -1283,14 +1289,15 @@ STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
                 // and we don't want to lookup native methods in object.
                 continue;
             }
+
             mp_obj_class_lookup(&lookup, (mp_obj_type_t *)MP_OBJ_TO_PTR(items[i]));
             if (dest[0] != MP_OBJ_NULL) {
                 break;
             }
         }
     #endif
-    } else if (type->parent != &mp_type_object) {
-        mp_obj_class_lookup(&lookup, type->parent);
+    } else if (MP_OBJ_TYPE_GET_SLOT(type, parent) != &mp_type_object) {
+        mp_obj_class_lookup(&lookup, MP_OBJ_TYPE_GET_SLOT(type, parent));
     }
 
     if (dest[0] != MP_OBJ_NULL) {
@@ -1302,20 +1309,18 @@ STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
         return;
     }
 
-    // Reset meth_offset so we don't look up any native methods in object,
+    // Reset slot_offset so we don't look up any native methods in object,
     // because object never takes up the native base-class slot.
-    lookup.meth_offset = 0;
+    lookup.slot_offset = 0;
 
     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]};
@@ -1342,13 +1347,13 @@ bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
 
         const mp_obj_type_t *self = MP_OBJ_TO_PTR(object);
 
-        if (self->parent == NULL) {
+        if (!MP_OBJ_TYPE_HAS_SLOT(self, parent)) {
             // type has no parents
             return false;
         #if MICROPY_MULTIPLE_INHERITANCE
-        } else if (((mp_obj_base_t *)self->parent)->type == &mp_type_tuple) {
+        } else if (((mp_obj_base_t *)MP_OBJ_TYPE_GET_SLOT(self, parent))->type == &mp_type_tuple) {
             // get the base objects (they should be type objects)
-            const mp_obj_tuple_t *parent_tuple = self->parent;
+            const mp_obj_tuple_t *parent_tuple = MP_OBJ_TYPE_GET_SLOT(self, parent);
             const mp_obj_t *item = parent_tuple->items;
             const mp_obj_t *top = item + parent_tuple->len - 1;
 
@@ -1364,7 +1369,7 @@ bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
         #endif
         } else {
             // type has 1 parent
-            object = MP_OBJ_FROM_PTR(self->parent);
+            object = MP_OBJ_FROM_PTR(MP_OBJ_TYPE_GET_SLOT(self, parent));
         }
     }
 }
@@ -1431,14 +1436,10 @@ 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,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_type_staticmethod, MP_QSTR_staticmethod, MP_TYPE_FLAG_NONE, 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_classmethod, MP_QSTR_classmethod, MP_TYPE_FLAG_NONE, static_class_method_make_new
+    );
diff --git a/py/objzip.c b/py/objzip.c
index 4abc917c3f525..0dbc5db91f22b 100644
--- a/py/objzip.c
+++ b/py/objzip.c
@@ -67,10 +67,8 @@ 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/opmethods.c b/py/opmethods.c
index 595cc088ba933..c3931fd358466 100644
--- a/py/opmethods.c
+++ b/py/opmethods.c
@@ -29,24 +29,28 @@
 
 STATIC mp_obj_t op_getitem(mp_obj_t self_in, mp_obj_t key_in) {
     const mp_obj_type_t *type = mp_obj_get_type(self_in);
-    return type->subscr(self_in, key_in, MP_OBJ_SENTINEL);
+    // Note: assumes type must have subscr (only used by dict).
+    return MP_OBJ_TYPE_GET_SLOT(type, subscr)(self_in, key_in, MP_OBJ_SENTINEL);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_op_getitem_obj, op_getitem);
 
 STATIC mp_obj_t op_setitem(mp_obj_t self_in, mp_obj_t key_in, mp_obj_t value_in) {
     const mp_obj_type_t *type = mp_obj_get_type(self_in);
-    return type->subscr(self_in, key_in, value_in);
+    // Note: assumes type must have subscr (only used by dict).
+    return MP_OBJ_TYPE_GET_SLOT(type, subscr)(self_in, key_in, value_in);
 }
 MP_DEFINE_CONST_FUN_OBJ_3(mp_op_setitem_obj, op_setitem);
 
 STATIC mp_obj_t op_delitem(mp_obj_t self_in, mp_obj_t key_in) {
     const mp_obj_type_t *type = mp_obj_get_type(self_in);
-    return type->subscr(self_in, key_in, MP_OBJ_NULL);
+    // Note: assumes type must have subscr (only used by dict).
+    return MP_OBJ_TYPE_GET_SLOT(type, subscr)(self_in, key_in, MP_OBJ_NULL);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_op_delitem_obj, op_delitem);
 
 STATIC mp_obj_t op_contains(mp_obj_t lhs_in, mp_obj_t rhs_in) {
     const mp_obj_type_t *type = mp_obj_get_type(lhs_in);
-    return type->binary_op(MP_BINARY_OP_CONTAINS, lhs_in, rhs_in);
+    // Note: assumes type must have binary_op (only used by set/frozenset).
+    return MP_OBJ_TYPE_GET_SLOT(type, binary_op)(MP_BINARY_OP_CONTAINS, lhs_in, rhs_in);
 }
 MP_DEFINE_CONST_FUN_OBJ_2(mp_op_contains_obj, op_contains);
diff --git a/py/profile.c b/py/profile.c
index 4e23e9eac43b5..0815f1be91e42 100644
--- a/py/profile.c
+++ b/py/profile.c
@@ -172,13 +172,12 @@ 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 +240,12 @@ 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 02b866d83953b..6fe93909e4b18 100644
--- a/py/runtime.c
+++ b/py/runtime.c
@@ -305,8 +305,8 @@ mp_obj_t mp_unary_op(mp_unary_op_t op, mp_obj_t arg) {
         return MP_OBJ_NEW_SMALL_INT(h);
     } else {
         const mp_obj_type_t *type = mp_obj_get_type(arg);
-        if (type->unary_op != NULL) {
-            mp_obj_t result = type->unary_op(op, arg);
+        if (MP_OBJ_TYPE_HAS_SLOT(type, unary_op)) {
+            mp_obj_t result = MP_OBJ_TYPE_GET_SLOT(type, unary_op)(op, arg);
             if (result != MP_OBJ_NULL) {
                 return result;
             }
@@ -602,8 +602,8 @@ mp_obj_t MICROPY_WRAP_MP_BINARY_OP(mp_binary_op)(mp_binary_op_t op, mp_obj_t lhs
     const mp_obj_type_t *type;
 generic_binary_op:
     type = mp_obj_get_type(lhs);
-    if (type->binary_op != NULL) {
-        mp_obj_t result = type->binary_op(op, lhs, rhs);
+    if (MP_OBJ_TYPE_HAS_SLOT(type, binary_op)) {
+        mp_obj_t result = MP_OBJ_TYPE_GET_SLOT(type, binary_op)(op, lhs, rhs);
         if (result != MP_OBJ_NULL) {
             return result;
         }
@@ -678,8 +678,8 @@ mp_obj_t mp_call_function_n_kw(mp_obj_t fun_in, size_t n_args, size_t n_kw, cons
     const mp_obj_type_t *type = mp_obj_get_type(fun_in);
 
     // do the call
-    if (type->call != NULL) {
-        return type->call(fun_in, n_args, n_kw, args);
+    if (MP_OBJ_TYPE_HAS_SLOT(type, call)) {
+        return MP_OBJ_TYPE_GET_SLOT(type, call)(fun_in, n_args, n_kw, args);
     }
 
     #if MICROPY_ERROR_REPORTING <= MICROPY_ERROR_REPORTING_TERSE
@@ -1059,12 +1059,10 @@ 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 = m_new_obj(mp_obj_checked_fun_t);
@@ -1156,14 +1154,14 @@ void mp_load_method_maybe(mp_obj_t obj, qstr attr, mp_obj_t *dest) {
     }
     #endif
 
-    if (attr == MP_QSTR___next__ && type->iternext != NULL) {
+    if (attr == MP_QSTR___next__ && MP_OBJ_TYPE_HAS_SLOT(type, iternext)) {
         dest[0] = MP_OBJ_FROM_PTR(&mp_builtin_next_obj);
         dest[1] = obj;
         return;
     }
-    if (type->attr != NULL) {
+    if (MP_OBJ_TYPE_HAS_SLOT(type, attr)) {
         // this type can do its own load, so call it
-        type->attr(obj, attr, dest);
+        MP_OBJ_TYPE_GET_SLOT(type, attr)(obj, attr, dest);
         // If type->attr has set dest[1] = MP_OBJ_SENTINEL, we should proceed
         // with lookups below (i.e. in locals_dict). If not, return right away.
         if (dest[1] != MP_OBJ_SENTINEL) {
@@ -1172,11 +1170,11 @@ void mp_load_method_maybe(mp_obj_t obj, qstr attr, mp_obj_t *dest) {
         // Clear the fail flag set by type->attr so it's like it never ran.
         dest[1] = MP_OBJ_NULL;
     }
-    if (type->locals_dict != NULL) {
+    if (MP_OBJ_TYPE_HAS_SLOT(type, locals_dict)) {
         // 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;
+        assert(MP_OBJ_TYPE_GET_SLOT(type, locals_dict)->base.type == &mp_type_dict); // MicroPython restriction, for now
+        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_convert_member_lookup(obj, type, elem->value, dest);
@@ -1228,9 +1226,9 @@ void mp_load_method_protected(mp_obj_t obj, qstr attr, mp_obj_t *dest, bool catc
 void mp_store_attr(mp_obj_t base, qstr attr, mp_obj_t value) {
     DEBUG_OP_printf("store attr %p.%s <- %p\n", base, qstr_str(attr), value);
     const mp_obj_type_t *type = mp_obj_get_type(base);
-    if (type->attr != NULL) {
+    if (MP_OBJ_TYPE_HAS_SLOT(type, attr)) {
         mp_obj_t dest[2] = {MP_OBJ_SENTINEL, value};
-        type->attr(base, attr, dest);
+        MP_OBJ_TYPE_GET_SLOT(type, attr)(base, attr, dest);
         if (dest[0] == MP_OBJ_NULL) {
             // success
             return;
@@ -1249,20 +1247,21 @@ mp_obj_t mp_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
     assert(o_in);
     const mp_obj_type_t *type = mp_obj_get_type(o_in);
 
-    // Check for native getiter which is the identity.  We handle this case explicitly
-    // so we don't unnecessarily allocate any RAM for the iter_buf, which won't be used.
-    if (type->getiter == mp_identity_getiter) {
-        return o_in;
-    }
 
-    // check for native getiter (corresponds to __iter__)
-    if (type->getiter != NULL) {
-        if (iter_buf == NULL && type->getiter != mp_obj_instance_getiter) {
+    if (MP_OBJ_TYPE_HAS_SLOT(type, getiter)) {
+        // Check for native getiter which is the identity.  We handle this case explicitly
+        // so we don't unnecessarily allocate any RAM for the iter_buf, which won't be used.
+        if (MP_OBJ_TYPE_GET_SLOT(type, getiter) == mp_identity_getiter) {
+            return o_in;
+        }
+
+        // check for native getiter (corresponds to __iter__)
+        if (iter_buf == NULL && MP_OBJ_TYPE_GET_SLOT(type, getiter) != mp_obj_instance_getiter) {
             // if caller did not provide a buffer then allocate one on the heap
             // mp_obj_instance_getiter is special, it will allocate only if needed
             iter_buf = m_new_obj(mp_obj_iter_buf_t);
         }
-        mp_obj_t iter = type->getiter(o_in, iter_buf);
+        mp_obj_t iter = MP_OBJ_TYPE_GET_SLOT(type, getiter)(o_in, iter_buf);
         if (iter != MP_OBJ_NULL) {
             return iter;
         }
@@ -1294,9 +1293,9 @@ mp_obj_t mp_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
 // may also raise StopIteration()
 mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
     const mp_obj_type_t *type = mp_obj_get_type(o_in);
-    if (type->iternext != NULL) {
+    if (MP_OBJ_TYPE_HAS_SLOT(type, iternext)) {
         MP_STATE_THREAD(stop_iteration_arg) = MP_OBJ_NULL;
-        return type->iternext(o_in);
+        return MP_OBJ_TYPE_GET_SLOT(type, iternext)(o_in);
     } else {
         // check for __next__ method
         mp_obj_t dest[2];
@@ -1320,9 +1319,9 @@ mp_obj_t mp_iternext_allow_raise(mp_obj_t o_in) {
 mp_obj_t mp_iternext(mp_obj_t o_in) {
     MP_STACK_CHECK(); // enumerate, filter, map and zip can recursively call mp_iternext
     const mp_obj_type_t *type = mp_obj_get_type(o_in);
-    if (type->iternext != NULL) {
+    if (MP_OBJ_TYPE_HAS_SLOT(type, iternext)) {
         MP_STATE_THREAD(stop_iteration_arg) = MP_OBJ_NULL;
-        return type->iternext(o_in);
+        return MP_OBJ_TYPE_GET_SLOT(type, iternext)(o_in);
     } else {
         // check for __next__ method
         mp_obj_t dest[2];
@@ -1360,9 +1359,9 @@ mp_vm_return_kind_t mp_resume(mp_obj_t self_in, mp_obj_t send_value, mp_obj_t th
         return mp_obj_gen_resume(self_in, send_value, throw_value, ret_val);
     }
 
-    if (type->iternext != NULL && send_value == mp_const_none) {
+    if (MP_OBJ_TYPE_HAS_SLOT(type, iternext) && send_value == mp_const_none) {
         MP_STATE_THREAD(stop_iteration_arg) = MP_OBJ_NULL;
-        mp_obj_t ret = type->iternext(self_in);
+        mp_obj_t ret = MP_OBJ_TYPE_GET_SLOT(type, iternext)(self_in);
         *ret_val = ret;
         if (ret != MP_OBJ_STOP_ITERATION) {
             return MP_VM_RETURN_YIELD;
diff --git a/py/stream.c b/py/stream.c
index dce64a44dbeda..ff02917e21833 100644
--- a/py/stream.c
+++ b/py/stream.c
@@ -86,15 +86,16 @@ mp_uint_t mp_stream_rw(mp_obj_t stream, void *buf_, mp_uint_t size, int *errcode
 
 const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags) {
     const mp_obj_type_t *type = mp_obj_get_type(self_in);
-    const mp_stream_p_t *stream_p = type->protocol;
-    if (stream_p == NULL
-        || ((flags & MP_STREAM_OP_READ) && stream_p->read == NULL)
-        || ((flags & MP_STREAM_OP_WRITE) && stream_p->write == NULL)
-        || ((flags & MP_STREAM_OP_IOCTL) && stream_p->ioctl == NULL)) {
-        // CPython: io.UnsupportedOperation, OSError subclass
-        mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("stream operation not supported"));
+    if (MP_OBJ_TYPE_HAS_SLOT(type, protocol)) {
+        const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(type, protocol);
+        if (!((flags & MP_STREAM_OP_READ) && stream_p->read == NULL)
+            && !((flags & MP_STREAM_OP_WRITE) && stream_p->write == NULL)
+            && !((flags & MP_STREAM_OP_IOCTL) && stream_p->ioctl == NULL)) {
+            return stream_p;
+        }
     }
-    return stream_p;
+    // CPython: io.UnsupportedOperation, OSError subclass
+    mp_raise_msg(&mp_type_OSError, MP_ERROR_TEXT("stream operation not supported"));
 }
 
 STATIC mp_obj_t stream_read_generic(size_t n_args, const mp_obj_t *args, byte flags) {
@@ -507,7 +508,7 @@ MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_ioctl_obj, 2, 3, stream_ioctl);
 
 ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
     mp_obj_base_t *o = stream;
-    const mp_stream_p_t *stream_p = o->type->protocol;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
     mp_uint_t out_sz = stream_p->write(MP_OBJ_FROM_PTR(stream), buf, len, &errno);
     if (out_sz == MP_STREAM_ERROR) {
         return -1;
@@ -518,7 +519,7 @@ ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len) {
 
 ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
     mp_obj_base_t *o = stream;
-    const mp_stream_p_t *stream_p = o->type->protocol;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
     mp_uint_t out_sz = stream_p->read(MP_OBJ_FROM_PTR(stream), buf, len, &errno);
     if (out_sz == MP_STREAM_ERROR) {
         return -1;
@@ -529,7 +530,7 @@ ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len) {
 
 off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
     const mp_obj_base_t *o = stream;
-    const mp_stream_p_t *stream_p = o->type->protocol;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
     struct mp_stream_seek_t seek_s;
     seek_s.offset = offset;
     seek_s.whence = whence;
@@ -542,7 +543,7 @@ off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence) {
 
 int mp_stream_posix_fsync(void *stream) {
     mp_obj_base_t *o = stream;
-    const mp_stream_p_t *stream_p = o->type->protocol;
+    const mp_stream_p_t *stream_p = MP_OBJ_TYPE_GET_SLOT(o->type, protocol);
     mp_uint_t res = stream_p->ioctl(MP_OBJ_FROM_PTR(stream), MP_STREAM_FLUSH, 0, &errno);
     if (res == MP_STREAM_ERROR) {
         return -1;
diff --git a/py/stream.h b/py/stream.h
index 45f36ef5a6f39..4bc329b3e790d 100644
--- a/py/stream.h
+++ b/py/stream.h
@@ -95,7 +95,7 @@ MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_ioctl_obj);
 
 // Object is assumed to have a non-NULL stream protocol with valid r/w/ioctl methods
 static inline const mp_stream_p_t *mp_get_stream(mp_const_obj_t self) {
-    return (const mp_stream_p_t *)((const mp_obj_base_t *)MP_OBJ_TO_PTR(self))->type->protocol;
+    return (const mp_stream_p_t *)MP_OBJ_TYPE_GET_SLOT(((const mp_obj_base_t *)MP_OBJ_TO_PTR(self))->type, protocol);
 }
 
 const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags);
diff --git a/shared/runtime/mpirq.c b/shared/runtime/mpirq.c
index 8e474bf5a2b13..a717206843958 100644
--- a/shared/runtime/mpirq.c
+++ b/shared/runtime/mpirq.c
@@ -125,11 +125,10 @@ STATIC const mp_rom_map_elem_t mp_irq_locals_dict_table[] = {
 };
 STATIC MP_DEFINE_CONST_DICT(mp_irq_locals_dict, mp_irq_locals_dict_table);
 
-const mp_obj_type_t mp_irq_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_irq,
-    .call = mp_irq_call,
-    .locals_dict = (mp_obj_dict_t *)&mp_irq_locals_dict,
-};
+MP_DEFINE_CONST_OBJ_TYPE(
+    mp_irq_type, MP_QSTR_irq, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    call, mp_irq_call,
+    locals_dict, (mp_obj_dict_t *)&mp_irq_locals_dict
+    );
 
 #endif // MICROPY_ENABLE_SCHEDULER
diff --git a/shared/runtime/sys_stdio_mphal.c b/shared/runtime/sys_stdio_mphal.c
index e72facb981d9c..dcd13011e7206 100644
--- a/shared/runtime/sys_stdio_mphal.c
+++ b/shared/runtime/sys_stdio_mphal.c
@@ -126,16 +126,15 @@ STATIC const mp_stream_p_t stdio_obj_stream_p = {
     .is_text = true,
 };
 
-STATIC const mp_obj_type_t stdio_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_FileIO,
+MP_DEFINE_CONST_OBJ_TYPE(
     // TODO .make_new?
-    .print = stdio_obj_print,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &stdio_obj_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&stdio_locals_dict,
-};
+    stdio_obj_type, MP_QSTR_FileIO, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, stdio_obj_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &stdio_obj_stream_p,
+    locals_dict, (mp_obj_dict_t *)&stdio_locals_dict
+    );
 
 const sys_stdio_obj_t mp_sys_stdin_obj = {{&stdio_obj_type}, .fd = STDIO_FD_IN};
 const sys_stdio_obj_t mp_sys_stdout_obj = {{&stdio_obj_type}, .fd = STDIO_FD_OUT};
@@ -161,15 +160,14 @@ STATIC const mp_stream_p_t stdio_buffer_obj_stream_p = {
     .is_text = false,
 };
 
-STATIC const mp_obj_type_t stdio_buffer_obj_type = {
-    { &mp_type_type },
-    .name = MP_QSTR_FileIO,
-    .print = stdio_obj_print,
-    .getiter = mp_identity_getiter,
-    .iternext = mp_stream_unbuffered_iter,
-    .protocol = &stdio_buffer_obj_stream_p,
-    .locals_dict = (mp_obj_dict_t *)&stdio_locals_dict,
-};
+STATIC MP_DEFINE_CONST_OBJ_TYPE(
+    stdio_buffer_obj_type, MP_QSTR_FileIO, MP_TYPE_FLAG_NONE, MP_TYPE_NULL_MAKE_NEW,
+    print, stdio_obj_print,
+    getiter, mp_identity_getiter,
+    iternext, mp_stream_unbuffered_iter,
+    protocol, &stdio_buffer_obj_stream_p,
+    locals_dict, (mp_obj_dict_t *)&stdio_locals_dict
+    );
 
 STATIC const sys_stdio_obj_t stdio_buffer_obj = {{&stdio_buffer_obj_type}, .fd = 0}; // fd unused
 #endif