Would it be worth making the returned dict readonly (setting is_fixed on the underlying map, just to make it really clear about thr behaviour?

That does sound sensible. The same change would make sense on the instance __dict__ function too!

@jimmo at the definition of mp_map_t the is_fixed flash comes with a comment of

// a fixed array that can't be modified; must also be ordered

https://github.com/micropython/micropython/blob/master/py/obj.h#L355

I'm not sure how firm that rule of needing to be ordered is, perhaps that flag should also be set in this case?

@jimmo I've exposed dict_copy and used that, makes for much cleaner and safer implementation.

I've not touched the is_fixed flag, unless we can be sure it's safe for use on dynamic dict objects I'm not comfortable using it.

@dpgeorge I believe this PR is ready for review, it behaves well for me at least. A couple of others on slack have asked about this functionality recently too!

I've not touched the is_fixed flag, unless we can be sure it's safe for use on dynamic dict objects I'm not comfortable using it.

In any case a short comment in the code stating that a copy is returned meaning the original cannot be modified would be good, likewise for adding a test to the CPython difference documentation? And while we're at it maybe same for __dict__ on instances since that has the same problem.

I think this is a good change, it mirrors the availability of this on instances.

But what I'd suggest to improve it is:

• wait for py/obj.h: Clarify comments about mp_map_t is_fixed and is_ordered. #6129
• make the existing instance code use the new mp_obj_dict_copy() function to reduce code size (this might have different memory usage to inserting each element, but I think it'd be very similar for dicts that have not had any deletions, which is most likely the case for class/instance dicts)
• set is_fixed=1 on the dict before returning it
• furthermore, as an optimisation, return locals_dict directly if it's already is_fixed

This should be a relatively small set of changes.

Also a test would eventually be needed, including a cpydiff test :)

* make the existing instance code use the new `mp_obj_dict_copy()` function to reduce code size (this might have different memory usage to inserting each element, but I think it'd be very similar for dicts that have not had any deletions, which is most likely the case for class/instance dicts)

I had originally thought to do this, however class self->locals_dict is a dict, so mp_obj_dict_copy just works whereas instance self->members is a map so isn't conveniently compatible.
Turns out wrapping it in a dict obj to pass it into dict_copy does still save almost 100bytes from flash though so is likely worth it

    if (attr == MP_QSTR___dict__) {
        // Create a new dict with a copy of the instance's map items.
        // This creates, unlike CPython, a 'read-only' __dict__: modifying
        // it will not result in modifications to the actual instance members.
        mp_obj_t members_dict = mp_obj_new_dict(0);
        mp_obj_dict_t *dict = MP_OBJ_TO_PTR(members_dict);
        dict->map = self->members;
        dest[0] = mp_obj_dict_copy(MP_OBJ_FROM_PTR(dict));
        return;
    }

from

   text    data     bss     dec     hex filename
1841732     260  302044 2144036  20b724 firmware.elf

to

   text    data     bss     dec     hex filename
1841636     260  302044 2143940  20b6c4 firmware.elf

I also like your suggestions regarding the is_fixed flag too

mp_obj_t members_dict = mp_obj_new_dict(0);

No need to use heap memory, instead:

mp_obj_dict_t dict;
dict.map = self->members;
dest[0] = mp_obj_dict_copy(MP_OBJ_FROM_PTR(&dict));

'mp_obj_dict_copy' starts with mp_check_self(mp_obj_is_dict_type(self_in)); so the bare struct wasn't going to be enough. I should be able to point the base object to something that'll satisfy the check though

Also now with the next optimisation, in the case where the underlying instance map is_fixed, wont it need a real dict to return?

        // Returns a read-only dict of the instance members.
        // If the internal locals is not fixed, a copy will be created.
        // This creates, unlike CPython, a 'read-only' __dict__: modifying
        // it will not result in modifications to the actual instance members.
        mp_obj_t members_dict = mp_obj_new_dict(0);
        mp_obj_dict_t *dict = MP_OBJ_TO_PTR(members_dict);
        dict->map = self->members;
        if (dict->map.is_fixed) {
            dest[0] = dict;
        } else {
            dest[0] = mp_obj_dict_copy(MP_OBJ_FROM_PTR(dict));
            dict = MP_OBJ_TO_PTR(dest[0]);
            dict->map.is_fixed = 1;
        }
        return;

Also now with the next optimisation, in the case where the underlying instance map is_fixed, wont it need a real dict to return?

That optimisation won't work for instances, just classes.

That optimisation won't work for instances, just classes.

Thanks for the suggestions and clarification, I've cleaned that up now and added a basic unit test.

Rebased and merged in 28370c0 and 95cbe6b, with some minor edits to the comments, and fixed up the test so it worked correctly (the last print was printing False because other things are in the type dict) and tests the already-is-fixed path.