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

nuitka/nodes/HardImportNodesGenerated.py

@@ -55,6 +55,7 @@ from nuitka.specs.HardImportSpecs import (
     importlib_resources_read_binary_spec,
     importlib_resources_read_text_spec,
     os_listdir_spec,
+    os_lstat_spec,
     os_path_abspath_spec,
     os_path_basename_spec,
     os_path_dirname_spec,
@@ -63,6 +64,7 @@ from nuitka.specs.HardImportSpecs import (
     os_path_isdir_spec,
     os_path_isfile_spec,
     os_path_normpath_spec,
+    os_stat_spec,
     os_uname_spec,
     pkg_resources_get_distribution_spec,
     pkg_resources_iter_entry_points_spec,
@@ -92,6 +94,8 @@ from .ChildrenHavingMixins import (
     ChildrenHavingPackageOrRequirementResourceNameMixin,
     ChildrenHavingPackageResourceEncodingOptionalErrorsOptionalMixin,
     ChildrenHavingPackageResourceMixin,
+    ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin,
+    ChildrenHavingPathOptionalDirFdOptionalMixin,
 )
 from .ExpressionBases import ExpressionBase
 from .ExpressionShapeMixins import (
@@ -1791,6 +1795,94 @@ class ExpressionOsListdirCallBase(ChildHavingPathOptionalMixin, ExpressionBase):
         return True
 
 
+class ExpressionOsLstatRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference os.lstat"""
+
+    kind = "EXPRESSION_OS_LSTAT_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name="os",
+            import_name="lstat",
+            module_guaranteed=True,
+            source_ref=source_ref,
+        )
+
+    def computeExpressionCall(self, call_node, call_args, call_kw, trace_collection):
+        # Anything may happen on call trace before this. On next pass, if
+        # replaced, we might be better but not now.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        from .OsSysNodes import ExpressionOsLstatCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionOsLstatCall,
+            builtin_spec=os_lstat_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'os.lstat' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionOsLstatRef] = os_lstat_spec
+
+
+class ExpressionOsLstatCallBase(
+    ChildrenHavingPathOptionalDirFdOptionalMixin, ExpressionBase
+):
+    """Base class for OsLstatCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = (
+        "path|optional",
+        "dir_fd|optional",
+    )
+
+    __slots__ = ("attempted",)
+
+    spec = os_lstat_spec
+
+    def __init__(self, path, dir_fd, source_ref):
+
+        ChildrenHavingPathOptionalDirFdOptionalMixin.__init__(
+            self,
+            path=path,
+            dir_fd=dir_fd,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.attempted = False
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not os_lstat_spec.isCompileTimeComputable(
+            (self.subnode_path,)
+        ):
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return self, None, None
+
+        try:
+            return self.replaceWithCompileTimeValue(trace_collection)
+        finally:
+            self.attempted = True
+
+    @abstractmethod
+    def replaceWithCompileTimeValue(self, trace_collection):
+        pass
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return True
+
+
 class ExpressionOsPathAbspathRef(ExpressionImportModuleNameHardExistsSpecificBase):
     """Function reference os.path.abspath"""
 
@@ -2449,6 +2541,96 @@ class ExpressionOsPathNormpathCallBase(ChildHavingPathMixin, ExpressionBase):
         return True
 
 
+class ExpressionOsStatRef(ExpressionImportModuleNameHardExistsSpecificBase):
+    """Function reference os.stat"""
+
+    kind = "EXPRESSION_OS_STAT_REF"
+
+    def __init__(self, source_ref):
+        ExpressionImportModuleNameHardExistsSpecificBase.__init__(
+            self,
+            module_name="os",
+            import_name="stat",
+            module_guaranteed=True,
+            source_ref=source_ref,
+        )
+
+    def computeExpressionCall(self, call_node, call_args, call_kw, trace_collection):
+        # Anything may happen on call trace before this. On next pass, if
+        # replaced, we might be better but not now.
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        from .OsSysNodes import ExpressionOsStatCall
+
+        result = extractBuiltinArgs(
+            node=call_node,
+            builtin_class=ExpressionOsStatCall,
+            builtin_spec=os_stat_spec,
+        )
+
+        return (
+            result,
+            "new_expression",
+            "Call to 'os.stat' recognized.",
+        )
+
+
+hard_import_node_classes[ExpressionOsStatRef] = os_stat_spec
+
+
+class ExpressionOsStatCallBase(
+    ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin, ExpressionBase
+):
+    """Base class for OsStatCall
+
+    Generated boiler plate code.
+    """
+
+    named_children = (
+        "path|optional",
+        "dir_fd|optional",
+        "follow_symlinks|optional",
+    )
+
+    __slots__ = ("attempted",)
+
+    spec = os_stat_spec
+
+    def __init__(self, path, dir_fd, follow_symlinks, source_ref):
+
+        ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin.__init__(
+            self,
+            path=path,
+            dir_fd=dir_fd,
+            follow_symlinks=follow_symlinks,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.attempted = False
+
+    def computeExpression(self, trace_collection):
+        if self.attempted or not os_stat_spec.isCompileTimeComputable(
+            (self.subnode_path,)
+        ):
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+            return self, None, None
+
+        try:
+            return self.replaceWithCompileTimeValue(trace_collection)
+        finally:
+            self.attempted = True
+
+    @abstractmethod
+    def replaceWithCompileTimeValue(self, trace_collection):
+        pass
+
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return True
+
+
 class ExpressionOsUnameRef(ExpressionImportModuleNameHardExistsSpecificBase):
     """Function reference os.uname"""
 

nuitka/nodes/ImportNodes.py

@@ -454,9 +454,9 @@ class ExpressionImportModuleHard(
 
     @staticmethod
     def _getImportNameErrorString(module, module_name, name):
-        if python_version < 0x340:
+        if python_version < 0x300:
             return "cannot import name %s" % name
-        if python_version < 0x370:
+        elif python_version < 0x370:
             return "cannot import name %r" % name
         elif isStandaloneMode():
             return "cannot import name %r from %r" % (name, module_name)

nuitka/nodes/NodeBases.py

@@ -185,6 +185,19 @@ class NodeBase(NodeMetaClassBase):
 
         return parent
 
+    def getContainingLoopNode(self):
+        """Return the parent that is module."""
+        parent = self.parent
+
+        while parent is not None and not parent.isExpressionFunctionBodyBase():
+
+            if parent.isStatementLoop():
+                return parent
+
+            parent = parent.getParent()
+
+        return parent
+
     def isParentVariableProvider(self):
         # Check if it's a closure giver, in which cases it can provide variables,
         return isinstance(self, ClosureGiverNodeMixin)
@@ -314,6 +327,10 @@ class NodeBase(NodeMetaClassBase):
     def isStatementsFrame():
         return False
 
+    @staticmethod
+    def isStatementsSequenceButNotFrame():
+        return False
+
     @staticmethod
     def isCompiledPythonModule():
         # For overload by module nodes
@@ -405,6 +422,11 @@ class NodeBase(NodeMetaClassBase):
     def getVisitableNodes():
         return ()
 
+    def checkChildren(self):
+        for c in self.getVisitableNodes():
+            assert c.parent is self, (c, "parent", self, "!=", c.parent)
+            c.checkChildren()
+
     @staticmethod
     def getVisitableNodesNamed():
         """Named children dictionary.
@@ -707,6 +729,11 @@ class StatementBase(NodeBase):
             expression = trace_collection.onExpression(expression)
 
             if expression.willRaiseAnyException():
+                # They probably have changed.
+                expressions = self.getVisitableNodes()
+
+                child_name = expression.getChildNameNice()
+
                 wrapped_expression = makeStatementOnlyNodesFromExpressions(
                     expressions[: count + 1]
                 )
@@ -717,7 +744,7 @@ class StatementBase(NodeBase):
                     wrapped_expression,
                     "new_raise",
                     lambda: "For %s the child expression '%s' will raise."
-                    % (self.getStatementNiceName(), expression.getChildNameNice()),
+                    % (self.getStatementNiceName(), child_name),
                 )
 
         return self, None, None

nuitka/nodes/NodeMakingHelpers.py

@@ -31,8 +31,10 @@ def makeConstantReplacementNode(constant, node, user_provided):
 def makeRaiseExceptionReplacementExpression(
     expression, exception_type, exception_value, no_warning=False
 ):
-    from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
-    from .ExceptionNodes import ExpressionRaiseException
+    from .ExceptionNodes import (
+        ExpressionRaiseException,
+        makeBuiltinMakeExceptionNode,
+    )
 
     source_ref = expression.source_ref
 
@@ -48,12 +50,22 @@ def makeRaiseExceptionReplacementExpression(
             )
         )
 
+    if type(exception_value) is not tuple:
+        exception_value = (exception_value,)
+
+    args = tuple(
+        makeConstantReplacementNode(
+            constant=element, node=expression, user_provided=False
+        )
+        for element in exception_value
+    )
+
     result = ExpressionRaiseException(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name=exception_type, source_ref=source_ref
-        ),
-        exception_value=makeConstantReplacementNode(
-            constant=exception_value, node=expression, user_provided=False
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name=exception_type,
+            args=args,
+            for_raise=False,
+            source_ref=source_ref,
         ),
         source_ref=source_ref,
     )
@@ -61,15 +73,19 @@ def makeRaiseExceptionReplacementExpression(
     return result
 
 
-def makeRaiseExceptionReplacementStatement(statement, exception_type, exception_value):
-    from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
-    from .ExceptionNodes import StatementRaiseExceptionImplicit
+def makeRaiseExceptionReplacementStatement(
+    statement, exception_type, exception_value, no_warning=False
+):
+    from .ExceptionNodes import (
+        StatementRaiseException,
+        makeBuiltinMakeExceptionNode,
+    )
 
     source_ref = statement.getSourceReference()
 
     assert type(exception_type) is str
 
-    if Options.shallWarnImplicitRaises():
+    if not no_warning and Options.shallWarnImplicitRaises():
         unusual_logger.warning(
             '%s: Will always raise exception: "%s(%s)"'
             % (
@@ -79,13 +95,18 @@ def makeRaiseExceptionReplacementStatement(statement, exception_type, exception_
             )
         )
 
-    result = StatementRaiseExceptionImplicit(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name=exception_type, source_ref=source_ref
-        ),
-        exception_value=makeConstantReplacementNode(
-            constant=exception_value, node=statement, user_provided=False
+    result = StatementRaiseException(
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name=exception_type,
+            args=(
+                makeConstantReplacementNode(
+                    constant=exception_value, node=statement, user_provided=False
+                ),
+            ),
+            for_raise=False,
+            source_ref=source_ref,
         ),
+        exception_value=None,
         exception_cause=None,
         exception_trace=None,
         source_ref=source_ref,
@@ -97,41 +118,35 @@ def makeRaiseExceptionReplacementStatement(statement, exception_type, exception_
 def makeRaiseExceptionReplacementExpressionFromInstance(expression, exception):
     assert isinstance(exception, Exception)
 
-    args = exception.args
-    if type(args) is tuple and len(args) == 1:
-        value = args[0]
-    else:
-        assert type(args) is tuple
-        value = args
-
     return makeRaiseExceptionReplacementExpression(
         expression=expression,
         exception_type=exception.__class__.__name__,
-        exception_value=value,
+        exception_value=exception.args,
     )
 
 
 def makeRaiseExceptionStatementFromInstance(exception, source_ref):
     assert isinstance(exception, Exception)
 
-    args = exception.args
-    if type(args) is tuple and len(args) == 1:
-        value = args[0]
-    else:
-        assert type(args) is tuple
-        value = args
-
-    from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
     from .ConstantRefNodes import makeConstantRefNode
-    from .ExceptionNodes import StatementRaiseExceptionImplicit
+    from .ExceptionNodes import (
+        StatementRaiseException,
+        makeBuiltinMakeExceptionNode,
+    )
 
-    return StatementRaiseExceptionImplicit(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name=exception.__class__.__name__, source_ref=source_ref
-        ),
-        exception_value=makeConstantRefNode(
-            constant=value, source_ref=source_ref, user_provided=False
+    args_value = tuple(
+        makeConstantRefNode(constant=arg, source_ref=source_ref, user_provided=False)
+        for arg in exception.args
+    )
+
+    return StatementRaiseException(
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name=exception.__class__.__name__,
+            args=args_value,
+            for_raise=False,
+            source_ref=source_ref,
         ),
+        exception_value=None,
         exception_cause=None,
         exception_trace=None,
         source_ref=source_ref,
@@ -141,10 +156,12 @@ def makeRaiseExceptionStatementFromInstance(exception, source_ref):
 def makeRaiseExceptionExpressionFromTemplate(
     exception_type, template, template_args, source_ref
 ):
-    from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
     from .ConstantRefNodes import makeConstantRefNode
     from .ContainerMakingNodes import makeExpressionMakeTupleOrConstant
-    from .ExceptionNodes import ExpressionRaiseException
+    from .ExceptionNodes import (
+        ExpressionRaiseException,
+        makeBuiltinMakeExceptionNode,
+    )
     from .OperatorNodes import makeBinaryOperationNode
 
     if type(template_args) is tuple:
@@ -153,15 +170,19 @@ def makeRaiseExceptionExpressionFromTemplate(
         )
 
     return ExpressionRaiseException(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name=exception_type, source_ref=source_ref
-        ),
-        exception_value=makeBinaryOperationNode(
-            operator="Mod",
-            left=makeConstantRefNode(
-                constant=template, source_ref=source_ref, user_provided=True
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name=exception_type,
+            args=(
+                makeBinaryOperationNode(
+                    operator="Mod",
+                    left=makeConstantRefNode(
+                        constant=template, source_ref=source_ref, user_provided=True
+                    ),
+                    right=template_args,
+                    source_ref=source_ref,
+                ),
             ),
-            right=template_args,
+            for_raise=False,
             source_ref=source_ref,
         ),
         source_ref=source_ref,

nuitka/nodes/OperatorNodesUnary.py

@@ -7,6 +7,7 @@ Some of these come from built-ins, e.g. abs, some from syntax, and repr from bot
 """
 
 from nuitka import PythonOperators
+from nuitka.Errors import NuitkaAssumptionError
 
 from .ChildrenHavingMixins import ChildHavingOperandMixin
 from .ConstantRefNodes import makeConstantRefNode
@@ -15,6 +16,11 @@ from .ExpressionShapeMixins import (
     ExpressionBoolShapeExactMixin,
     ExpressionStrOrUnicodeDerivedShapeMixin,
 )
+from .NodeMakingHelpers import (
+    makeRaiseExceptionReplacementExpressionFromInstance,
+    wrapExpressionWithSideEffects,
+)
+from .shapes.StandardShapes import tshape_unknown
 
 
 class ExpressionOperationUnaryBase(ChildHavingOperandMixin, ExpressionBase):
@@ -31,10 +37,10 @@ class ExpressionOperationUnaryBase(ChildHavingOperandMixin, ExpressionBase):
         return self.operator
 
     def computeExpression(self, trace_collection):
-        operator = self.getOperator()
         operand = self.subnode_operand
 
         if operand.isCompileTimeConstant():
+            operator = self.getOperator()
             operand_value = operand.getCompileTimeConstant()
 
             return trace_collection.getCompileTimeComputationResult(
@@ -61,6 +67,10 @@ class ExpressionOperationUnaryBase(ChildHavingOperandMixin, ExpressionBase):
     def isExpressionOperationUnary():
         return True
 
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return True
+
 
 class ExpressionOperationUnaryRepr(  # TODO: Not exact
     ExpressionStrOrUnicodeDerivedShapeMixin, ExpressionOperationUnaryBase
@@ -104,7 +114,100 @@ class ExpressionOperationUnaryRepr(  # TODO: Not exact
         return self.escape_desc is None or self.escape_desc.isControlFlowEscape()
 
 
-class ExpressionOperationUnarySub(ExpressionOperationUnaryBase):
+# TODO: This should merge into base class.
+class ExpressionOperationUnaryMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    def mayRaiseExceptionOperation(self):
+        return self.escape_desc.getExceptionExit() is not None
+
+    def mayRaiseException(self, exception_type):
+        # TODO: Match getExceptionExit() more precisely against exception type given
+        return (
+            self.escape_desc is None
+            or self.escape_desc.getExceptionExit() is not None
+            or self.subnode_operand.mayRaiseException(exception_type)
+        )
+
+    def getTypeShape(self):
+        return self.type_shape
+
+    def createUnsupportedException(self, operand_shape):
+        typical_value = operand_shape.typical_value
+
+        try:
+            self.simulator(typical_value)
+        except TypeError as e:
+            return e
+        except Exception as e:
+            raise NuitkaAssumptionError(
+                "Unexpected exception type doing operation simulation",
+                self.operator,
+                self.simulator,
+                operand_shape,
+                e,
+            )
+        else:
+            raise NuitkaAssumptionError(
+                "Unexpected no-exception doing operation simulation",
+                self.operator,
+                self.simulator,
+                operand_shape,
+            )
+
+    def computeExpression(self, trace_collection):
+        operand = self.subnode_operand
+
+        if operand.isCompileTimeConstant():
+            operand_value = operand.getCompileTimeConstant()
+            operator = self.getOperator()
+
+            return trace_collection.getCompileTimeComputationResult(
+                node=self,
+                computation=lambda: self.simulator(operand_value),
+                description="Operator '%s' with constant argument." % operator,
+            )
+        else:
+            operand_shape = operand.getTypeShape()
+
+            self.type_shape, self.escape_desc = self._getOperationShape(operand_shape)
+
+            if self.escape_desc.isUnsupported():
+                result = wrapExpressionWithSideEffects(
+                    new_node=makeRaiseExceptionReplacementExpressionFromInstance(
+                        expression=self,
+                        exception=self.createUnsupportedException(operand_shape),
+                    ),
+                    old_node=self,
+                    side_effects=(operand,),
+                )
+
+                return (
+                    result,
+                    "new_raise",
+                    "Replaced operator '%s' with %s arguments that cannot work."
+                    % (self.operator, operand_shape),
+                )
+
+            exception_raise_exit = self.escape_desc.getExceptionExit()
+            if exception_raise_exit is not None:
+                trace_collection.onExceptionRaiseExit(exception_raise_exit)
+
+            if self.escape_desc.isValueEscaping():
+                # The value of these nodes escaped and could change its contents.
+                trace_collection.removeKnowledge(operand)
+
+            if self.escape_desc.isControlFlowEscape():
+                # Any code could be run, note that.
+                trace_collection.onControlFlowEscape(self)
+
+            return self, None, None
+
+
+class ExpressionOperationUnarySub(
+    ExpressionOperationUnaryMixin, ExpressionOperationUnaryBase
+):
     """Python unary operator -"""
 
     kind = "EXPRESSION_OPERATION_UNARY_SUB"
@@ -112,13 +215,25 @@ class ExpressionOperationUnarySub(ExpressionOperationUnaryBase):
     operator = "USub"
     simulator = PythonOperators.unary_operator_functions[operator]
 
+    __slots__ = ("type_shape", "escape_desc")
+
     def __init__(self, operand, source_ref):
         ExpressionOperationUnaryBase.__init__(
             self, operand=operand, source_ref=source_ref
         )
 
+        self.type_shape = tshape_unknown
 
-class ExpressionOperationUnaryAdd(ExpressionOperationUnaryBase):
+        self.escape_desc = None
+
+    @staticmethod
+    def _getOperationShape(operand_shape):
+        return operand_shape.getOperationUnarySubShape()
+
+
+class ExpressionOperationUnaryAdd(
+    ExpressionOperationUnaryMixin, ExpressionOperationUnaryBase
+):
     """Python unary operator +"""
 
     kind = "EXPRESSION_OPERATION_UNARY_ADD"
@@ -126,11 +241,21 @@ class ExpressionOperationUnaryAdd(ExpressionOperationUnaryBase):
     operator = "UAdd"
     simulator = PythonOperators.unary_operator_functions[operator]
 
+    __slots__ = ("type_shape", "escape_desc")
+
     def __init__(self, operand, source_ref):
         ExpressionOperationUnaryBase.__init__(
             self, operand=operand, source_ref=source_ref
         )
 
+        self.type_shape = tshape_unknown
+
+        self.escape_desc = None
+
+    @staticmethod
+    def _getOperationShape(operand_shape):
+        return operand_shape.getOperationUnaryAddShape()
+
 
 class ExpressionOperationUnaryInvert(ExpressionOperationUnaryBase):
     """Python unary operator ~"""