Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

nuitka/build/static_src/CompiledMethodType.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 /** Compiled methods.
  *
  * It strives to be full replacement for normal method objects, but
@@ -27,9 +12,11 @@
 #ifdef __IDE_ONLY__
 #include "nuitka/freelists.h"
 #include "nuitka/prelude.h"
+#include <structmember.h>
 #endif
 
-static PyObject *Nuitka_Method_get__doc__(struct Nuitka_MethodObject *method, void *closure) {
+static PyObject *Nuitka_Method_get__doc__(PyObject *self, void *data) {
+    struct Nuitka_MethodObject *method = (struct Nuitka_MethodObject *)self;
     PyObject *result = method->m_function->m_doc;
 
     if (result == NULL) {
@@ -40,8 +27,7 @@ static PyObject *Nuitka_Method_get__doc__(struct Nuitka_MethodObject *method, vo
     return result;
 }
 
-static PyGetSetDef Nuitka_Method_getsets[] = {{(char *)"__doc__", (getter)Nuitka_Method_get__doc__, NULL, NULL},
-                                              {NULL}};
+static PyGetSetDef Nuitka_Method_tp_getset[] = {{(char *)"__doc__", Nuitka_Method_get__doc__, NULL, NULL}, {NULL}};
 
 #define OFF(x) offsetof(struct Nuitka_MethodObject, x)
 
@@ -57,21 +43,17 @@ static PyMemberDef Nuitka_Method_members[] = {
      (char *)"the instance to which a method is bound; None for unbound method"},
     {NULL}};
 
-static PyObject *Nuitka_Method_reduce(struct Nuitka_MethodObject *method) {
-#if PYTHON_VERSION < 0x300
+static PyObject *Nuitka_Method_reduce(struct Nuitka_MethodObject *method, PyObject *unused) {
     PyThreadState *tstate = PyThreadState_GET();
 
+#if PYTHON_VERSION < 0x300
+    // spell-checker: ignore instancemethod
     SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "can't pickle instancemethod objects");
     return NULL;
-#elif PYTHON_VERSION < 0x340
-    PyThreadState *tstate = PyThreadState_GET();
-
-    SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "can't pickle method objects");
-    return NULL;
 #else
-    PyObject *result = MAKE_TUPLE_EMPTY(2);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, 2);
     PyTuple_SET_ITEM0(result, 0, LOOKUP_BUILTIN(const_str_plain_getattr));
-    PyObject *arg_tuple = MAKE_TUPLE2(method->m_object, method->m_function->m_name);
+    PyObject *arg_tuple = MAKE_TUPLE2(tstate, method->m_object, method->m_function->m_name);
     PyTuple_SET_ITEM(result, 1, arg_tuple);
 
     CHECK_OBJECT_DEEP(result);
@@ -89,12 +71,9 @@ static PyObject *Nuitka_Method_reduce_ex(struct Nuitka_MethodObject *method, PyO
 
     // Python API, spell-checker: ignore copyreg,newobj
 
-#if PYTHON_VERSION < 0x340
 #if PYTHON_VERSION < 0x300
     PyObject *copy_reg = PyImport_ImportModule("copy_reg");
-#else
-    PyObject *copy_reg = PyImport_ImportModule("copyreg");
-#endif
+
     CHECK_OBJECT(copy_reg);
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -104,19 +83,19 @@ static PyObject *Nuitka_Method_reduce_ex(struct Nuitka_MethodObject *method, PyO
         return NULL;
     }
 
-    PyObject *result = MAKE_TUPLE_EMPTY(5);
+    PyObject *result = MAKE_TUPLE_EMPTY(tstate, 5);
     PyTuple_SET_ITEM(result, 0, newobj_func);
-    PyObject *type_tuple = MAKE_TUPLE1((PyObject *)&Nuitka_Method_Type);
+    PyObject *type_tuple = MAKE_TUPLE1(tstate, (PyObject *)&Nuitka_Method_Type);
     PyTuple_SET_ITEM(result, 1, type_tuple);
-    PyTuple_SET_ITEM0(result, 2, Py_None);
-    PyTuple_SET_ITEM0(result, 3, Py_None);
-    PyTuple_SET_ITEM0(result, 4, Py_None);
+    PyTuple_SET_ITEM_IMMORTAL(result, 2, Py_None);
+    PyTuple_SET_ITEM_IMMORTAL(result, 3, Py_None);
+    PyTuple_SET_ITEM_IMMORTAL(result, 4, Py_None);
 
     CHECK_OBJECT_DEEP(result);
 
     return result;
 #else
-    return Nuitka_Method_reduce(method);
+    return Nuitka_Method_reduce(method, NULL);
 #endif
 }
 
@@ -140,7 +119,10 @@ static PyObject *Nuitka_Method_deepcopy(struct Nuitka_MethodObject *method, PyOb
         return NULL;
     }
 
-    return Nuitka_Method_New(method->m_function, object, method->m_class);
+    PyObject *result = Nuitka_Method_New(method->m_function, object, method->m_class);
+    // Nuitka_Method_New took a reference to the object.
+    Py_DECREF(object);
+    return result;
 }
 
 static PyMethodDef Nuitka_Method_methods[] = {
@@ -258,16 +240,17 @@ static PyObject *Nuitka_Method_tp_call(struct Nuitka_MethodObject *method, PyObj
     }
 }
 
-static PyObject *Nuitka_Method_tp_descr_get(struct Nuitka_MethodObject *method, PyObject *object, PyObject *klass) {
+static PyObject *Nuitka_Method_tp_descr_get(struct Nuitka_MethodObject *method, PyObject *object,
+                                            PyObject *class_object) {
     // Don't rebind already bound methods.
     if (method->m_object != NULL) {
         Py_INCREF(method);
         return (PyObject *)method;
     }
 
-    if (method->m_class != NULL && klass != NULL) {
+    if (method->m_class != NULL && class_object != NULL) {
         // Quick subclass test, bound methods remain the same if the class is a sub class
-        int result = PyObject_IsSubclass(klass, method->m_class);
+        int result = PyObject_IsSubclass(class_object, method->m_class);
 
         if (unlikely(result < 0)) {
             return NULL;
@@ -277,7 +260,7 @@ static PyObject *Nuitka_Method_tp_descr_get(struct Nuitka_MethodObject *method,
         }
     }
 
-    return Nuitka_Method_New(method->m_function, object, klass);
+    return Nuitka_Method_New(method->m_function, object, class_object);
 }
 
 static PyObject *Nuitka_Method_tp_getattro(struct Nuitka_MethodObject *method, PyObject *name) {
@@ -292,6 +275,8 @@ static PyObject *Nuitka_Method_tp_getattro(struct Nuitka_MethodObject *method, P
         }
     }
 
+    // Delegate all other attributes to the underlying function.
+    // TODO: Could be a bit more direct here, and know this is generic lookup.
     return PyObject_GetAttr((PyObject *)method->m_function, name);
 }
 
@@ -334,13 +319,13 @@ static PyObject *Nuitka_Method_tp_repr(struct Nuitka_MethodObject *method) {
 #endif
 
 #if PYTHON_VERSION < 0x350
-        PyObject *result = Nuitka_String_FromFormat(
-            "<bound compiled_method %s.%s of %s>", GET_CLASS_NAME(method->m_class),
-            Nuitka_String_AsString(method->m_function->m_name), Nuitka_String_AsString_Unchecked(object_repr));
+        PyObject *result =
+            Nuitka_String_FromFormat("<bound compiled_method %s.%s of %s>", GET_CLASS_NAME(method->m_class),
+                                     Nuitka_String_AsString_Unchecked(method->m_function->m_name),
+                                     Nuitka_String_AsString_Unchecked(object_repr));
 #else
-        PyObject *result = PyUnicode_FromFormat("<bound compiled_method %s of %s>",
-                                                Nuitka_String_AsString(method->m_function->m_qualname),
-                                                Nuitka_String_AsString_Unchecked(object_repr));
+        PyObject *result =
+            PyUnicode_FromFormat("<bound compiled_method %U of %U>", method->m_function->m_qualname, object_repr);
 #endif
 
         Py_DECREF(object_repr);
@@ -410,7 +395,7 @@ static PyObject *Nuitka_Method_tp_richcompare(struct Nuitka_MethodObject *a, str
         result = BOOL_FROM(!b_res);
     }
 
-    Py_INCREF(result);
+    Py_INCREF_IMMORTAL(result);
     return result;
 }
 
@@ -428,10 +413,9 @@ static void Nuitka_Method_tp_dealloc(struct Nuitka_MethodObject *method) {
     // Save the current exception, if any, we must to not corrupt it.
     PyThreadState *tstate = PyThreadState_GET();
 
-    PyObject *save_exception_type, *save_exception_value;
-    PyTracebackObject *save_exception_tb;
-    FETCH_ERROR_OCCURRED(tstate, &save_exception_type, &save_exception_value, &save_exception_tb);
-    RESTORE_ERROR_OCCURRED(tstate, save_exception_type, save_exception_value, save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state1;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state1);
 #endif
 
     Nuitka_GC_UnTrack(method);
@@ -449,42 +433,57 @@ static void Nuitka_Method_tp_dealloc(struct Nuitka_MethodObject *method) {
     releaseToFreeList(free_list_methods, method, MAX_METHOD_FREE_LIST_COUNT);
 
 #ifndef __NUITKA_NO_ASSERT__
-    assert(tstate->curexc_type == save_exception_type);
-    assert(tstate->curexc_value == save_exception_value);
-    assert((PyTracebackObject *)tstate->curexc_traceback == save_exception_tb);
+    struct Nuitka_ExceptionPreservationItem saved_exception_state2;
+    FETCH_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
+    RESTORE_ERROR_OCCURRED_STATE(tstate, &saved_exception_state2);
+
+    ASSERT_SAME_EXCEPTION_STATE(&saved_exception_state1, &saved_exception_state2);
 #endif
 }
 
 static PyObject *Nuitka_Method_tp_new(PyTypeObject *type, PyObject *args, PyObject *kw) {
     PyObject *func;
     PyObject *self;
-    PyObject *klass = NULL;
+    PyObject *class_object = NULL;
 
     if (!_PyArg_NoKeywords("compiled_method", kw)) {
         return NULL;
-    } else if (!PyArg_UnpackTuple(args, "compiled_method", 2, 3, &func, &self, &klass)) {
+    }
+
+    if (!PyArg_UnpackTuple(args, "compiled_method", 2, 3, &func, &self, &class_object)) {
         return NULL;
-    } else if (!PyCallable_Check(func)) {
+    }
+
+    CHECK_OBJECT(func);
+
+    if (!PyCallable_Check(func)) {
         PyThreadState *tstate = PyThreadState_GET();
 
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "first argument must be callable");
         return NULL;
-    } else {
-        if (self == Py_None) {
-            self = NULL;
-        }
+    }
 
-        if (self == NULL && klass == NULL) {
-            PyThreadState *tstate = PyThreadState_GET();
+    if (self == Py_None) {
+        self = NULL;
+    }
 
-            SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "unbound methods must have non-NULL im_class");
-            return NULL;
-        }
+    if (self == NULL && class_object == NULL) {
+        PyThreadState *tstate = PyThreadState_GET();
+
+        SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_TypeError, "unbound methods must have non-NULL im_class");
+        return NULL;
+    }
+
+    if (Nuitka_Method_Check(func)) {
+        return Nuitka_Method_New(((struct Nuitka_MethodObject *)func)->m_function, self, class_object);
     }
 
-    assert(Nuitka_Function_Check(func));
+    if (Nuitka_Function_Check(func) == false) {
+        SET_CURRENT_EXCEPTION_TYPE_COMPLAINT_NICE("Cannot create compiled_ method from type '%s'", func);
+        return NULL;
+    }
 
-    return Nuitka_Method_New((struct Nuitka_FunctionObject *)func, self, klass);
+    return Nuitka_Method_New((struct Nuitka_FunctionObject *)func, self, class_object);
 }
 
 PyTypeObject Nuitka_Method_Type = {
@@ -531,7 +530,7 @@ PyTypeObject Nuitka_Method_Type = {
     0,                                                // tp_iternext
     Nuitka_Method_methods,                            // tp_methods
     Nuitka_Method_members,                            // tp_members
-    Nuitka_Method_getsets,                            // tp_getset
+    Nuitka_Method_tp_getset,                          // tp_getset
     0,                                                // tp_base
     0,                                                // tp_dict
     (descrgetfunc)Nuitka_Method_tp_descr_get,         // tp_descr_get
@@ -549,7 +548,7 @@ PyTypeObject Nuitka_Method_Type = {
     0,                                                // tp_weaklist
     0,                                                // tp_del
     0                                                 // tp_version_tag
-#if PYTHON_VERSION >= 0x340
+#if PYTHON_VERSION >= 0x300
     ,
     0 /* tp_finalizer */
 #endif
@@ -557,14 +556,9 @@ PyTypeObject Nuitka_Method_Type = {
 
 void _initCompiledMethodType(void) {
     Nuitka_PyType_Ready(&Nuitka_Method_Type, &PyMethod_Type, false, true, false, false, false);
-
-#ifdef _NUITKA_PLUGIN_DILL_ENABLED
-    // TODO: Move this to a __nuitka__ module maybe
-    PyObject_SetAttrString((PyObject *)builtin_module, "compiled_method", (PyObject *)&Nuitka_Method_Type);
-#endif
 }
 
-PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *object, PyObject *klass) {
+PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *object, PyObject *class_object) {
     struct Nuitka_MethodObject *result;
 
     CHECK_OBJECT((PyObject *)function);
@@ -584,8 +578,8 @@ PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *ob
 
     result->m_object = object;
     Py_XINCREF(object);
-    result->m_class = klass;
-    Py_XINCREF(klass);
+    result->m_class = class_object;
+    Py_XINCREF(class_object);
 
     result->m_weakrefs = NULL;
 
@@ -596,3 +590,18 @@ PyObject *Nuitka_Method_New(struct Nuitka_FunctionObject *function, PyObject *ob
     Nuitka_GC_Track(result);
     return (PyObject *)result;
 }
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.