Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__cp311-cp311-win_amd64.whl

nuitka/tree/ReformulationClasses3.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Reformulation of Python3 class statements.
 
 Consult the Developer Manual for information. TODO: Add ability to sync
@@ -33,7 +19,8 @@ from nuitka.nodes.BuiltinRefNodes import makeExpressionBuiltinTypeRef
 from nuitka.nodes.BuiltinTypeNodes import ExpressionBuiltinTuple
 from nuitka.nodes.CallNodes import makeExpressionCall
 from nuitka.nodes.ClassNodes import (
-    ExpressionClassBodyP3,
+    ExpressionClassDictBody,
+    ExpressionClassMappingBody,
     ExpressionSelectMetaclass,
 )
 from nuitka.nodes.CodeObjectSpecs import CodeObjectSpec
@@ -52,7 +39,6 @@ from nuitka.nodes.DictionaryNodes import (
     ExpressionDictOperationGet2,
     ExpressionDictOperationIn,
     StatementDictOperationRemove,
-    StatementDictOperationUpdate,
 )
 from nuitka.nodes.ExceptionNodes import (
     ExpressionBuiltinMakeException,
@@ -91,8 +77,8 @@ from nuitka.nodes.VariableRefNodes import (
     ExpressionTempVariableRef,
     ExpressionVariableRef,
 )
-from nuitka.nodes.VariableReleaseNodes import makeStatementsReleaseVariables
 from nuitka.Options import isExperimental
+from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonVersions import python_version
 from nuitka.specs.ParameterSpecs import ParameterSpec
 
@@ -101,12 +87,15 @@ from .InternalModule import (
     makeInternalHelperFunctionBody,
     once_decorator,
 )
+from .ReformulationDictionaryCreation import buildDictionaryUnpacking
 from .ReformulationSequenceCreation import buildTupleUnpacking
 from .ReformulationTryExceptStatements import makeTryExceptSingleHandlerNode
-from .ReformulationTryFinallyStatements import makeTryFinallyStatement
+from .ReformulationTryFinallyStatements import (
+    makeTryFinallyReleaseStatement,
+    makeTryFinallyStatement,
+)
 from .TreeHelpers import (
     buildFrameNode,
-    buildNode,
     buildNodeTuple,
     extractDocFromBody,
     getKind,
@@ -133,27 +122,54 @@ def _buildBasesTupleCreationNode(provider, elements, source_ref):
     )
 
 
+def _selectClassBody(_static_qualname):
+    if isExperimental("force-p2-class"):
+        return ExpressionClassDictBody
+    else:
+        return ExpressionClassMappingBody
+
+
+def _needsOrigBases(_static_qualname):
+    if isExperimental("force-p2-class"):
+        return False
+    elif python_version < 0x370:
+        return False
+    else:
+        return True
+
+
 def buildClassNode3(provider, node, source_ref):
     # Many variables, due to the huge re-formulation that is going on here,
     # which just has the complexity and optimization checks:
-    # pylint: disable=I0021,too-many-branches,too-many-locals,too-many-statements
+    # pylint: disable=too-many-branches,too-many-locals,too-many-statements
 
     # This function is the Python3 special case with special re-formulation as
     # according to Developer Manual.
+
+    # First, allow plugins to modify the code if they want to.
+    Plugins.onClassBodyParsing(provider=provider, class_name=node.name, node=node)
+
     class_statement_nodes, class_doc = extractDocFromBody(node)
 
     # We need a scope for the temporary variables, and they might be closured.
     temp_scope = provider.allocateTempScope(name="class_creation")
 
     tmp_class_decl_dict = provider.allocateTempVariable(
-        temp_scope=temp_scope, name="class_decl_dict"
+        temp_scope=temp_scope, name="class_decl_dict", temp_type="object"
     )
     tmp_metaclass = provider.allocateTempVariable(
-        temp_scope=temp_scope, name="metaclass"
+        temp_scope=temp_scope, name="metaclass", temp_type="object"
+    )
+    tmp_prepared = provider.allocateTempVariable(
+        temp_scope=temp_scope, name="prepared", temp_type="object"
     )
-    tmp_prepared = provider.allocateTempVariable(temp_scope=temp_scope, name="prepared")
 
-    class_creation_function = ExpressionClassBodyP3(
+    # Can be overridden, but for code object creation, we use that.
+    static_qualname = provider.getChildQualname(node.name)
+
+    class_body_class = _selectClassBody(static_qualname)
+
+    class_creation_function = class_body_class(
         provider=provider, name=node.name, doc=class_doc, source_ref=source_ref
     )
 
@@ -174,7 +190,7 @@ def buildClassNode3(provider, node, source_ref):
 
     code_object = CodeObjectSpec(
         co_name=node.name,
-        co_qualname=provider.getChildQualname(node.name),
+        co_qualname=static_qualname,
         co_kind="Class",
         co_varnames=(),
         co_freevars=(),
@@ -255,7 +271,7 @@ def buildClassNode3(provider, node, source_ref):
         )
     )
 
-    if python_version >= 0x340:
+    if python_version >= 0x300:
         qualname_assign = statements[-1]
 
     if python_version >= 0x360 and class_creation_function.needsAnnotationsDictionary():
@@ -272,12 +288,16 @@ def buildClassNode3(provider, node, source_ref):
 
     statements.append(body)
 
+    needs_orig_bases = _needsOrigBases(static_qualname)
+
     if node.bases:
-        tmp_bases = provider.allocateTempVariable(temp_scope=temp_scope, name="bases")
+        tmp_bases = provider.allocateTempVariable(
+            temp_scope=temp_scope, name="bases", temp_type="object"
+        )
 
-        if python_version >= 0x370:
+        if needs_orig_bases:
             tmp_bases_orig = provider.allocateTempVariable(
-                temp_scope=temp_scope, name="bases_orig"
+                temp_scope=temp_scope, name="bases_orig", temp_type="object"
             )
 
         def makeBasesRef():
@@ -288,7 +308,9 @@ def buildClassNode3(provider, node, source_ref):
         def makeBasesRef():
             return makeConstantRefNode(constant=(), source_ref=source_ref)
 
-    if python_version >= 0x370 and node.bases:
+        needs_orig_bases = False
+
+    if node.bases and needs_orig_bases:
         statements.append(
             makeStatementConditional(
                 condition=makeComparisonExpression(
@@ -345,6 +367,7 @@ def buildClassNode3(provider, node, source_ref):
         StatementReturn(expression=class_variable_ref, source_ref=source_ref),
     )
 
+    # TODO: Is this something similar to makeTryFinallyReleaseStatement
     body = makeStatementsSequenceFromStatement(
         statement=makeTryFinallyStatement(
             provider=class_creation_function,
@@ -378,17 +401,12 @@ def buildClassNode3(provider, node, source_ref):
             source_ref=decorator.getSourceReference(),
         )
 
-    if node.keywords and node.keywords[-1].arg is None:
-        keywords = node.keywords[:-1]
-    else:
-        keywords = node.keywords
-
     statements = []
 
     if node.bases:
         statements.append(
             makeStatementAssignmentVariable(
-                variable=tmp_bases if python_version < 0x370 else tmp_bases_orig,
+                variable=tmp_bases_orig if needs_orig_bases else tmp_bases,
                 source=_buildBasesTupleCreationNode(
                     provider=provider, elements=node.bases, source_ref=source_ref
                 ),
@@ -396,7 +414,7 @@ def buildClassNode3(provider, node, source_ref):
             )
         )
 
-        if python_version >= 0x370:
+        if needs_orig_bases:
             bases_conversion = makeExpressionFunctionCall(
                 function=makeExpressionFunctionCreation(
                     function_ref=ExpressionFunctionRef(
@@ -422,32 +440,35 @@ def buildClassNode3(provider, node, source_ref):
                 )
             )
 
+    # TODO: It's not really clear, since when those in the middle keywords are accepted
+    # and not a SyntaxError, and if then we might have to raise it.
+    keyword_keys = tuple(keyword.arg for keyword in node.keywords)
+    keyword_values = tuple(keyword.value for keyword in node.keywords)
+
+    if None in keyword_keys:
+        assert python_version >= 0x350
+
+        make_keywords_dict = buildDictionaryUnpacking(
+            provider,
+            keys=keyword_keys,
+            values=keyword_values,
+            source_ref=source_ref,
+        )
+    else:
+        make_keywords_dict = makeDictCreationOrConstant2(
+            keys=keyword_keys,
+            values=buildNodeTuple(provider, keyword_values, source_ref),
+            source_ref=source_ref,
+        )
+
     statements.append(
         makeStatementAssignmentVariable(
             variable=tmp_class_decl_dict,
-            source=makeDictCreationOrConstant2(
-                keys=[keyword.arg for keyword in keywords],
-                values=[
-                    buildNode(provider, keyword.value, source_ref)
-                    for keyword in keywords
-                ],
-                source_ref=source_ref,
-            ),
+            source=make_keywords_dict,
             source_ref=source_ref,
         )
     )
 
-    if node.keywords and node.keywords[-1].arg is None:
-        statements.append(
-            StatementDictOperationUpdate(
-                dict_arg=ExpressionVariableRef(
-                    variable=tmp_class_decl_dict, source_ref=source_ref
-                ),
-                value=buildNode(provider, node.keywords[-1].value, source_ref),
-                source_ref=source_ref,
-            )
-        )
-
     # Check if there are bases, and if there are, go with the type of the
     # first base class as a metaclass unless it was specified in the class
     # decl dict of course.
@@ -465,7 +486,7 @@ def buildClassNode3(provider, node, source_ref):
 
         # Might become empty behind our back during conversion, therefore make the
         # check at run time for 3.7 or higher.
-        if python_version >= 0x370:
+        if needs_orig_bases:
             unspecified_metaclass_expression = ExpressionConditional(
                 condition=ExpressionTempVariableRef(
                     variable=tmp_bases, source_ref=source_ref
@@ -553,6 +574,17 @@ def buildClassNode3(provider, node, source_ref):
             ),
         )
 
+    if class_body_class is ExpressionClassDictBody:
+        prepare_condition = makeConstantRefNode(constant=False, source_ref=source_ref)
+    else:
+        prepare_condition = ExpressionAttributeCheck(
+            expression=ExpressionTempVariableRef(
+                variable=tmp_metaclass, source_ref=source_ref
+            ),
+            attribute_name="__prepare__",
+            source_ref=source_ref,
+        )
+
     statements += (
         makeStatementAssignmentVariable(
             variable=tmp_metaclass,
@@ -611,13 +643,7 @@ def buildClassNode3(provider, node, source_ref):
             source_ref=source_ref,
         ),
         makeStatementConditional(
-            condition=ExpressionAttributeCheck(
-                expression=ExpressionTempVariableRef(
-                    variable=tmp_metaclass, source_ref=source_ref
-                ),
-                attribute_name="__prepare__",
-                source_ref=source_ref,
-            ),
+            condition=prepare_condition,
             yes_branch=call_prepare,
             no_branch=makeStatementAssignmentVariable(
                 variable=tmp_prepared,
@@ -636,21 +662,19 @@ def buildClassNode3(provider, node, source_ref):
         ),
     )
 
-    if python_version >= 0x340:
+    if python_version >= 0x300:
         class_creation_function.qualname_setup = node.name, qualname_assign
 
     tmp_variables = [tmp_class_decl_dict, tmp_metaclass, tmp_prepared]
     if node.bases:
         tmp_variables.insert(0, tmp_bases)
-        if python_version >= 0x370:
+        if needs_orig_bases:
             tmp_variables.insert(0, tmp_bases_orig)
 
-    return makeTryFinallyStatement(
+    return makeTryFinallyReleaseStatement(
         provider=provider,
         tried=statements,
-        final=makeStatementsReleaseVariables(
-            variables=tmp_variables, source_ref=source_ref
-        ),
+        variables=tmp_variables,
         source_ref=source_ref,
     )
 
@@ -677,9 +701,15 @@ def getClassBasesMroConversionHelper():
 
     temp_scope = None
 
-    tmp_result_variable = result.allocateTempVariable(temp_scope, "list")
-    tmp_iter_variable = result.allocateTempVariable(temp_scope, "iter")
-    tmp_item_variable = result.allocateTempVariable(temp_scope, "base")
+    tmp_result_variable = result.allocateTempVariable(
+        temp_scope, "list", temp_type="object"
+    )
+    tmp_iter_variable = result.allocateTempVariable(
+        temp_scope, "iter", temp_type="object"
+    )
+    tmp_item_variable = result.allocateTempVariable(
+        temp_scope, "base", temp_type="object"
+    )
 
     args_variable = result.getVariableForAssignment(variable_name="bases")
 
@@ -800,17 +830,14 @@ def getClassBasesMroConversionHelper():
 
     result.setChildBody(
         makeStatementsSequenceFromStatement(
-            makeTryFinallyStatement(
+            makeTryFinallyReleaseStatement(
                 provider=result,
                 tried=tried,
-                final=makeStatementsReleaseVariables(
-                    variables=(
-                        args_variable,
-                        tmp_result_variable,
-                        tmp_iter_variable,
-                        tmp_item_variable,
-                    ),
-                    source_ref=internal_source_ref,
+                variables=(
+                    args_variable,
+                    tmp_result_variable,
+                    tmp_iter_variable,
+                    tmp_item_variable,
                 ),
                 source_ref=internal_source_ref,
             )
@@ -891,10 +918,18 @@ def getClassSelectMetaClassHelper():
 
     temp_scope = None
 
-    tmp_winner_variable = result.allocateTempVariable(temp_scope, "winner")
-    tmp_iter_variable = result.allocateTempVariable(temp_scope, "iter")
-    tmp_item_variable = result.allocateTempVariable(temp_scope, "base")
-    tmp_item_type_variable = result.allocateTempVariable(temp_scope, "base_type")
+    tmp_winner_variable = result.allocateTempVariable(
+        temp_scope, "winner", temp_type="object"
+    )
+    tmp_iter_variable = result.allocateTempVariable(
+        temp_scope, "iter", temp_type="object"
+    )
+    tmp_item_variable = result.allocateTempVariable(
+        temp_scope, "base", temp_type="object"
+    )
+    tmp_item_type_variable = result.allocateTempVariable(
+        temp_scope, "base_type", temp_type="object"
+    )
 
     # For non-types, the metaclass cannot be overruled by bases.
     non_type_case = StatementReturn(
@@ -1006,17 +1041,14 @@ def getClassSelectMetaClassHelper():
 
     result.setChildBody(
         makeStatementsSequenceFromStatement(
-            makeTryFinallyStatement(
+            makeTryFinallyReleaseStatement(
                 provider=result,
                 tried=tried,
-                final=makeStatementsReleaseVariables(
-                    variables=(
-                        tmp_winner_variable,
-                        tmp_iter_variable,
-                        tmp_item_variable,
-                        tmp_item_type_variable,
-                    ),
-                    source_ref=internal_source_ref,
+                variables=(
+                    tmp_winner_variable,
+                    tmp_iter_variable,
+                    tmp_item_variable,
+                    tmp_item_type_variable,
                 ),
                 source_ref=internal_source_ref,
             )
@@ -1024,3 +1056,19 @@ def getClassSelectMetaClassHelper():
     )
 
     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/tree/ReformulationComparisonExpressions.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     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.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Reformulation of comparison chain expressions.
 
 Consult the Developer Manual for information. TODO: Add ability to sync
@@ -29,9 +15,8 @@ from nuitka.nodes.OutlineNodes import ExpressionOutlineBody
 from nuitka.nodes.ReturnNodes import StatementReturn
 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,
     getKind,
@@ -82,12 +67,14 @@ def buildComplexComparisonNode(provider, left, rights, comparators, source_ref):
     )
 
     variables = [
-        outline_body.allocateTempVariable(temp_scope=None, name="operand_%d" % count)
+        outline_body.allocateTempVariable(
+            temp_scope=None, name="operand_%d" % count, temp_type="object"
+        )
         for count in range(2, len(rights) + 2)
     ]
 
     tmp_variable = outline_body.allocateTempVariable(
-        temp_scope=None, name="comparison_result"
+        temp_scope=None, name="comparison_result", temp_type="object"
     )
 
     def makeTempAssignment(count, value):
@@ -95,11 +82,6 @@ def buildComplexComparisonNode(provider, left, rights, comparators, source_ref):
             variable=variables[count], source=value, source_ref=source_ref
         )
 
-    def makeReleaseStatement(count):
-        return makeStatementReleaseVariable(
-            variable=variables[count], source_ref=source_ref
-        )
-
     def makeValueComparisonReturn(left, right, comparator):
         yield makeStatementAssignmentVariable(
             variable=tmp_variable,
@@ -127,12 +109,12 @@ def buildComplexComparisonNode(provider, left, rights, comparators, source_ref):
         )
 
     statements = []
-    final = []
+    release_variables = []
 
     for count, value in enumerate(rights):
         if value is not rights[-1]:
             statements.append(makeTempAssignment(count, value))
-            final.append(makeReleaseStatement(count))
+            release_variables.append(variables[count])
             right = ExpressionTempVariableRef(
                 variable=variables[count], source_ref=source_ref
             )
@@ -160,21 +142,33 @@ def buildComplexComparisonNode(provider, left, rights, comparators, source_ref):
                     source_ref=source_ref,
                 )
             )
-            final.append(
-                makeStatementReleaseVariable(
-                    variable=tmp_variable, source_ref=source_ref
-                )
-            )
+            release_variables.append(tmp_variable)
 
     outline_body.setChildBody(
         makeStatementsSequenceFromStatement(
-            statement=makeTryFinallyStatement(
+            statement=makeTryFinallyReleaseStatement(
                 provider=outline_body,
                 tried=statements,
-                final=final,
+                variables=release_variables,
                 source_ref=source_ref,
             )
         )
     )
 
     return outline_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.