Merge pull request #1068 from dhalbert/micropython-25ae98f-merge

Micropython 25ae98f merge

1 files changed, 229 insertions, 91 deletions

diff --git a/py/objtype.c b/py/objtype.c
index 5b70e8e48..b12fadbf7 100644
--- a/py/objtype.c
+++ b/py/objtype.c
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2013, 2014 Damien P. George
+ * Copyright (c) 2013-2018 Damien P. George
  * Copyright (c) 2014-2016 Paul Sokolovsky
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -42,19 +42,17 @@
 #define DEBUG_printf(...) (void)0
 #endif
 
+#define ENABLE_SPECIAL_ACCESSORS \
+    (MICROPY_PY_DESCRIPTORS  || MICROPY_PY_DELATTR_SETATTR || MICROPY_PY_BUILTINS_PROPERTY)
+
+#define TYPE_FLAG_IS_SUBCLASSED (0x0001)
+#define TYPE_FLAG_HAS_SPECIAL_ACCESSORS (0x0002)
+
 STATIC mp_obj_t static_class_method_make_new(const mp_obj_type_t *self_in, size_t n_args, size_t n_kw, const mp_obj_t *args);
 
 /******************************************************************************/
 // instance object
 
-STATIC mp_obj_t mp_obj_new_instance(const mp_obj_type_t *class, size_t subobjs) {
-    mp_obj_instance_t *o = m_new_obj_var(mp_obj_instance_t, mp_obj_t, subobjs);
-    o->base.type = class;
-    mp_map_init(&o->members, 0);
-    mp_seq_clear(o->subobj, 0, subobjs, sizeof(*o->subobj));
-    return MP_OBJ_FROM_PTR(o);
-}
-
 STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_type_t **last_native_base) {
     int count = 0;
     for (;;) {
@@ -68,6 +66,7 @@ STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_t
         } else if (type->parent == NULL) {
             // No parents so end search here.
             return count;
+        #if MICROPY_MULTIPLE_INHERITANCE
         } else if (((mp_obj_base_t*)type->parent)->type == &mp_type_tuple) {
             // Multiple parents, search through them all recursively.
             const mp_obj_tuple_t *parent_tuple = type->parent;
@@ -79,6 +78,7 @@ STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_t
                 count += instance_count_native_bases(bt, last_native_base);
             }
             return count;
+        #endif
         } else {
             // A single parent, use iteration to continue the search.
             type = type->parent;
@@ -86,6 +86,35 @@ STATIC int instance_count_native_bases(const mp_obj_type_t *type, const mp_obj_t
     }
 }
 
+// This wrapper function is allows a subclass of a native type to call the
+// __init__() method (corresponding to type->make_new) of the native type.
+STATIC mp_obj_t native_base_init_wrapper(size_t n_args, const mp_obj_t *args) {
+    mp_obj_instance_t *self = MP_OBJ_TO_PTR(args[0]);
+    const mp_obj_type_t *native_base = NULL;
+    instance_count_native_bases(self->base.type, &native_base);
+    self->subobj[0] = native_base->make_new(native_base, n_args - 1, 0, args + 1);
+    return mp_const_none;
+}
+STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(native_base_init_wrapper_obj, 1, MP_OBJ_FUN_ARGS_MAX, native_base_init_wrapper);
+
+#if !MICROPY_CPYTHON_COMPAT
+STATIC
+#endif
+mp_obj_instance_t *mp_obj_new_instance(const mp_obj_type_t *class, const mp_obj_type_t **native_base) {
+    size_t num_native_bases = instance_count_native_bases(class, native_base);
+    assert(num_native_bases < 2);
+    mp_obj_instance_t *o = m_new_obj_var(mp_obj_instance_t, mp_obj_t, num_native_bases);
+    o->base.type = class;
+    mp_map_init(&o->members, 0);
+    // Initialise the native base-class slot (should be 1 at most) with a valid
+    // object.  It doesn't matter which object, so long as it can be uniquely
+    // distinguished from a native class that is initialised.
+    if (num_native_bases != 0) {
+        o->subobj[0] = MP_OBJ_FROM_PTR(&native_base_init_wrapper_obj);
+    }
+    return o;
+}
+
 // TODO
 // This implements depth-first left-to-right MRO, which is not compliant with Python3 MRO
 // http://python-history.blogspot.com/2010/06/method-resolution-order.html
@@ -176,6 +205,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
         if (type->parent == NULL) {
             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;
             const mp_obj_t *item = parent_tuple->items;
@@ -196,6 +226,7 @@ STATIC void mp_obj_class_lookup(struct class_lookup_data  *lookup, const mp_obj_
             // search last base (simple tail recursion elimination)
             assert(MP_OBJ_IS_TYPE(*item, &mp_type_type));
             type = (mp_obj_type_t*)MP_OBJ_TO_PTR(*item);
+        #endif
         } else {
             type = type->parent;
         }
@@ -251,20 +282,6 @@ STATIC void instance_print(const mp_print_t *print, mp_obj_t self_in, mp_print_k
 mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size_t n_kw, const mp_obj_t *args) {
     assert(mp_obj_is_instance_type(self));
 
-    const mp_obj_type_t *native_base;
-    size_t num_native_bases = instance_count_native_bases(self, &native_base);
-    assert(num_native_bases < 2);
-
-    mp_obj_instance_t *o = MP_OBJ_TO_PTR(mp_obj_new_instance(self, num_native_bases));
-
-    // This executes only "__new__" part of instance creation.
-    // TODO: This won't work well for classes with native bases.
-    // TODO: This is a hack, should be resolved along the lines of
-    // https://github.com/micropython/micropython/issues/606#issuecomment-43685883
-    if (n_args == 1 && *args == MP_OBJ_SENTINEL) {
-        return MP_OBJ_FROM_PTR(o);
-    }
-
     // look for __new__ function
     mp_obj_t init_fn[2] = {MP_OBJ_NULL};
     struct class_lookup_data lookup = {
@@ -276,13 +293,22 @@ mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size
     };
     mp_obj_class_lookup(&lookup, self);
 
-    mp_obj_t new_ret = MP_OBJ_FROM_PTR(o);
-    if (init_fn[0] == MP_OBJ_SENTINEL) {
-        // Native type's constructor is what wins - it gets all our arguments,
-        // and none Python classes are initialized at all.
-        o->subobj[0] = native_base->make_new(native_base, n_args, n_kw, args);
-    } else if (init_fn[0] != MP_OBJ_NULL) {
-        // now call Python class __new__ function with all args
+    const mp_obj_type_t *native_base = NULL;
+    mp_obj_instance_t *o;
+    if (init_fn[0] == MP_OBJ_NULL || init_fn[0] == MP_OBJ_SENTINEL) {
+        // Either there is no __new__() method defined or there is a native
+        // constructor.  In both cases create a blank instance.
+        o = mp_obj_new_instance(self, &native_base);
+
+        // Since type->make_new() implements both __new__() and __init__() in
+        // one go, of which the latter may be overridden by the Python subclass,
+        // we defer (see the end of this function) the call of the native
+        // constructor to give a chance for the Python __init__() method to call
+        // said native constructor.
+
+    } else {
+        // Call Python class __new__ function with all args to create an instance
+        mp_obj_t new_ret;
         if (n_args == 0 && n_kw == 0) {
             mp_obj_t args2[1] = {MP_OBJ_FROM_PTR(self)};
             new_ret = mp_call_function_n_kw(init_fn[0], 1, 0, args2);
@@ -294,17 +320,20 @@ mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size
             m_del(mp_obj_t, args2, 1 + n_args + 2 * n_kw);
         }
 
-    }
+        // https://docs.python.org/3.4/reference/datamodel.html#object.__new__
+        // "If __new__() does not return an instance of cls, then the new
+        // instance's __init__() method will not be invoked."
+        if (mp_obj_get_type(new_ret) != self) {
+            return new_ret;
+        }
 
-    // https://docs.python.org/3.4/reference/datamodel.html#object.__new__
-    // "If __new__() does not return an instance of cls, then the new instance's __init__() method will not be invoked."
-    if (mp_obj_get_type(new_ret) != self) {
-        return new_ret;
+        // The instance returned by __new__() becomes the new object
+        o = MP_OBJ_TO_PTR(new_ret);
     }
 
-    o = MP_OBJ_TO_PTR(new_ret);
-
     // now call Python class __init__ function with all args
+    // This method has a chance to call super().__init__() to construct a
+    // possible native base class.
     init_fn[0] = init_fn[1] = MP_OBJ_NULL;
     lookup.obj = o;
     lookup.attr = MP_QSTR___init__;
@@ -333,6 +362,12 @@ mp_obj_t mp_obj_instance_make_new(const mp_obj_type_t *self, size_t n_args, size
 
     }
 
+    // If the type had a native base that was not explicitly initialised
+    // (constructed) by the Python __init__() method then construct it now.
+    if (native_base != NULL && o->subobj[0] == MP_OBJ_FROM_PTR(&native_base_init_wrapper_obj)) {
+        o->subobj[0] = native_base->make_new(native_base, n_args, n_kw, args);
+    }
+
     return MP_OBJ_FROM_PTR(o);
 }
 
@@ -424,7 +459,7 @@ const byte mp_binary_op_method_name[MP_BINARY_OP_NUM_RUNTIME] = {
     [MP_BINARY_OP_LESS_EQUAL] = MP_QSTR___le__,
     [MP_BINARY_OP_MORE_EQUAL] = MP_QSTR___ge__,
     // MP_BINARY_OP_NOT_EQUAL, // a != b calls a == b and inverts result
-    [MP_BINARY_OP_IN] = MP_QSTR___contains__,
+    [MP_BINARY_OP_CONTAINS] = MP_QSTR___contains__,
 
     // All inplace methods are optional, and normal methods will be used
     // as a fallback.
@@ -537,7 +572,6 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
     mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP);
     if (elem != NULL) {
         // object member, always treated as a value
-        // TODO should we check for properties?
         dest[0] = elem->value;
         return;
     }
@@ -568,6 +602,11 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
     mp_obj_t member = dest[0];
     if (member != MP_OBJ_NULL) {
         // changes here may may require changes to super_attr, below
+        if (!(self->base.type->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
+            // Class doesn't have any special accessors to check so return straightaway
+            return;
+        }
+
         #if MICROPY_PY_BUILTINS_PROPERTY
         if (MP_OBJ_IS_TYPE(member, &mp_type_property)) {
             // object member is a property; delegate the load to the property
@@ -629,11 +668,15 @@ STATIC void mp_obj_instance_load_attr(mp_obj_t self_in, qstr attr, mp_obj_t *des
 STATIC bool mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t value) {
     mp_obj_instance_t *self = MP_OBJ_TO_PTR(self_in);
 
+    if (!(self->base.type->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
+        // Class doesn't have any special accessors so skip their checks
+        goto skip_special_accessors;
+    }
+
     #if MICROPY_PY_BUILTINS_PROPERTY || MICROPY_PY_DESCRIPTORS
     // With property and/or descriptors enabled we need to do a lookup
     // first in the class dict for the attribute to see if the store should
     // be delegated.
-    // Note: this makes all stores slow... how to fix?
     mp_obj_t member[2] = {MP_OBJ_NULL};
     struct class_lookup_data lookup = {
         .obj = self,
@@ -705,9 +748,9 @@ STATIC bool mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t val
     }
     #endif
 
+    #if MICROPY_PY_DELATTR_SETATTR
     if (value == MP_OBJ_NULL) {
         // delete attribute
-        #if MICROPY_PY_DELATTR_SETATTR
         // try __delattr__ first
         mp_obj_t attr_delattr_method[3];
         mp_load_method_maybe(self_in, MP_QSTR___delattr__, attr_delattr_method);
@@ -717,13 +760,8 @@ STATIC bool mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t val
             mp_call_method_n_kw(1, 0, attr_delattr_method);
             return true;
         }
-        #endif
-
-        mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
-        return elem != NULL;
     } else {
         // store attribute
-        #if MICROPY_PY_DELATTR_SETATTR
         // try __setattr__ first
         mp_obj_t attr_setattr_method[4];
         mp_load_method_maybe(self_in, MP_QSTR___setattr__, attr_setattr_method);
@@ -734,14 +772,23 @@ STATIC bool mp_obj_instance_store_attr(mp_obj_t self_in, qstr attr, mp_obj_t val
             mp_call_method_n_kw(2, 0, attr_setattr_method);
             return true;
         }
-        #endif
+    }
+    #endif
 
+skip_special_accessors:
+
+    if (value == MP_OBJ_NULL) {
+        // delete attribute
+        mp_map_elem_t *elem = mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
+        return elem != NULL;
+    } else {
+        // store attribute
         mp_map_lookup(&self->members, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND)->value = value;
         return true;
     }
 }
 
-void mp_obj_instance_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
+STATIC void mp_obj_instance_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
     if (dest[0] == MP_OBJ_NULL) {
         mp_obj_instance_load_attr(self_in, attr, dest);
     } else {
@@ -876,6 +923,34 @@ STATIC mp_int_t instance_get_buffer(mp_obj_t self_in, mp_buffer_info_t *bufinfo,
 //  - there is a constant mp_obj_type_t (called mp_type_type) for the 'type' object
 //  - creating a new class (a new type) creates a new mp_obj_type_t
 
+#if ENABLE_SPECIAL_ACCESSORS
+STATIC bool check_for_special_accessors(mp_obj_t key, mp_obj_t value) {
+    #if MICROPY_PY_DELATTR_SETATTR
+    if (key == MP_OBJ_NEW_QSTR(MP_QSTR___setattr__) || key == MP_OBJ_NEW_QSTR(MP_QSTR___delattr__)) {
+        return true;
+    }
+    #endif
+    #if MICROPY_PY_BUILTINS_PROPERTY
+    if (MP_OBJ_IS_TYPE(value, &mp_type_property)) {
+        return true;
+    }
+    #endif
+    #if MICROPY_PY_DESCRIPTORS
+    static const uint8_t to_check[] = {
+        MP_QSTR___get__, MP_QSTR___set__, MP_QSTR___delete__,
+    };
+    for (size_t i = 0; i < MP_ARRAY_SIZE(to_check); ++i) {
+        mp_obj_t dest_temp[2];
+        mp_load_method_protected(value, to_check[i], dest_temp, true);
+        if (dest_temp[0] != MP_OBJ_NULL) {
+            return true;
+        }
+    }
+    #endif
+    return false;
+}
+#endif
+
 STATIC void type_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
     (void)kind;
     mp_obj_type_t *self = MP_OBJ_TO_PTR(self_in);
@@ -950,21 +1025,34 @@ STATIC void type_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
         if (self->locals_dict != NULL) {
             assert(self->locals_dict->base.type == &mp_type_dict); // MicroPython restriction, for now
             mp_map_t *locals_map = &self->locals_dict->map;
+            if (locals_map->is_fixed) {
+                // can't apply delete/store to a fixed map
+                return;
+            }
             if (dest[1] == MP_OBJ_NULL) {
                 // delete attribute
                 mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
-                // note that locals_map may be in ROM, so remove will fail in that case
                 if (elem != NULL) {
                     dest[0] = MP_OBJ_NULL; // indicate success
                 }
             } else {
+                #if ENABLE_SPECIAL_ACCESSORS
+                // Check if we add any special accessor methods with this store
+                if (!(self->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS)) {
+                    if (check_for_special_accessors(MP_OBJ_NEW_QSTR(attr), dest[1])) {
+                        if (self->flags & TYPE_FLAG_IS_SUBCLASSED) {
+                            // This class is already subclassed so can't have special accessors added
+                            mp_raise_msg(&mp_type_AttributeError, "can't add special method to already-subclassed class");
+                        }
+                        self->flags |= TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
+                    }
+                }
+                #endif
+
                 // store attribute
                 mp_map_elem_t *elem = mp_map_lookup(locals_map, MP_OBJ_NEW_QSTR(attr), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
-                // note that locals_map may be in ROM, so add will fail in that case
-                if (elem != NULL) {
-                    elem->value = make_obj_long_lived(dest[1], 10);
-                    dest[0] = MP_OBJ_NULL; // indicate success
-                }
+                elem->value = make_obj_long_lived(dest[1], 10);
+                dest[0] = MP_OBJ_NULL; // indicate success
             }
         }
     }
@@ -981,26 +1069,26 @@ const mp_obj_type_t mp_type_type = {
 };
 
 mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict) {
-    if(!MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)) {
-        // MicroPython restriction, for now
-        mp_raise_TypeError("type() argument 2 must be tuple");
+    // Verify input objects have expected type
+    if (!MP_OBJ_IS_TYPE(bases_tuple, &mp_type_tuple)) {
+        mp_raise_TypeError(NULL);
     }
-    if(!MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)) {
-        // MicroPython restriction, for now
-        mp_raise_TypeError("type() argument 3 must be dict");
+    if (!MP_OBJ_IS_TYPE(locals_dict, &mp_type_dict)) {
+        mp_raise_TypeError(NULL);
     }
 
     // TODO might need to make a copy of locals_dict; at least that's how CPython does it
 
     // Basic validation of base classes
-    size_t len;
-    mp_obj_t *items;
-    mp_obj_tuple_get(bases_tuple, &len, &items);
-    for (size_t i = 0; i < len; i++) {
-        if(!MP_OBJ_IS_TYPE(items[i], &mp_type_type)) {
+    uint16_t base_flags = 0;
+    size_t bases_len;
+    mp_obj_t *bases_items;
+    mp_obj_tuple_get(bases_tuple, &bases_len, &bases_items);
+    for (size_t i = 0; i < bases_len; i++) {
+        if (!MP_OBJ_IS_TYPE(bases_items[i], &mp_type_type)) {
             mp_raise_TypeError("type is not an acceptable base type");
         }
-        mp_obj_type_t *t = MP_OBJ_TO_PTR(items[i]);
+        mp_obj_type_t *t = MP_OBJ_TO_PTR(bases_items[i]);
         // TODO: Verify with CPy, tested on function type
         if (t->make_new == NULL) {
             if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
@@ -1010,10 +1098,17 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
                     "type '%q' is not an acceptable base type", t->name);
             }
         }
+        #if ENABLE_SPECIAL_ACCESSORS
+        if (mp_obj_is_instance_type(t)) {
+            t->flags |= TYPE_FLAG_IS_SUBCLASSED;
+            base_flags |= t->flags & TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
+        }
+        #endif
     }
 
     mp_obj_type_t *o = m_new0_ll(mp_obj_type_t, 1);
     o->base.type = &mp_type_type;
+    o->flags = base_flags;
     o->name = name;
     o->print = instance_print;
     o->make_new = mp_obj_instance_make_new;
@@ -1026,22 +1121,41 @@ mp_obj_t mp_obj_new_type(qstr name, mp_obj_t bases_tuple, mp_obj_t locals_dict)
     //o->iternext = ; not implemented
     o->buffer_p.get_buffer = instance_get_buffer;
 
-    if (len > 0) {
+    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(items[0]))->protocol;
+        o->protocol = ((mp_obj_type_t*)MP_OBJ_TO_PTR(bases_items[0]))->protocol;
 
-        if (len >= 2) {
+        if (bases_len >= 2) {
+            #if MICROPY_MULTIPLE_INHERITANCE
             o->parent = MP_OBJ_TO_PTR(bases_tuple);
+            #else
+            mp_raise_NotImplementedError("multiple inheritance not supported");
+            #endif
         } else {
-            o->parent = MP_OBJ_TO_PTR(items[0]);
+            o->parent = MP_OBJ_TO_PTR(bases_items[0]);
         }
     }
 
     o->locals_dict = make_dict_long_lived(locals_dict, 10);
 
+    #if ENABLE_SPECIAL_ACCESSORS
+    // Check if the class has any special accessor methods
+    if (!(o->flags & 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];
+                if (check_for_special_accessors(elem->key, elem->value)) {
+                    o->flags |= TYPE_FLAG_HAS_SPECIAL_ACCESSORS;
+                    break;
+                }
+            }
+        }
+    }
+    #endif
+
     const mp_obj_type_t *native_base;
     size_t num_native_bases = instance_count_native_bases(o, &native_base);
     if (num_native_bases > 1) {
@@ -1114,49 +1228,71 @@ STATIC void super_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
         .is_type = false,
     };
 
+    // 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);
+    }
+
     if (type->parent == NULL) {
         // 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;
         size_t len = parent_tuple->len;
         const mp_obj_t *items = parent_tuple->items;
         for (size_t i = 0; i < len; i++) {
             assert(MP_OBJ_IS_TYPE(items[i], &mp_type_type));
+            if (MP_OBJ_TO_PTR(items[i]) == &mp_type_object) {
+                // The "object" type will be searched at the end of this function,
+                // 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;
             }
         }
-    } else {
+    #endif
+    } else if (type->parent != &mp_type_object) {
         mp_obj_class_lookup(&lookup, type->parent);
     }
 
     if (dest[0] != MP_OBJ_NULL) {
-        mp_obj_t member = dest[0];
-        // changes to mp_obj_instance_load_attr may require changes
-        // here...
-        #if MICROPY_PY_BUILTINS_PROPERTY
-        if (MP_OBJ_IS_TYPE(member, &mp_type_property)) {
-            const mp_obj_t *proxy = mp_obj_property_get(member);
-            if (proxy[0] == mp_const_none) {
-                mp_raise_AttributeError("unreadable attribute");
-            } else {
-                dest[0] = mp_call_function_n_kw(proxy[0], 1, 0, &self_in);
+        if (dest[0] == MP_OBJ_SENTINEL) {
+            // Looked up native __init__ so defer to it
+            dest[0] = MP_OBJ_FROM_PTR(&native_base_init_wrapper_obj);
+            dest[1] = self->obj;
+        } else {
+            mp_obj_t member = dest[0];
+            // changes to mp_obj_instance_load_attr may require changes
+            // here...
+            #if MICROPY_PY_BUILTINS_PROPERTY
+            if (MP_OBJ_IS_TYPE(member, &mp_type_property)) {
+                const mp_obj_t *proxy = mp_obj_property_get(member);
+                if (proxy[0] == mp_const_none) {
+                    mp_raise_AttributeError("unreadable attribute");
+                } else {
+                    dest[0] = mp_call_function_n_kw(proxy[0], 1, 0, &self_in);
+                }
             }
+            #endif
+            #if MICROPY_PY_DESCRIPTORS
+            mp_obj_t attr_get_method[4];
+            mp_load_method_maybe(member, MP_QSTR___get__, attr_get_method);
+            if (attr_get_method[0] != MP_OBJ_NULL) {
+                attr_get_method[2] = self_in;
+                attr_get_method[3] = MP_OBJ_FROM_PTR(mp_obj_get_type(self_in));
+                dest[0] = mp_call_method_n_kw(2, 0, attr_get_method);
+            }
+            #endif
         }
-        #endif
-        #if MICROPY_PY_DESCRIPTORS
-        mp_obj_t attr_get_method[4];
-        mp_load_method_maybe(member, MP_QSTR___get__, attr_get_method);
-        if (attr_get_method[0] != MP_OBJ_NULL) {
-            attr_get_method[2] = self_in;
-            attr_get_method[3] = MP_OBJ_FROM_PTR(mp_obj_get_type(self_in));
-            dest[0] = mp_call_method_n_kw(2, 0, attr_get_method);
-        }
-        #endif
         return;
     }
 
+    // Reset meth_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;
+
     mp_obj_class_lookup(&lookup, &mp_type_object);
 }
 
@@ -1196,6 +1332,7 @@ bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
         if (self->parent == NULL) {
             // type has no parents
             return false;
+        #if MICROPY_MULTIPLE_INHERITANCE
         } else if (((mp_obj_base_t*)self->parent)->type == &mp_type_tuple) {
             // get the base objects (they should be type objects)
             const mp_obj_tuple_t *parent_tuple = self->parent;
@@ -1211,6 +1348,7 @@ bool mp_obj_is_subclass_fast(mp_const_obj_t object, mp_const_obj_t classinfo) {
 
             // search last base (simple tail recursion elimination)
             object = *item;
+        #endif
         } else {
             // type has 1 parent
             object = MP_OBJ_FROM_PTR(self->parent);