Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/nodes/FutureSpecs.py

@@ -0,0 +1,224 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Specification record for future flags.
+
+A source reference also implies a specific set of future flags in use by the
+parser at that location. Can be different inside a module due to e.g. the
+in-lining of "exec" statements with their own future imports, or in-lining of
+code from other modules.
+"""
+
+from nuitka.containers.OrderedDicts import OrderedDict
+from nuitka.containers.OrderedSets import OrderedSet
+from nuitka.PythonVersions import python_version
+from nuitka.utils.InstanceCounters import (
+    counted_del,
+    counted_init,
+    isCountingInstances,
+)
+
+# These defaults have changed with Python versions.
+_future_division_default = python_version >= 0x300
+_future_absolute_import_default = python_version >= 0x300
+_future_generator_stop_default = python_version >= 0x370
+_future_annotations_default = python_version >= 0x400
+
+
+class FutureSpec(object):
+    # We are using a bunch of flags here, Python decides them and then we add
+    # even more modes ourselves, pylint: disable=too-many-instance-attributes
+
+    __slots__ = (
+        "future_division",
+        "unicode_literals",
+        "absolute_import",
+        "future_print",
+        "barry_bdfl",  # spell-checker: ignore bdfl
+        "generator_stop",
+        "future_annotations",
+        "use_annotations",
+    )
+
+    @counted_init
+    def __init__(self, use_annotations):
+        self.future_division = _future_division_default
+        self.unicode_literals = False
+        self.absolute_import = _future_absolute_import_default
+        self.future_print = False
+        self.barry_bdfl = False
+        self.generator_stop = _future_generator_stop_default
+        self.future_annotations = _future_annotations_default
+
+        # Attaching our special modes here still.
+        self.use_annotations = use_annotations
+
+    if isCountingInstances():
+        __del__ = counted_del()
+
+    def __repr__(self):
+        return "<FutureSpec %s>" % ",".join(self.asFlags())
+
+    def clone(self):
+        result = FutureSpec(use_annotations=self.use_annotations)
+
+        result.future_division = self.future_division
+        result.unicode_literals = self.unicode_literals
+        result.absolute_import = self.absolute_import
+        result.future_print = self.future_print
+        result.barry_bdfl = self.barry_bdfl
+        result.generator_stop = self.generator_stop
+        result.future_annotations = result.future_annotations
+
+        return result
+
+    def isFutureDivision(self):
+        return self.future_division
+
+    def enableFutureDivision(self):
+        self.future_division = True
+
+    def isFuturePrint(self):
+        return self.future_print
+
+    def enableFuturePrint(self):
+        self.future_print = True
+
+    def enableUnicodeLiterals(self):
+        self.unicode_literals = True
+
+    def enableAbsoluteImport(self):
+        self.absolute_import = True
+
+    def enableBarry(self):
+        self.barry_bdfl = True
+
+    def enableGeneratorStop(self):
+        self.generator_stop = True
+
+    def isAbsoluteImport(self):
+        return self.absolute_import
+
+    def isGeneratorStop(self):
+        return self.generator_stop
+
+    def enableFutureAnnotations(self):
+        self.future_annotations = True
+
+    def shallUseAnnotations(self):
+        return self.use_annotations
+
+    def isFutureAnnotations(self):
+        return self.future_annotations
+
+    def asFlags(self):
+        """Create a list of C identifiers to represent the flag values.
+
+        This is for use in code generation and to restore from
+        saved modules.
+        """
+
+        result = []
+
+        if python_version < 0x300 and self.future_division:
+            result.append("CO_FUTURE_DIVISION")
+
+        if self.unicode_literals:
+            result.append("CO_FUTURE_UNICODE_LITERALS")
+
+        if python_version < 0x300 and self.absolute_import:
+            result.append("CO_FUTURE_ABSOLUTE_IMPORT")
+
+        if python_version < 0x300 and self.future_print:
+            result.append("CO_FUTURE_PRINT_FUNCTION")
+
+        if python_version >= 0x300 and self.barry_bdfl:
+            result.append("CO_FUTURE_BARRY_AS_BDFL")
+
+        if 0x350 <= python_version < 0x370 and self.generator_stop:
+            result.append("CO_FUTURE_GENERATOR_STOP")
+
+        if python_version >= 0x370 and self.future_annotations:
+            result.append("CO_FUTURE_ANNOTATIONS")
+
+        return tuple(result)
+
+    def encode(self):
+        # TODO: Maybe asFlags becomes unnecessary.
+        return _encodeFlags(self.asFlags())
+
+
+def fromFlags(flags):
+    flags = flags.split(",")
+    if "" in flags:
+        flags.remove("")
+
+    # TODO: For persistence, that's not very good, but it's actually only using
+    # our "no_annotations" flag during building phase, which is completed here,
+    # but we might have to add it in the future to XML differently.
+    result = FutureSpec(use_annotations=False)
+
+    if "CO_FUTURE_DIVISION" in flags:
+        result.enableFutureDivision()
+
+    if "CO_FUTURE_UNICODE_LITERALS" in flags:
+        result.enableUnicodeLiterals()
+
+    if "CO_FUTURE_ABSOLUTE_IMPORT" in flags:
+        result.enableAbsoluteImport()
+
+    if "CO_FUTURE_PRINT_FUNCTION" in flags:
+        result.enableFuturePrint()
+
+    if "CO_FUTURE_BARRY_AS_BDFL" in flags:
+        result.enableBarry()
+
+    if "CO_FUTURE_GENERATOR_STOP" in flags:
+        result.enableGeneratorStop()
+
+    # Check if we are going to give similar results than what we got.
+    assert tuple(result.asFlags()) == tuple(flags), (result, result.asFlags(), flags)
+
+    return result
+
+
+# Relevance of future flags.
+_future_version_specific_flags = OrderedDict(
+    (
+        ("CO_FUTURE_DIVISION", python_version < 0x300),
+        ("CO_FUTURE_UNICODE_LITERALS", True),
+        ("CO_FUTURE_PRINT_FUNCTION", python_version < 0x300),
+        ("CO_FUTURE_ABSOLUTE_IMPORT", python_version < 0x300),
+        ("CO_FUTURE_GENERATOR_STOP", 0x350 <= python_version < 0x370),
+        ("CO_FUTURE_ANNOTATIONS", python_version >= 0x370),
+        ("CO_FUTURE_BARRY_AS_BDFL", python_version >= 0x300),
+    )
+)
+
+_future_version_specific_flags = OrderedSet(
+    key for (key, value) in _future_version_specific_flags.items() if value
+)
+
+
+def _encodeFlags(flags):
+    result = 0
+    for bit, flag in enumerate(_future_version_specific_flags):
+        if flag in flags:
+            result |= 1 << bit
+    return result
+
+
+#     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/GeneratorNodes.py

@@ -0,0 +1,201 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Nodes for generator objects and their creations.
+
+Generators are turned into normal functions that create generator objects,
+whose implementation lives here. The creation itself also lives here.
+
+"""
+
+from nuitka.PythonVersions import python_version
+
+from .ChildrenHavingMixins import ChildHavingGeneratorRefMixin
+from .ExpressionBases import ExpressionBase, ExpressionNoSideEffectsMixin
+from .FunctionNodes import ExpressionFunctionEntryPointBase
+from .IndicatorMixins import MarkUnoptimizedFunctionIndicatorMixin
+from .ReturnNodes import StatementReturn, StatementReturnNone
+
+
+class ExpressionMakeGeneratorObject(
+    ExpressionNoSideEffectsMixin, ChildHavingGeneratorRefMixin, ExpressionBase
+):
+    kind = "EXPRESSION_MAKE_GENERATOR_OBJECT"
+
+    named_children = ("generator_ref",)
+
+    __slots__ = ("variable_closure_traces",)
+
+    def __init__(self, generator_ref, source_ref):
+        assert (
+            generator_ref.getFunctionBody().isExpressionGeneratorObjectBody()
+        ), generator_ref
+
+        ChildHavingGeneratorRefMixin.__init__(self, generator_ref=generator_ref)
+
+        ExpressionBase.__init__(self, source_ref)
+
+        self.variable_closure_traces = None
+
+    def getCodeObject(self):
+        return self.code_object
+
+    def computeExpression(self, trace_collection):
+        self.variable_closure_traces = []
+
+        for (
+            closure_variable
+        ) in self.subnode_generator_ref.getFunctionBody().getClosureVariables():
+            trace = trace_collection.getVariableCurrentTrace(closure_variable)
+            trace.addNameUsage()
+
+            self.variable_closure_traces.append((closure_variable, trace))
+
+        # TODO: Generator body may know something too.
+        return self, None, None
+
+    def getClosureVariableVersions(self):
+        return self.variable_closure_traces
+
+
+class ExpressionGeneratorObjectBody(
+    MarkUnoptimizedFunctionIndicatorMixin, ExpressionFunctionEntryPointBase
+):
+    kind = "EXPRESSION_GENERATOR_OBJECT_BODY"
+
+    __slots__ = (
+        "unoptimized_locals",
+        "unqualified_exec",
+        "needs_generator_return_exit",
+        "qualname_provider",
+    )
+
+    if python_version >= 0x300:
+        __slots__ += ("qualname_setup",)
+
+    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="genexpr" if name == "<genexpr>" else "genobj",
+            flags=flags,
+            auto_release=auto_release,
+            source_ref=source_ref,
+        )
+
+        MarkUnoptimizedFunctionIndicatorMixin.__init__(self, flags)
+
+        self.needs_generator_return_exit = False
+
+        self.trace_collection = None
+
+        if python_version >= 0x300:
+            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
+
+    def getConstantReturnValue(self):
+        """Special function that checks if code generation allows to use common C code."""
+        body = self.subnode_body
+
+        if body is None:
+            return True, None
+
+        return False, False
+
+
+class StatementGeneratorReturn(StatementReturn):
+    kind = "STATEMENT_GENERATOR_RETURN"
+
+    def __init__(self, expression, source_ref):
+        StatementReturn.__init__(self, expression=expression, source_ref=source_ref)
+
+    @staticmethod
+    def isStatementGeneratorReturn():
+        return True
+
+    def computeStatement(self, trace_collection):
+        expression = trace_collection.onExpression(self.subnode_expression)
+
+        if expression.mayRaiseException(BaseException):
+            trace_collection.onExceptionRaiseExit(BaseException)
+
+        if expression.willRaiseAnyException():
+            from .NodeMakingHelpers import (
+                makeStatementExpressionOnlyReplacementNode,
+            )
+
+            result = makeStatementExpressionOnlyReplacementNode(
+                expression=expression, node=self
+            )
+
+            return (
+                result,
+                "new_raise",
+                """\
+Return statement raises in returned expression, removed return.""",
+            )
+
+        trace_collection.onFunctionReturn()
+
+        if expression.isExpressionConstantNoneRef():
+            result = StatementGeneratorReturnNone(source_ref=self.source_ref)
+
+            return (
+                result,
+                "new_statements",
+                """\
+Generator return value is always None.""",
+            )
+
+        return self, None, None
+
+    @staticmethod
+    def getStatementNiceName():
+        return "generator return statement"
+
+
+class StatementGeneratorReturnNone(StatementReturnNone):
+    kind = "STATEMENT_GENERATOR_RETURN_NONE"
+
+    __slots__ = ()
+
+    def __init__(self, source_ref):
+        StatementReturnNone.__init__(self, source_ref=source_ref)
+
+    @staticmethod
+    def isStatementGeneratorReturn():
+        return True
+
+    @staticmethod
+    def getStatementNiceName():
+        return "generator return statement"
+
+
+#     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/GlobalsLocalsNodes.py

@@ -0,0 +1,209 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Globals/locals/single arg dir nodes
+
+These nodes give access to variables, highly problematic, because using them,
+the code may change or access anything about them, so nothing can be trusted
+anymore, if we start to not know where their value goes.
+
+The "dir()" call without arguments is reformulated to locals or globals calls.
+"""
+
+from .DictionaryNodes import makeExpressionMakeDict
+from .ExpressionBases import (
+    ExpressionBase,
+    ExpressionBuiltinSingleArgBase,
+    ExpressionNoSideEffectsMixin,
+)
+from .KeyValuePairNodes import makeKeyValuePairExpressionsFromKwArgs
+from .VariableRefNodes import ExpressionTempVariableRef, ExpressionVariableRef
+
+
+class ExpressionBuiltinGlobals(ExpressionNoSideEffectsMixin, ExpressionBase):
+    kind = "EXPRESSION_BUILTIN_GLOBALS"
+
+    def __init__(self, source_ref):
+        ExpressionBase.__init__(self, source_ref)
+
+    def finalize(self):
+        del self.parent
+
+    def computeExpressionRaw(self, trace_collection):
+        return self, None, None
+
+
+class ExpressionBuiltinLocalsBase(ExpressionNoSideEffectsMixin, ExpressionBase):
+    # Base classes can be abstract, pylint: disable=abstract-method
+
+    __slots__ = ("variable_traces", "locals_scope")
+
+    def __init__(self, locals_scope, source_ref):
+        ExpressionBase.__init__(self, source_ref)
+
+        self.variable_traces = None
+        self.locals_scope = locals_scope
+
+    def finalize(self):
+        del self.locals_scope
+        del self.variable_traces
+
+    def getVariableTraces(self):
+        return self.variable_traces
+
+    def getLocalsScope(self):
+        return self.locals_scope
+
+
+class ExpressionBuiltinLocalsUpdated(ExpressionBuiltinLocalsBase):
+    kind = "EXPRESSION_BUILTIN_LOCALS_UPDATED"
+
+    def __init__(self, locals_scope, source_ref):
+        ExpressionBuiltinLocalsBase.__init__(
+            self, locals_scope=locals_scope, source_ref=source_ref
+        )
+
+        assert locals_scope is not None
+
+    def computeExpressionRaw(self, trace_collection):
+        # Just inform the collection that all escaped.
+        self.variable_traces = trace_collection.onLocalsUsage(self.locals_scope)
+
+        return self, None, None
+
+
+class ExpressionBuiltinLocalsRef(ExpressionBuiltinLocalsBase):
+    kind = "EXPRESSION_BUILTIN_LOCALS_REF"
+
+    def __init__(self, locals_scope, source_ref):
+        ExpressionBuiltinLocalsBase.__init__(
+            self, locals_scope=locals_scope, source_ref=source_ref
+        )
+
+    def getDetails(self):
+        return {"locals_scope": self.locals_scope}
+
+    def getLocalsScope(self):
+        return self.locals_scope
+
+    # For overload.
+    def isFinalUseOfLocals(self):
+        return self.parent.isStatementReturn()
+
+    def computeExpressionRaw(self, trace_collection):
+        if self.locals_scope.isMarkedForPropagation():
+            result = makeExpressionMakeDict(
+                pairs=makeKeyValuePairExpressionsFromKwArgs(
+                    pairs=(
+                        (
+                            variable_name,
+                            ExpressionTempVariableRef(
+                                variable=variable, source_ref=self.source_ref
+                            ),
+                        )
+                        for (
+                            variable_name,
+                            variable,
+                        ) in self.locals_scope.getPropagationVariables().items()
+                    )
+                ),
+                source_ref=self.source_ref,
+            )
+
+            new_result = result.computeExpressionRaw(trace_collection)
+
+            assert new_result[0] is result
+
+            self.finalize()
+
+            return result, "new_expression", "Propagated locals dictionary reference."
+
+        # Just inform the collection that all escaped unless it is aborting or for
+        # a locals dict.
+        if not self.isFinalUseOfLocals():
+            trace_collection.onLocalsUsage(locals_scope=self.locals_scope)
+
+        return self, None, None
+
+
+class ExpressionBuiltinLocalsCopy(ExpressionBuiltinLocalsBase):
+    kind = "EXPRESSION_BUILTIN_LOCALS_COPY"
+
+    def computeExpressionRaw(self, trace_collection):
+        # Just inform the collection that all escaped.
+
+        self.variable_traces = trace_collection.onLocalsUsage(
+            locals_scope=self.locals_scope
+        )
+
+        for variable, variable_trace in self.variable_traces:
+            if (
+                not variable_trace.mustHaveValue()
+                and not variable_trace.mustNotHaveValue()
+            ):
+                return self, None, None
+
+            # Other locals elsewhere.
+            if variable_trace.getNameUsageCount() > 1:
+                return self, None, None
+
+        pairs = makeKeyValuePairExpressionsFromKwArgs(
+            (
+                variable.getName(),
+                ExpressionVariableRef(variable=variable, source_ref=self.source_ref),
+            )
+            for variable, variable_trace in self.variable_traces
+            if variable_trace.mustHaveValue()
+        )
+
+        # Locals is sorted of course.
+        def _sorted(pairs):
+            names = [
+                variable.getName()
+                for variable in self.locals_scope.getProvidedVariables()
+            ]
+
+            return tuple(
+                sorted(
+                    pairs,
+                    key=lambda pair: names.index(pair.getKeyCompileTimeConstant()),
+                )
+            )
+
+        result = makeExpressionMakeDict(
+            pairs=_sorted(pairs), source_ref=self.source_ref
+        )
+
+        return result, "new_expression", "Statically predicted locals dictionary."
+
+
+class ExpressionBuiltinDir1(ExpressionBuiltinSingleArgBase):
+    kind = "EXPRESSION_BUILTIN_DIR1"
+
+    def computeExpression(self, trace_collection):
+        # TODO: Quite some cases should be possible to predict and this
+        # should be using a slot, with "__dir__" being overloaded or not.
+
+        # Any code could be run, note that.
+        trace_collection.onControlFlowEscape(self)
+
+        # Any exception may be raised.
+        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.