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

nuitka/tree/Building.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
+
+
 """ Build the internal node tree from source code.
 
 Does all the Python parsing and puts it into a tree structure for use in later
@@ -48,15 +34,11 @@ special attribute lookups for "__enter__" and "__exit__", calls of them,
 catching and passing in exceptions raised.
 
 """
+
 import marshal
 import os
 
-from nuitka import (
-    ModuleRegistry,
-    Options,
-    OutputDirectories,
-    SourceCodeReferences,
-)
+from nuitka import ModuleRegistry, OutputDirectories, SourceCodeReferences
 from nuitka.__past__ import long, unicode
 from nuitka.BytecodeCaching import (
     getCachedImportedModuleUsageAttempts,
@@ -97,7 +79,10 @@ from nuitka.nodes.ExceptionNodes import (
     StatementReraiseException,
 )
 from nuitka.nodes.FutureSpecs import FutureSpec
-from nuitka.nodes.GeneratorNodes import StatementGeneratorReturn
+from nuitka.nodes.GeneratorNodes import (
+    StatementGeneratorReturn,
+    StatementGeneratorReturnNone,
+)
 from nuitka.nodes.ImportNodes import (
     isHardModuleWithoutSideEffect,
     makeExpressionImportModuleFixed,
@@ -128,7 +113,16 @@ from nuitka.nodes.VariableNameNodes import (
     StatementAssignmentVariableName,
 )
 from nuitka.optimizations.BytecodeDemotion import demoteSourceCodeToBytecode
-from nuitka.Options import shallWarnUnusualCode
+from nuitka.Options import (
+    getMainEntryPointFilenames,
+    hasPythonFlagNoSite,
+    hasPythonFlagPackageMode,
+    isShowMemory,
+    isStandaloneMode,
+    shallDisableBytecodeCacheUsage,
+    shallMakeModule,
+    shallWarnUnusualCode,
+)
 from nuitka.pgo.PGO import decideCompilationFromPGO
 from nuitka.plugins.Plugins import Plugins
 from nuitka.PythonVersions import python_version
@@ -141,6 +135,7 @@ from nuitka.Tracing import (
 )
 from nuitka.utils import MemoryUsage
 from nuitka.utils.ModuleNames import ModuleName
+from nuitka.utils.Utils import withNoSyntaxWarning
 
 from . import SyntaxErrors
 from .ReformulationAssertStatements import buildAssertNode
@@ -150,6 +145,7 @@ from .ReformulationAssignmentStatements import (
     buildDeleteNode,
     buildInplaceAssignNode,
     buildNamedExprNode,
+    buildTypeAliasNode,
 )
 from .ReformulationBooleanExpressions import buildBoolOpNode
 from .ReformulationCallExpressions import buildCallNode
@@ -292,9 +288,9 @@ def buildTryFinallyNode2(provider, node, source_ref):
 
 
 def buildTryNode(provider, node, source_ref):
-    # Note: This variant is used for Python3.3 or higher only, older stuff uses
-    # the above ones, this one merges try/except with try/finally in the
-    # "ast". We split it up again, as it's logically separated of course.
+    # Note: This variant is used for Python3 only, older stuff uses the above
+    # ones, this one merges try/except with try/finally in the "ast". We split
+    # it up again, as it's logically separated of course.
 
     # Shortcut missing try/finally.
     if not node.handlers:
@@ -440,7 +436,7 @@ def handleGlobalDeclarationNode(provider, node, source_ref):
     for variable_name in node.names:
         closure_variable = None
 
-        # Re-use already taken global variables, in order to avoid creating yet
+        # Reuse already taken global variables, in order to avoid creating yet
         # another instance, esp. as the indications could then potentially not
         # be shared.
         if provider.hasTakenVariable(variable_name):
@@ -594,10 +590,12 @@ def buildReturnNode(provider, node, source_ref):
         provider.isExpressionGeneratorObjectBody()
         or provider.isExpressionAsyncgenObjectBody()
     ):
-        if expression is None:
-            expression = ExpressionConstantNoneRef(source_ref=source_ref)
-
-        return StatementGeneratorReturn(expression=expression, source_ref=source_ref)
+        if expression is None or expression.isExpressionConstantNoneRef():
+            return StatementGeneratorReturnNone(source_ref=source_ref)
+        else:
+            return StatementGeneratorReturn(
+                expression=expression, source_ref=source_ref
+            )
     else:
         return makeStatementReturn(expression=expression, source_ref=source_ref)
 
@@ -771,6 +769,7 @@ setBuildingDispatchers(
         "NamedExpr": buildNamedExprNode,
         "Slice": buildSliceNode,
         "Match": buildMatchNode,
+        "TypeAlias": buildTypeAliasNode,
     },
     path_args2={
         "Constant": buildNamedConstantNode,  # Python3.8
@@ -784,19 +783,18 @@ setBuildingDispatchers(
 )
 
 
-def buildParseTree(provider, ast_tree, source_ref, is_module, is_main):
+def buildParseTree(provider, ast_tree, source_ref, is_main):
     # There are a bunch of branches here, mostly to deal with version
     # differences for module default variables. pylint: disable=too-many-branches
 
     # Maybe one day, we do exec inlining again, that is what this is for,
     # then is_module won't be True, for now it always is.
-    pushFutureSpec()
-    if is_module:
-        provider.setFutureSpec(getFutureSpec())
+    pushFutureSpec(provider.getFullName())
+    provider.setFutureSpec(getFutureSpec())
 
     body, doc = extractDocFromBody(ast_tree)
 
-    if is_module and is_main and python_version >= 0x360:
+    if is_main and python_version >= 0x360:
         provider.markAsNeedsAnnotationsDictionary()
 
     try:
@@ -817,100 +815,105 @@ def buildParseTree(provider, ast_tree, source_ref, is_module, is_main):
 
     statements = []
 
-    if is_module:
-        # Add import of "site" module of main programs visibly in the node tree,
-        # so recursion and optimization can pick it up, checking its effects.
-        if is_main and not Options.hasPythonFlagNoSite():
+    # Add import of "site" module of main programs visibly in the node tree,
+    # so recursion and optimization can pick it up, checking its effects.
+    if is_main and not hasPythonFlagNoSite():
+        statements.append(
+            StatementExpressionOnly(
+                expression=makeExpressionImportModuleFixed(
+                    using_module_name=provider.getParentModule().getFullName(),
+                    module_name="site",
+                    value_name="site",
+                    source_ref=source_ref,
+                ),
+                source_ref=source_ref,
+            )
+        )
+
+        for path_imported_name in getPthImportedPackages():
+            if isHardModuleWithoutSideEffect(path_imported_name):
+                continue
+
             statements.append(
                 StatementExpressionOnly(
                     expression=makeExpressionImportModuleFixed(
-                        module_name="site", source_ref=source_ref
+                        using_module_name=provider.getParentModule().getFullName(),
+                        module_name=path_imported_name,
+                        value_name=path_imported_name.getTopLevelPackageName(),
+                        source_ref=source_ref,
                     ),
                     source_ref=source_ref,
                 )
             )
 
-            for path_imported_name in getPthImportedPackages():
-                if isHardModuleWithoutSideEffect(path_imported_name):
-                    continue
-
-                statements.append(
-                    StatementExpressionOnly(
-                        expression=makeExpressionImportModuleFixed(
-                            module_name=path_imported_name, source_ref=source_ref
-                        ),
-                        source_ref=source_ref,
-                    )
-                )
+    statements.append(
+        StatementAssignmentVariableName(
+            provider=provider,
+            variable_name="__doc__",
+            source=makeConstantRefNode(
+                constant=doc, source_ref=internal_source_ref, user_provided=True
+            ),
+            source_ref=internal_source_ref,
+        )
+    )
 
-        statements.append(
-            StatementAssignmentVariableName(
-                provider=provider,
-                variable_name="__doc__",
-                source=makeConstantRefNode(
-                    constant=doc, source_ref=internal_source_ref, user_provided=True
-                ),
+    statements.append(
+        StatementAssignmentVariableName(
+            provider=provider,
+            variable_name="__file__",
+            source=ExpressionModuleAttributeFileRef(
+                variable=provider.getVariableForReference("__file__"),
                 source_ref=internal_source_ref,
-            )
+            ),
+            source_ref=internal_source_ref,
         )
+    )
 
-        statements.append(
-            StatementAssignmentVariableName(
-                provider=provider,
-                variable_name="__file__",
+    if provider.isCompiledPythonPackage():
+        # This assigns "__path__" value.
+        statements.append(createPathAssignment(provider, internal_source_ref))
+
+    if python_version >= 0x340 and not is_main:
+        statements += (
+            StatementAssignmentAttribute(
+                expression=ExpressionModuleAttributeSpecRef(
+                    variable=provider.getVariableForReference("__spec__"),
+                    source_ref=internal_source_ref,
+                ),
+                attribute_name="origin",
                 source=ExpressionModuleAttributeFileRef(
                     variable=provider.getVariableForReference("__file__"),
                     source_ref=internal_source_ref,
                 ),
                 source_ref=internal_source_ref,
-            )
+            ),
+            StatementAssignmentAttribute(
+                expression=ExpressionModuleAttributeSpecRef(
+                    variable=provider.getVariableForReference("__spec__"),
+                    source_ref=internal_source_ref,
+                ),
+                attribute_name="has_location",
+                source=makeConstantRefNode(True, internal_source_ref),
+                source_ref=internal_source_ref,
+            ),
         )
 
         if provider.isCompiledPythonPackage():
-            # This assigns "__path__" value.
-            statements.append(createPathAssignment(provider, internal_source_ref))
-
-        if python_version >= 0x340 and not is_main:
-            statements += (
+            statements.append(
                 StatementAssignmentAttribute(
                     expression=ExpressionModuleAttributeSpecRef(
                         variable=provider.getVariableForReference("__spec__"),
                         source_ref=internal_source_ref,
                     ),
-                    attribute_name="origin",
-                    source=ExpressionModuleAttributeFileRef(
-                        variable=provider.getVariableForReference("__file__"),
+                    attribute_name="submodule_search_locations",
+                    source=ExpressionVariableNameRef(
+                        provider=provider,
+                        variable_name="__path__",
                         source_ref=internal_source_ref,
                     ),
                     source_ref=internal_source_ref,
-                ),
-                StatementAssignmentAttribute(
-                    expression=ExpressionModuleAttributeSpecRef(
-                        variable=provider.getVariableForReference("__spec__"),
-                        source_ref=internal_source_ref,
-                    ),
-                    attribute_name="has_location",
-                    source=makeConstantRefNode(True, internal_source_ref),
-                    source_ref=internal_source_ref,
-                ),
-            )
-
-            if provider.isCompiledPythonPackage():
-                statements.append(
-                    StatementAssignmentAttribute(
-                        expression=ExpressionModuleAttributeSpecRef(
-                            variable=provider.getVariableForReference("__spec__"),
-                            source_ref=internal_source_ref,
-                        ),
-                        attribute_name="submodule_search_locations",
-                        source=ExpressionVariableNameRef(
-                            provider=provider,
-                            variable_name="__path__",
-                            source_ref=internal_source_ref,
-                        ),
-                        source_ref=internal_source_ref,
-                    )
                 )
+            )
 
     if python_version >= 0x300:
         statements.append(
@@ -969,27 +972,26 @@ def buildParseTree(provider, ast_tree, source_ref, is_module, is_main):
             )
         )
 
-    if is_module:
-        result = makeModuleFrame(
-            module=provider, statements=statements, source_ref=source_ref
-        )
+    result = makeModuleFrame(
+        module=provider, statements=statements, source_ref=source_ref
+    )
 
-        popFutureSpec()
+    popFutureSpec()
 
-        return result
-    else:
-        assert False
+    return result
 
 
-def decideCompilationMode(is_top, module_name, for_pgo):
+def decideCompilationMode(is_top, module_name, module_filename, for_pgo):
     """Decide the compilation mode for a module.
 
     module_name - The module to decide compilation mode for.
     for_pgo - consider PGO information or not
     """
 
+    is_stdlib = module_filename is not None and isStandardLibraryPath(module_filename)
+
     # Technically required modules must be bytecode
-    if module_name in detectEarlyImports():
+    if is_stdlib and module_name in detectEarlyImports():
         return "bytecode"
 
     result = Plugins.decideCompilation(module_name)
@@ -1008,13 +1010,8 @@ required to compiled."""
 
     # Include all of standard library as bytecode, for now. We need to identify
     # which ones really need that.
-    if not is_top:
-        module_filename = Importing.locateModule(
-            module_name=module_name, parent_package=None, level=0
-        )[1]
-
-        if module_filename is not None and isStandardLibraryPath(module_filename):
-            result = "bytecode"
+    if not is_top and is_stdlib:
+        result = "bytecode"
 
     # Plugins need to win over PGO, as they might know it better
     if result is None and not for_pgo:
@@ -1022,7 +1019,7 @@ required to compiled."""
 
     # Default if neither plugins nor PGO have expressed an opinion
     if result is None:
-        if module_name in detectStdlibAutoInclusionModules():
+        if is_stdlib and module_name in detectStdlibAutoInclusionModules():
             result = "bytecode"
         else:
             result = "compiled"
@@ -1061,6 +1058,7 @@ def _loadUncompiledModuleFromCache(
 
 def _createModule(
     module_name,
+    module_filename,
     module_kind,
     reason,
     source_code,
@@ -1071,11 +1069,14 @@ def _createModule(
     is_main,
     main_added,
 ):
+    is_stdlib = module_filename is not None and isStandardLibraryPath(module_filename)
+
     if module_kind == "extension":
         result = PythonExtensionModule(
             module_name=module_name,
+            module_filename=module_filename,
             reason=reason,
-            technical=module_name in detectEarlyImports(),
+            technical=is_stdlib and module_name in detectEarlyImports(),
             source_ref=source_ref,
         )
     elif is_main:
@@ -1085,7 +1086,10 @@ def _createModule(
             main_added=main_added,
             module_name=module_name,
             mode=decideCompilationMode(
-                is_top=is_top, module_name=module_name, for_pgo=False
+                is_top=is_top,
+                module_name=module_name,
+                module_filename=module_filename,
+                for_pgo=False,
             ),
             future_spec=None,
             source_ref=source_ref,
@@ -1101,13 +1105,16 @@ def _createModule(
         )
     else:
         mode = decideCompilationMode(
-            is_top=is_top, module_name=module_name, for_pgo=False
+            is_top=is_top,
+            module_name=module_name,
+            module_filename=module_filename,
+            for_pgo=False,
         )
 
         if (
             mode == "bytecode"
             and not is_top
-            and not Options.shallDisableBytecodeCacheUsage()
+            and not shallDisableBytecodeCacheUsage()
             and hasCachedImportedModuleUsageAttempts(
                 module_name=module_name, source_code=source_code, source_ref=source_ref
             )
@@ -1146,14 +1153,13 @@ def _createModule(
 
 
 def createModuleTree(module, source_ref, ast_tree, is_main):
-    if Options.isShowMemory():
+    if isShowMemory():
         memory_watch = MemoryUsage.MemoryWatch()
 
     module_body = buildParseTree(
         provider=module,
         ast_tree=ast_tree,
         source_ref=source_ref,
-        is_module=True,
         is_main=is_main,
     )
 
@@ -1164,17 +1170,19 @@ def createModuleTree(module, source_ref, ast_tree, is_main):
 
     completeVariableClosures(module)
 
-    if Options.isShowMemory():
+    if isShowMemory():
         memory_watch.finish(
             "Memory usage changed loading module '%s'" % module.getFullName()
         )
 
 
-def buildMainModuleTree(filename, source_code):
+def buildMainModuleTree(source_code):
     # Detect to be frozen modules if any, so we can consider to not follow
     # to them.
 
-    if Options.shallMakeModule():
+    filename = getMainEntryPointFilenames()[0]
+
+    if shallMakeModule():
         module_name = Importing.getModuleNameAndKindFromFilename(filename)[0]
 
         if module_name is None:
@@ -1184,7 +1192,7 @@ def buildMainModuleTree(filename, source_code):
             )
     else:
         # TODO: Doesn't work for deeply nested packages at all.
-        if Options.hasPythonFlagPackageMode():
+        if hasPythonFlagPackageMode():
             module_name = ModuleName(os.path.basename(filename) + ".__main__")
         else:
             module_name = ModuleName("__main__")
@@ -1195,13 +1203,13 @@ def buildMainModuleTree(filename, source_code):
         module_filename=filename,
         source_code=source_code,
         is_top=True,
-        is_main=not Options.shallMakeModule(),
+        is_main=not shallMakeModule(),
         module_kind="py",
         is_fake=source_code is not None,
         hide_syntax_error=False,
     )
 
-    if Options.isStandaloneMode():
+    if isStandaloneMode():
         module.setStandardLibraryModules(
             early_module_names=detectEarlyImports(),
             stdlib_modules_names=detectStdlibAutoInclusionModules(),
@@ -1233,7 +1241,7 @@ Cannot follow import to module '%s' because of '%s'."""
         reason=reason,
         is_top=False,
         mode="compiled",
-        future_spec=FutureSpec(),
+        future_spec=FutureSpec(use_annotations=False),
         source_ref=source_ref,
     )
 
@@ -1259,11 +1267,14 @@ def _makeModuleBodyTooComplex(
     if module_filename not in Importing.warned_about:
         Importing.warned_about.add(module_filename)
 
-        recursion_logger.info(
-            """\
+        # Known harmless case, not causing issues, lets not warn about it.
+        # spell-checker: ignore sympy,numberfields
+        if module_name != "sympy.polys.numberfields.resolvent_lookup":
+            recursion_logger.info(
+                """\
 Cannot compile module '%s' because its code is too complex, included as bytecode."""
-            % module_name
-        )
+                % module_name
+            )
 
     return makeUncompiledPythonModule(
         module_name=module_name,
@@ -1304,8 +1315,8 @@ def buildModule(
         logger=general,
     )
 
-    if Options.hasPythonFlagPackageMode():
-        if is_top and Options.shallMakeModule():
+    if hasPythonFlagPackageMode():
+        if is_top and shallMakeModule():
             optimization_logger.warning(
                 "Python flag -m (package_mode) has no effect in module mode, it's only for executables."
             )
@@ -1358,12 +1369,13 @@ def buildModule(
                 )
 
         try:
-            ast_tree = parseSourceCodeToAst(
-                source_code=source_code,
-                module_name=module_name,
-                filename=source_filename,
-                line_offset=0,
-            )
+            with withNoSyntaxWarning():
+                ast_tree = parseSourceCodeToAst(
+                    source_code=source_code,
+                    module_name=module_name,
+                    filename=source_filename,
+                    line_offset=0,
+                )
         except (SyntaxError, IndentationError) as e:
             # Do not hide SyntaxError if asked not to.
             if not hide_syntax_error:
@@ -1384,7 +1396,7 @@ def buildModule(
                     source_diff = getSourceCodeDiff(original_source_code, source_code)
 
                     for line in source_diff:
-                        plugins_logger.warning(line)
+                        plugins_logger.warning(line, keep_format=True)
 
                     if len(contributing_plugins) == 1:
                         next(iter(contributing_plugins)).sysexit(
@@ -1421,6 +1433,7 @@ def buildModule(
 
     module = _createModule(
         module_name=module_name,
+        module_filename=None if is_fake else module_filename,
         module_kind=module_kind,
         reason=reason,
         source_code=source_code,
@@ -1459,3 +1472,19 @@ def buildModule(
             )
 
     return module
+
+
+#     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.