add support for non string keys to the object's magic __dict__

- added new hybrid storage for the case when non string keys are set
- added relevant unittest

- HashingStorageNodes: getItem add specialization for the case of the fixed PythonObject storage

Author: cosminbasca

graalpython/com.oracle.graal.python.test/src/tests/test_dict.py

@@ -425,3 +425,13 @@ def helper_keys_contained(fn):
     # With the same size, an elementwise compare happens
     assert larger != larger3
     assert not larger == larger3
+
+
+def test_object_set_item_single_instance_non_str_key():
+    class Foo(object):
+        pass
+
+    f = Foo()
+    f.__dict__[1] = 1
+    f.a = 'a'
+    assert f.__dict__ == {1: 1, 'a': 'a'}

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/common/DynamicObjectStorage.java

@@ -171,4 +171,118 @@ public HashingStorage copy(Equivalence eq) {
         }
     }
 
+    public static class PythonObjectHybridDictStorage extends DynamicObjectStorage {
+        private final EconomicMapStorage nonAttributesStorage;
+
+        public PythonObjectHybridDictStorage(PythonObjectDictStorage storage) {
+            this(storage.getStore());
+        }
+
+        public PythonObjectHybridDictStorage(DynamicObject store) {
+            this(store, EconomicMapStorage.create(false));
+        }
+
+        PythonObjectHybridDictStorage(DynamicObject store, EconomicMapStorage nonAttributesStorage) {
+            super(store);
+            this.nonAttributesStorage = nonAttributesStorage;
+        }
+
+        @Override
+        public int length() {
+            return super.length() + nonAttributesStorage.length();
+        }
+
+        @Override
+        public boolean hasKey(Object key, Equivalence eq) {
+            if (super.hasKey(key, DEFAULT_EQIVALENCE)) {
+                return true;
+            }
+            return nonAttributesStorage.hasKey(key, eq);
+        }
+
+        @Override
+        public Object getItem(Object key, Equivalence eq) {
+            Object value = super.getItem(key, DEFAULT_EQIVALENCE);
+            if (value != null) {
+                return value;
+            }
+            return this.nonAttributesStorage.getItem(key, eq);
+        }
+
+        @Override
+        public void setItem(Object key, Object value, Equivalence eq) {
+            if (key instanceof String) {
+                super.setItem(key, value, DEFAULT_EQIVALENCE);
+            } else {
+                this.nonAttributesStorage.setItem(key, value, eq);
+            }
+        }
+
+        @Override
+        public boolean remove(Object key, Equivalence eq) {
+            if (super.remove(key, DEFAULT_EQIVALENCE)) {
+                return true;
+            }
+            return this.nonAttributesStorage.remove(key, eq);
+        }
+
+        @Override
+        public Iterable<Object> keys() {
+            if (this.nonAttributesStorage.length() == 0) {
+                return super.keys();
+            } else {
+                ArrayList<Object> entries = new ArrayList<>(this.length());
+                for (Object entry : super.keys()) {
+                    entries.add(entry);
+                }
+                for (Object entry : this.nonAttributesStorage.keys()) {
+                    entries.add(entry);
+                }
+                return wrapJavaIterable(entries);
+            }
+        }
+
+        @Override
+        public Iterable<Object> values() {
+            if (this.nonAttributesStorage.length() == 0) {
+                return super.values();
+            } else {
+                ArrayList<Object> entries = new ArrayList<>(this.length());
+                for (Object entry : super.values()) {
+                    entries.add(entry);
+                }
+                for (Object entry : this.nonAttributesStorage.values()) {
+                    entries.add(entry);
+                }
+                return wrapJavaIterable(entries);
+            }
+        }
+
+        @Override
+        public Iterable<DictEntry> entries() {
+            if (this.nonAttributesStorage.length() == 0) {
+                return super.entries();
+            } else {
+                ArrayList<DictEntry> entries = new ArrayList<>(this.length());
+                for (DictEntry entry : super.entries()) {
+                    entries.add(entry);
+                }
+                for (DictEntry entry : this.nonAttributesStorage.entries()) {
+                    entries.add(entry);
+                }
+                return wrapJavaIterable(entries);
+            }
+        }
+
+        @Override
+        public void clear() {
+            super.clear();
+            this.nonAttributesStorage.clear();
+        }
+
+        @Override
+        public HashingStorage copy(Equivalence eq) {
+            return new PythonObjectHybridDictStorage(getStore().copy(getStore().getShape()), (EconomicMapStorage) nonAttributesStorage.copy(eq));
+        }
+    }
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/common/HashingStorageNodes.java

@@ -42,7 +42,6 @@
 
 import static com.oracle.graal.python.builtins.objects.common.HashingStorage.DEFAULT_EQIVALENCE;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__HASH__;
-import static com.oracle.graal.python.runtime.exception.PythonErrorType.KeyError;
 import static com.oracle.graal.python.runtime.exception.PythonErrorType.TypeError;
 import static com.oracle.graal.python.runtime.exception.PythonErrorType.ValueError;
 
@@ -52,6 +51,7 @@
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.common.DynamicObjectStorage.FastDictStorage;
 import com.oracle.graal.python.builtins.objects.common.DynamicObjectStorage.PythonObjectDictStorage;
+import com.oracle.graal.python.builtins.objects.common.DynamicObjectStorage.PythonObjectHybridDictStorage;
 import com.oracle.graal.python.builtins.objects.common.HashingStorage.Equivalence;
 import com.oracle.graal.python.builtins.objects.common.HashingStorageNodesFactory.ContainsKeyNodeGen;
 import com.oracle.graal.python.builtins.objects.common.HashingStorageNodesFactory.ContainsValueNodeGen;
@@ -237,6 +237,12 @@ protected static DynamicObjectStorage switchToFastDictStorage(PHashingCollection
             return newStorage;
         }
 
+        protected static PythonObjectHybridDictStorage switchToHybridDictStorage(PHashingCollection container, PythonObjectDictStorage dictStorage) {
+            PythonObjectHybridDictStorage newStorage = new PythonObjectHybridDictStorage(dictStorage);
+            container.setDictStorage(newStorage);
+            return newStorage;
+        }
+
         protected static Location lookupLocation(Shape shape, Object name) {
             /* Initialization of cached values always happens in a slow path. */
             CompilerAsserts.neverPartOfCompilation();
@@ -828,7 +834,7 @@ protected void doKeywordsPStringGeneralize(PHashingCollection container, Keyword
         @Specialization(guards = {"!isJavaString(key)", "isHashable(key)"})
         @SuppressWarnings("unused")
         protected void doDynamicObjectGeneralize(PHashingCollection container, PythonObjectDictStorage storage, Object key, Object value) {
-            throw raise(KeyError, "unsupported key: %p", key);
+            switchToHybridDictStorage(container, storage).setItem(key, value, getEquivalence());
         }
 
         @Specialization(guards = {"!isJavaString(key)", "isHashable(key)"})
@@ -965,6 +971,11 @@ protected Object doDynamicObjectUpdateShapePString(DynamicObjectStorage storage,
             return doDynamicObjectUncachedPString(storage, name);
         }
 
+        @Specialization(guards = {"!isJavaString(key)", "isHashable(key)"})
+        Object doDynamicObject(PythonObjectHybridDictStorage storage, Object key) {
+            return storage.getItem(key, getEquivalence());
+        }
+
         @Specialization(guards = {"!isJavaString(key)", "isHashable(key)"})
         @SuppressWarnings("unused")
         Object doDynamicObject(DynamicObjectStorage storage, Object key) {