Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/nodes/ContainerMakingNodes.py

@@ -0,0 +1,408 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Nodes that build containers.
+
+"""
+
+import functools
+from abc import abstractmethod
+
+from nuitka.PythonVersions import needsSetLiteralReverseInsertion
+
+from .ChildrenHavingMixins import ChildHavingElementsTupleMixin
+from .ConstantRefNodes import (
+    ExpressionConstantListEmptyRef,
+    ExpressionConstantSetEmptyRef,
+    ExpressionConstantTupleEmptyRef,
+    makeConstantRefNode,
+)
+from .ExpressionBases import ExpressionBase
+from .ExpressionShapeMixins import (
+    ExpressionListShapeExactMixin,
+    ExpressionSetShapeExactMixin,
+    ExpressionTupleShapeExactMixin,
+)
+from .IterationHandles import ListAndTupleContainerMakingIterationHandle
+from .NodeBases import SideEffectsFromChildrenMixin
+from .NodeMakingHelpers import makeStatementOnlyNodesFromExpressions
+
+
+class ExpressionMakeSequenceMixin(object):
+    __slots__ = ()
+
+    def isKnownToBeIterable(self, count):
+        return count is None or count == len(self.subnode_elements)
+
+    def isKnownToBeIterableAtMin(self, count):
+        return count <= len(self.subnode_elements)
+
+    def getIterationValue(self, count):
+        return self.subnode_elements[count]
+
+    def getIterationValueRange(self, start, stop):
+        return self.subnode_elements[start:stop]
+
+    @staticmethod
+    def canPredictIterationValues():
+        return True
+
+    def getIterationValues(self):
+        return self.subnode_elements
+
+    def getIterationHandle(self):
+        return ListAndTupleContainerMakingIterationHandle(self.subnode_elements)
+
+    @staticmethod
+    def getTruthValue():
+        return True
+
+    def mayRaiseException(self, exception_type):
+        for element in self.subnode_elements:
+            if element.mayRaiseException(exception_type):
+                return True
+
+        return False
+
+    # TODO: Make this happen from auto-compute, children only side effects
+    def computeExpressionDrop(self, statement, trace_collection):
+        # Virtual method overload, pylint: disable=unused-argument
+
+        result = makeStatementOnlyNodesFromExpressions(
+            expressions=self.subnode_elements
+        )
+
+        del self.parent
+
+        return (
+            result,
+            "new_statements",
+            """\
+Removed %s creation for unused sequence."""
+            % self.getSequenceName(),
+        )
+
+    def onContentEscapes(self, trace_collection):
+        for element in self.subnode_elements:
+            element.onContentEscapes(trace_collection)
+
+    @abstractmethod
+    def getSequenceName(self):
+        """Get name for use in traces"""
+
+
+class ExpressionMakeSequenceBase(
+    SideEffectsFromChildrenMixin,
+    ExpressionMakeSequenceMixin,
+    ChildHavingElementsTupleMixin,
+    ExpressionBase,
+):
+    named_children = ("elements|tuple",)
+
+    def __init__(self, elements, source_ref):
+        assert elements
+
+        ChildHavingElementsTupleMixin.__init__(
+            self,
+            elements=elements,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def getSequenceName(self):
+        """Get name for use in traces"""
+        simulator = self.getSimulator()
+        return simulator.__name__.capitalize()
+
+    @staticmethod
+    def isExpressionMakeSequence():
+        return True
+
+    @abstractmethod
+    def getSimulator(self):
+        """The simulator for the container making, for overload."""
+
+    def computeExpression(self, trace_collection):
+        for element in self.subnode_elements:
+            if not element.isCompileTimeConstant():
+                return self, None, None
+
+        simulator = self.getSimulator()
+        assert simulator is not None
+
+        return trace_collection.getCompileTimeComputationResult(
+            node=self,
+            computation=lambda: simulator(
+                element.getCompileTimeConstant() for element in self.subnode_elements
+            ),
+            description="%s with constant arguments." % simulator.__name__.capitalize(),
+            user_provided=True,
+        )
+
+
+def makeExpressionMakeTuple(elements, source_ref):
+    if elements:
+        return ExpressionMakeTuple(elements, source_ref)
+    else:
+        # TODO: Get rid of user provided for empty tuple refs, makes no sense.
+        return ExpressionConstantTupleEmptyRef(
+            user_provided=False, source_ref=source_ref
+        )
+
+
+def makeExpressionMakeTupleOrConstant(elements, user_provided, source_ref):
+    for element in elements:
+        # TODO: Compile time constant ought to be the criterion.
+        if not element.isExpressionConstantRef():
+            result = makeExpressionMakeTuple(elements, source_ref)
+            break
+    else:
+        result = makeConstantRefNode(
+            constant=tuple(element.getCompileTimeConstant() for element in elements),
+            user_provided=user_provided,
+            source_ref=source_ref,
+        )
+
+    if elements:
+        result.setCompatibleSourceReference(
+            source_ref=elements[-1].getCompatibleSourceReference()
+        )
+
+    return result
+
+
+class ExpressionMakeTuple(ExpressionTupleShapeExactMixin, ExpressionMakeSequenceBase):
+    kind = "EXPRESSION_MAKE_TUPLE"
+
+    def __init__(self, elements, source_ref):
+        ExpressionMakeSequenceBase.__init__(
+            self, elements=elements, source_ref=source_ref
+        )
+
+    @staticmethod
+    def getSimulator():
+        return tuple
+
+    def getIterationLength(self):
+        return len(self.subnode_elements)
+
+
+def makeExpressionMakeList(elements, source_ref):
+    if elements:
+        return ExpressionMakeList(elements, source_ref)
+    else:
+        # TODO: Get rid of user provided for empty list refs, makes no sense.
+        return ExpressionConstantListEmptyRef(
+            user_provided=False, source_ref=source_ref
+        )
+
+
+def makeExpressionMakeListOrConstant(elements, user_provided, source_ref):
+    for element in elements:
+        # TODO: Compile time constant ought to be the criterion.
+        if not element.isExpressionConstantRef():
+            result = makeExpressionMakeList(elements, source_ref)
+            break
+    else:
+        result = makeConstantRefNode(
+            constant=[element.getCompileTimeConstant() for element in elements],
+            user_provided=user_provided,
+            source_ref=source_ref,
+        )
+
+    if elements:
+        result.setCompatibleSourceReference(
+            source_ref=elements[-1].getCompatibleSourceReference()
+        )
+
+    return result
+
+
+class ExpressionMakeListMixin(object):
+    __slots__ = ()
+
+    def computeExpressionIter1(self, iter_node, trace_collection):
+        result = ExpressionMakeTuple(
+            elements=self.subnode_elements, source_ref=self.source_ref
+        )
+
+        self.parent.replaceChild(self, result)
+        del self.parent
+
+        return (
+            iter_node,
+            "new_expression",
+            """\
+Iteration over list lowered to iteration over tuple.""",
+        )
+
+
+class ExpressionMakeList(
+    ExpressionListShapeExactMixin, ExpressionMakeListMixin, ExpressionMakeSequenceBase
+):
+    kind = "EXPRESSION_MAKE_LIST"
+
+    def __init__(self, elements, source_ref):
+        ExpressionMakeSequenceBase.__init__(
+            self, elements=elements, source_ref=source_ref
+        )
+
+    @staticmethod
+    def getSimulator():
+        return list
+
+    def getIterationLength(self):
+        return len(self.subnode_elements)
+
+
+class ExpressionMakeSet(ExpressionSetShapeExactMixin, ExpressionMakeSequenceBase):
+    kind = "EXPRESSION_MAKE_SET"
+
+    def __init__(self, elements, source_ref):
+        ExpressionMakeSequenceBase.__init__(
+            self, elements=elements, source_ref=source_ref
+        )
+
+    @staticmethod
+    def getSimulator():
+        return set
+
+    def getIterationLength(self):
+        element_count = len(self.subnode_elements)
+
+        # Hashing and equality may consume elements of the produced set.
+        if element_count >= 2:
+            return None
+        else:
+            return element_count
+
+    @staticmethod
+    def getIterationMinLength():
+        # Hashing and equality may consume elements of the produced set.
+        return 1
+
+    def computeExpression(self, trace_collection):
+        # For sets, we need to consider hashing
+        are_constants = True
+        are_hashable = True
+
+        for element in self.subnode_elements:
+            if are_constants and not element.isCompileTimeConstant():
+                are_constants = False
+
+            if are_hashable and not element.isKnownToBeHashable():
+                are_hashable = False
+
+            if not are_hashable and not are_constants:
+                break
+
+        if not are_constants:
+            if not are_hashable:
+                trace_collection.onExceptionRaiseExit(BaseException)
+
+            return self, None, None
+
+        simulator = self.getSimulator()
+        assert simulator is not None
+
+        return trace_collection.getCompileTimeComputationResult(
+            node=self,
+            computation=lambda: simulator(
+                element.getCompileTimeConstant() for element in self.subnode_elements
+            ),
+            description="%s with constant arguments." % simulator.__name__.capitalize(),
+            user_provided=True,
+        )
+
+    def mayRaiseException(self, exception_type):
+        for element in self.subnode_elements:
+            if not element.isKnownToBeHashable():
+                return True
+
+            if element.mayRaiseException(exception_type):
+                return True
+
+        return False
+
+    def computeExpressionIter1(self, iter_node, trace_collection):
+        result = ExpressionMakeTuple(
+            elements=self.subnode_elements, source_ref=self.source_ref
+        )
+
+        self.parent.replaceChild(self, result)
+        del self.parent
+
+        return (
+            iter_node,
+            "new_expression",
+            """\
+Iteration over set lowered to iteration over tuple.""",
+        )
+
+
+needs_set_literal_reverse = needsSetLiteralReverseInsertion()
+
+
+def makeExpressionMakeSetLiteral(elements, source_ref):
+    if elements:
+        if needs_set_literal_reverse:
+            return ExpressionMakeSetLiteral(elements, source_ref)
+        else:
+            return ExpressionMakeSet(elements, source_ref)
+    else:
+        # TODO: Get rid of user provided for empty set refs, makes no sense.
+        return ExpressionConstantSetEmptyRef(user_provided=False, source_ref=source_ref)
+
+
+@functools.wraps(set)
+def reversed_set(value):
+    return set(reversed(tuple(value)))
+
+
+def makeExpressionMakeSetLiteralOrConstant(elements, user_provided, source_ref):
+    for element in elements:
+        # TODO: Compile time constant ought to be the criterion.
+        if not element.isExpressionConstantRef():
+            result = makeExpressionMakeSetLiteral(elements, source_ref)
+            break
+    else:
+        # Need to reverse now if needed.
+        if needs_set_literal_reverse:
+            elements = tuple(reversed(elements))
+
+        result = makeConstantRefNode(
+            constant=set(element.getCompileTimeConstant() for element in elements),
+            user_provided=user_provided,
+            source_ref=source_ref,
+        )
+
+    if elements:
+        result.setCompatibleSourceReference(
+            source_ref=elements[-1].getCompatibleSourceReference()
+        )
+
+    return result
+
+
+class ExpressionMakeSetLiteral(ExpressionMakeSet):
+    kind = "EXPRESSION_MAKE_SET_LITERAL"
+
+    @staticmethod
+    def getSimulator():
+        return reversed_set
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/nodes/ContainerOperationNodes.py

@@ -0,0 +1,87 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Operations on Containers.
+
+"""
+
+from .ChildrenHavingMixins import ChildrenExpressionSetOperationUpdateMixin
+from .ExpressionBases import ExpressionBase
+from .StatementBasesGenerated import (
+    StatementListOperationAppendBase,
+    StatementSetOperationAddBase,
+)
+
+
+class StatementListOperationAppend(StatementListOperationAppendBase):
+    kind = "STATEMENT_LIST_OPERATION_APPEND"
+
+    named_children = ("list_arg", "value")
+    auto_compute_handling = "operation"
+
+    def computeStatementOperation(self, trace_collection):
+        # TODO: Until we have proper list tracing.
+        trace_collection.removeKnowledge(self.subnode_list_arg)
+
+        return self, None, None
+
+    def mayRaiseException(self, exception_type):
+        return self.subnode_list_arg.mayRaiseException(
+            exception_type
+        ) or self.subnode_value.mayRaiseException(exception_type)
+
+
+class StatementSetOperationAdd(StatementSetOperationAddBase):
+    kind = "STATEMENT_SET_OPERATION_ADD"
+
+    named_children = ("set_arg", "value")
+    auto_compute_handling = "operation"
+
+    def computeStatementOperation(self, trace_collection):
+        # TODO: Until we have proper set tracing.
+        trace_collection.removeKnowledge(self.subnode_set_arg)
+
+        return self, None, None
+
+    def mayRaiseException(self, exception_type):
+        return self.subnode_set_arg.mayRaiseException(
+            exception_type
+        ) or self.subnode_value.mayRaiseException(exception_type)
+
+
+class ExpressionSetOperationUpdate(
+    ChildrenExpressionSetOperationUpdateMixin, ExpressionBase
+):
+    kind = "EXPRESSION_SET_OPERATION_UPDATE"
+
+    named_children = ("set_arg", "value")
+
+    def __init__(self, set_arg, value, source_ref):
+        ChildrenExpressionSetOperationUpdateMixin.__init__(
+            self,
+            set_arg=set_arg,
+            value=value,
+        )
+
+        ExpressionBase.__init__(self, source_ref)
+
+    def computeExpression(self, trace_collection):
+        trace_collection.removeKnowledge(self.subnode_set_arg)
+
+        return self, None, None
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/nodes/CoroutineNodes.py

@@ -0,0 +1,144 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Nodes for coroutine objects and their creations.
+
+Coroutines are turned into normal functions that create generator objects,
+whose implementation lives here. The creation itself also lives here.
+
+"""
+
+from .ChildrenHavingMixins import (
+    ChildHavingCoroutineRefMixin,
+    ChildHavingExpressionMixin,
+)
+from .ExpressionBases import ExpressionBase, ExpressionNoSideEffectsMixin
+from .FunctionNodes import ExpressionFunctionEntryPointBase
+
+
+class ExpressionMakeCoroutineObject(
+    ExpressionNoSideEffectsMixin, ChildHavingCoroutineRefMixin, ExpressionBase
+):
+    kind = "EXPRESSION_MAKE_COROUTINE_OBJECT"
+
+    named_children = ("coroutine_ref",)
+
+    __slots__ = ("variable_closure_traces",)
+
+    def __init__(self, coroutine_ref, source_ref):
+        assert coroutine_ref.getFunctionBody().isExpressionCoroutineObjectBody()
+
+        ChildHavingCoroutineRefMixin.__init__(self, coroutine_ref=coroutine_ref)
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.variable_closure_traces = None
+
+    def getDetailsForDisplay(self):
+        return {"coroutine": self.subnode_coroutine_ref.getFunctionBody().getCodeName()}
+
+    def computeExpression(self, trace_collection):
+        self.variable_closure_traces = []
+
+        for (
+            closure_variable
+        ) in self.subnode_coroutine_ref.getFunctionBody().getClosureVariables():
+            trace = trace_collection.getVariableCurrentTrace(closure_variable)
+            trace.addNameUsage()
+
+            self.variable_closure_traces.append((closure_variable, trace))
+
+        # TODO: Coroutine body may know something too.
+        return self, None, None
+
+    def getClosureVariableVersions(self):
+        return self.variable_closure_traces
+
+
+class ExpressionCoroutineObjectBody(ExpressionFunctionEntryPointBase):
+    kind = "EXPRESSION_COROUTINE_OBJECT_BODY"
+
+    __slots__ = ("qualname_setup", "needs_generator_return_exit")
+
+    def __init__(self, provider, name, code_object, flags, auto_release, source_ref):
+        ExpressionFunctionEntryPointBase.__init__(
+            self,
+            provider=provider,
+            name=name,
+            code_object=code_object,
+            code_prefix="coroutine",
+            flags=flags,
+            auto_release=auto_release,
+            source_ref=source_ref,
+        )
+
+        self.needs_generator_return_exit = False
+
+        self.qualname_setup = None
+
+    def getFunctionName(self):
+        return self.name
+
+    def markAsNeedsGeneratorReturnHandling(self):
+        self.needs_generator_return_exit = True
+
+    def needsGeneratorReturnExit(self):
+        return self.needs_generator_return_exit
+
+    @staticmethod
+    def needsCreation():
+        return False
+
+    @staticmethod
+    def isUnoptimized():
+        return False
+
+
+class ExpressionAsyncWait(ChildHavingExpressionMixin, ExpressionBase):
+    kind = "EXPRESSION_ASYNC_WAIT"
+
+    named_children = ("expression",)
+
+    __slots__ = ("exception_preserving",)
+
+    def __init__(self, expression, source_ref):
+        ChildHavingExpressionMixin.__init__(self, expression=expression)
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.exception_preserving = False
+
+    @staticmethod
+    def isExpressionAsyncWait():
+        return True
+
+    def computeExpression(self, trace_collection):
+        # TODO: Might be predictable based awaitable analysis or for constants.
+
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+
+class ExpressionAsyncWaitEnter(ExpressionAsyncWait):
+    kind = "EXPRESSION_ASYNC_WAIT_ENTER"
+
+
+class ExpressionAsyncWaitExit(ExpressionAsyncWait):
+    kind = "EXPRESSION_ASYNC_WAIT_EXIT"
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/nodes/CtypesNodes.py

@@ -0,0 +1,51 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Nodes for all things "ctypes" stdlib module.
+
+"""
+
+from .HardImportNodesGenerated import (
+    ExpressionCtypesCdllBefore38CallBase,
+    ExpressionCtypesCdllSince38CallBase,
+)
+
+
+class ExpressionCtypesCdllSince38Call(ExpressionCtypesCdllSince38CallBase):
+    """Function reference ctypes.CDLL"""
+
+    kind = "EXPRESSION_CTYPES_CDLL_SINCE38_CALL"
+
+    def replaceWithCompileTimeValue(self, trace_collection):
+        # TODO: Locate DLLs and report to freezer
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+
+class ExpressionCtypesCdllBefore38Call(ExpressionCtypesCdllBefore38CallBase):
+    """Function reference ctypes.CDLL"""
+
+    kind = "EXPRESSION_CTYPES_CDLL_BEFORE38_CALL"
+
+    def replaceWithCompileTimeValue(self, trace_collection):
+        # TODO: Locate DLLs and report to freezer
+        trace_collection.onExceptionRaiseExit(BaseException)
+
+        return self, None, None
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.