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

nuitka/code_generation/RaisingCodes.py

@@ -8,13 +8,16 @@ Exceptions from other operations are consider ErrorCodes domain.
 """
 
 from nuitka import Options
+from nuitka.Builtins import isBaseExceptionSimpleExtension
+from nuitka.PythonVersions import python_version
 
 from .CodeHelpers import (
     generateChildExpressionsCode,
     generateExpressionCode,
     withObjectCodeTemporaryAssignment,
 )
-from .ErrorCodes import getFrameVariableTypeDescriptionCode
+from .ErrorCodes import getErrorExitCode, getFrameVariableTypeDescriptionCode
+from .ExceptionCodes import getExceptionIdentifier
 from .LabelCodes import getGotoCode
 from .LineNumberCodes import (
     emitErrorLineNumberUpdateCode,
@@ -30,6 +33,80 @@ def generateReraiseCode(statement, emit, context):
         getReRaiseExceptionCode(emit=emit, context=context)
 
 
+def _haveQuickExceptionCreationCode(exception_name):
+    result = exception_name in ("StopIteration",)
+
+    # TODO: Get this complete for larger test suites.
+    # assert result, exception_name
+
+    return result
+
+
+def _generateExceptionNormalizeCode(to_name, exception_type, emit, context):
+
+    if exception_type.isExpressionBuiltinExceptionRef():
+        exception_name = exception_type.getExceptionName()
+        if isBaseExceptionSimpleExtension(exception_type.getCompileTimeConstant()):
+            emit(
+                "%s = MAKE_BASE_EXCEPTION_DERIVED_EMPTY(%s);"
+                % (to_name, getExceptionIdentifier(exception_name))
+            )
+            context.addCleanupTempName(to_name)
+
+            return
+        elif _haveQuickExceptionCreationCode(exception_type.getExceptionName()):
+            # TODO: Code generation like this here, ought to be shared with
+            # the one for ExpressionBuiltinMakeExceptionRef once that is
+            # done too.
+            if exception_name == "StopIteration":
+                emit("%s = MAKE_STOP_ITERATION_EMPTY();" % to_name)
+            else:
+                assert False, exception_name
+
+            context.addCleanupTempName(to_name)
+            return
+
+    # TODO: Can only fall through if exception builtins are not fully handled,
+    # but we should make sure that doesn't ever happen by handling them all.
+
+    if exception_type.isExpressionBuiltinMakeException():
+        # TODO: Make this shape based, but currently the nodes do not
+        # provide the shape, we need to add that.
+
+        # No need to normalize these.
+        generateExpressionCode(
+            to_name=to_name,
+            expression=exception_type,
+            emit=emit,
+            context=context,
+        )
+    else:
+        # Need to normalize exceptions.
+        raise_type_input_name = context.allocateTempName("raise_type_input")
+
+        generateExpressionCode(
+            to_name=raise_type_input_name,
+            expression=exception_type,
+            emit=emit,
+            context=context,
+        )
+
+        emit(
+            "%s = NORMALIZE_EXCEPTION_VALUE_FOR_RAISE(tstate, %s);"
+            % (to_name, raise_type_input_name)
+        )
+
+        getErrorExitCode(
+            check_name=to_name,
+            release_name=raise_type_input_name,
+            needs_check=True,
+            emit=emit,
+            context=context,
+        )
+
+        context.addCleanupTempName(to_name)
+
+
 def generateRaiseCode(statement, emit, context):
     exception_type = statement.subnode_exception_type
     exception_value = statement.subnode_exception_value
@@ -44,12 +121,20 @@ def generateRaiseCode(statement, emit, context):
 
         raise_type_name = context.allocateTempName("raise_type")
 
-        generateExpressionCode(
-            to_name=raise_type_name,
-            expression=exception_type,
-            emit=emit,
-            context=context,
-        )
+        if python_version >= 0x3C0:
+            _generateExceptionNormalizeCode(
+                to_name=raise_type_name,
+                exception_type=exception_type,
+                emit=emit,
+                context=context,
+            )
+        else:
+            generateExpressionCode(
+                to_name=raise_type_name,
+                expression=exception_type,
+                emit=emit,
+                context=context,
+            )
 
         raise_cause_name = context.allocateTempName("raise_cause")
 
@@ -74,12 +159,20 @@ def generateRaiseCode(statement, emit, context):
     elif exception_value is None and exception_tb is None:
         raise_type_name = context.allocateTempName("raise_type")
 
-        generateExpressionCode(
-            to_name=raise_type_name,
-            expression=exception_type,
-            emit=emit,
-            context=context,
-        )
+        if python_version >= 0x3C0:
+            _generateExceptionNormalizeCode(
+                to_name=raise_type_name,
+                exception_type=exception_type,
+                emit=emit,
+                context=context,
+            )
+        else:
+            generateExpressionCode(
+                to_name=raise_type_name,
+                expression=exception_type,
+                emit=emit,
+                context=context,
+            )
 
         with context.withCurrentSourceCodeReference(
             value=exception_type.getCompatibleSourceReference()
@@ -113,7 +206,6 @@ def generateRaiseCode(statement, emit, context):
             _getRaiseExceptionWithValueCode(
                 raise_type_name=raise_type_name,
                 raise_value_name=raise_value_name,
-                implicit=statement.isStatementRaiseExceptionImplicit(),
                 emit=emit,
                 context=context,
             )
@@ -153,7 +245,7 @@ def generateRaiseCode(statement, emit, context):
 
 
 def generateRaiseExpressionCode(to_name, expression, emit, context):
-    arg_names = generateChildExpressionsCode(
+    (exception_value_name,) = generateChildExpressionsCode(
         expression=expression, emit=emit, context=context
     )
 
@@ -178,10 +270,8 @@ def generateRaiseExpressionCode(to_name, expression, emit, context):
         # That's how we indicate exception to the surrounding world.
         emit("%s = NULL;" % value_name)
 
-        _getRaiseExceptionWithValueCode(
-            raise_type_name=arg_names[0],
-            raise_value_name=arg_names[1],
-            implicit=True,
+        _getRaiseExceptionWithTypeCode(
+            raise_type_name=exception_value_name,
             emit=emit,
             context=context,
         )
@@ -189,26 +279,25 @@ def generateRaiseExpressionCode(to_name, expression, emit, context):
 
 def getReRaiseExceptionCode(emit, context):
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
-    keeper_variables = context.getExceptionKeeperVariables()
+    (
+        keeper_exception_state_name,
+        _keeper_lineno,
+    ) = context.getExceptionKeeperVariables()
 
-    if keeper_variables[0] is None:
+    if keeper_exception_state_name is None:
         emit(
             """\
-%(bool_res_name)s = RERAISE_EXCEPTION(&%(exception_type)s, &%(exception_value)s, &%(exception_tb)s);
+%(bool_res_name)s = RERAISE_EXCEPTION(tstate, &%(exception_state_name)s);
 if (unlikely(%(bool_res_name)s == false)) {
     %(update_code)s
 }
 """
             % {
-                "exception_type": exception_type,
-                "exception_value": exception_value,
-                "exception_tb": exception_tb,
+                "exception_state_name": exception_state_name,
                 "bool_res_name": context.getBoolResName(),
                 "update_code": getErrorLineNumberUpdateCode(context),
             }
@@ -219,10 +308,15 @@ if (unlikely(%(bool_res_name)s == false)) {
         if frame_handle:
             emit(
                 """\
-if (%(exception_tb)s && %(exception_tb)s->tb_frame == &%(frame_identifier)s->m_frame) \
-%(frame_identifier)s->m_frame.f_lineno = %(exception_tb)s->tb_lineno;"""
+{
+    PyTracebackObject *exception_tb = GET_EXCEPTION_STATE_TRACEBACK(&%(exception_state_name)s);
+
+    if ((exception_tb != NULL) && (exception_tb->tb_frame == &%(frame_identifier)s->m_frame)) {
+        %(frame_identifier)s->m_frame.f_lineno = exception_tb->tb_lineno;
+    }
+}"""
                 % {
-                    "exception_tb": exception_tb,
+                    "exception_state_name": exception_state_name,
                     "frame_identifier": context.getFrameHandle(),
                 }
             )
@@ -230,28 +324,20 @@ if (%(exception_tb)s && %(exception_tb)s->tb_frame == &%(frame_identifier)s->m_f
             emit(getFrameVariableTypeDescriptionCode(context))
     else:
         (
-            keeper_type,
-            keeper_value,
-            keeper_tb,
+            keeper_exception_state_name,
             keeper_lineno,
         ) = context.getExceptionKeeperVariables()
 
         emit(
             """\
 // Re-raise.
-%(exception_type)s = %(keeper_type)s;
-%(exception_value)s = %(keeper_value)s;
-%(exception_tb)s = %(keeper_tb)s;
+%(exception_state_name)s = %(keeper_exception_state_name)s;
 %(exception_lineno)s = %(keeper_lineno)s;
 """
             % {
-                "exception_type": exception_type,
-                "exception_value": exception_value,
-                "exception_tb": exception_tb,
+                "exception_state_name": exception_state_name,
                 "exception_lineno": exception_lineno,
-                "keeper_type": keeper_type,
-                "keeper_value": keeper_value,
-                "keeper_tb": keeper_tb,
+                "keeper_exception_state_name": keeper_exception_state_name,
                 "keeper_lineno": keeper_lineno,
             }
         )
@@ -261,23 +347,23 @@ if (%(exception_tb)s && %(exception_tb)s->tb_frame == &%(frame_identifier)s->m_f
 
 def _getRaiseExceptionWithCauseCode(raise_type_name, raise_cause_name, emit, context):
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
-    emit("%s = %s;" % (exception_type, raise_type_name))
-    getReferenceExportCode(raise_type_name, emit, context)
+    if python_version < 0x3C0:
+        emit("%s.exception_type = %s;" % (exception_state_name, raise_type_name))
+    else:
+        emit("%s.exception_value = %s;" % (exception_state_name, raise_type_name))
 
-    emit("%s = NULL;" % exception_value)
+    getReferenceExportCode(raise_type_name, emit, context)
 
     getReferenceExportCode(raise_cause_name, emit, context)
 
     emitErrorLineNumberUpdateCode(emit, context)
     emit(
-        "RAISE_EXCEPTION_WITH_CAUSE(tstate, &%s, &%s, &%s, %s);"
-        % (exception_type, exception_value, exception_tb, raise_cause_name)
+        "RAISE_EXCEPTION_WITH_CAUSE(tstate, &%s, %s);"
+        % (exception_state_name, raise_cause_name)
     )
 
     emit(getFrameVariableTypeDescriptionCode(context))
@@ -292,20 +378,24 @@ def _getRaiseExceptionWithCauseCode(raise_type_name, raise_cause_name, emit, con
 
 def _getRaiseExceptionWithTypeCode(raise_type_name, emit, context):
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
-    emit("%s = %s;" % (exception_type, raise_type_name))
-    getReferenceExportCode(raise_type_name, emit, context)
+    if python_version < 0x3C0:
+        emit("%s.exception_type = %s;" % (exception_state_name, raise_type_name))
+        getReferenceExportCode(raise_type_name, emit, context)
 
-    emitErrorLineNumberUpdateCode(emit, context)
-    emit(
-        "RAISE_EXCEPTION_WITH_TYPE(tstate, &%s, &%s, &%s);"
-        % (exception_type, exception_value, exception_tb)
-    )
+        emitErrorLineNumberUpdateCode(emit, context)
+
+        emit("RAISE_EXCEPTION_WITH_TYPE(tstate, &%s);" % exception_state_name)
+    else:
+        emit("%s.exception_value = %s;" % (exception_state_name, raise_type_name))
+        getReferenceExportCode(raise_type_name, emit, context)
+
+        emitErrorLineNumberUpdateCode(emit, context)
+
+        emit("RAISE_EXCEPTION_WITH_VALUE(tstate, &%s);" % exception_state_name)
 
     emit(getFrameVariableTypeDescriptionCode(context))
 
@@ -315,33 +405,20 @@ def _getRaiseExceptionWithTypeCode(raise_type_name, emit, context):
         context.removeCleanupTempName(raise_type_name)
 
 
-def _getRaiseExceptionWithValueCode(
-    raise_type_name, raise_value_name, implicit, emit, context
-):
+def _getRaiseExceptionWithValueCode(raise_type_name, raise_value_name, emit, context):
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
-    emit("%s = %s;" % (exception_type, raise_type_name))
+    emit("%s.exception_type = %s;" % (exception_state_name, raise_type_name))
     getReferenceExportCode(raise_type_name, emit, context)
-    emit("%s = %s;" % (exception_value, raise_value_name))
+    emit("%s.exception_value = %s;" % (exception_state_name, raise_value_name))
     getReferenceExportCode(raise_value_name, emit, context)
 
     emitErrorLineNumberUpdateCode(emit, context)
 
-    # Using RAISE_EXCEPTION_WITH_VALUE (user driven) or RAISE_EXCEPTION_IMPLICIT as needed.
-    emit(
-        "RAISE_EXCEPTION_%s(tstate, &%s, &%s, &%s);"
-        % (
-            ("IMPLICIT" if implicit else "WITH_VALUE"),
-            exception_type,
-            exception_value,
-            exception_tb,
-        )
-    )
+    emit("RAISE_EXCEPTION_WITH_TYPE_AND_VALUE(tstate, &%s);" % (exception_state_name,))
 
     emit(getFrameVariableTypeDescriptionCode(context))
 
@@ -357,24 +434,21 @@ def _getRaiseExceptionWithTracebackCode(
     raise_type_name, raise_value_name, raise_tb_name, emit, context
 ):
     (
-        exception_type,
-        exception_value,
-        exception_tb,
+        exception_state_name,
         _exception_lineno,
     ) = context.variable_storage.getExceptionVariableDescriptions()
 
-    emit("%s = %s;" % (exception_type, raise_type_name))
+    emit("%s.exception_type = %s;" % (exception_state_name, raise_type_name))
     getReferenceExportCode(raise_type_name, emit, context)
-    emit("%s = %s;" % (exception_value, raise_value_name))
+    emit("%s.exception_value = %s;" % (exception_state_name, raise_value_name))
     getReferenceExportCode(raise_value_name, emit, context)
-
-    emit("%s = (PyTracebackObject *)%s;" % (exception_tb, raise_tb_name))
-    getReferenceExportCode(raise_tb_name, emit, context)
-
     emit(
-        "RAISE_EXCEPTION_WITH_TRACEBACK(tstate, &%s, &%s, &%s);"
-        % (exception_type, exception_value, exception_tb)
+        "%s.exception_tb = (PyTracebackObject *)%s;"
+        % (exception_state_name, raise_tb_name)
     )
+    getReferenceExportCode(raise_tb_name, emit, context)
+
+    emit("RAISE_EXCEPTION_WITH_TRACEBACK(tstate, &%s);" % (exception_state_name))
 
     # If anything is wrong, that will be used.
     emitErrorLineNumberUpdateCode(emit, context)

nuitka/code_generation/Reports.py

@@ -7,6 +7,7 @@ Initially this is about missing optimization only, but it should expand into
 real stuff.
 """
 
+from nuitka import Options
 from nuitka.containers.OrderedDicts import OrderedDict
 from nuitka.containers.OrderedSets import OrderedSet
 from nuitka.Tracing import code_generation_logger, optimization_logger
@@ -26,8 +27,8 @@ _error_for_missing = False
 def doMissingOptimizationReport():
     for helper, source_refs in _missing_helpers.items():
         message = "Missing C helper code variant, used fallback: %s at %s" % (
-            ",".join(source_ref.getAsString() for source_ref in source_refs),
             helper,
+            ",".join(source_ref.getAsString() for source_ref in source_refs),
         )
 
         if _error_for_missing:
@@ -75,13 +76,20 @@ def onMissingOperation(operation, left, right):
         _missing_operations.add((operation, left, right))
 
 
+def onMissingUnaryOperation(operation, shape):
+    # Avoid the circular dependency on tshape_uninitialized from StandardShapes.
+    if shape.__class__.__name__ != "ShapeTypeUninitialized":
+        _missing_operations.add((operation, shape))
+
+
 def onMissingTrust(operation, source_ref, *args):
-    key = (operation,) + args
+    if Options.report_missing_trust:
+        key = (operation,) + args
 
-    if key not in _missing_trust:
-        _missing_trust[key] = OrderedSet()
+        if key not in _missing_trust:
+            _missing_trust[key] = OrderedSet()
 
-    _missing_trust[key].add(source_ref)
+        _missing_trust[key].add(source_ref)
 
 
 def onMissingOverload(method_name, node):

nuitka/code_generation/ReturnCodes.py

@@ -95,19 +95,13 @@ def generateGeneratorReturnValueCode(statement, emit, context):
             context.removeCleanupTempName(return_value_name)
         else:
             emit("Py_INCREF(%s);" % return_value_name)
-    elif statement.getParentVariableProvider().needsGeneratorReturnHandling():
-        return_value_name = context.getGeneratorReturnValueName()
-
-        generator_return_name = context.allocateTempName(
-            "generator_return", "bool", unique=True
-        )
-
-        emit("%s = true;" % generator_return_name)
 
     getGotoCode(context.getReturnTarget(), emit)
 
 
 def generateGeneratorReturnNoneCode(statement, emit, context):
+    # We don't need the statement, pylint: disable=unused-argument
+
     if context.getOwner().isExpressionAsyncgenObjectBody():
         pass
     elif python_version >= 0x300:
@@ -129,14 +123,6 @@ def generateGeneratorReturnNoneCode(statement, emit, context):
             context.removeCleanupTempName(return_value_name)
         else:
             emit("Py_INCREF(%s);" % return_value_name)
-    elif statement.getParentVariableProvider().needsGeneratorReturnHandling():
-        return_value_name = context.getGeneratorReturnValueName()
-
-        generator_return_name = context.allocateTempName(
-            "generator_return", "bool", unique=True
-        )
-
-        emit("%s = true;" % generator_return_name)
 
     getGotoCode(context.getReturnTarget(), emit)
 

nuitka/code_generation/TryCodes.py

@@ -125,46 +125,30 @@ def generateTryCode(statement, emit, context):
 
         # Need to preserve exception state.
         (
-            keeper_type,
-            keeper_value,
-            keeper_tb,
+            keeper_exception_state_name,
             keeper_lineno,
         ) = context.allocateExceptionKeeperVariables()
 
         old_keepers = context.setExceptionKeeperVariables(
-            (keeper_type, keeper_value, keeper_tb, keeper_lineno)
+            (keeper_exception_state_name, keeper_lineno)
         )
 
-        assert keeper_type is not None
-
         (
-            exception_type,
-            exception_value,
-            exception_tb,
+            exception_state_name,
             exception_lineno,
         ) = context.variable_storage.getExceptionVariableDescriptions()
 
-        # TODO: That normalization and chaining is only necessary if the
-        # exception is published.
         emit(
             """\
-%(keeper_type)s = %(exception_type)s;
-%(keeper_value)s = %(exception_value)s;
-%(keeper_tb)s = %(exception_tb)s;
 %(keeper_lineno)s = %(exception_lineno)s;
-%(exception_type)s = NULL;
-%(exception_value)s = NULL;
-%(exception_tb)s = NULL;
 %(exception_lineno)s = 0;
+%(keeper_exception_state_name)s = %(exception_state_name)s;
+INIT_ERROR_OCCURRED_STATE(&%(exception_state_name)s);
 """
             % {
-                "keeper_type": keeper_type,
-                "keeper_value": keeper_value,
-                "keeper_tb": keeper_tb,
+                "keeper_exception_state_name": keeper_exception_state_name,
                 "keeper_lineno": keeper_lineno,
-                "exception_type": exception_type,
-                "exception_value": exception_value,
-                "exception_tb": exception_tb,
+                "exception_state_name": exception_state_name,
                 "exception_lineno": exception_lineno,
             }
         )
@@ -303,7 +287,11 @@ def generateTryNextExceptStopIterationCode(statement, emit, context):
         else statement.getSourceReference()
     ):
         getBuiltinLoopBreakNextCode(
-            to_name=tmp_name2, value=tmp_name, emit=emit, context=context
+            expression=assign_source.subnode_value,
+            to_name=tmp_name2,
+            value=tmp_name,
+            emit=emit,
+            context=context,
         )
 
         getVariableAssignmentCode(

nuitka/code_generation/TypeAliasCodes.py

@@ -55,6 +55,54 @@ def generateTypeAliasCode(to_name, expression, emit, context):
         context.addCleanupTempName(value_name)
 
 
+def generateTypeVarCode(to_name, expression, emit, context):
+    with withObjectCodeTemporaryAssignment(
+        to_name, "type_var_value", expression, emit, context
+    ) as value_name:
+        emit(
+            "%s = MAKE_TYPE_VAR(tstate, %s);"
+            % (
+                value_name,
+                context.getConstantCode(constant=expression.name),
+            )
+        )
+
+        getErrorExitCode(
+            check_name=value_name,
+            emit=emit,
+            context=context,
+            needs_check=False,
+        )
+
+        context.addCleanupTempName(value_name)
+
+
+def generateTypeGenericCode(to_name, expression, emit, context):
+    type_params_value = generateChildExpressionCode(
+        expression=expression.subnode_type_params, emit=emit, context=context
+    )
+
+    with withObjectCodeTemporaryAssignment(
+        to_name, "type_params_value", expression, emit, context
+    ) as value_name:
+        emit(
+            "%s = MAKE_TYPE_GENERIC(tstate, %s);"
+            % (
+                value_name,
+                type_params_value,
+            )
+        )
+
+        getErrorExitCode(
+            check_name=value_name,
+            release_name=type_params_value,
+            emit=emit,
+            context=context,
+        )
+
+        context.addCleanupTempName(value_name)
+
+
 #     Part of "Nuitka", an optimizing Python compiler that is compatible and
 #     integrates with CPython, but also works on its own.
 #