Regions: Generators are a mess

Author: xFrednet

Objects/genobject.c

@@ -187,16 +187,16 @@ gen_dealloc(PyObject *self)
         /* We have to handle this case for asynchronous generators
            right here, because this code has to be between UNTRACK
            and GC_Del. */
-        Py_CLEAR(((PyAsyncGenObject*)gen)->ag_origin_or_finalizer);
+        PyRegion_CLEAR(gen, ((PyAsyncGenObject*)gen)->ag_origin_or_finalizer);
     }
     if (PyCoro_CheckExact(gen)) {
-        Py_CLEAR(((PyCoroObject *)gen)->cr_origin_or_finalizer);
+        PyRegion_CLEAR(gen, ((PyCoroObject *)gen)->cr_origin_or_finalizer);
     }
     gen_clear_frame(gen);
     assert(gen->gi_exc_state.exc_value == NULL);
     PyStackRef_CLEAR(gen->gi_iframe.f_executable);
-    Py_CLEAR(gen->gi_name);
-    Py_CLEAR(gen->gi_qualname);
+    PyRegion_CLEAR(gen, gen->gi_name);
+    PyRegion_CLEAR(gen, gen->gi_qualname);
 
     PyObject_GC_Del(gen);
 }
@@ -285,7 +285,7 @@ gen_send_ex2(PyGenObject *gen, PyObject *arg, PyObject **presult,
         assert(result == Py_None || !PyAsyncGen_CheckExact(gen));
         if (result == Py_None && !PyAsyncGen_CheckExact(gen) && !arg) {
             /* Return NULL if called by gen_iternext() */
-            Py_CLEAR(result);
+            PyRegion_CLEARLOCAL(result);
         }
     }
     else {
@@ -322,7 +322,7 @@ gen_send_ex(PyGenObject *gen, PyObject *arg, int exc, int closing)
         else {
             _PyGen_SetStopIterationValue(result);
         }
-        Py_CLEAR(result);
+        PyRegion_CLEARLOCAL(result);
     }
     return result;
 }
@@ -648,7 +648,7 @@ gen_iternext(PyObject *self)
         if (result != Py_None) {
             _PyGen_SetStopIterationValue(result);
         }
-        Py_CLEAR(result);
+        PyRegion_CLEARLOCAL(result);
     }
     return result;
 }
@@ -908,6 +908,7 @@ PyTypeObject PyGen_Type = {
     offsetof(PyGenObject, gi_weakreflist),      /* tp_weaklistoffset */
     PyObject_SelfIter,                          /* tp_iter */
     gen_iternext,                               /* tp_iternext */
+    // TODO: Migrate
     gen_methods,                                /* tp_methods */
     gen_memberlist,                             /* tp_members */
     gen_getsetlist,                             /* tp_getset */

Objects/object.c

@@ -1614,7 +1614,7 @@ _PyObject_GetDictPtr(PyObject *obj)
 PyObject *
 PyObject_SelfIter(PyObject *obj)
 {
-    return Py_NewRef(obj);
+    return PyRegion_NewRef(obj);
 }
 
 /* Helper used when the __next__ method is removed from a type:

Objects/typeobject.c

@@ -6052,6 +6052,10 @@ find_name_in_mro(PyTypeObject *type, PyObject *name, int *error)
     PyObject *res = NULL;
     /* Keep a strong reference to mro because type->tp_mro can be replaced
        during dict lookup, e.g. when comparing to non-string keys. */
+    if (PyRegion_AddLocalRef(mro)) {
+        *error = -1;
+        return NULL;
+    }
     Py_INCREF(mro);
     PyRegion_AddLocalRef(mro);
     Py_ssize_t n = PyTuple_GET_SIZE(mro);
@@ -6069,8 +6073,7 @@ find_name_in_mro(PyTypeObject *type, PyObject *name, int *error)
     }
     *error = 0;
 done:
-    PyRegion_RemoveLocalRef(mro);
-    Py_DECREF(mro);
+    PyRegion_CLEARLOCAL(mro);
     return res;
 }
 
@@ -6263,8 +6266,7 @@ _PyType_LookupStackRefAndVersion(PyTypeObject *type, PyObject *name, _PyStackRef
         update_cache_gil_disabled(entry, name, assigned_version, res);
 #else
         PyObject *old_value = update_cache(entry, name, assigned_version, res);
-        PyRegion_RemoveLocalRef(old_value);
-        Py_DECREF(old_value);
+        PyRegion_CLEARLOCAL(old_value);
 #endif
     }
     *out = res ? PyStackRef_FromPyObjectSteal(res) : PyStackRef_NULL;

Python/region.c

@@ -1291,10 +1291,15 @@ int _add_to_region_check_obj(PyObject *obj, void *state_void) {
     assert(_PyRegion_Get(obj) == ((AddRegionState*)state_void)->merge_region);
     assert(_PyRegion_GetFollowPending(obj) == ((AddRegionState*)state_void)->subject_region);
 
-    if (PyFrame_Check(obj)) {
+    if (PyFrame_Check(obj)
+        || PyGen_CheckExact(obj)
+        || PyCoro_CheckExact(obj)
+        || PyAsyncGen_CheckExact(obj)
+        || PyAsyncGenASend_CheckExact(obj)
+    ) {
         throw_region_error(
-            "Frame objects are not movable and have to remain local",
-             NULL, NULL, obj);
+            "The given object is movable and has to remain local",
+            NULL, NULL, obj);
         return Py_OWNERSHIP_TRAVERSE_ERR;
     }
 

Python/specialize.c

@@ -923,6 +923,7 @@ analyze_descriptor_load(PyTypeObject *type, PyObject *name, PyObject **descr, un
         /* Normal attribute lookup; */
         has_getattr = false;
     }
+    // TODO(regions): xFrednet: Support slots getter and setter
     else if (getattro_slot == _Py_slot_tp_getattr_hook ||
         getattro_slot == _Py_slot_tp_getattro) {
         /* One or both of __getattribute__ or __getattr__ may have been
@@ -944,7 +945,7 @@ analyze_descriptor_load(PyTypeObject *type, PyObject *name, PyObject **descr, un
             }
             /* Potentially both __getattr__ and __getattribute__ are set.
                Too complicated */
-            Py_DECREF(getattribute);
+            PyRegion_CLEARLOCAL(getattribute);
             *descr = NULL;
             *tp_version = ga_version;
             return GETSET_OVERRIDDEN;
@@ -956,7 +957,7 @@ analyze_descriptor_load(PyTypeObject *type, PyObject *name, PyObject **descr, un
            raised. This means some specializations, e.g. specializing
            for property() isn't safe.
         */
-        Py_XDECREF(getattribute);
+        PyRegion_CLEARLOCAL(getattribute);
     }
     else {
         *descr = NULL;
@@ -1337,7 +1338,7 @@ specialize_instance_load_attr(PyObject* owner, _Py_CODEUNIT* instr, PyObject* na
     PyTypeObject *type = Py_TYPE(owner);
     DescriptorClassification kind = analyze_descriptor_load(type, name, &descr, &tp_version);
     int result = do_specialize_instance_load_attr(owner, instr, name, shadow, shared_keys_version, kind, descr, tp_version);
-    Py_XDECREF(descr);
+    PyRegion_CLEARLOCAL(descr);
     return result;
 }
 
@@ -1523,7 +1524,7 @@ specialize_class_load_attr(PyObject *owner, _Py_CODEUNIT *instr,
     unsigned int meta_version = 0;
     PyObject *metadescriptor = _PyType_LookupRefAndVersion(Py_TYPE(cls), name, &meta_version);
     DescriptorClassification metakind = classify_descriptor(metadescriptor, false);
-    Py_XDECREF(metadescriptor);
+    PyRegion_CLEARLOCAL(metadescriptor);
     switch (metakind) {
         case METHOD:
         case NON_DESCRIPTOR:
@@ -1542,15 +1543,15 @@ specialize_class_load_attr(PyObject *owner, _Py_CODEUNIT *instr,
     kind = analyze_descriptor_load(cls, name, &descr, &tp_version);
     if (tp_version == 0) {
         SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_OUT_OF_VERSIONS);
-        Py_XDECREF(descr);
+        PyRegion_CLEARLOCAL(descr);
         return -1;
     }
     bool metaclass_check = false;
     if ((Py_TYPE(cls)->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) == 0) {
         metaclass_check = true;
         if (meta_version == 0) {
             SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_OUT_OF_VERSIONS);
-            Py_XDECREF(descr);
+            PyRegion_CLEARLOCAL(descr);
             return -1;
         }
     }
@@ -1573,17 +1574,17 @@ specialize_class_load_attr(PyObject *owner, _Py_CODEUNIT *instr,
             else {
                 specialize(instr, LOAD_ATTR_CLASS);
             }
-            Py_XDECREF(descr);
+            PyRegion_CLEARLOCAL(descr);
             return 0;
 #ifdef Py_STATS
         case ABSENT:
             SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_EXPECTED_ERROR);
-            Py_XDECREF(descr);
+            PyRegion_CLEARLOCAL(descr);
             return -1;
 #endif
         default:
             SPECIALIZATION_FAIL(LOAD_ATTR, load_attr_fail_kind(kind));
-            Py_XDECREF(descr);
+            PyRegion_CLEARLOCAL(descr);
             return -1;
     }
 }