objdict: Cast mp_obj_t to concrete types explicitly.

Continuation of refactoring applied previously to objlist.

1 files changed, 58 insertions, 51 deletions

diff --git a/py/objdict.c b/py/objdict.c
index 09a5b3212..3e255ec88 100644
--- a/py/objdict.c
+++ b/py/objdict.c
@@ -56,7 +56,7 @@ STATIC mp_map_elem_t *dict_iter_next(mp_obj_dict_t *dict, mp_uint_t *cur) {
 }
 
 STATIC void dict_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
-    mp_obj_dict_t *self = self_in;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
     bool first = true;
     if (!(MICROPY_PY_UJSON && kind == PRINT_JSON)) {
         kind = PRINT_REPR;
@@ -83,24 +83,25 @@ STATIC void dict_print(void (*print)(void *env, const char *fmt, ...), void *env
 }
 
 STATIC mp_obj_t dict_make_new(mp_obj_t type_in, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
-    mp_obj_dict_t *dict = mp_obj_new_dict(0);
-    dict->base.type = type_in;
+    mp_obj_t dict_out = mp_obj_new_dict(0);
+    mp_obj_dict_t *dict = MP_OBJ_CAST(dict_out);
+    dict->base.type = MP_OBJ_CAST(type_in);
     #if MICROPY_PY_COLLECTIONS_ORDEREDDICT
-    if (type_in == &mp_type_ordereddict) {
+    if (MP_OBJ_CAST(type_in) == &mp_type_ordereddict) {
         dict->map.is_ordered = 1;
     }
     #endif
     if (n_args > 0 || n_kw > 0) {
-        mp_obj_t args2[2] = {dict, args[0]}; // args[0] is always valid, even if it's not a positional arg
+        mp_obj_t args2[2] = {dict_out, args[0]}; // args[0] is always valid, even if it's not a positional arg
         mp_map_t kwargs;
         mp_map_init_fixed_table(&kwargs, n_kw, args + n_args);
         dict_update(n_args + 1, args2, &kwargs); // dict_update will check that n_args + 1 == 1 or 2
     }
-    return dict;
+    return dict_out;
 }
 
 STATIC mp_obj_t dict_unary_op(mp_uint_t op, mp_obj_t self_in) {
-    mp_obj_dict_t *self = self_in;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
     switch (op) {
         case MP_UNARY_OP_BOOL: return MP_BOOL(self->map.used != 0);
         case MP_UNARY_OP_LEN: return MP_OBJ_NEW_SMALL_INT(self->map.used);
@@ -109,7 +110,7 @@ STATIC mp_obj_t dict_unary_op(mp_uint_t op, mp_obj_t self_in) {
 }
 
 STATIC mp_obj_t dict_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
-    mp_obj_dict_t *o = lhs_in;
+    mp_obj_dict_t *o = MP_OBJ_CAST(lhs_in);
     switch (op) {
         case MP_BINARY_OP_IN: {
             mp_map_elem_t *elem = mp_map_lookup(&o->map, rhs_in, MP_MAP_LOOKUP);
@@ -123,7 +124,7 @@ STATIC mp_obj_t dict_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
             } else
             #endif
             if (MP_OBJ_IS_TYPE(rhs_in, &mp_type_dict)) {
-                mp_obj_dict_t *rhs = rhs_in;
+                mp_obj_dict_t *rhs = MP_OBJ_CAST(rhs_in);
                 if (o->map.used != rhs->map.used) {
                     return mp_const_false;
                 }
@@ -150,7 +151,7 @@ STATIC mp_obj_t dict_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
 
 // TODO: Make sure this is inlined in dict_subscr() below.
 mp_obj_t mp_obj_dict_get(mp_obj_t self_in, mp_obj_t index) {
-    mp_obj_dict_t *self = self_in;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
     mp_map_elem_t *elem = mp_map_lookup(&self->map, index, MP_MAP_LOOKUP);
     if (elem == NULL) {
         nlr_raise(mp_obj_new_exception_msg(&mp_type_KeyError, "<value>"));
@@ -166,7 +167,7 @@ STATIC mp_obj_t dict_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
         return mp_const_none;
     } else if (value == MP_OBJ_SENTINEL) {
         // load
-        mp_obj_dict_t *self = self_in;
+        mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
         mp_map_elem_t *elem = mp_map_lookup(&self->map, index, MP_MAP_LOOKUP);
         if (elem == NULL) {
             nlr_raise(mp_obj_new_exception_msg(&mp_type_KeyError, "<value>"));
@@ -185,13 +186,13 @@ STATIC mp_obj_t dict_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
 
 typedef struct _mp_obj_dict_it_t {
     mp_obj_base_t base;
-    mp_obj_dict_t *dict;
+    mp_obj_t dict;
     mp_uint_t cur;
 } mp_obj_dict_it_t;
 
 STATIC mp_obj_t dict_it_iternext(mp_obj_t self_in) {
-    mp_obj_dict_it_t *self = self_in;
-    mp_map_elem_t *next = dict_iter_next(self->dict, &self->cur);
+    mp_obj_dict_it_t *self = MP_OBJ_CAST(self_in);
+    mp_map_elem_t *next = dict_iter_next(MP_OBJ_CAST(self->dict), &self->cur);
 
     if (next == NULL) {
         return MP_OBJ_STOP_ITERATION;
@@ -207,12 +208,13 @@ STATIC const mp_obj_type_t mp_type_dict_it = {
     .iternext = dict_it_iternext,
 };
 
-STATIC mp_obj_t dict_getiter(mp_obj_t o_in) {
-    mp_obj_dict_it_t *o = m_new_obj(mp_obj_dict_it_t);
+STATIC mp_obj_t dict_getiter(mp_obj_t self_in) {
+    mp_obj_t o_out = m_new_obj(mp_obj_dict_it_t);
+    mp_obj_dict_it_t *o = MP_OBJ_CAST(o_out);
     o->base.type = &mp_type_dict_it;
-    o->dict = o_in;
+    o->dict = self_in;
     o->cur = 0;
-    return o;
+    return o_out;
 }
 
 /******************************************************************************/
@@ -220,7 +222,7 @@ STATIC mp_obj_t dict_getiter(mp_obj_t o_in) {
 
 STATIC mp_obj_t dict_clear(mp_obj_t self_in) {
     assert(MP_OBJ_IS_DICT_TYPE(self_in));
-    mp_obj_dict_t *self = self_in;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
 
     mp_map_clear(&self->map);
 
@@ -230,15 +232,16 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(dict_clear_obj, dict_clear);
 
 STATIC mp_obj_t dict_copy(mp_obj_t self_in) {
     assert(MP_OBJ_IS_DICT_TYPE(self_in));
-    mp_obj_dict_t *self = self_in;
-    mp_obj_dict_t *other = mp_obj_new_dict(self->map.alloc);
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
+    mp_obj_t other_out = mp_obj_new_dict(self->map.alloc);
+    mp_obj_dict_t *other = MP_OBJ_CAST(other_out);
     other->base.type = self->base.type;
     other->map.used = self->map.used;
     other->map.all_keys_are_qstrs = self->map.all_keys_are_qstrs;
     other->map.is_fixed = 0;
     other->map.is_ordered = self->map.is_ordered;
     memcpy(other->map.table, self->map.table, self->map.alloc * sizeof(mp_map_elem_t));
-    return other;
+    return other_out;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_1(dict_copy_obj, dict_copy);
 
@@ -249,7 +252,7 @@ STATIC mp_obj_t dict_fromkeys(mp_uint_t n_args, const mp_obj_t *args) {
     mp_obj_t len = mp_obj_len_maybe(iter);
     mp_obj_t value = mp_const_none;
     mp_obj_t next = NULL;
-    mp_obj_dict_t *self = NULL;
+    mp_obj_t self_out;
 
     if (n_args > 2) {
         value = args[2];
@@ -257,16 +260,17 @@ STATIC mp_obj_t dict_fromkeys(mp_uint_t n_args, const mp_obj_t *args) {
 
     if (len == MP_OBJ_NULL) {
         /* object's type doesn't have a __len__ slot */
-        self = mp_obj_new_dict(0);
+        self_out = mp_obj_new_dict(0);
     } else {
-        self = mp_obj_new_dict(MP_OBJ_SMALL_INT_VALUE(len));
+        self_out = mp_obj_new_dict(MP_OBJ_SMALL_INT_VALUE(len));
     }
 
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_out);
     while ((next = mp_iternext(iter)) != MP_OBJ_STOP_ITERATION) {
         mp_map_lookup(&self->map, next, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
     }
 
-    return self;
+    return self_out;
 }
 STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(dict_fromkeys_fun_obj, 2, 3, dict_fromkeys);
 STATIC MP_DEFINE_CONST_CLASSMETHOD_OBJ(dict_fromkeys_obj, (const mp_obj_t)&dict_fromkeys_fun_obj);
@@ -333,7 +337,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(dict_setdefault_obj, 2, 3, dict_setde
 
 STATIC mp_obj_t dict_popitem(mp_obj_t self_in) {
     assert(MP_OBJ_IS_DICT_TYPE(self_in));
-    mp_obj_dict_t *self = self_in;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
     mp_uint_t cur = 0;
     mp_map_elem_t *next = dict_iter_next(self, &cur);
     if (next == NULL) {
@@ -351,7 +355,7 @@ STATIC MP_DEFINE_CONST_FUN_OBJ_1(dict_popitem_obj, dict_popitem);
 
 STATIC mp_obj_t dict_update(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kwargs) {
     assert(MP_OBJ_IS_DICT_TYPE(args[0]));
-    mp_obj_dict_t *self = args[0];
+    mp_obj_dict_t *self = MP_OBJ_CAST(args[0]);
 
     mp_arg_check_num(n_args, kwargs->used, 1, 2, true);
 
@@ -360,7 +364,7 @@ STATIC mp_obj_t dict_update(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw
 
         if (MP_OBJ_IS_DICT_TYPE(args[1])) {
             // update from other dictionary (make sure other is not self)
-            if (args[1] != self) {
+            if (args[1] != args[0]) {
                 mp_uint_t cur = 0;
                 mp_map_elem_t *elem = NULL;
                 while ((elem = dict_iter_next((mp_obj_dict_t*)args[1], &cur)) != NULL) {
@@ -418,20 +422,20 @@ STATIC char *mp_dict_view_names[] = {"dict_items", "dict_keys", "dict_values"};
 typedef struct _mp_obj_dict_view_it_t {
     mp_obj_base_t base;
     mp_dict_view_kind_t kind;
-    mp_obj_dict_t *dict;
+    mp_obj_t dict;
     mp_uint_t cur;
 } mp_obj_dict_view_it_t;
 
 typedef struct _mp_obj_dict_view_t {
     mp_obj_base_t base;
-    mp_obj_dict_t *dict;
+    mp_obj_t dict;
     mp_dict_view_kind_t kind;
 } mp_obj_dict_view_t;
 
 STATIC mp_obj_t dict_view_it_iternext(mp_obj_t self_in) {
     assert(MP_OBJ_IS_TYPE(self_in, &dict_view_it_type));
-    mp_obj_dict_view_it_t *self = self_in;
-    mp_map_elem_t *next = dict_iter_next(self->dict, &self->cur);
+    mp_obj_dict_view_it_t *self = MP_OBJ_CAST(self_in);
+    mp_map_elem_t *next = dict_iter_next(MP_OBJ_CAST(self->dict), &self->cur);
 
     if (next == NULL) {
         return MP_OBJ_STOP_ITERATION;
@@ -459,24 +463,25 @@ STATIC const mp_obj_type_t dict_view_it_type = {
 
 STATIC mp_obj_t dict_view_getiter(mp_obj_t view_in) {
     assert(MP_OBJ_IS_TYPE(view_in, &dict_view_type));
-    mp_obj_dict_view_t *view = view_in;
-    mp_obj_dict_view_it_t *o = m_new_obj(mp_obj_dict_view_it_t);
+    mp_obj_dict_view_t *view = MP_OBJ_CAST(view_in);
+    mp_obj_t o_out = m_new_obj(mp_obj_dict_view_it_t);
+    mp_obj_dict_view_it_t *o = MP_OBJ_CAST(o_out);
     o->base.type = &dict_view_it_type;
     o->kind = view->kind;
     o->dict = view->dict;
     o->cur = 0;
-    return o;
+    return o_out;
 }
 
 STATIC void dict_view_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
     assert(MP_OBJ_IS_TYPE(self_in, &dict_view_type));
-    mp_obj_dict_view_t *self = self_in;
+    mp_obj_dict_view_t *self = MP_OBJ_CAST(self_in);
     bool first = true;
     print(env, mp_dict_view_names[self->kind]);
     print(env, "([");
-    mp_obj_t *self_iter = dict_view_getiter(self);
-    mp_obj_t *next = NULL;
+    mp_obj_t self_iter = dict_view_getiter(self_in);
+    mp_obj_t next = MP_OBJ_NULL;
     while ((next = dict_view_it_iternext(self_iter)) != MP_OBJ_STOP_ITERATION) {
         if (!first) {
             print(env, ", ");
@@ -489,7 +494,7 @@ STATIC void dict_view_print(void (*print)(void *env, const char *fmt, ...), void
 
 STATIC mp_obj_t dict_view_binary_op(mp_uint_t op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
     // only supported for the 'keys' kind until sets and dicts are refactored
-    mp_obj_dict_view_t *o = lhs_in;
+    mp_obj_dict_view_t *o = MP_OBJ_CAST(lhs_in);
     if (o->kind != MP_DICT_VIEW_KEYS) {
         return MP_OBJ_NULL; // op not supported
     }
@@ -507,18 +512,18 @@ STATIC const mp_obj_type_t dict_view_type = {
     .getiter = dict_view_getiter,
 };
 
-STATIC mp_obj_t mp_obj_new_dict_view(mp_obj_dict_t *dict, mp_dict_view_kind_t kind) {
-    mp_obj_dict_view_t *o = m_new_obj(mp_obj_dict_view_t);
+STATIC mp_obj_t mp_obj_new_dict_view(mp_obj_t dict, mp_dict_view_kind_t kind) {
+    mp_obj_t o_out = m_new_obj(mp_obj_dict_view_t);
+    mp_obj_dict_view_t *o = MP_OBJ_CAST(o_out);
     o->base.type = &dict_view_type;
     o->dict = dict;
     o->kind = kind;
-    return o;
+    return o_out;
 }
 
 STATIC mp_obj_t dict_view(mp_obj_t self_in, mp_dict_view_kind_t kind) {
     assert(MP_OBJ_IS_DICT_TYPE(self_in));
-    mp_obj_dict_t *self = self_in;
-    return mp_obj_new_dict_view(self, kind);
+    return mp_obj_new_dict_view(self_in, kind);
 }
 
 STATIC mp_obj_t dict_items(mp_obj_t self_in) {
@@ -593,31 +598,33 @@ void mp_obj_dict_init(mp_obj_dict_t *dict, mp_uint_t n_args) {
 }
 
 mp_obj_t mp_obj_new_dict(mp_uint_t n_args) {
-    mp_obj_dict_t *o = m_new_obj(mp_obj_dict_t);
+    mp_obj_t o_out = m_new_obj(mp_obj_dict_t);
+    mp_obj_dict_t *o = MP_OBJ_CAST(o_out);
     mp_obj_dict_init(o, n_args);
-    return o;
+    return o_out;
 }
 
 mp_uint_t mp_obj_dict_len(mp_obj_t self_in) {
-    return ((mp_obj_dict_t *)self_in)->map.used;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
+    return self->map.used;
 }
 
 mp_obj_t mp_obj_dict_store(mp_obj_t self_in, mp_obj_t key, mp_obj_t value) {
     assert(MP_OBJ_IS_DICT_TYPE(self_in));
-    mp_obj_dict_t *self = self_in;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
     mp_map_lookup(&self->map, key, MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
     return self_in;
 }
 
 mp_obj_t mp_obj_dict_delete(mp_obj_t self_in, mp_obj_t key) {
     assert(MP_OBJ_IS_DICT_TYPE(self_in));
-    mp_obj_dict_t *self = self_in;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
     dict_get_helper(&self->map, key, MP_OBJ_NULL, MP_MAP_LOOKUP_REMOVE_IF_FOUND);
     return self_in;
 }
 
 mp_map_t *mp_obj_dict_get_map(mp_obj_t self_in) {
     assert(MP_OBJ_IS_DICT_TYPE(self_in));
-    mp_obj_dict_t *self = self_in;
+    mp_obj_dict_t *self = MP_OBJ_CAST(self_in);
     return &self->map;
 }