Nuitka-winsvc 2.3.11__cp311-cp311-win_amd64.whl → 2.4.5__cp311-cp311-win_amd64.whl

nuitka/tree/ReformulationFunctionStatements.py

@@ -50,14 +50,16 @@ from nuitka.nodes.VariableRefNodes import (
     ExpressionTempVariableRef,
     ExpressionVariableRef,
 )
-from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
-from nuitka.Options import hasPythonFlagNoAnnotations
 from nuitka.plugins.Plugins import Plugins, hasActivePlugin
 from nuitka.PythonVersions import python_version
 from nuitka.specs.ParameterSpecs import ParameterSpec
 
 from .ReformulationExecStatements import wrapEvalGlobalsAndLocals
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationImportStatements import getFutureSpec
+from .ReformulationTryFinallyStatements import (
+    makeTryFinallyReleaseStatement,
+    makeTryFinallyStatement,
+)
 from .SyntaxErrors import raiseSyntaxError
 from .TreeHelpers import (
     buildAnnotationNode,
@@ -391,7 +393,7 @@ def buildFunctionNode(provider, node, source_ref):
         source_ref=source_ref,
     )
 
-    if python_version >= 0x340:
+    if python_version >= 0x300:
         function_body.qualname_setup = result.getVariableName()
 
     return result
@@ -580,21 +582,15 @@ def buildParameterAnnotations(provider, node, source_ref):
     # spell-checker: ignore kwargannotation
 
     # Build annotations. We are hiding here, that it is a Python3 only feature.
-    if python_version < 0x300 or hasPythonFlagNoAnnotations():
+    if not getFutureSpec().use_annotations:
         return None
 
-    # Starting with Python 3.4, the names of parameters are mangled in
-    # annotations as well.
-    if python_version < 0x340:
-        mangle = lambda variable_name: variable_name
-    else:
-        mangle = lambda variable_name: mangleName(variable_name, provider)
-
     keys = []
     values = []
 
+    # The names of parameters are mangled in annotations as well.
     def addAnnotation(key, value):
-        keys.append(mangle(key))
+        keys.append(mangleName(key, provider))
         values.append(value)
 
     def extractArgAnnotation(arg):
@@ -760,20 +756,16 @@ def _wrapFunctionWithSpecialNestedArgs(
 
     outer_body.setChildBody(
         makeStatementsSequenceFromStatement(
-            statement=makeTryFinallyStatement(
+            statement=makeTryFinallyReleaseStatement(
                 provider=outer_body,
                 tried=statements,
-                final=[
-                    makeStatementReleaseVariable(
-                        variable=variable, source_ref=source_ref
-                    )
-                    for variable in sorted(
+                variables=tuple(
+                    sorted(
                         outer_body.getTempVariables(),
                         key=lambda variable: variable.getName(),
                     )
-                ],
+                ),
                 source_ref=source_ref,
-                public_exc=False,
             )
         )
     )
@@ -895,7 +887,7 @@ def buildFunctionWithParsing(
 def addFunctionVariableReleases(function):
     assert function.isExpressionFunctionBodyBase()
 
-    releases = []
+    release_variables = []
 
     # We attach everything to the function definition source location.
     source_ref = function.getSourceReference()
@@ -905,18 +897,19 @@ def addFunctionVariableReleases(function):
         if variable.getOwner() is not function:
             continue
 
-        releases.append(
-            makeStatementReleaseVariable(variable=variable, source_ref=source_ref)
-        )
+        release_variables.append(variable)
 
-    if releases:
+    if release_variables:
         body = function.subnode_body
 
         if body.isStatementsFrame():
             body = makeStatementsSequenceFromStatement(statement=body)
 
-        body = makeTryFinallyStatement(
-            provider=function, tried=body, final=releases, source_ref=source_ref
+        body = makeTryFinallyReleaseStatement(
+            provider=function,
+            tried=body,
+            variables=release_variables,
+            source_ref=source_ref,
         )
 
         function.setChildBody(makeStatementsSequenceFromStatement(statement=body))

nuitka/tree/ReformulationImportStatements.py

@@ -25,11 +25,11 @@ from nuitka.nodes.StatementNodes import StatementsSequence
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
 from nuitka.nodes.VariableNameNodes import StatementAssignmentVariableName
 from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
-from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
+from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonVersions import python_version
 from nuitka.utils.ModuleNames import ModuleName
 
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import makeTryFinallyReleaseStatement
 from .SyntaxErrors import raiseSyntaxError
 from .TreeHelpers import makeStatementsSequenceOrStatement, mangleName
 
@@ -77,8 +77,10 @@ from __future__ imports must occur at the beginning of the file""",
 _future_specs = []
 
 
-def pushFutureSpec():
-    _future_specs.append(FutureSpec())
+def pushFutureSpec(module_name):
+    _future_specs.append(
+        FutureSpec(use_annotations=Plugins.decideAnnotations(module_name))
+    )
 
 
 def getFutureSpec():
@@ -272,14 +274,10 @@ def buildImportFromNode(provider, node, source_ref):
         # Release the temporary module value as well.
         if multi_names:
             statements.append(
-                makeTryFinallyStatement(
+                makeTryFinallyReleaseStatement(
                     provider=provider,
                     tried=import_statements,
-                    final=(
-                        makeStatementReleaseVariable(
-                            variable=tmp_import_from, source_ref=source_ref
-                        ),
-                    ),
+                    variables=(tmp_import_from,),
                     source_ref=source_ref,
                 )
             )

nuitka/tree/ReformulationLambdaExpressions.py

@@ -27,7 +27,6 @@ from nuitka.nodes.ReturnNodes import StatementReturn
 from nuitka.nodes.StatementNodes import StatementExpressionOnly
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
 from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
-from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
 from nuitka.nodes.YieldNodes import ExpressionYield
 from nuitka.PythonVersions import python_version
 
@@ -36,7 +35,7 @@ from .ReformulationFunctionStatements import (
     buildParameterAnnotations,
     buildParameterKwDefaults,
 )
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import makeTryFinallyReleaseStatement
 from .TreeHelpers import (
     buildNode,
     buildNodeTuple,
@@ -130,12 +129,10 @@ def buildLambdaNode(provider, node, source_ref):
                     source_ref=source_ref,
                 ),
             )
-            body = makeTryFinallyStatement(
+            body = makeTryFinallyReleaseStatement(
                 provider=provider,
                 tried=statements,
-                final=makeStatementReleaseVariable(
-                    variable=tmp_return_value, source_ref=source_ref
-                ),
+                variables=(tmp_return_value,),
                 source_ref=source_ref,
             )
         else:

nuitka/tree/ReformulationMatchStatements.py

@@ -10,18 +10,19 @@ source code comments with Developer Manual sections.
 
 import ast
 
-from nuitka.nodes.AttributeNodes import (
-    ExpressionAttributeCheck,
-    makeExpressionAttributeLookup,
-)
+from nuitka.nodes.AttributeNodes import ExpressionAttributeCheck
 from nuitka.nodes.BuiltinDictNodes import ExpressionBuiltinDict
 from nuitka.nodes.BuiltinLenNodes import ExpressionBuiltinLen
 from nuitka.nodes.BuiltinTypeNodes import ExpressionBuiltinList
-from nuitka.nodes.ComparisonNodes import makeComparisonExpression
+from nuitka.nodes.ComparisonNodes import (
+    ExpressionComparisonIs,
+    makeComparisonExpression,
+)
 from nuitka.nodes.ConditionalNodes import makeStatementConditional
 from nuitka.nodes.ConstantRefNodes import makeConstantRefNode
 from nuitka.nodes.DictionaryNodes import StatementDictOperationRemove
 from nuitka.nodes.MatchNodes import ExpressionMatchArgs
+from nuitka.nodes.OperatorNodes import ExpressionOperationBinarySub
 from nuitka.nodes.OutlineNodes import ExpressionOutlineBody
 from nuitka.nodes.ReturnNodes import makeStatementReturnConstant
 from nuitka.nodes.SubscriptNodes import (
@@ -42,7 +43,7 @@ from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
 from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
 
 from .ReformulationBooleanExpressions import makeAndNode, makeOrNode
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import makeTryFinallyReleaseStatement
 from .TreeHelpers import (
     buildNode,
     buildStatementsNode,
@@ -176,16 +177,23 @@ def _buildMatchSequence(provider, pattern, make_against, source_ref):
 
     star_pos = None
 
-    count = seq_pattern = None
-
-    for count, seq_pattern in enumerate(pattern.patterns):
-        # offset from the start.
+    def makeOffsetNode(count):
         if star_pos is None:
-            offset = count
+            return makeConstantRefNode(constant=count, source_ref=source_ref)
         else:
-            # offset from the end.
-            offset = -(len(pattern.patterns) - count)
+            return ExpressionOperationBinarySub(
+                ExpressionBuiltinLen(
+                    value=make_against(),
+                    source_ref=source_ref,
+                ),
+                makeConstantRefNode(
+                    constant=len(pattern.patterns) - count,
+                    source_ref=source_ref,
+                ),
+                source_ref=source_ref,
+            )
 
+    for count, seq_pattern in enumerate(pattern.patterns):
         if seq_pattern.__class__ is ast.MatchStar:
             star_pos = count
 
@@ -225,9 +233,7 @@ def _buildMatchSequence(provider, pattern, make_against, source_ref):
                 # It's called before return, pylint: disable=cell-var-from-loop
                 make_against=lambda: ExpressionSubscriptLookup(
                     expression=make_against(),
-                    subscript=makeConstantRefNode(
-                        constant=offset, source_ref=source_ref
-                    ),
+                    subscript=makeOffsetNode(count),
                     source_ref=source_ref,
                 ),
                 source_ref=source_ref,
@@ -318,41 +324,45 @@ def _buildMatchMapping(provider, pattern, make_against, source_ref):
 
 
 def _buildMatchClass(provider, pattern, make_against, source_ref):
-    cls_node = buildNode(provider, pattern.cls, source_ref)
+    # Slightly complicated, due to using an outline body and there is also
+    # keyword and positional arguments to deal with, pylint: disable=too-many-locals
 
-    assignments = []
-
-    conditions = [
-        ExpressionBuiltinIsinstance(
-            instance=make_against(),
-            classes=cls_node,
-            source_ref=source_ref,
-        )
-    ]
+    cls_node = buildNode(provider, pattern.cls, source_ref)
 
-    assert not (pattern.patterns and pattern.kwd_patterns), (
-        source_ref,
-        ast.dump(pattern),
-    )
     assert len(pattern.kwd_attrs) == len(pattern.kwd_patterns), (
         source_ref,
         ast.dump(pattern),
     )
 
-    for count, pos_pattern in enumerate(pattern.patterns):
-        # TODO: Not reusing Match args, is very wasteful for performance, but
-        # temporary variable handling is a bit of a problem in this so far,
-        # we should create an outline function for it, but match value args
-        # ought to be global probably, so they can be shared.
+    if len(pattern.kwd_attrs) + len(pattern.patterns) == 0:
+        conditions = [
+            ExpressionBuiltinIsinstance(
+                instance=make_against(),
+                classes=cls_node,
+                source_ref=source_ref,
+            )
+        ]
+        assignments = None
+
+        return conditions, assignments
+
+    class_conditions_list = []
+    class_assignments_list = []
 
+    outline_body = ExpressionOutlineBody(
+        provider=provider, name="match_class", source_ref=source_ref
+    )
+    tmp_match_args = outline_body.allocateTempVariable(
+        temp_scope=None, name="match_args", temp_type="PyObject *"
+    )
+
+    for count, pos_pattern in enumerate(pattern.patterns):
         # It's called before return, pylint: disable=cell-var-from-loop
         item_conditions, item_assignments = _buildMatch(
             provider=provider,
             make_against=lambda: ExpressionSubscriptLookup(
-                expression=ExpressionMatchArgs(
-                    expression=make_against(),
-                    max_allowed=len(pattern.patterns),
-                    source_ref=source_ref,
+                expression=ExpressionTempVariableRef(
+                    variable=tmp_match_args, source_ref=source_ref
                 ),
                 subscript=makeConstantRefNode(constant=count, source_ref=source_ref),
                 source_ref=source_ref,
@@ -361,38 +371,136 @@ def _buildMatchClass(provider, pattern, make_against, source_ref):
             source_ref=source_ref,
         )
 
-        if item_conditions:
-            conditions.extend(item_conditions)
+        class_conditions_list.append(item_conditions)
+        class_assignments_list.append(item_assignments)
 
-        if item_assignments:
-            assignments.extend(item_assignments)
+    for count, (key, kwd_pattern) in enumerate(
+        zip(pattern.kwd_attrs, pattern.kwd_patterns)
+    ):
+        # It's called before return, pylint: disable=cell-var-from-loop
+        item_conditions, item_assignments = _buildMatch(
+            provider=provider,
+            make_against=lambda: ExpressionSubscriptLookup(
+                expression=ExpressionTempVariableRef(
+                    variable=tmp_match_args, source_ref=source_ref
+                ),
+                subscript=makeConstantRefNode(
+                    constant=count + len(pattern.patterns), source_ref=source_ref
+                ),
+                source_ref=source_ref,
+            ),
+            pattern=kwd_pattern,
+            source_ref=source_ref,
+        )
 
-    for key, kwd_pattern in zip(pattern.kwd_attrs, pattern.kwd_patterns):
-        conditions.append(
+        item_conditions = item_conditions or []
+
+        item_conditions.insert(
+            0,
             ExpressionAttributeCheck(
                 expression=make_against(),
                 attribute_name=key,
                 source_ref=source_ref,
+            ),
+        )
+
+        class_conditions_list.append(item_conditions)
+        class_assignments_list.append(item_assignments)
+
+    statements = []
+
+    for count, (class_conditions, class_assignments) in enumerate(
+        zip(class_conditions_list, class_assignments_list)
+    ):
+        class_assignments = class_assignments or ()
+
+        if class_conditions:
+            class_conditions = makeAndNode(
+                values=class_conditions, source_ref=source_ref
+            )
+        else:
+            class_conditions = makeConstantRefNode(constant=True, source_ref=source_ref)
+
+        if count == len(class_assignments_list) - 1:
+            class_assignments = list(class_assignments or ())
+            class_assignments.append(
+                makeStatementReturnConstant(constant=True, source_ref=source_ref)
+            )
+
+        statements.append(
+            makeStatementConditional(
+                condition=class_conditions,
+                yes_branch=makeStatementsSequence(
+                    statements=class_assignments,
+                    allow_none=False,
+                    source_ref=source_ref,
+                ),
+                no_branch=makeStatementReturnConstant(
+                    constant=False, source_ref=source_ref
+                ),
+                source_ref=source_ref,
             )
         )
 
-        # It's called before return, pylint: disable=cell-var-from-loop
-        item_conditions, item_assignments = _buildMatch(
-            provider=provider,
-            make_against=lambda: makeExpressionAttributeLookup(
+    assert statements
+
+    statements = [
+        makeStatementAssignmentVariable(
+            variable=tmp_match_args,
+            source=ExpressionMatchArgs(
                 expression=make_against(),
-                attribute_name=key,
+                # TODO: Maybe use a temp variable instead for caching.
+                match_type=cls_node.makeClone(),
+                max_allowed=len(pattern.patterns),
+                keywords=pattern.kwd_attrs,
                 source_ref=source_ref,
             ),
-            pattern=kwd_pattern,
             source_ref=source_ref,
-        )
+        ),
+        makeStatementConditional(
+            condition=ExpressionComparisonIs(
+                ExpressionTempVariableRef(
+                    variable=tmp_match_args, source_ref=source_ref
+                ),
+                makeConstantRefNode(constant=None, source_ref=source_ref),
+                source_ref=source_ref,
+            ),
+            yes_branch=makeStatementsSequence(
+                statements=(
+                    makeStatementReleaseVariable(
+                        variable=tmp_match_args, source_ref=source_ref
+                    ),
+                    makeStatementReturnConstant(constant=False, source_ref=source_ref),
+                ),
+                allow_none=False,
+                source_ref=source_ref,
+            ),
+            no_branch=None,
+            source_ref=source_ref,
+        ),
+        makeTryFinallyReleaseStatement(
+            provider=provider,
+            tried=statements,
+            variables=(tmp_match_args,),
+            source_ref=source_ref,
+        ),
+    ]
 
-        if item_conditions:
-            conditions.extend(item_conditions)
+    body = makeStatementsSequence(
+        statements=statements, allow_none=False, source_ref=source_ref
+    )
 
-        if item_assignments:
-            assignments.extend(item_assignments)
+    outline_body.setChildBody(body)
+
+    conditions = [
+        ExpressionBuiltinIsinstance(
+            instance=make_against(),
+            classes=cls_node,
+            source_ref=source_ref,
+        ),
+        outline_body,
+    ]
+    assignments = None
 
     return conditions, assignments
 
@@ -659,12 +767,10 @@ def buildMatchNode(provider, node, source_ref):
                 source=subject_node,
                 source_ref=subject_node.getSourceReference(),
             ),
-            makeTryFinallyStatement(
+            makeTryFinallyReleaseStatement(
                 provider=provider,
                 tried=case_statements,
-                final=makeStatementReleaseVariable(
-                    variable=tmp_indicator_variable, source_ref=source_ref
-                ),
+                variables=(tmp_indicator_variable,),
                 source_ref=source_ref,
             ),
         ),

nuitka/tree/ReformulationMultidist.py

@@ -18,7 +18,9 @@ def _stripPythonSuffix(filename):
         return filename
 
 
-def createMultidistMainSourceCode(main_filenames):
+def createMultidistMainSourceCode():
+    main_filenames = getMainEntryPointFilenames()
+
     main_basenames = [
         _stripPythonSuffix(os.path.basename(main_filename))
         for main_filename in main_filenames

nuitka/tree/ReformulationNamespacePackages.py

@@ -185,7 +185,7 @@ def createNamespacePackage(module_name, reason, is_top, source_ref):
         reason=reason,
         is_top=is_top,
         mode="compiled",
-        future_spec=FutureSpec(),
+        future_spec=FutureSpec(use_annotations=False),
         source_ref=source_ref,
     )
 

nuitka/tree/ReformulationPrintStatements.py

@@ -15,9 +15,8 @@ from nuitka.nodes.ImportNodes import makeExpressionImportModuleNameHard
 from nuitka.nodes.PrintNodes import StatementPrintNewline, StatementPrintValue
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
 from nuitka.nodes.VariableRefNodes import ExpressionTempVariableRef
-from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
 
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import makeTryFinallyReleaseStatement
 from .TreeHelpers import (
     buildNode,
     buildNodeTuple,
@@ -93,12 +92,10 @@ def buildPrintNode(provider, node, source_ref):
             )
 
         statements.append(
-            makeTryFinallyStatement(
+            makeTryFinallyReleaseStatement(
                 provider=provider,
                 tried=print_statements,
-                final=makeStatementReleaseVariable(
-                    variable=tmp_target_variable, source_ref=source_ref
-                ),
+                variables=(tmp_target_variable,),
                 source_ref=source_ref,
             )
         )

nuitka/tree/ReformulationSequenceCreation.py

@@ -42,7 +42,6 @@ from nuitka.nodes.VariableRefNodes import (
     ExpressionTempVariableRef,
     ExpressionVariableRef,
 )
-from nuitka.nodes.VariableReleaseNodes import makeStatementReleaseVariable
 from nuitka.PythonVersions import python_version
 from nuitka.specs.ParameterSpecs import ParameterSpec
 
@@ -53,7 +52,7 @@ from .InternalModule import (
     once_decorator,
 )
 from .ReformulationTryExceptStatements import makeTryExceptSingleHandlerNode
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import makeTryFinallyReleaseStatement
 from .TreeHelpers import (
     buildNode,
     buildNodeTuple,
@@ -190,16 +189,10 @@ def getListUnpackingHelper():
 
     args_variable = result.getVariableForAssignment(variable_name="args")
 
-    final = (
-        makeStatementReleaseVariable(
-            variable=tmp_result_variable, source_ref=internal_source_ref
-        ),
-        makeStatementReleaseVariable(
-            variable=tmp_iter_variable, source_ref=internal_source_ref
-        ),
-        makeStatementReleaseVariable(
-            variable=tmp_item_variable, source_ref=internal_source_ref
-        ),
+    release_variables = (
+        tmp_result_variable,
+        tmp_iter_variable,
+        tmp_item_variable,
     )
 
     tried = makeStatementsSequenceFromStatements(
@@ -229,10 +222,10 @@ def getListUnpackingHelper():
 
     result.setChildBody(
         makeStatementsSequenceFromStatement(
-            makeTryFinallyStatement(
+            makeTryFinallyReleaseStatement(
                 provider=result,
                 tried=tried,
-                final=final,
+                variables=release_variables,
                 source_ref=internal_source_ref,
             )
         )
@@ -302,16 +295,10 @@ def getSetUnpackingHelper():
 
     args_variable = result.getVariableForAssignment(variable_name="args")
 
-    final = (
-        makeStatementReleaseVariable(
-            variable=tmp_result_variable, source_ref=internal_source_ref
-        ),
-        makeStatementReleaseVariable(
-            variable=tmp_iter_variable, source_ref=internal_source_ref
-        ),
-        makeStatementReleaseVariable(
-            variable=tmp_item_variable, source_ref=internal_source_ref
-        ),
+    release_variables = (
+        tmp_result_variable,
+        tmp_iter_variable,
+        tmp_item_variable,
     )
 
     tried = makeStatementsSequenceFromStatements(
@@ -341,10 +328,10 @@ def getSetUnpackingHelper():
 
     result.setChildBody(
         makeStatementsSequenceFromStatement(
-            makeTryFinallyStatement(
+            makeTryFinallyReleaseStatement(
                 provider=result,
                 tried=tried,
-                final=final,
+                variables=release_variables,
                 source_ref=internal_source_ref,
             )
         )

nuitka/tree/ReformulationTryFinallyStatements.py

@@ -17,6 +17,7 @@ from nuitka.nodes.StatementNodes import (
     StatementsSequence,
 )
 from nuitka.nodes.TryNodes import StatementTry
+from nuitka.nodes.VariableReleaseNodes import makeStatementsReleaseVariables
 from nuitka.PythonVersions import python_version
 
 from .TreeHelpers import (
@@ -52,6 +53,20 @@ def _checkCloning(final, provider):
         compare(f1, f2)
 
 
+def makeTryFinallyReleaseStatement(provider, tried, variables, source_ref):
+    variables = tuple(variables)
+
+    return makeTryFinallyStatement(
+        provider=provider,
+        tried=tried,
+        final=makeStatementsReleaseVariables(
+            variables=variables,
+            source_ref=source_ref,
+        ),
+        source_ref=source_ref,
+    )
+
+
 def makeTryFinallyStatement(provider, tried, final, source_ref, public_exc=False):
     # Complex handling, due to the many variants, pylint: disable=too-many-branches