Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.5.1__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,
@@ -77,6 +63,7 @@ from nuitka.nodes.NodeMakingHelpers import (
     makeRaiseExceptionExpressionFromTemplate,
     mergeStatements,
 )
+from nuitka.nodes.OperatorNodes import makeBinaryOperationNode
 from nuitka.nodes.ReturnNodes import StatementReturn
 from nuitka.nodes.StatementNodes import StatementExpressionOnly
 from nuitka.nodes.SubscriptNodes import makeExpressionIndexLookup
@@ -84,15 +71,19 @@ from nuitka.nodes.TypeNodes import (
     ExpressionBuiltinType1,
     ExpressionSubtypeCheck,
     ExpressionTypeCheck,
+    ExpressionTypeMakeGeneric,
 )
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
-from nuitka.nodes.VariableNameNodes import StatementAssignmentVariableName
+from nuitka.nodes.VariableNameNodes import (
+    ExpressionVariableNameRef,
+    StatementAssignmentVariableName,
+)
 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 +92,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 +127,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
     )
 
@@ -161,11 +182,36 @@ def buildClassNode3(provider, node, source_ref):
 
     # Only local variable, for provision to methods.
     class_variable = class_locals_scope.getLocalVariable(
-        owner=class_creation_function, variable_name="__class__"
+        owner=class_creation_function,
+        variable_name="__class__",
     )
 
     class_locals_scope.registerProvidedVariable(class_variable)
 
+    if python_version >= 0x3C0:
+        type_param_nodes = node.type_params
+    else:
+        type_param_nodes = None
+
+    if type_param_nodes is not None:
+        type_params_expressions = buildNodeTuple(
+            provider=provider, nodes=type_param_nodes, source_ref=source_ref
+        )
+    else:
+        type_params_expressions = ()
+
+    type_variables = []
+
+    for type_params_expression in type_params_expressions:
+        type_variable = class_locals_scope.getLocalVariable(
+            owner=class_creation_function,
+            variable_name=type_params_expression.name,
+        )
+
+        class_locals_scope.registerProvidedVariable(type_variable)
+
+        type_variables.append(type_variable)
+
     class_variable_ref = ExpressionVariableRef(
         variable=class_variable, source_ref=source_ref
     )
@@ -174,7 +220,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=(),
@@ -222,6 +268,35 @@ def buildClassNode3(provider, node, source_ref):
         ),
     ]
 
+    for type_variable, type_params_expression in zip(
+        type_variables, type_params_expressions
+    ):
+        statements.append(
+            makeStatementAssignmentVariable(
+                variable=type_variable,
+                source=type_params_expression,
+                source_ref=source_ref,
+            )
+        )
+
+    if type_params_expressions:
+        statements.append(
+            StatementAssignmentVariableName(
+                provider=class_creation_function,
+                variable_name="__type_params__",
+                source=makeExpressionMakeTuple(
+                    elements=tuple(
+                        ExpressionVariableRef(
+                            variable=type_variable, source_ref=source_ref
+                        )
+                        for type_variable in type_variables
+                    ),
+                    source_ref=source_ref,
+                ),
+                source_ref=source_ref,
+            )
+        )
+
     if class_doc is not None:
         statements.append(
             StatementAssignmentVariableName(
@@ -234,17 +309,10 @@ def buildClassNode3(provider, node, source_ref):
             )
         )
 
-    # The "__qualname__" attribute is new in Python3.
-    qualname = class_creation_function.getFunctionQualname()
-
-    if python_version < 0x340:
-        qualname_ref = makeConstantRefNode(
-            constant=qualname, source_ref=source_ref, user_provided=True
-        )
-    else:
-        qualname_ref = ExpressionFunctionQualnameRef(
-            function_body=class_creation_function, source_ref=source_ref
-        )
+    # The "__qualname__" attribute has a dedicated node.
+    qualname_ref = ExpressionFunctionQualnameRef(
+        function_body=class_creation_function, source_ref=source_ref
+    )
 
     statements.append(
         StatementLocalsDictOperationSet(
@@ -255,7 +323,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 +340,18 @@ def buildClassNode3(provider, node, source_ref):
 
     statements.append(body)
 
-    if node.bases:
-        tmp_bases = provider.allocateTempVariable(temp_scope=temp_scope, name="bases")
+    needs_orig_bases = _needsOrigBases(static_qualname)
+
+    has_bases = node.bases or type_params_expressions
 
-        if python_version >= 0x370:
+    if has_bases:
+        tmp_bases = provider.allocateTempVariable(
+            temp_scope=temp_scope, name="bases", temp_type="object"
+        )
+
+        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 +362,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 has_bases and needs_orig_bases:
         statements.append(
             makeStatementConditional(
                 condition=makeComparisonExpression(
@@ -345,6 +421,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,25 +455,40 @@ 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:
+    if has_bases:
+        if node.bases:
+            bases_value = _buildBasesTupleCreationNode(
+                provider=provider, elements=node.bases, source_ref=source_ref
+            )
+
+            if type_params_expressions:
+                bases_value = makeBinaryOperationNode(
+                    operator="Add",
+                    left=bases_value,
+                    right=ExpressionTypeMakeGeneric(
+                        type_params=ExpressionVariableNameRef(
+                            provider=class_creation_function,
+                            variable_name="__type_params__",
+                            source_ref=source_ref,
+                        ),
+                        source_ref=source_ref,
+                    ),
+                    source_ref=source_ref,
+                )
+        else:
+            assert False
+
         statements.append(
             makeStatementAssignmentVariable(
-                variable=tmp_bases if python_version < 0x370 else tmp_bases_orig,
-                source=_buildBasesTupleCreationNode(
-                    provider=provider, elements=node.bases, source_ref=source_ref
-                ),
+                variable=tmp_bases_orig if needs_orig_bases else tmp_bases,
+                source=bases_value,
                 source_ref=source_ref,
             )
         )
 
-        if python_version >= 0x370:
+        if needs_orig_bases:
             bases_conversion = makeExpressionFunctionCall(
                 function=makeExpressionFunctionCreation(
                     function_ref=ExpressionFunctionRef(
@@ -422,32 +514,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 +560,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 +648,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 +717,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 +736,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 +775,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 +904,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,
             )
@@ -855,6 +956,7 @@ subclass of the metaclasses of all its bases""",
                     source_ref=internal_source_ref,
                 ),
             ),
+            for_raise=False,
             source_ref=internal_source_ref,
         ),
         exception_value=None,
@@ -891,10 +993,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 +1116,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 +1131,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.