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

nuitka/nodes/ChildrenHavingMixins.py

@@ -6079,7 +6079,7 @@ ChildrenExpressionMakeSetLiteralMixin = ChildHavingElementsTupleMixin
 ChildrenExpressionMakeTupleMixin = ChildHavingElementsTupleMixin
 
 
-class ChildrenHavingExceptionTypeExceptionValueMixin(object):
+class ChildHavingExceptionTypeMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
@@ -6089,23 +6089,15 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
     def __init__(
         self,
         exception_type,
-        exception_value,
     ):
         exception_type.parent = self
 
         self.subnode_exception_type = exception_type
 
-        exception_value.parent = self
-
-        self.subnode_exception_value = exception_value
-
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
-        return (
-            self.subnode_exception_type,
-            self.subnode_exception_value,
-        )
+        return (self.subnode_exception_type,)
 
     def getVisitableNodesNamed(self):
         """Named children dictionary.
@@ -6113,10 +6105,7 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
         For use in cloning nodes, debugging and XML output.
         """
 
-        return (
-            ("exception_type", self.subnode_exception_type),
-            ("exception_value", self.subnode_exception_value),
-        )
+        return (("exception_type", self.subnode_exception_type),)
 
     def replaceChild(self, old_node, new_node):
         value = self.subnode_exception_type
@@ -6127,14 +6116,6 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
 
             return
 
-        value = self.subnode_exception_value
-        if old_node is value:
-            new_node.parent = self
-
-            self.subnode_exception_value = new_node
-
-            return
-
         raise AssertionError("Didn't find child", old_node, "in", self)
 
     def getCloneArgs(self):
@@ -6145,7 +6126,6 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
 
         values = {
             "exception_type": self.subnode_exception_type.makeClone(),
-            "exception_value": self.subnode_exception_value.makeClone(),
         }
 
         values.update(self.getDetails())
@@ -6157,8 +6137,6 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
 
         self.subnode_exception_type.finalize()
         del self.subnode_exception_type
-        self.subnode_exception_value.finalize()
-        del self.subnode_exception_value
 
     def computeExpressionRaw(self, trace_collection):
         """Compute an expression.
@@ -6168,26 +6146,16 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
         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,
-                )
+        # First apply the sub-expression, as they it's evaluated before.
+        expression = trace_collection.onExpression(self.subnode_exception_type)
 
-                return (
-                    wrapped_expression,
-                    "new_raise",
-                    lambda: "For '%s' the child expression '%s' will raise."
-                    % (self.getChildNameNice(), expression.getChildNameNice()),
-                )
+        if expression.willRaiseAnyException():
+            return (
+                expression,
+                "new_raise",
+                lambda: "For '%s' the child expression '%s' will raise."
+                % (self.getChildNameNice(), expression.getChildNameNice()),
+            )
 
         # Then ask ourselves to work on it.
         return self.computeExpression(trace_collection)
@@ -6196,11 +6164,10 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
         """Collect variable reads and writes of child nodes."""
 
         self.subnode_exception_type.collectVariableAccesses(emit_read, emit_write)
-        self.subnode_exception_value.collectVariableAccesses(emit_read, emit_write)
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionRaiseExceptionMixin = ChildrenHavingExceptionTypeExceptionValueMixin
+ChildrenExpressionRaiseExceptionMixin = ChildHavingExceptionTypeMixin
 
 
 class ChildHavingExitCodeOptionalMixin(object):
@@ -13838,6 +13805,341 @@ class ChildHavingPathOptionalMixin(object):
 ChildrenExpressionOsListdirMixin = ChildHavingPathOptionalMixin
 
 
+class ChildrenHavingPathOptionalDirFdOptionalMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionOsLstat
+
+    def __init__(
+        self,
+        path,
+        dir_fd,
+    ):
+        if path is not None:
+            path.parent = self
+
+        self.subnode_path = path
+
+        if dir_fd is not None:
+            dir_fd.parent = self
+
+        self.subnode_dir_fd = dir_fd
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        result = []
+        value = self.subnode_path
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_dir_fd
+        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 (
+            ("path", self.subnode_path),
+            ("dir_fd", self.subnode_dir_fd),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_path
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_path = new_node
+
+            return
+
+        value = self.subnode_dir_fd
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_dir_fd = 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 = {
+            "path": (
+                self.subnode_path.makeClone() if self.subnode_path is not None else None
+            ),
+            "dir_fd": (
+                self.subnode_dir_fd.makeClone()
+                if self.subnode_dir_fd is not None
+                else None
+            ),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        if self.subnode_path is not None:
+            self.subnode_path.finalize()
+        del self.subnode_path
+        if self.subnode_dir_fd is not None:
+            self.subnode_dir_fd.finalize()
+        del self.subnode_dir_fd
+
+    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()),
+                )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        subnode_path = self.subnode_path
+
+        if subnode_path is not None:
+            self.subnode_path.collectVariableAccesses(emit_read, emit_write)
+        subnode_dir_fd = self.subnode_dir_fd
+
+        if subnode_dir_fd is not None:
+            self.subnode_dir_fd.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionOsLstatMixin = ChildrenHavingPathOptionalDirFdOptionalMixin
+
+
+class ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionOsStat
+
+    def __init__(
+        self,
+        path,
+        dir_fd,
+        follow_symlinks,
+    ):
+        if path is not None:
+            path.parent = self
+
+        self.subnode_path = path
+
+        if dir_fd is not None:
+            dir_fd.parent = self
+
+        self.subnode_dir_fd = dir_fd
+
+        if follow_symlinks is not None:
+            follow_symlinks.parent = self
+
+        self.subnode_follow_symlinks = follow_symlinks
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        result = []
+        value = self.subnode_path
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_dir_fd
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_follow_symlinks
+        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 (
+            ("path", self.subnode_path),
+            ("dir_fd", self.subnode_dir_fd),
+            ("follow_symlinks", self.subnode_follow_symlinks),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_path
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_path = new_node
+
+            return
+
+        value = self.subnode_dir_fd
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_dir_fd = new_node
+
+            return
+
+        value = self.subnode_follow_symlinks
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_follow_symlinks = 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 = {
+            "path": (
+                self.subnode_path.makeClone() if self.subnode_path is not None else None
+            ),
+            "dir_fd": (
+                self.subnode_dir_fd.makeClone()
+                if self.subnode_dir_fd is not None
+                else None
+            ),
+            "follow_symlinks": (
+                self.subnode_follow_symlinks.makeClone()
+                if self.subnode_follow_symlinks is not None
+                else None
+            ),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        if self.subnode_path is not None:
+            self.subnode_path.finalize()
+        del self.subnode_path
+        if self.subnode_dir_fd is not None:
+            self.subnode_dir_fd.finalize()
+        del self.subnode_dir_fd
+        if self.subnode_follow_symlinks is not None:
+            self.subnode_follow_symlinks.finalize()
+        del self.subnode_follow_symlinks
+
+    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()),
+                )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        subnode_path = self.subnode_path
+
+        if subnode_path is not None:
+            self.subnode_path.collectVariableAccesses(emit_read, emit_write)
+        subnode_dir_fd = self.subnode_dir_fd
+
+        if subnode_dir_fd is not None:
+            self.subnode_dir_fd.collectVariableAccesses(emit_read, emit_write)
+        subnode_follow_symlinks = self.subnode_follow_symlinks
+
+        if subnode_follow_symlinks is not None:
+            self.subnode_follow_symlinks.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionOsStatMixin = (
+    ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin
+)
+
+
 class ChildrenHavingPosArgOptionalPairsTupleMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
@@ -19927,6 +20229,97 @@ class ChildrenHavingTypeNameBasesDictArgMixin(object):
 ChildrenExpressionBuiltinType3Mixin = ChildrenHavingTypeNameBasesDictArgMixin
 
 
+class ChildHavingTypeParamsMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionTypeMakeGeneric
+
+    def __init__(
+        self,
+        type_params,
+    ):
+        type_params.parent = self
+
+        self.subnode_type_params = type_params
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        return (self.subnode_type_params,)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (("type_params", self.subnode_type_params),)
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_type_params
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_type_params = 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 = {
+            "type_params": self.subnode_type_params.makeClone(),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        self.subnode_type_params.finalize()
+        del self.subnode_type_params
+
+    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-expression, as they it's evaluated before.
+        expression = trace_collection.onExpression(self.subnode_type_params)
+
+        if expression.willRaiseAnyException():
+            return (
+                expression,
+                "new_raise",
+                lambda: "For '%s' the child expression '%s' will raise."
+                % (self.getChildNameNice(), expression.getChildNameNice()),
+            )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        self.subnode_type_params.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionTypeMakeGenericMixin = ChildHavingTypeParamsMixin
+
+
 class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()

nuitka/nodes/ConditionalNodes.py

@@ -25,7 +25,8 @@ from .NodeMakingHelpers import (
     wrapStatementWithSideEffects,
 )
 from .OperatorNodesUnary import ExpressionOperationNot
-from .shapes.BuiltinTypeShapes import tshape_bool, tshape_unknown
+from .shapes.BuiltinTypeShapes import tshape_bool
+from .shapes.StandardShapes import tshape_unknown
 from .StatementBasesGenerated import StatementConditionalBase
 from .StatementNodes import StatementsSequence
 
@@ -754,7 +755,7 @@ Removed conditional statement without effect.""",
                 new_statement,
                 "new_statements",
                 """\
-Condition for branch statement was predicted to be always %s."""
+Condition for branch statement was predicted to be always '%s'."""
                 % choice,
             )
 

nuitka/nodes/CoroutineNodes.py

@@ -79,14 +79,11 @@ class ExpressionCoroutineObjectBody(ExpressionFunctionEntryPointBase):
     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():

nuitka/nodes/DictionaryNodes.py

@@ -61,7 +61,7 @@ from .NodeMakingHelpers import (
     makeStatementOnlyNodesFromExpressions,
     wrapExpressionWithSideEffects,
 )
-from .shapes.StandardShapes import tshape_iterator
+from .shapes.IteratorShapes import tshape_iterator
 from .StatementBasesGenerated import (
     StatementDictOperationRemoveBase,
     StatementDictOperationSetBase,