Nuitka-winsvc 2.7.7__cp313-cp313-win_amd64.whl

nuitka/tree/ReformulationWhileLoopStatements.py

@@ -0,0 +1,160 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Reformulation of while loop statements.
+
+Loops in Nuitka have no condition attached anymore, so while loops are
+re-formulated like this:
+
+.. code-block:: python
+
+    while condition:
+        something()
+
+.. code-block:: python
+
+    while 1:
+        if not condition:
+            break
+
+        something()
+
+This is to totally remove the specialization of loops, with the condition moved
+to the loop body in an initial conditional statement, which contains a ``break``
+statement.
+
+That achieves, that only ``break`` statements exit the loop, and allow for
+optimization to remove always true loop conditions, without concerning code
+generation about it, and to detect such a situation, consider e.g. endless
+loops.
+
+.. note::
+
+   Loop analysis (not yet done) can then work on a reduced problem (which
+   ``break`` statements are executed under what conditions) and is then
+   automatically very general.
+
+   The fact that the loop body may not be entered at all, is still optimized,
+   but also in the general sense. Explicit breaks at the loop start and loop
+   conditions are the same.
+
+"""
+
+from nuitka.nodes.ComparisonNodes import ExpressionComparisonIs
+from nuitka.nodes.ConditionalNodes import makeStatementConditional
+from nuitka.nodes.ConstantRefNodes import makeConstantRefNode
+from nuitka.nodes.LoopNodes import StatementLoop, StatementLoopBreak
+from nuitka.nodes.OperatorNodesUnary import ExpressionOperationNot
+from nuitka.nodes.StatementNodes import StatementsSequence
+from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
+from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
+
+from .TreeHelpers import (
+    buildNode,
+    buildStatementsNode,
+    makeStatementsSequence,
+    makeStatementsSequenceFromStatements,
+    popBuildContext,
+    pushBuildContext,
+)
+
+
+def buildWhileLoopNode(provider, node, source_ref):
+    # The while loop is re-formulated according to Developer Manual. The
+    # condition becomes an early condition to break the loop. The else block is
+    # taken if a while loop exits normally, i.e. because of condition not being
+    # true. We do this by introducing an indicator variable.
+
+    else_block = buildStatementsNode(
+        provider=provider,
+        nodes=node.orelse if node.orelse else None,
+        source_ref=source_ref,
+    )
+
+    if else_block is not None:
+        temp_scope = provider.allocateTempScope("while_loop")
+
+        # Indicator variable, will end up with C bool type, and need not be released.
+        tmp_break_indicator = provider.allocateTempVariable(
+            temp_scope=temp_scope, name="break_indicator", temp_type="bool"
+        )
+
+        statements = (
+            makeStatementAssignmentVariable(
+                variable=tmp_break_indicator,
+                source=makeConstantRefNode(constant=True, source_ref=source_ref),
+                source_ref=source_ref,
+            ),
+            StatementLoopBreak(source_ref=source_ref),
+        )
+    else:
+        statements = (StatementLoopBreak(source_ref=source_ref),)
+
+    pushBuildContext("loop_body")
+    loop_statements = buildStatementsNode(
+        provider=provider, nodes=node.body, source_ref=source_ref
+    )
+    popBuildContext()
+
+    # The loop body contains a conditional statement at the start that breaks
+    # the loop if it fails.
+    loop_body = makeStatementsSequence(
+        statements=(
+            makeStatementConditional(
+                condition=ExpressionOperationNot(
+                    operand=buildNode(provider, node.test, source_ref),
+                    source_ref=source_ref,
+                ),
+                yes_branch=StatementsSequence(
+                    statements=statements, source_ref=source_ref
+                ),
+                no_branch=None,
+                source_ref=source_ref,
+            ),
+            loop_statements,
+        ),
+        allow_none=True,
+        source_ref=source_ref,
+    )
+
+    loop_statement = StatementLoop(loop_body=loop_body, source_ref=source_ref)
+
+    if else_block is None:
+        return loop_statement
+    else:
+        return makeStatementsSequenceFromStatements(
+            makeStatementAssignmentVariable(
+                variable=tmp_break_indicator,
+                source=makeConstantRefNode(constant=False, source_ref=source_ref),
+                source_ref=source_ref,
+            ),
+            loop_statement,
+            makeStatementConditional(
+                condition=ExpressionComparisonIs(
+                    left=ExpressionTempVariableRef(
+                        variable=tmp_break_indicator, source_ref=source_ref
+                    ),
+                    right=makeConstantRefNode(constant=True, source_ref=source_ref),
+                    source_ref=source_ref,
+                ),
+                yes_branch=else_block,
+                no_branch=None,
+                source_ref=source_ref,
+            ),
+        )
+
+
+#     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/tree/ReformulationWithStatements.py

@@ -0,0 +1,382 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Reformulation of with statements.
+
+Consult the Developer Manual for information. TODO: Add ability to sync
+source code comments with Developer Manual sections.
+
+"""
+
+from nuitka import Options
+from nuitka.nodes.AttributeLookupNodes import ExpressionAttributeLookupSpecial
+from nuitka.nodes.AttributeNodes import makeExpressionAttributeLookup
+from nuitka.nodes.CallNodes import (
+    ExpressionCallEmpty,
+    ExpressionCallNoKeywords,
+)
+from nuitka.nodes.ComparisonNodes import ExpressionComparisonIs
+from nuitka.nodes.ConditionalNodes import makeStatementConditional
+from nuitka.nodes.ConstantRefNodes import makeConstantRefNode
+from nuitka.nodes.ContainerMakingNodes import makeExpressionMakeTuple
+from nuitka.nodes.CoroutineNodes import (
+    ExpressionAsyncWaitEnter,
+    ExpressionAsyncWaitExit,
+)
+from nuitka.nodes.ExceptionNodes import (
+    ExpressionCaughtExceptionTracebackRef,
+    ExpressionCaughtExceptionTypeRef,
+    ExpressionCaughtExceptionValueRef,
+)
+from nuitka.nodes.StatementNodes import (
+    StatementExpressionOnly,
+    StatementsSequence,
+)
+from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
+from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
+from nuitka.nodes.YieldNodes import ExpressionYieldFromAwaitable
+from nuitka.PythonVersions import python_version
+
+from .ReformulationAssignmentStatements import buildAssignmentStatements
+from .ReformulationTryExceptStatements import (
+    makeTryExceptSingleHandlerNodeWithPublish,
+)
+from .ReformulationTryFinallyStatements import (
+    makeTryFinallyReleaseStatement,
+    makeTryFinallyStatement,
+)
+from .TreeHelpers import (
+    buildNode,
+    buildStatementsNode,
+    makeReraiseExceptionStatement,
+    makeStatementsSequence,
+)
+
+
+def _buildWithNode(provider, context_expr, assign_target, body, sync, source_ref):
+    # Many details, pylint: disable=too-many-branches,too-many-locals
+    with_source = buildNode(provider, context_expr, source_ref)
+
+    if python_version < 0x380 and Options.is_full_compat:
+        source_ref = with_source.getCompatibleSourceReference()
+
+    temp_scope = provider.allocateTempScope("with")
+
+    tmp_source_variable = provider.allocateTempVariable(
+        temp_scope=temp_scope, name="source", temp_type="object"
+    )
+    tmp_exit_variable = provider.allocateTempVariable(
+        temp_scope=temp_scope, name="exit", temp_type="object"
+    )
+    tmp_enter_variable = provider.allocateTempVariable(
+        temp_scope=temp_scope, name="enter", temp_type="object"
+    )
+
+    # Indicator variable, will end up with C bool type, and need not be released.
+    tmp_indicator_variable = provider.allocateTempVariable(
+        temp_scope=temp_scope, name="indicator", temp_type="bool"
+    )
+
+    statements = (
+        buildAssignmentStatements(
+            provider=provider,
+            node=assign_target,
+            allow_none=True,
+            source=ExpressionTempVariableRef(
+                variable=tmp_enter_variable, source_ref=source_ref
+            ),
+            source_ref=source_ref,
+        ),
+        body,
+    )
+
+    with_body = makeStatementsSequence(
+        statements=statements, allow_none=True, source_ref=source_ref
+    )
+
+    if body and python_version < 0x3A0:
+        deepest = body
+
+        while deepest.getVisitableNodes():
+            deepest = deepest.getVisitableNodes()[-1]
+
+        if python_version < 0x370:
+            body_lineno = deepest.getCompatibleSourceReference().getLineNumber()
+        else:
+            body_lineno = deepest.getSourceReference().getLineNumber()
+
+        with_exit_source_ref = source_ref.atLineNumber(body_lineno)
+    else:
+        with_exit_source_ref = source_ref
+
+    # The "__enter__" and "__exit__" were normal attribute lookups under
+    # CPython2.6, but that changed with CPython2.7.
+    if python_version < 0x270:
+        attribute_lookup_maker = makeExpressionAttributeLookup
+    else:
+        attribute_lookup_maker = ExpressionAttributeLookupSpecial
+
+    enter_value = ExpressionCallEmpty(
+        called=attribute_lookup_maker(
+            expression=ExpressionTempVariableRef(
+                variable=tmp_source_variable, source_ref=source_ref
+            ),
+            attribute_name="__enter__" if sync else "__aenter__",
+            source_ref=source_ref,
+        ),
+        source_ref=source_ref,
+    )
+
+    exit_value_exception = ExpressionCallNoKeywords(
+        called=ExpressionTempVariableRef(
+            variable=tmp_exit_variable, source_ref=with_exit_source_ref
+        ),
+        args=makeExpressionMakeTuple(
+            elements=(
+                ExpressionCaughtExceptionTypeRef(source_ref=with_exit_source_ref),
+                ExpressionCaughtExceptionValueRef(source_ref=with_exit_source_ref),
+                ExpressionCaughtExceptionTracebackRef(source_ref=source_ref),
+            ),
+            source_ref=source_ref,
+        ),
+        source_ref=with_exit_source_ref,
+    )
+
+    exit_value_no_exception = ExpressionCallNoKeywords(
+        called=ExpressionTempVariableRef(
+            variable=tmp_exit_variable, source_ref=source_ref
+        ),
+        args=makeConstantRefNode(constant=(None, None, None), source_ref=source_ref),
+        source_ref=with_exit_source_ref,
+    )
+
+    # For "async with", await the entered value and exit value must be awaited.
+    if not sync:
+        exit_value_exception = ExpressionYieldFromAwaitable(
+            expression=ExpressionAsyncWaitExit(
+                expression=exit_value_exception, source_ref=source_ref
+            ),
+            source_ref=source_ref,
+        )
+        exit_value_no_exception = ExpressionYieldFromAwaitable(
+            ExpressionAsyncWaitExit(
+                expression=exit_value_no_exception, source_ref=source_ref
+            ),
+            source_ref=source_ref,
+        )
+
+    # First assign the with context to a temporary variable.
+    statements = [
+        makeStatementAssignmentVariable(
+            variable=tmp_source_variable, source=with_source, source_ref=source_ref
+        )
+    ]
+
+    # Before 3.9, __aenter__ is immediately awaited, after we first do __aexit__ lookup.
+    if not sync and python_version < 0x390:
+        enter_value = ExpressionYieldFromAwaitable(
+            expression=ExpressionAsyncWaitEnter(
+                expression=enter_value, source_ref=source_ref
+            ),
+            source_ref=source_ref,
+        )
+
+    attribute_enter_assignment = makeStatementAssignmentVariable(
+        variable=tmp_enter_variable, source=enter_value, source_ref=source_ref
+    )
+
+    attribute_exit_assignment = makeStatementAssignmentVariable(
+        variable=tmp_exit_variable,
+        source=attribute_lookup_maker(
+            expression=ExpressionTempVariableRef(
+                variable=tmp_source_variable, source_ref=source_ref
+            ),
+            attribute_name="__exit__" if sync else "__aexit__",
+            source_ref=source_ref,
+        ),
+        source_ref=source_ref,
+    )
+
+    # Next, assign "__enter__" and "__exit__" attributes to temporary variables, and
+    # depending on Python versions switch the order of these lookups and the order of
+    # awaiting enter.
+    # Normal "with" statements are enter, exit ordered after 3.6, and "async with"
+    # are since 3.9, and since 3.9 the enter is not awaited, until an exit is present.
+    if python_version >= 0x390 and not sync:
+        enter_await_statement = makeStatementAssignmentVariable(
+            variable=tmp_enter_variable,
+            source=ExpressionYieldFromAwaitable(
+                expression=ExpressionAsyncWaitEnter(
+                    expression=ExpressionTempVariableRef(
+                        variable=tmp_enter_variable, source_ref=source_ref
+                    ),
+                    source_ref=source_ref,
+                ),
+                source_ref=source_ref,
+            ),
+            source_ref=source_ref,
+        )
+
+        attribute_assignments = (
+            attribute_enter_assignment,
+            attribute_exit_assignment,
+            enter_await_statement,
+        )
+    elif python_version >= 0x360 and sync:
+        attribute_assignments = (attribute_enter_assignment, attribute_exit_assignment)
+    else:
+        attribute_assignments = (attribute_exit_assignment, attribute_enter_assignment)
+
+    statements.extend(attribute_assignments)
+
+    statements.append(
+        makeStatementAssignmentVariable(
+            variable=tmp_indicator_variable,
+            source=makeConstantRefNode(constant=True, source_ref=source_ref),
+            source_ref=source_ref,
+        )
+    )
+
+    statements += (
+        makeTryFinallyStatement(
+            provider=provider,
+            tried=makeTryExceptSingleHandlerNodeWithPublish(
+                provider=provider,
+                tried=with_body,
+                exception_name="BaseException",
+                handler_body=StatementsSequence(
+                    statements=(
+                        # Prevents final block from calling __exit__ as
+                        # well.
+                        makeStatementAssignmentVariable(
+                            variable=tmp_indicator_variable,
+                            source=makeConstantRefNode(
+                                constant=False, source_ref=source_ref
+                            ),
+                            source_ref=source_ref,
+                        ),
+                        makeStatementConditional(
+                            condition=exit_value_exception,
+                            no_branch=makeReraiseExceptionStatement(
+                                source_ref=with_exit_source_ref
+                            ),
+                            yes_branch=None,
+                            source_ref=with_exit_source_ref,
+                        ),
+                    ),
+                    source_ref=source_ref,
+                ),
+                public_exc=python_version >= 0x270,
+                source_ref=source_ref,
+            ),
+            final=makeStatementConditional(
+                condition=ExpressionComparisonIs(
+                    left=ExpressionTempVariableRef(
+                        variable=tmp_indicator_variable, source_ref=source_ref
+                    ),
+                    right=makeConstantRefNode(constant=True, source_ref=source_ref),
+                    source_ref=source_ref,
+                ),
+                yes_branch=StatementExpressionOnly(
+                    expression=exit_value_no_exception, source_ref=source_ref
+                ),
+                no_branch=None,
+                source_ref=source_ref,
+            ),
+            source_ref=source_ref,
+        ),
+    )
+
+    return makeTryFinallyReleaseStatement(
+        provider=provider,
+        tried=statements,
+        variables=(
+            tmp_source_variable,
+            tmp_enter_variable,
+            tmp_exit_variable,
+        ),
+        source_ref=source_ref,
+    )
+
+
+def buildWithNode(provider, node, source_ref):
+    # "with" statements are re-formulated as described in the developer
+    # manual. Catches exceptions, and provides them to "__exit__", while making
+    # the "__enter__" value available under a given name.
+
+    # Before Python3, multiple context managers are not visible in the parse
+    # tree, now we need to handle it ourselves.
+    if hasattr(node, "items"):
+        context_exprs = [item.context_expr for item in node.items]
+        assign_targets = [item.optional_vars for item in node.items]
+    else:
+        # Make it a list for before Python3
+        context_exprs = [node.context_expr]
+        assign_targets = [node.optional_vars]
+
+    # The body for the first context manager is the other things.
+    body = buildStatementsNode(provider, node.body, source_ref)
+
+    assert context_exprs and len(context_exprs) == len(assign_targets)
+
+    context_exprs.reverse()
+    assign_targets.reverse()
+
+    for context_expr, assign_target in zip(context_exprs, assign_targets):
+        body = _buildWithNode(
+            provider=provider,
+            body=body,
+            context_expr=context_expr,
+            assign_target=assign_target,
+            sync=True,
+            source_ref=source_ref,
+        )
+
+    return body
+
+
+def buildAsyncWithNode(provider, node, source_ref):
+    # "with" statements are re-formulated as described in the developer
+    # manual. Catches exceptions, and provides them to "__exit__", while making
+    # the "__enter__" value available under a given name.
+
+    # Before Python3, multiple context managers are not visible in the parse
+    # tree, now we need to handle it ourselves.
+    context_exprs = [item.context_expr for item in node.items]
+    assign_targets = [item.optional_vars for item in node.items]
+
+    # The body for the first context manager is the other things.
+    body = buildStatementsNode(provider, node.body, source_ref)
+
+    assert context_exprs and len(context_exprs) == len(assign_targets)
+
+    context_exprs.reverse()
+    assign_targets.reverse()
+
+    for context_expr, assign_target in zip(context_exprs, assign_targets):
+        body = _buildWithNode(
+            provider=provider,
+            body=body,
+            context_expr=context_expr,
+            assign_target=assign_target,
+            sync=False,
+            source_ref=source_ref,
+        )
+
+    return body
+
+
+#     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/tree/ReformulationYieldExpressions.py

@@ -0,0 +1,133 @@
+#     Copyright 2025, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Reformulation of "yield" and "yield from" expressions.
+
+Consult the Developer Manual for information. TODO: Add ability to sync
+source code comments with Developer Manual sections.
+
+"""
+
+import ast
+
+from nuitka.nodes.ConstantRefNodes import ExpressionConstantNoneRef
+from nuitka.nodes.CoroutineNodes import ExpressionAsyncWait
+from nuitka.nodes.YieldNodes import (
+    ExpressionYield,
+    ExpressionYieldFrom,
+    ExpressionYieldFromAwaitable,
+)
+from nuitka.PythonVersions import python_version
+
+from .SyntaxErrors import raiseSyntaxError
+from .TreeHelpers import buildNode
+
+
+def _getErrorMessageYieldFromOutsideFunction():
+    # Need to use "exec" to detect the syntax error, pylint: disable=W0122
+
+    try:
+        exec("""yield from ()""")
+    except SyntaxError as e:
+        if "yield from" in str(e):
+            return "yield from"
+        else:
+            return "yield"
+
+
+def _checkInsideGenerator(construct_name, provider, node, source_ref):
+
+    if provider.isCompiledPythonModule():
+        # Bug compatibility
+        if construct_name == "yield from":
+            construct_error_name = _getErrorMessageYieldFromOutsideFunction()
+        else:
+            construct_error_name = construct_name
+
+        raiseSyntaxError(
+            "'%s' outside function" % construct_error_name,
+            source_ref.atColumnNumber(node.col_offset),
+        )
+
+    # This yield is forbidden in 3.5, but allowed in 3.6, but "yield from"
+    # is neither.
+    if provider.isExpressionAsyncgenObjectBody() and construct_name == "yield from":
+        raiseSyntaxError(
+            "'%s' inside async function"
+            % ("yield" if node.__class__ is ast.Yield else "yield from",),
+            source_ref.atColumnNumber(node.col_offset),
+        )
+
+    if (
+        python_version >= 0x380
+        and provider.isExpressionGeneratorObjectBody()
+        and provider.name == "<genexpr>"
+        and construct_name != "await"
+    ):
+        raiseSyntaxError(
+            "'%s' inside generator expression"
+            % ("yield" if node.__class__ is ast.Yield else "yield from",),
+            provider.getSourceReference(),
+        )
+
+    while provider.isExpressionOutlineFunction():
+        provider = provider.getParentVariableProvider()
+
+    assert (
+        provider.isExpressionGeneratorObjectBody()
+        or provider.isExpressionAsyncgenObjectBody()
+        or provider.isExpressionCoroutineObjectBody()
+    ), provider
+
+
+def buildYieldNode(provider, node, source_ref):
+    _checkInsideGenerator("yield", provider, node, source_ref)
+
+    if node.value is not None:
+        return ExpressionYield(
+            expression=buildNode(provider, node.value, source_ref),
+            source_ref=source_ref,
+        )
+    else:
+        return ExpressionYield(
+            expression=ExpressionConstantNoneRef(source_ref=source_ref),
+            source_ref=source_ref,
+        )
+
+
+def buildYieldFromNode(provider, node, source_ref):
+    assert python_version >= 0x300
+
+    _checkInsideGenerator("yield from", provider, node, source_ref)
+
+    return ExpressionYieldFrom(
+        expression=buildNode(provider, node.value, source_ref), source_ref=source_ref
+    )
+
+
+def buildAwaitNode(provider, node, source_ref):
+    _checkInsideGenerator("await", provider, node, source_ref)
+
+    return ExpressionYieldFromAwaitable(
+        expression=ExpressionAsyncWait(
+            expression=buildNode(provider, node.value, source_ref),
+            source_ref=source_ref,
+        ),
+        source_ref=source_ref,
+    )
+
+
+#     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.