Nuitka-winsvc 2.4.11__cp311-cp311-win_amd64.whl → 2.5.6__cp311-cp311-win_amd64.whl

nuitka/build/inline_copy/stubgen/stubgen.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+import ast
+import sys
+import typing
+
+if sys.version_info < (3, 9):
+    from astunparse import unparse
+
+    ast.unparse = unparse
+
+def generate_stub_from_source(source_code, output_file_path, text_only=False):
+    tree = ast.parse(source_code)
+
+    class StubGenerator(ast.NodeVisitor):
+        def __init__(self):
+            self.stubs = []
+            self.imports_helper_dict = {}
+            self.imports_output = set()
+            self.typing_imports = typing.__all__
+
+        def visit_Import(self, node: ast.Import):
+            for alias in node.names:
+                self.imports_output.add(f"import {alias.name}")
+
+        def visit_ImportFrom(self, node):
+            module = node.module if node.module is not None else "."
+            for alias in node.names:
+                name = alias.name
+
+                if module not in self.imports_helper_dict:
+                    self.imports_helper_dict[module] = set()
+                self.imports_helper_dict[module].add(name)
+
+        def visit_FunctionDef(self, node):
+            if any(isinstance(n, ast.ClassDef) for n in ast.walk(tree)):
+                if self.is_method(node):
+                    self.visit_MethodDef(node)
+                else:
+                    self.visit_RegularFunctionDef(node)
+            else:
+                self.visit_RegularFunctionDef(node)
+
+        def visit_Assign(self, node):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    target_name = target.id
+                    target_type = ast.unparse(node.value).strip()
+                    if target_type in self.typing_imports:
+                        self.imports_output.add(target_type)
+                    if target_type in self.typing_imports:
+                        stub = f"{target_name}: {target_type}\n"
+                        self.stubs.append(stub)
+                    else:
+                        if isinstance(node.value, ast.Call):
+                            if isinstance(node.value.func, ast.Name):
+                                if node.value.func.id == "frozenset":
+                                    stub = f"{target_name} = frozenset({', '.join([ast.unparse(arg).strip() for arg in node.value.args])})\n"
+                                    self.stubs.append(stub)
+                                elif node.value.func.id == "namedtuple":
+                                    tuple_name = ast.unparse(node.value.args[0]).strip()
+
+                                    stub = f"{target_name} =  namedtuple({tuple_name}, {', '.join([ast.unparse(arg).strip() for arg in node.value.args[1:]])})\n"
+                                    self.stubs.append(stub)
+                        elif isinstance(node.value, ast.Subscript):
+                            if isinstance(node.value.value, ast.Name):
+                                target_name = node.value.value.id
+                            target_type = ast.unparse(node.value).strip()
+                            if "typing_extensions" not in self.imports_helper_dict:
+                                self.imports_helper_dict["typing_extensions"] = set()
+                            self.imports_helper_dict["typing_extensions"].add(
+                                "TypeAlias"
+                            )
+                            stub = f"{target_name}: TypeAlias = {target_type}\n"
+                            self.stubs.append(stub)
+
+                elif isinstance(target, ast.Subscript):
+                    if isinstance(target.value, ast.Name):
+                        target_name = target.value.id
+                    else:
+                        continue
+                    target_type = ast.unparse(node.value).strip()
+                    stub = f"{target_name}: {target_type}\n"
+                    self.stubs.append(stub)
+
+        def is_method(self, node):
+            for parent_node in ast.walk(tree):
+                if isinstance(parent_node, ast.ClassDef):
+                    for child_node in parent_node.body:
+                        if (
+                            isinstance(child_node, ast.FunctionDef)
+                            and child_node.name == node.name
+                        ):
+                            return True
+            return False
+
+        def visit_MethodDef(self, node):
+            args_list = []
+            for arg in node.args.args:
+                arg_type = self.get_arg_type(arg)
+                args_list.append(f"{arg.arg}: {arg_type}")
+            if node.returns:
+                return_type = self.get_return_type(node.returns)
+            else:
+                return_type = "typing.Any"
+
+            if return_type in self.typing_imports:
+                self.imports_output.add(return_type)
+            # handle the case where the node.name is __init__, __init__ is a special case which always returns None
+            if node.name == "__init__":
+                return_type = "None"
+            if node.decorator_list:
+                for decorator in node.decorator_list:
+                    if isinstance(decorator, ast.Name):
+                        if decorator.id == "classmethod":
+                            args_list = args_list[1:]
+                            stub = f"    @classmethod\n    def {node.name}(cls, {', '.join(args_list)}) -> {return_type}: ...\n"
+
+                            self.stubs.append(stub)
+                            return
+
+                        elif decorator.id == "staticmethod":
+                            stub = f"    @staticmethod\n    def {node.name}({', '.join(args_list)}) -> {return_type}: ...\n"
+                            self.stubs.append(stub)
+                            return
+                        else:
+                            stub = f"    def {node.name}({', '.join(args_list)}) -> {return_type}: ...\n"
+                            self.stubs.append(stub)
+                            return
+            stub = (
+                f"    def {node.name}({', '.join(args_list)}) -> {return_type}: ...\n"
+            )
+            self.stubs.append(stub)
+
+        def visit_RegularFunctionDef(self, node):
+            args_list = []
+            for arg in node.args.args:
+                arg_type = self.get_arg_type(arg)
+                args_list.append(f"{arg.arg}: {arg_type}")
+            if node.returns:
+                return_type = self.get_return_type(node.returns)
+            else:
+                return_type = "typing.Any"
+            stub = (
+                f"def {node.name}({', '.join(args_list)}) -> {return_type}:\n    ...\n"
+            )
+            self.stubs.append(stub)
+
+        def visit_ClassDef(self, node):
+            class_name = node.name
+            stub = ""
+            case = self.special_cases(node)
+            if case == "TypedDict":
+                stub = f"class {class_name}(TypedDict):\n"
+                if "typing" not in self.imports_helper_dict:
+                    self.imports_helper_dict["typing"] = set()
+                self.imports_helper_dict["typing"].add("TypedDict")
+                for key in node.body:
+                    if isinstance(key, ast.Assign):
+                        for target in key.targets:
+                            if isinstance(target, ast.Name):
+                                target_name = target.id
+                                target_type = ast.unparse(key.value).strip()
+                                stub += f"    {target_name}: {target_type}\n"
+                            elif isinstance(target, ast.Subscript):
+                                if isinstance(target.value, ast.Name):
+                                    target_name = target.value.id
+                                target_type = ast.unparse(key.value).strip()
+                                stub += f"    {target_name}: {target_type}\n"
+                    elif isinstance(key, ast.AnnAssign):
+                        target = key.target
+                        if isinstance(target, ast.Name):
+                            target_name = target.id
+                            target_type = ast.unparse(key.annotation).strip()
+                            stub += f"    {target_name}: {target_type}\n"
+                        elif isinstance(target, ast.Subscript):
+                            if isinstance(target.value, ast.Name):
+                                target_name = target.value.id
+                            target_type = ast.unparse(key.annotation).strip()
+                            stub += f"    {target_name}: {target_type}\n"
+                stub += "\n"
+            elif case == "Exception":
+                if not any(isinstance(n, ast.FunctionDef) for n in node.body):
+                    stub = f"\nclass {class_name}(Exception): ..."
+                else:
+                    stub = f"\nclass {class_name}(Exception):"
+            elif case == "NamedTuple":
+                stub = f"class {class_name}(NamedTuple):\n"
+                self.imports_output.add("from typing import NamedTuple")
+            else:
+                is_dataclass = any(isinstance(n, ast.AnnAssign) for n in node.body)
+                if is_dataclass:
+                    stub = "@dataclass\n"
+                    self.imports_output.add("from dataclasses import dataclass")
+                stub += f"class {class_name}:"
+
+            self.stubs.append(stub)
+            methods = [n for n in node.body if isinstance(n, ast.FunctionDef)]
+            if methods:
+                self.stubs.append("\n")
+                for method in methods:
+                    self.visit_FunctionDef(method)
+
+        def special_cases(self, node):
+            for obj in node.bases:
+                ob_instance = isinstance(obj, ast.Name)
+                if ob_instance:
+                    if obj.id == "TypedDict":  # type: ignore
+                        return "TypedDict"
+                    elif obj.id == "Exception":  # type: ignore
+                        return "Exception"
+                    elif obj.id == "NamedTuple":  # type: ignore
+                        return "NamedTuple"
+                    else:
+                        return False
+            return False
+
+        def get_arg_type(self, arg_node):
+            selfs = ["self", "cls"]
+            if arg_node.arg in selfs:
+                if "typing_extensions" not in self.imports_helper_dict:
+                    self.imports_helper_dict["typing_extensions"] = set()
+                self.imports_helper_dict["typing_extensions"].add("Self")
+                return "Self"
+            elif arg_node.annotation:
+                unparsed = ast.unparse(arg_node.annotation).strip()
+                return unparsed
+            else:
+                return "typing.Any"
+
+        def get_return_type(self, return_node):
+            if return_node:
+                unparsed = ast.unparse(return_node).strip()
+                return unparsed
+            else:
+                return "typing.Any"
+
+        def visit_AnnAssign(self, node):
+            target = node.target
+            if isinstance(node.annotation, ast.Name):
+                target_type = node.annotation.id
+            else:
+                target_type = ast.unparse(node.annotation).strip()
+
+            if isinstance(node.annotation, ast.Subscript):
+                if isinstance(target, ast.Name):
+                    stub = f"{target.id}: {target_type}\n"
+                elif isinstance(target, ast.Name):
+                    stub = f"{target.id}: {target_type}\n"
+            elif isinstance(node.annotation, ast.Name):
+                if isinstance(target, ast.Name):
+                    stub = f"{target.id}: {target_type}\n"
+                elif isinstance(target, ast.Subscript):
+                    if isinstance(target.value, ast.Name):
+                        target_name = target.value.id
+                    stub = f"{target_name}: {target_type}\n"
+            else:
+                raise NotImplementedError(
+                    f"Type {type(node.annotation)} not implemented, report this issue"
+                )
+
+            self.stubs.append(stub)
+
+        def generate_imports(self):
+            imports_helper = set()
+            sorted_items = sorted(self.imports_helper_dict.items())
+            for module, names in sorted_items:
+                imports_helper.add(f"from {module} import {', '.join(sorted(names))}")
+
+            imports_helper.update(self.imports_output)
+
+            self.imports_output.add("from __future__ import annotations")
+
+            imports = "".join([f"{imp}\n" for imp in imports_helper])
+
+            return imports + "\n"
+
+    stub_generator = StubGenerator()
+    stub_generator.visit(tree)
+    out_str = ""
+    sempt = stub_generator.generate_imports()
+    if sempt:
+        out_str += sempt
+    for stub in stub_generator.stubs:
+        out_str += stub
+
+    if text_only:
+        return out_str
+    else:
+
+        with open(output_file_path, "w") as output_file:
+            output_file.write(out_str)
+
+        return None
+
+def generate_stub(source_file_path, output_file_path, text_only=False):
+    with open(source_file_path, "r", encoding="utf-8") as source_file:
+        source_code = source_file.read()
+
+    return generate_stub_from_source(source_code=source_code, output_file_path=output_file_path, text_only=text_only)
+
+
+def generate_text_stub(source_file_path):
+    stubs = generate_stub(source_file_path, "", text_only=True)
+    if stubs:
+        return stubs
+    else:
+        raise ValueError("Stub generation failed")

nuitka/build/static_src/CompiledAsyncgenType.c

@@ -63,15 +63,16 @@ static void Nuitka_MarkAsyncgenAsNotRunning(struct Nuitka_AsyncgenObject *asyncg
 
 static long Nuitka_Asyncgen_tp_hash(struct Nuitka_AsyncgenObject *asyncgen) { return asyncgen->m_counter; }
 
-static PyObject *Nuitka_Asyncgen_get_name(struct Nuitka_AsyncgenObject *asyncgen) {
-    CHECK_OBJECT(asyncgen);
+static PyObject *Nuitka_Asyncgen_get_name(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
 
+    struct Nuitka_AsyncgenObject *asyncgen = (struct Nuitka_AsyncgenObject *)self;
     Py_INCREF(asyncgen->m_name);
     return asyncgen->m_name;
 }
 
-static int Nuitka_Asyncgen_set_name(struct Nuitka_AsyncgenObject *asyncgen, PyObject *value) {
-    CHECK_OBJECT(asyncgen);
+static int Nuitka_Asyncgen_set_name(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
     CHECK_OBJECT_X(value);
 
     // Cannot be deleted, not be non-unicode value.
@@ -82,6 +83,7 @@ static int Nuitka_Asyncgen_set_name(struct Nuitka_AsyncgenObject *asyncgen, PyOb
         return -1;
     }
 
+    struct Nuitka_AsyncgenObject *asyncgen = (struct Nuitka_AsyncgenObject *)self;
     PyObject *tmp = asyncgen->m_name;
     Py_INCREF(value);
     asyncgen->m_name = value;
@@ -90,15 +92,16 @@ static int Nuitka_Asyncgen_set_name(struct Nuitka_AsyncgenObject *asyncgen, PyOb
     return 0;
 }
 
-static PyObject *Nuitka_Asyncgen_get_qualname(struct Nuitka_AsyncgenObject *asyncgen) {
-    CHECK_OBJECT(asyncgen);
+static PyObject *Nuitka_Asyncgen_get_qualname(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
 
+    struct Nuitka_AsyncgenObject *asyncgen = (struct Nuitka_AsyncgenObject *)self;
     Py_INCREF(asyncgen->m_qualname);
     return asyncgen->m_qualname;
 }
 
-static int Nuitka_Asyncgen_set_qualname(struct Nuitka_AsyncgenObject *asyncgen, PyObject *value) {
-    CHECK_OBJECT(asyncgen);
+static int Nuitka_Asyncgen_set_qualname(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
     CHECK_OBJECT_X(value);
 
     // Cannot be deleted, not be non-unicode value.
@@ -109,6 +112,7 @@ static int Nuitka_Asyncgen_set_qualname(struct Nuitka_AsyncgenObject *asyncgen,
         return -1;
     }
 
+    struct Nuitka_AsyncgenObject *asyncgen = (struct Nuitka_AsyncgenObject *)self;
     PyObject *tmp = asyncgen->m_qualname;
     Py_INCREF(value);
     asyncgen->m_qualname = value;
@@ -117,9 +121,10 @@ static int Nuitka_Asyncgen_set_qualname(struct Nuitka_AsyncgenObject *asyncgen,
     return 0;
 }
 
-static PyObject *Nuitka_Asyncgen_get_ag_await(struct Nuitka_AsyncgenObject *asyncgen) {
-    CHECK_OBJECT(asyncgen);
+static PyObject *Nuitka_Asyncgen_get_ag_await(PyObject *self, void *data) {
+    CHECK_OBJECT(self);
 
+    struct Nuitka_AsyncgenObject *asyncgen = (struct Nuitka_AsyncgenObject *)self;
     if (asyncgen->m_yield_from) {
         Py_INCREF(asyncgen->m_yield_from);
         return asyncgen->m_yield_from;
@@ -129,7 +134,8 @@ static PyObject *Nuitka_Asyncgen_get_ag_await(struct Nuitka_AsyncgenObject *asyn
     }
 }
 
-static PyObject *Nuitka_Asyncgen_get_code(struct Nuitka_AsyncgenObject *asyncgen) {
+static PyObject *Nuitka_Asyncgen_get_code(PyObject *self, void *data) {
+    struct Nuitka_AsyncgenObject *asyncgen = (struct Nuitka_AsyncgenObject *)self;
     CHECK_OBJECT(asyncgen);
     CHECK_OBJECT(asyncgen->m_code_object);
 
@@ -137,8 +143,8 @@ static PyObject *Nuitka_Asyncgen_get_code(struct Nuitka_AsyncgenObject *asyncgen
     return (PyObject *)asyncgen->m_code_object;
 }
 
-static int Nuitka_Asyncgen_set_code(struct Nuitka_AsyncgenObject *asyncgen, PyObject *value) {
-    CHECK_OBJECT(asyncgen);
+static int Nuitka_Asyncgen_set_code(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
 
     PyThreadState *tstate = PyThreadState_GET();
 
@@ -146,7 +152,8 @@ static int Nuitka_Asyncgen_set_code(struct Nuitka_AsyncgenObject *asyncgen, PyOb
     return -1;
 }
 
-static PyObject *Nuitka_Asyncgen_get_frame(struct Nuitka_AsyncgenObject *asyncgen) {
+static PyObject *Nuitka_Asyncgen_get_frame(PyObject *self, void *data) {
+    struct Nuitka_AsyncgenObject *asyncgen = (struct Nuitka_AsyncgenObject *)self;
     CHECK_OBJECT(asyncgen);
     CHECK_OBJECT_X(asyncgen->m_frame);
 
@@ -159,8 +166,8 @@ static PyObject *Nuitka_Asyncgen_get_frame(struct Nuitka_AsyncgenObject *asyncge
     }
 }
 
-static int Nuitka_Asyncgen_set_frame(struct Nuitka_AsyncgenObject *asyncgen, PyObject *value) {
-    CHECK_OBJECT(asyncgen);
+static int Nuitka_Asyncgen_set_frame(PyObject *self, PyObject *value, void *data) {
+    CHECK_OBJECT(self);
     CHECK_OBJECT_X(value);
 
     PyThreadState *tstate = PyThreadState_GET();
@@ -463,7 +470,7 @@ static PyObject *_Nuitka_Asyncgen_send(PyThreadState *tstate, struct Nuitka_Asyn
 
     switch (res) {
     case PYGEN_RETURN:
-        SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopAsyncIteration);
+        SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
         return NULL;
     case PYGEN_NEXT:
         return result;
@@ -626,7 +633,7 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
         if (unlikely(ret == NULL)) {
             PyObject *val;
 
-            if (_PyGen_FetchStopIterationValue(&val) == 0) {
+            if (Nuitka_PyGen_FetchStopIterationValue(tstate, &val)) {
                 CHECK_OBJECT(val);
 
                 asyncgen->m_yield_from = NULL;
@@ -770,7 +777,7 @@ static PyObject *Nuitka_Asyncgen_throw(PyThreadState *tstate, struct Nuitka_Asyn
 
     if (result == NULL) {
         if (HAS_ERROR_OCCURRED(tstate) == false) {
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopAsyncIteration);
+            SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
         }
     }
 
@@ -1049,11 +1056,11 @@ static PyAsyncMethods Nuitka_Asyncgen_as_async = {
 // TODO: Set "__doc__" automatically for method clones of compiled types from
 // the documentation of built-in original type.
 static PyGetSetDef Nuitka_Asyncgen_tp_getset[] = {
-    {(char *)"__name__", (getter)Nuitka_Asyncgen_get_name, (setter)Nuitka_Asyncgen_set_name, NULL},
-    {(char *)"__qualname__", (getter)Nuitka_Asyncgen_get_qualname, (setter)Nuitka_Asyncgen_set_qualname, NULL},
-    {(char *)"ag_await", (getter)Nuitka_Asyncgen_get_ag_await, (setter)NULL, NULL},
-    {(char *)"ag_code", (getter)Nuitka_Asyncgen_get_code, (setter)Nuitka_Asyncgen_set_code, NULL},
-    {(char *)"ag_frame", (getter)Nuitka_Asyncgen_get_frame, (setter)Nuitka_Asyncgen_set_frame, NULL},
+    {(char *)"__name__", Nuitka_Asyncgen_get_name, Nuitka_Asyncgen_set_name, NULL},
+    {(char *)"__qualname__", Nuitka_Asyncgen_get_qualname, Nuitka_Asyncgen_set_qualname, NULL},
+    {(char *)"ag_await", Nuitka_Asyncgen_get_ag_await, NULL, NULL},
+    {(char *)"ag_code", Nuitka_Asyncgen_get_code, Nuitka_Asyncgen_set_code, NULL},
+    {(char *)"ag_frame", Nuitka_Asyncgen_get_frame, Nuitka_Asyncgen_set_frame, NULL},
 
     {NULL}};
 
@@ -1367,7 +1374,7 @@ static PyObject *_Nuitka_Asyncgen_unwrap_value(PyThreadState *tstate, struct Nui
         PyObject *error = GET_ERROR_OCCURRED(tstate);
 
         if (error == NULL) {
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopAsyncIteration);
+            SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
             asyncgen->m_closed = true;
         } else if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_StopAsyncIteration) ||
                    EXCEPTION_MATCH_BOOL_SINGLE(tstate, error, PyExc_GeneratorExit)) {
@@ -1449,7 +1456,7 @@ static PyObject *Nuitka_AsyncgenAsend_send(struct Nuitka_AsyncgenAsendObject *as
 
     if (asyncgen_asend->m_state == AWAITABLE_STATE_CLOSED) {
 #if PYTHON_VERSION < 0x390
-        SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+        SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
 #else
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "cannot reuse already awaited __anext__()/asend()");
 #endif
@@ -1557,7 +1564,7 @@ static PyObject *Nuitka_AsyncgenAsend_throw(struct Nuitka_AsyncgenAsendObject *a
     PyThreadState *tstate = PyThreadState_GET();
 
     if (asyncgen_asend->m_state == AWAITABLE_STATE_CLOSED) {
-        SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+        SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
         return NULL;
     }
 
@@ -1601,7 +1608,7 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
 #endif
 
     if (asyncgen_asend->m_state == AWAITABLE_STATE_CLOSED) {
-        SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+        SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
         return NULL;
     }
 
@@ -1610,8 +1617,8 @@ static PyObject *_Nuitka_AsyncgenAsend_throw2(PyThreadState *tstate, struct Nuit
     // TODO: This might not be all that necessary as this is not directly outside facing,
     // but there were tests failing when this was not the specific value.
     if (result == NULL) {
-        if (GET_ERROR_OCCURRED(tstate) == NULL) {
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopAsyncIteration);
+        if (HAS_ERROR_OCCURRED(tstate) == false) {
+            SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
         }
     }
 
@@ -1822,7 +1829,7 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
     // Closing twice is not allowed with 3.9 or higher.
     if (asyncgen_athrow->m_state == AWAITABLE_STATE_CLOSED) {
 #if PYTHON_VERSION < 0x390
-        SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+        SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
 #else
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "cannot reuse already awaited aclose()/athrow()");
 #endif
@@ -1832,7 +1839,7 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
 
     // If finished, just report StopIteration.
     if (asyncgen->m_status == status_Finished) {
-        SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+        SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
         return NULL;
     }
 
@@ -1856,9 +1863,9 @@ static PyObject *Nuitka_AsyncgenAthrow_send(struct Nuitka_AsyncgenAthrowObject *
         if (asyncgen->m_closed) {
 #if PYTHON_VERSION >= 0x380
             asyncgen_athrow->m_state = AWAITABLE_STATE_CLOSED;
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopAsyncIteration);
+            SET_CURRENT_EXCEPTION_STOP_ASYNC_ITERATION(tstate);
 #else
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+            SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
 #endif
             return NULL;
         }
@@ -1968,7 +1975,7 @@ check_error:
 
         if (asyncgen_athrow->m_args == NULL) {
             CLEAR_ERROR_OCCURRED(tstate);
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+            SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
         }
     } else if (PyErr_ExceptionMatches(PyExc_GeneratorExit)) {
         asyncgen_athrow->m_state = AWAITABLE_STATE_CLOSED;
@@ -1976,8 +1983,7 @@ check_error:
 #if PYTHON_VERSION >= 0x380
         if (asyncgen_athrow->m_args == NULL) {
 #endif
-            CLEAR_ERROR_OCCURRED(tstate);
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+            SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
 #if PYTHON_VERSION >= 0x380
         }
 #endif
@@ -2008,7 +2014,7 @@ static PyObject *Nuitka_AsyncgenAthrow_throw(struct Nuitka_AsyncgenAthrowObject
 
     if (asyncgen_athrow->m_state == AWAITABLE_STATE_CLOSED) {
 #if PYTHON_VERSION < 0x390
-        SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+        SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
 #else
         SET_CURRENT_EXCEPTION_TYPE0_STR(tstate, PyExc_RuntimeError, "cannot reuse already awaited aclose()/athrow()");
 #endif
@@ -2036,7 +2042,7 @@ static PyObject *Nuitka_AsyncgenAthrow_throw(struct Nuitka_AsyncgenAthrowObject
 
 #if PYTHON_VERSION >= 0x390
         if (PyErr_ExceptionMatches(PyExc_StopAsyncIteration) || PyErr_ExceptionMatches(PyExc_GeneratorExit)) {
-            SET_CURRENT_EXCEPTION_TYPE0(tstate, PyExc_StopIteration);
+            SET_CURRENT_EXCEPTION_STOP_ITERATION_EMPTY(tstate);
         }
 #endif
 

nuitka/build/static_src/CompiledCellType.c

@@ -150,7 +150,8 @@ static int Nuitka_Cell_tp_clear(struct Nuitka_CellObject *cell) {
     return 0;
 }
 
-static PyObject *Nuitka_Cell_get_contents(struct Nuitka_CellObject *cell, void *closure) {
+static PyObject *Nuitka_Cell_get_contents(PyObject *self, void *data) {
+    struct Nuitka_CellObject *cell = (struct Nuitka_CellObject *)self;
     if (unlikely(cell->ob_ref == NULL)) {
         PyThreadState *tstate = PyThreadState_GET();
 
@@ -163,7 +164,8 @@ static PyObject *Nuitka_Cell_get_contents(struct Nuitka_CellObject *cell, void *
 }
 
 #if PYTHON_VERSION >= 0x370
-static int Nuitka_Cell_set_contents(struct Nuitka_CellObject *cell, PyObject *value) {
+static int Nuitka_Cell_set_contents(PyObject *self, PyObject *value, void *data) {
+    struct Nuitka_CellObject *cell = (struct Nuitka_CellObject *)self;
     PyObject *old = cell->ob_ref;
 
     if (old != NULL && value == NULL) {
@@ -184,9 +186,9 @@ static int Nuitka_Cell_set_contents(struct Nuitka_CellObject *cell, PyObject *va
 
 static PyGetSetDef Nuitka_Cell_tp_getset[] = {
 #if PYTHON_VERSION < 0x370
-    {(char *)"cell_contents", (getter)Nuitka_Cell_get_contents, NULL, NULL},
+    {(char *)"cell_contents", Nuitka_Cell_get_contents, NULL, NULL},
 #else
-    {(char *)"cell_contents", (getter)Nuitka_Cell_get_contents, (setter)Nuitka_Cell_set_contents, NULL},
+    {(char *)"cell_contents", Nuitka_Cell_get_contents, Nuitka_Cell_set_contents, NULL},
 #endif
     {NULL}};