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

nuitka/nodes/NodeBases.py

@@ -319,8 +319,9 @@ class NodeBase(NodeMetaClassBase):
         # For overload by module nodes
         return False
 
-    def isExpressionBuiltin(self):
-        return self.kind.startswith("EXPRESSION_BUILTIN_")
+    @staticmethod
+    def isExpressionBuiltin():
+        return False
 
     @staticmethod
     def isStatementAssignmentVariable():

nuitka/nodes/NodeMetaClasses.py

@@ -36,6 +36,16 @@ def _checkBases(name, bases):
             raise NuitkaNodeDesignError(name, "All bases must set __slots__.", base)
 
 
+@staticmethod
+def returnTrueShared():
+    return True
+
+
+@staticmethod
+def returnFalseShared():
+    return False
+
+
 class NodeCheckMetaClass(ABCMeta):
     kinds = {}
 
@@ -113,22 +123,28 @@ class NodeCheckMetaClass(ABCMeta):
 
             # Automatically add checker methods for everything to the common
             # base class
-            checker_method = "is" + kind_to_name_part
-
-            # TODO: How about making these two functions, one to statically
-            # return True and False, and put one in the base class, and one
-            # in the new class, would be slightly faster.
-            def checkKind(self):
-                return self.kind == kind
+            checker_method_name = "is" + kind_to_name_part
 
-            # Add automatic checker methods to the node base class.
+            # Add automatic checker "False" to the node base class.
             from .NodeBases import NodeBase
 
-            if not hasattr(NodeBase, checker_method):
-                setattr(NodeBase, checker_method, checkKind)
+            if not hasattr(NodeBase, checker_method_name):
+                setattr(NodeBase, checker_method_name, returnFalseShared)
 
         ABCMeta.__init__(cls, name, bases, dictionary)
 
+        if not name.endswith(("Base", "Mixin")):
+            if kind.startswith("EXPRESSION_BUILTIN_"):
+                cls.isExpressionBuiltin = returnTrueShared
+
+            # Add automatic checker "True" to the node class.
+            if getattr(cls, checker_method_name) is returnFalseShared.__func__:
+
+                def checkKind(self):
+                    return self.kind == kind
+
+                setattr(cls, checker_method_name, checkKind)
+
 
 # For every node type, there is a test, and then some more members,
 

nuitka/nodes/ReturnNodes.py

@@ -212,7 +212,7 @@ class StatementReturnReturnedValue(StatementBase):
 
     @staticmethod
     def getStatementNiceName():
-        return "rereturn statement"
+        return "re-return statement"
 
 
 def makeStatementReturnConstant(constant, source_ref):

nuitka/nodes/StatementBasesGenerated.py

@@ -10,18 +10,18 @@
 
 WARNING, this code is GENERATED. Modify the template ChildrenHavingMixin.py.j2 instead!
 
-spell-checker: ignore __prepare__ append args autograph buffering capitalize casefold
-spell-checker: ignore center chars clear closefd copy count decode default delete dist
-spell-checker: ignore distribution_name encode encoding end endswith errors exit_code
-spell-checker: ignore expandtabs experimental_attributes experimental_autograph_options
+spell-checker: ignore __prepare__ append args autograph capitalize casefold center chars
+spell-checker: ignore clear copy count decode default delete dist distribution_name encode
+spell-checker: ignore encoding end endswith errors exit_code expandtabs
+spell-checker: ignore experimental_attributes experimental_autograph_options
 spell-checker: ignore experimental_compile experimental_follow_type_hints
-spell-checker: ignore experimental_implements experimental_relax_shapes extend file
-spell-checker: ignore fillchar find format format_map formatmap fromkeys func get group
-spell-checker: ignore handle has_key haskey index input_signature insert isalnum isalpha
-spell-checker: ignore isascii isdecimal isdigit isidentifier islower isnumeric isprintable
-spell-checker: ignore isspace istitle isupper item items iterable iteritems iterkeys
-spell-checker: ignore itervalues jit_compile join keepends key keys kwargs ljust lower
-spell-checker: ignore lstrip maketrans maxsplit mode name new newline old opener p package
+spell-checker: ignore experimental_implements experimental_relax_shapes extend fillchar
+spell-checker: ignore find format format_map formatmap fromkeys func get group handle
+spell-checker: ignore has_key haskey index input_signature insert isalnum isalpha isascii
+spell-checker: ignore isdecimal isdigit isidentifier islower isnumeric isprintable isspace
+spell-checker: ignore istitle isupper item items iterable iteritems iterkeys itervalues
+spell-checker: ignore jit_compile join keepends key keys kwargs ljust lower lstrip
+spell-checker: ignore maketrans maxsplit mode name new old p package
 spell-checker: ignore package_or_requirement pairs partition path pop popitem prefix
 spell-checker: ignore prepare reduce_retracing remove replace resource resource_name
 spell-checker: ignore reverse rfind rindex rjust rpartition rsplit rstrip s sep setdefault

nuitka/nodes/SubscriptNodes.py

@@ -161,13 +161,13 @@ class ExpressionMatchSubscriptCheck(
 
             return result, tags, change_desc
 
-        trace_collection.onExceptionRaiseExit(BaseException)
+        if subscript.mayRaiseException(BaseException):
+            trace_collection.onExceptionRaiseExit(BaseException)
 
         return self, None, None
 
-    @staticmethod
-    def mayRaiseException(exception_type):
-        return False
+    def mayRaiseException(self, exception_type):
+        return self.subnode_subscript.mayRaiseException(exception_type)
 
 
 class ExpressionSubscriptLookupForUnpack(ExpressionSubscriptLookup):

nuitka/nodes/VariableAssignNodes.py

@@ -798,7 +798,7 @@ class StatementAssignmentVariableConstantMutableTrusted(
 
     @staticmethod
     def hasVeryTrustedValue():
-        return True
+        return False
 
 
 class StatementAssignmentVariableConstantImmutableTrusted(

nuitka/nodes/VariableRefNodes.py

@@ -318,6 +318,23 @@ Subscript del to dictionary lowered to dictionary del."""
 Subscript look-up to dictionary lowered to dictionary look-up.""",
             )
 
+        if subscript.isCompileTimeConstant():
+            attribute_node = self.variable_trace.getAttributeNode()
+
+            if attribute_node is not None:
+                # TODO: That could probably be one single question.
+                if (
+                    attribute_node.isCompileTimeConstant()
+                    and not attribute_node.isMutable()
+                ):
+                    return trace_collection.getCompileTimeComputationResult(
+                        node=lookup_node,
+                        computation=lambda: attribute_node.getCompileTimeConstant()[
+                            subscript.getCompileTimeConstant()
+                        ],
+                        description="Subscript of variable immutable value.",
+                    )
+
         # Any code could be run, note that.
         trace_collection.onControlFlowEscape(self)
 
@@ -420,6 +437,15 @@ class ExpressionVariableRef(ExpressionVariableRefBase):
             # could be decided from context.
             trace_collection.onExceptionRaiseExit(BaseException)
 
+        very_trusted_node = self.variable_trace.getAttributeNodeVeryTrusted()
+        if very_trusted_node is not None:
+            return (
+                very_trusted_node.makeClone(),
+                "new_expression",
+                lambda: "Forward propagating value of %s from very trusted %s value."
+                % (self.getVariableName(), very_trusted_node.kind),
+            )
+
         if variable.isModuleVariable() and (
             variable.hasDefiniteWrites() is False or variable.getName() == "super"
         ):
@@ -494,7 +520,7 @@ Replaced read-only module attribute '__package__' with module attribute referenc
                 change_tags = "new_expression"
                 change_desc = """\
 Replaced read-only module attribute '__loader__' with module attribute reference."""
-            elif variable_name == "__spec__" and python_version >= 0x340:
+            elif variable_name == "__spec__" and python_version >= 0x300:
                 new_node = ExpressionModuleAttributeSpecRef(
                     variable=variable, source_ref=self.source_ref
                 )
@@ -586,7 +612,7 @@ Replaced read-only module attribute '__spec__' with module attribute reference."
                     return (
                         bool(attribute_node.getCompileTimeConstant()),
                         attribute_node.makeClone(),
-                        "Using very trusted constant truth value.",
+                        "Using trusted constant's truth value.",
                     )
 
         # TODO: This is probably only default stuff here, that could be compressed.

nuitka/optimizations/FunctionInlining.py

@@ -9,10 +9,9 @@ from the in-lined function.
 
 from nuitka.nodes.OutlineNodes import ExpressionOutlineBody
 from nuitka.nodes.VariableAssignNodes import makeStatementAssignmentVariable
-from nuitka.nodes.VariableReleaseNodes import makeStatementsReleaseVariables
 from nuitka.tree.Operations import VisitorNoopMixin, visitTree
 from nuitka.tree.ReformulationTryFinallyStatements import (
-    makeTryFinallyStatement,
+    makeTryFinallyReleaseStatement,
 )
 from nuitka.tree.TreeHelpers import makeStatementsSequence
 
@@ -83,12 +82,10 @@ def convertFunctionCallToOutline(provider, function_body, values, call_source_re
 
     # TODO: Not possible to auto release with outline bodies too?
     if auto_releases:
-        body = makeTryFinallyStatement(
+        body = makeTryFinallyReleaseStatement(
             provider=outline_body,
             tried=body,
-            final=makeStatementsReleaseVariables(
-                variables=auto_releases, source_ref=function_source_ref
-            ),
+            variables=auto_releases,
             source_ref=function_source_ref,
         )
 

nuitka/optimizations/Optimization.py

@@ -26,7 +26,7 @@ from nuitka.utils.Timing import TimerReport
 from . import Graphs
 from .BytecodeDemotion import demoteCompiledModuleToBytecode
 from .Tags import TagSet
-from .TraceCollections import withChangeIndicationsTo
+from .TraceCollections import fetchMergeCounts, withChangeIndicationsTo
 
 tag_set = None
 
@@ -68,7 +68,12 @@ def optimizeCompiledPythonModule(module):
     # allow to continue the loop even without changes one more time.
     unchanged_count = 0
 
+    # Count the micro passes, so we can see how often we looped
+    micro_pass = 0
+
     while True:
+        micro_pass += 1
+
         tag_set.clear()
 
         try:
@@ -120,7 +125,7 @@ def optimizeCompiledPythonModule(module):
 
     considerUsedModules(module=module, pass_count=pass_count)
 
-    return touched
+    return touched, micro_pass
 
 
 def optimizeUncompiledPythonModule(module):
@@ -156,14 +161,12 @@ def optimizeModule(module):
 
     if module.isPythonExtensionModule():
         optimizeExtensionModule(module)
-        changed = False
+        return False, 0
     elif module.isCompiledPythonModule():
-        changed = optimizeCompiledPythonModule(module)
+        return optimizeCompiledPythonModule(module)
     else:
         optimizeUncompiledPythonModule(module)
-        changed = False
-
-    return changed
+        return False, 0
 
 
 pass_count = 0
@@ -250,8 +253,6 @@ def restoreFromXML(text):
 def makeOptimizationPass():
     """Make a single pass for optimization, indication potential completion."""
 
-    # Controls complex optimization
-
     finished = True
 
     ModuleRegistry.startTraversal()
@@ -284,14 +285,14 @@ def makeOptimizationPass():
         with TimerReport(
             message="Optimizing %s" % module_name, decider=False
         ) as module_timer:
-            changed = optimizeModule(current_module)
-
-            # module_timer=module_time_report.getTimer()
+            changed, micro_passes = optimizeModule(current_module)
 
         ModuleRegistry.addModuleOptimizationTimeInformation(
             module_name=module_name,
             pass_number=pass_count,
             time_used=module_timer.getDelta(),
+            micro_passes=micro_passes,
+            merge_counts=fetchMergeCounts(),
         )
 
         _traceProgressModuleEnd(current_module)

nuitka/optimizations/TraceCollections.py

@@ -51,6 +51,16 @@ from .ValueTraces import (
     ValueTraceUnknown,
 )
 
+# Keeping trace of how often branches are merged between calls
+_merge_counts = defaultdict(int)
+
+
+def fetchMergeCounts():
+    result = dict(_merge_counts)
+    _merge_counts.clear()
+    return result
+
+
 signalChange = None
 
 
@@ -189,10 +199,10 @@ class CollectionStartPointMixin(CollectionUpdateMixin):
 
         # TODO: We might want to track per exception, pylint: disable=unused-argument
 
-        if collection is None:
-            collection = self
-
         if self.exception_collections is not None:
+            if collection is None:
+                collection = self
+
             self.exception_collections.append(
                 TraceCollectionBranch(parent=collection, name="exception")
             )
@@ -754,6 +764,8 @@ class TraceCollectionBase(object):
             collection1 = collection_yes
             collection2 = collection_no
 
+        _merge_counts[2] += 1
+
         variable_versions = {}
 
         for variable, version in iterItems(collection1.variable_actives):
@@ -816,7 +828,8 @@ class TraceCollectionBase(object):
         elif merge_size == 2:
             return self.mergeBranches(*collections)
 
-        # print("Enter mergeMultipleBranches", len(collections))
+        _merge_counts[len(collections)] += 1
+
         with TimerReport(
             message="Running merge for %s took %%.2f seconds" % collections,
             decider=False,
@@ -874,6 +887,8 @@ class TraceCollectionBase(object):
         self.variable_actives.update(collection_replace.variable_actives)
         collection_replace.variable_actives = None
 
+        _merge_counts[1] += 1
+
     def onLoopBreak(self, collection=None):
         if collection is None:
             collection = self