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

nuitka/nodes/ExceptionNodes.py

@@ -5,15 +5,16 @@
 
 """
 
-from .ChildrenHavingMixins import (
-    ChildrenHavingExceptionTypeExceptionValueMixin,
-)
+from nuitka.PythonVersions import python_version
+
+from .ChildrenHavingMixins import ChildHavingExceptionTypeMixin
 from .ExpressionBases import ExpressionBase, ExpressionNoSideEffectsMixin
 from .ExpressionBasesGenerated import (
+    ExpressionBuiltinMakeExceptionAttributeErrorBase,
     ExpressionBuiltinMakeExceptionBase,
     ExpressionBuiltinMakeExceptionImportErrorBase,
 )
-from .NodeBases import StatementBase
+from .NodeBases import SideEffectsFromChildrenMixin, StatementBase
 from .StatementBasesGenerated import StatementRaiseExceptionBase
 
 
@@ -67,14 +68,6 @@ class StatementRaiseException(
         return "exception raise statement"
 
 
-class StatementRaiseExceptionImplicit(StatementRaiseException):
-    kind = "STATEMENT_RAISE_EXCEPTION_IMPLICIT"
-
-    @staticmethod
-    def getStatementNiceName():
-        return "implicit exception raise statement"
-
-
 class StatementReraiseException(StatementRaiseExceptionMixin, StatementBase):
     kind = "STATEMENT_RERAISE_EXCEPTION"
 
@@ -97,9 +90,7 @@ class StatementReraiseException(StatementRaiseExceptionMixin, StatementBase):
         return "exception re-raise statement"
 
 
-class ExpressionRaiseException(
-    ChildrenHavingExceptionTypeExceptionValueMixin, ExpressionBase
-):
+class ExpressionRaiseException(ChildHavingExceptionTypeMixin, ExpressionBase):
     """This node type is only produced via optimization.
 
     CPython only knows exception raising as a statement, but often the raising
@@ -109,13 +100,12 @@ class ExpressionRaiseException(
 
     kind = "EXPRESSION_RAISE_EXCEPTION"
 
-    named_children = ("exception_type", "exception_value")
+    named_children = ("exception_type",)
 
-    def __init__(self, exception_type, exception_value, source_ref):
-        ChildrenHavingExceptionTypeExceptionValueMixin.__init__(
+    def __init__(self, exception_type, source_ref):
+        ChildHavingExceptionTypeMixin.__init__(
             self,
             exception_type=exception_type,
-            exception_value=exception_value,
         )
 
         ExpressionBase.__init__(self, source_ref)
@@ -142,9 +132,9 @@ Propagated implicit raise expression to raise statement.""",
         )
 
     def asStatement(self):
-        return StatementRaiseExceptionImplicit(
+        return StatementRaiseException(
             exception_type=self.subnode_exception_type,
-            exception_value=self.subnode_exception_value,
+            exception_value=None,
             exception_trace=None,
             exception_cause=None,
             source_ref=self.source_ref,
@@ -156,18 +146,19 @@ class ExpressionBuiltinMakeException(ExpressionBuiltinMakeExceptionBase):
 
     named_children = ("args|tuple",)
 
-    __slots__ = ("exception_name",)
+    __slots__ = ("exception_name", "for_raise")
 
     # There is nothing to compute for it as a value.
     auto_compute_handling = "final,no_raise"
 
-    def __init__(self, exception_name, args, source_ref):
+    def __init__(self, exception_name, args, for_raise, source_ref):
         ExpressionBuiltinMakeExceptionBase.__init__(self, args, source_ref=source_ref)
 
         self.exception_name = exception_name
+        self.for_raise = for_raise
 
     def getDetails(self):
-        return {"exception_name": self.exception_name}
+        return {"exception_name": self.exception_name, "for_raise": self.for_raise}
 
     def getExceptionName(self):
         return self.exception_name
@@ -188,7 +179,7 @@ class ExpressionBuiltinMakeException(ExpressionBuiltinMakeExceptionBase):
 
 
 class ExpressionBuiltinMakeExceptionImportError(
-    ExpressionBuiltinMakeExceptionImportErrorBase
+    SideEffectsFromChildrenMixin, ExpressionBuiltinMakeExceptionImportErrorBase
 ):
     """Python3 ImportError dedicated node with extra arguments."""
 
@@ -196,11 +187,15 @@ class ExpressionBuiltinMakeExceptionImportError(
 
     named_children = ("args|tuple", "name|optional", "path|optional")
 
-    __slots__ = ("exception_name",)
+    node_attributes = ("for_raise",)
+
+    __slots__ = ()
 
     # There is nothing to compute for it as a value.
     auto_compute_handling = "final,no_raise"
 
+    python_version_spec = ">= 0x300"
+
     @staticmethod
     def getExceptionName():
         return "ImportError"
@@ -225,11 +220,50 @@ class ExpressionBuiltinMakeExceptionModuleNotFoundError(
 ):
     kind = "EXPRESSION_BUILTIN_MAKE_EXCEPTION_MODULE_NOT_FOUND_ERROR"
 
+    python_version_spec = ">= 0x360"
+
     @staticmethod
     def getExceptionName():
         return "ModuleNotFoundError"
 
 
+class ExpressionBuiltinMakeExceptionAttributeError(
+    SideEffectsFromChildrenMixin, ExpressionBuiltinMakeExceptionAttributeErrorBase
+):
+    """Python3 ImportError dedicated node with extra arguments."""
+
+    kind = "EXPRESSION_BUILTIN_MAKE_EXCEPTION_ATTRIBUTE_ERROR"
+
+    named_children = ("args|tuple", "name|optional", "obj|optional")
+
+    node_attributes = ("for_raise",)
+
+    __slots__ = ()
+
+    # There is nothing to compute for it as a value.
+    auto_compute_handling = "final,no_raise"
+
+    python_version_spec = ">= 0x3a0"
+
+    @staticmethod
+    def getExceptionName():
+        return "AttributeError"
+
+    def computeExpression(self, trace_collection):
+        return self, None, None
+
+    def mayRaiseException(self, exception_type):
+        for arg in self.subnode_args:
+            if arg.mayRaiseException(exception_type):
+                return True
+
+        return False
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+
 class ExpressionCaughtMixin(ExpressionNoSideEffectsMixin):
     """Common things for all caught exception references."""
 
@@ -271,6 +305,48 @@ class ExpressionCaughtExceptionTracebackRef(ExpressionCaughtMixin, ExpressionBas
         return self, None, None
 
 
+def makeBuiltinMakeExceptionNode(
+    exception_name, args, for_raise, name=None, path=None, obj=None, source_ref=None
+):
+    assert type(exception_name) is str, exception_name
+
+    if exception_name == "ImportError" and python_version >= 0x300:
+        return ExpressionBuiltinMakeExceptionImportError(
+            args=args,
+            name=name,
+            path=path,
+            for_raise=for_raise,
+            source_ref=source_ref,
+        )
+    elif exception_name == "ModuleNotFoundError" and python_version >= 0x360:
+        return ExpressionBuiltinMakeExceptionModuleNotFoundError(
+            args=args,
+            name=name,
+            path=path,
+            for_raise=for_raise,
+            source_ref=source_ref,
+        )
+    elif exception_name == "AttributeError" and python_version >= 0x3A0:
+        return ExpressionBuiltinMakeExceptionAttributeError(
+            args=args,
+            name=name,
+            obj=obj,
+            for_raise=for_raise,
+            source_ref=source_ref,
+        )
+    else:
+        # We expect to only get the star arguments for these.
+        assert name is None
+        assert path is None
+
+        return ExpressionBuiltinMakeException(
+            exception_name=exception_name,
+            args=args,
+            for_raise=for_raise,
+            source_ref=source_ref,
+        )
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #

nuitka/nodes/ExpressionBasesGenerated.py

@@ -80,6 +80,80 @@ ExpressionImportlibMetadataBackportEntryPointValueRefBase = (
 ExpressionImportlibMetadataEntryPointValueRefBase = NoChildHavingFinalNoRaiseMixin
 
 
+class NoChildHavingFinalNoRaiseNameMixin(ExpressionBase):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionTypeVariable
+
+    def __init__(self, name, source_ref):
+        self.name = name
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def getDetails(self):
+        return {
+            "name": self.name,
+        }
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        return ()
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return ()
+
+    def replaceChild(self, old_node, new_node):
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {}
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        return self, None, None
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+    @staticmethod
+    def mayRaiseException(exception_type):
+        return False
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+
+# Assign the names that are easier to import with a stable name.
+ExpressionTypeVariableBase = NoChildHavingFinalNoRaiseNameMixin
+
+
 class ChildHavingArgsTupleFinalNoRaiseMixin(ExpressionBase):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
@@ -200,7 +274,210 @@ class ChildHavingArgsTupleFinalNoRaiseMixin(ExpressionBase):
 ExpressionBuiltinMakeExceptionBase = ChildHavingArgsTupleFinalNoRaiseMixin
 
 
-class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(ExpressionBase):
+class ChildrenHavingArgsTupleNameOptionalObjOptionalFinalNoRaiseForRaiseMixin(
+    ExpressionBase
+):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionBuiltinMakeExceptionAttributeError
+
+    def __init__(self, args, name, obj, for_raise, source_ref):
+        assert type(args) is tuple
+
+        for val in args:
+            val.parent = self
+
+        self.subnode_args = args
+
+        if name is not None:
+            name.parent = self
+
+        self.subnode_name = name
+
+        if obj is not None:
+            obj.parent = self
+
+        self.subnode_obj = obj
+
+        self.for_raise = for_raise
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def getDetails(self):
+        return {
+            "for_raise": self.for_raise,
+        }
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        result = []
+        result.extend(self.subnode_args)
+        value = self.subnode_name
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_obj
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        return tuple(result)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (
+            ("args", self.subnode_args),
+            ("name", self.subnode_name),
+            ("obj", self.subnode_obj),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_args
+        if old_node in value:
+            if new_node is not None:
+                new_node.parent = self
+
+                self.subnode_args = tuple(
+                    (val if val is not old_node else new_node) for val in value
+                )
+            else:
+                self.subnode_args = tuple(val for val in value if val is not old_node)
+
+            return
+
+        value = self.subnode_name
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_name = new_node
+
+            return
+
+        value = self.subnode_obj
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_obj = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "args": tuple(v.makeClone() for v in self.subnode_args),
+            "name": (
+                self.subnode_name.makeClone() if self.subnode_name is not None else None
+            ),
+            "obj": (
+                self.subnode_obj.makeClone() if self.subnode_obj is not None else None
+            ),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        for c in self.subnode_args:
+            c.finalize()
+        del self.subnode_args
+        if self.subnode_name is not None:
+            self.subnode_name.finalize()
+        del self.subnode_name
+        if self.subnode_obj is not None:
+            self.subnode_obj.finalize()
+        del self.subnode_obj
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
+
+            if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
+                return (
+                    wrapped_expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        return self, None, None
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return False
+
+    def mayRaiseException(self, exception_type):
+        return (
+            any(value.mayRaiseException(exception_type) for value in self.subnode_args)
+            or (
+                self.subnode_name is not None
+                and self.subnode_name.mayRaiseException(exception_type)
+            )
+            or (
+                self.subnode_obj is not None
+                and self.subnode_obj.mayRaiseException(exception_type)
+            )
+        )
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        for element in self.subnode_args:
+            element.collectVariableAccesses(emit_read, emit_write)
+        subnode_name = self.subnode_name
+
+        if subnode_name is not None:
+            self.subnode_name.collectVariableAccesses(emit_read, emit_write)
+        subnode_obj = self.subnode_obj
+
+        if subnode_obj is not None:
+            self.subnode_obj.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ExpressionBuiltinMakeExceptionAttributeErrorBase = (
+    ChildrenHavingArgsTupleNameOptionalObjOptionalFinalNoRaiseForRaiseMixin
+)
+
+
+class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseForRaiseMixin(
+    ExpressionBase
+):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
@@ -208,7 +485,7 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
     #   ExpressionBuiltinMakeExceptionImportError
     #   ExpressionBuiltinMakeExceptionModuleNotFoundError
 
-    def __init__(self, args, name, path, source_ref):
+    def __init__(self, args, name, path, for_raise, source_ref):
         assert type(args) is tuple
 
         for val in args:
@@ -226,8 +503,15 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 
         self.subnode_path = path
 
+        self.for_raise = for_raise
+
         ExpressionBase.__init__(self, source_ref)
 
+    def getDetails(self):
+        return {
+            "for_raise": self.for_raise,
+        }
+
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
@@ -389,10 +673,10 @@ class ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin(Expressio
 
 # Assign the names that are easier to import with a stable name.
 ExpressionBuiltinMakeExceptionImportErrorBase = (
-    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin
+    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseForRaiseMixin
 )
 ExpressionBuiltinMakeExceptionModuleNotFoundErrorBase = (
-    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseMixin
+    ChildrenHavingArgsTupleNameOptionalPathOptionalFinalNoRaiseForRaiseMixin
 )
 
 

nuitka/nodes/FrameNodes.py

@@ -18,7 +18,8 @@ from nuitka.PythonVersions import python_version
 
 from .CodeObjectSpecs import CodeObjectSpec
 from .FutureSpecs import fromFlags
-from .StatementNodes import StatementsSequence
+from .StatementBasesGenerated import StatementsSequenceBase
+from .StatementNodes import StatementsSequenceMixin
 
 
 def checkFrameStatements(value):
@@ -33,30 +34,39 @@ def checkFrameStatements(value):
     return tuple(value)
 
 
-class StatementsFrameBase(StatementsSequence):
+class StatementsFrameBase(StatementsSequenceMixin, StatementsSequenceBase):
     checkers = {"statements": checkFrameStatements}
 
     __slots__ = ("code_object", "needs_frame_exception_preserve")
 
+    named_children = ("statements|tuple+setter",)
+
     def __init__(self, statements, code_object, source_ref):
-        StatementsSequence.__init__(self, statements=statements, source_ref=source_ref)
+        StatementsSequenceBase.__init__(
+            self, statements=statements, source_ref=source_ref
+        )
 
         self.code_object = code_object
 
         self.needs_frame_exception_preserve = False
 
-    def isStatementsFrame(self):
+    @staticmethod
+    def isStatementsFrame():
+        return True
+
+    @staticmethod
+    def isStatementsSequence():
         return True
 
     def getDetails(self):
         result = {"code_object": self.code_object}
 
-        result.update(StatementsSequence.getDetails(self))
+        result.update(StatementsSequenceBase.getDetails(self))
 
         return result
 
     def getDetailsForDisplay(self):
-        result = StatementsSequence.getDetails(self)
+        result = StatementsSequenceBase.getDetails(self)
         result.update()
 
         result.update(self.code_object.getDetails())
@@ -139,7 +149,7 @@ class StatementsFrameBase(StatementsSequence):
         self.code_object.setFlagIsOptimizedValue(is_optimized)
 
         new_locals = not provider.isCompiledPythonModule() and (
-            python_version < 0x340
+            python_version < 0x300
             or (
                 not provider.isExpressionClassBodyBase()
                 and not provider.isUnoptimized()
@@ -174,10 +184,7 @@ class StatementsFrameBase(StatementsSequence):
                 new_statement = trace_collection.onStatement(statement=statement)
 
             if new_statement is not None:
-                if (
-                    new_statement.isStatementsSequence()
-                    and not new_statement.isStatementsFrame()
-                ):
+                if new_statement.isStatementsSequenceButNotFrame():
                     new_statements.extend(new_statement.subnode_statements)
                 else:
                     new_statements.append(new_statement)
@@ -265,6 +272,10 @@ class StatementsFrameBase(StatementsSequence):
 
         return None
 
+    @staticmethod
+    def getStatementNiceName():
+        return "frame statements sequence"
+
 
 class StatementsFrameModule(StatementsFrameBase):
     kind = "STATEMENTS_FRAME_MODULE"

nuitka/nodes/FunctionNodes.py

@@ -344,7 +344,7 @@ class ExpressionFunctionBodyBase(
 
         function_name = self.getFunctionName()
 
-        if python_version < 0x340:
+        if python_version < 0x300:
             qualname_provider = self.getParentVariableProvider()
         else:
             qualname_provider = self.qualname_provider
@@ -1028,7 +1028,7 @@ class ExpressionFunctionCreationOld(
 ):
     kind = "EXPRESSION_FUNCTION_CREATION_OLD"
 
-    python_version_spec = "< 0x340"
+    python_version_spec = "< 0x300"
     # Note: The order of evaluation for these is a bit unexpected, but
     # true. Keyword defaults go first, then normal defaults, and annotations of
     # all kinds go last.
@@ -1096,7 +1096,7 @@ class ExpressionFunctionCreation(
         self.variable_closure_traces = None
 
 
-if python_version < 0x340:
+if python_version < 0x300:
     ExpressionFunctionCreation = ExpressionFunctionCreationOld
 
 

nuitka/nodes/GeneratorNodes.py

@@ -97,14 +97,11 @@ class ExpressionGeneratorObjectBody(
     def getFunctionName(self):
         return self.name
 
-    def markAsNeedsGeneratorReturnHandling(self, value):
-        self.needs_generator_return_exit = max(self.needs_generator_return_exit, value)
-
-    def needsGeneratorReturnHandling(self):
-        return self.needs_generator_return_exit == 2
+    def markAsNeedsGeneratorReturnHandling(self):
+        self.needs_generator_return_exit = True
 
     def needsGeneratorReturnExit(self):
-        return bool(self.needs_generator_return_exit)
+        return self.needs_generator_return_exit
 
     @staticmethod
     def needsCreation():