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

nuitka/build/include/nuitka/helper/dictionaries.h

@@ -197,9 +197,17 @@ static Nuitka_DictEntryHandle GET_STRING_DICT_ENTRY(PyDictObject *dict, Nuitka_S
     }
 
 #else
-    // Will be written by Nuitka_PyDictLookupStr in all cases.
     PyObject **value;
-    NUITKA_MAY_BE_UNUSED Py_ssize_t found = Nuitka_PyDictLookupStr(dict, (PyObject *)key, hash, &value);
+    NUITKA_MAY_BE_UNUSED Py_ssize_t found;
+
+    // We cannot use Nuitka_PyDictLookupStr in all cases, some modules misbehave
+    // and put non-strings in module dictionaries.
+    if (unlikely(dict->ma_keys->dk_kind == DICT_KEYS_GENERAL)) {
+        found = Nuitka_PyDictLookup(dict, (PyObject *)key, hash, &value);
+    } else {
+        found = Nuitka_PyDictLookupStr(dict, (PyObject *)key, hash, &value);
+    }
+
     assert(found != DKIX_ERROR);
 
     return value;

nuitka/build/include/nuitka/helper/tuples.h

@@ -34,6 +34,7 @@ extern PyObject *MAKE_TUPLE_EMPTY_VAR(PyThreadState *tstate, Py_ssize_t size);
 #endif
 
 NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE(PyThreadState *tstate, PyObject *const *elements, Py_ssize_t size) {
+    assert(size > 0);
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
 
     for (Py_ssize_t i = 0; i < size; i++) {
@@ -43,6 +44,17 @@ NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE(PyThreadState *tstate, PyObject
     return result;
 }
 
+NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE_VAR(PyThreadState *tstate, PyObject *const *elements,
+                                                     Py_ssize_t size) {
+    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, size);
+
+    for (Py_ssize_t i = 0; i < size; i++) {
+        PyTuple_SET_ITEM0(result, i, elements[i]);
+    }
+
+    return result;
+}
+
 NUITKA_MAY_BE_UNUSED static PyObject *MAKE_TUPLE1(PyThreadState *tstate, PyObject *element1) {
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, 1);
 

nuitka/build/include/nuitka/prelude.h

@@ -195,6 +195,7 @@ NUITKA_MAY_BE_UNUSED static inline managed_static_type_state *Nuitka_PyStaticTyp
 #include <internal/pycore_intrinsics.h>
 #include <internal/pycore_modsupport.h>
 #include <internal/pycore_parking_lot.h>
+#include <internal/pycore_pyatomic_ft_wrappers.h>
 #include <internal/pycore_setobject.h>
 #include <internal/pycore_time.h>
 #endif

nuitka/build/static_src/CompiledCodeHelpers.c

@@ -1629,6 +1629,7 @@ wchar_t const *getBinaryDirectoryWideChars(bool resolve_symlinks) {
 
         stripFilenameW(binary_directory);
 
+#ifndef _NUITKA_EXPERIMENTAL_AVOID_SHORT_PATH
         // Query length of result first.
         DWORD length = GetShortPathNameW(binary_directory, NULL, 0);
         assert(length != 0);
@@ -1645,6 +1646,7 @@ wchar_t const *getBinaryDirectoryWideChars(bool resolve_symlinks) {
         appendWStringSafeW(binary_directory, short_binary_directory, sizeof(binary_directory) / sizeof(wchar_t));
 
         free(short_binary_directory);
+#endif
 #else
         appendStringSafeW(binary_directory, getBinaryDirectoryHostEncoded(true),
                           sizeof(binary_directory) / sizeof(wchar_t));

nuitka/build/static_src/CompiledCoroutineType.c

@@ -1402,7 +1402,7 @@ static PyObject *computeCoroutineOrigin(PyThreadState *tstate, int origin_depth)
         frame_count += 1;
     }
 
-    PyObject *cr_origin = MAKE_TUPLE_EMPTY(tstate, frame_count);
+    PyObject *cr_origin = MAKE_TUPLE_EMPTY_VAR(tstate, frame_count);
 
     frame = PyEval_GetFrame();
 

nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c

@@ -148,12 +148,15 @@ static void SET_CURRENT_EXCEPTION_GENERATOR_EXIT(PyThreadState *tstate) {
 
 #if PYTHON_VERSION >= 0x300
 static bool Nuitka_PyGen_FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue) {
-    assert(HAS_ERROR_OCCURRED(tstate));
-
 #if PYTHON_VERSION < 0x3c0
-    PyObject *value = NULL;
+    if (!HAS_ERROR_OCCURRED(tstate)) {
+        *pvalue = Py_None;
+        Py_INCREF_IMMORTAL(Py_None);
+
+        return true;
+    } else if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, tstate->curexc_type, PyExc_StopIteration)) {
+        PyObject *value = NULL;
 
-    if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, tstate->curexc_type, PyExc_StopIteration)) {
         PyObject *exception_type, *exception_value;
         PyTracebackObject *exception_tb;
 
@@ -185,38 +188,44 @@ static bool Nuitka_PyGen_FetchStopIterationValue(PyThreadState *tstate, PyObject
 
         Py_XDECREF(exception_type);
         Py_XDECREF(exception_tb);
-    } else if (HAS_ERROR_OCCURRED(tstate)) {
-        return false;
-    }
 
-    if (value == NULL) {
-        value = Py_None;
-        Py_INCREF(value);
-    }
+        if (value == NULL) {
+            value = Py_None;
+            Py_INCREF(value);
+        }
 
-    *pvalue = value;
+        *pvalue = value;
 
-    return true;
+        return true;
+    } else {
+        return false;
+    }
 #else
-    PyObject *value = NULL;
+    if (!HAS_ERROR_OCCURRED(tstate)) {
+        *pvalue = Py_None;
+        Py_INCREF_IMMORTAL(Py_None);
+
+        return true;
+    } else if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, tstate->current_exception, PyExc_StopIteration)) {
+        PyObject *value = NULL;
 
-    if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, tstate->current_exception, PyExc_StopIteration)) {
         PyObject *exc = tstate->current_exception;
         tstate->current_exception = NULL;
 
         value = Py_NewRef(((PyStopIterationObject *)exc)->value);
         Py_DECREF(exc);
-    } else if (HAS_ERROR_OCCURRED(tstate)) {
-        return false;
-    }
 
-    if (value == NULL) {
-        value = Py_None;
-    }
+        if (value == NULL) {
+            value = Py_None;
+        }
+
+        *pvalue = value;
 
-    *pvalue = value;
+        return true;
 
-    return true;
+    } else {
+        return false;
+    }
 #endif
 }
 #endif

nuitka/build/static_src/HelpersBuiltin.c

@@ -48,7 +48,7 @@ PyObject *CALL_BUILTIN_KW_ARGS(PyThreadState *tstate, PyObject *callable, PyObje
         i++;
     }
 
-    PyObject *args_tuple = MAKE_TUPLE(tstate, args, usable_args);
+    PyObject *args_tuple = MAKE_TUPLE_VAR(tstate, args, usable_args);
 
     PyObject *result = CALL_FUNCTION(tstate, callable, args_tuple, kw_dict);
     Py_XDECREF(kw_dict);

nuitka/build/static_src/HelpersDeepcopy.c

@@ -594,6 +594,7 @@ static PyObject *_DEEP_COPY_TUPLE_GUIDED(PyThreadState *tstate, PyObject *value,
     Py_ssize_t size = PyTuple_GET_SIZE(value);
 
     // We cannot have size 0, so this is safe.
+    assert(size > 0);
     PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
 
     for (Py_ssize_t i = 0; i < size; i++) {

nuitka/build/static_src/HelpersDictionaries.c

@@ -1015,9 +1015,14 @@ void DICT_CLEAR(PyObject *dict) {
 #if PYTHON_VERSION >= 0x3b0
 static inline int Nuitka_py_get_index_from_order(PyDictObject *mp, Py_ssize_t i) {
     assert(mp->ma_used <= SHARED_KEYS_MAX_SIZE);
+#if PYTHON_VERSION < 0x3d0
     assert(i < (((char *)mp->ma_values)[-2]));
-
     return ((char *)mp->ma_values)[-3 - i];
+#else
+    assert(i < mp->ma_values->size);
+    uint8_t *array = get_insertion_order_array(mp->ma_values);
+    return array[i];
+#endif
 }
 #endif
 
@@ -1049,7 +1054,14 @@ static inline Py_ssize_t Nuitka_Py_dictkeys_get_index(const PyDictKeysObject *ke
     return ix;
 }
 
-static inline Py_hash_t Nuitka_Py_unicode_get_hash(PyObject *o) { return _PyASCIIObject_CAST(o)->hash; }
+static inline Py_hash_t Nuitka_Py_unicode_get_hash(PyObject *o) {
+#if PYTHON_VERSION < 0x3d0
+    return _PyASCIIObject_CAST(o)->hash;
+#else
+    assert(PyUnicode_CheckExact(o));
+    return FT_ATOMIC_LOAD_SSIZE_RELAXED(_PyASCIIObject_CAST(o)->hash);
+#endif
+}
 
 // From CPython
 #define PERTURB_SHIFT 5

nuitka/build/static_src/HelpersDictionariesGenerated.c

@@ -75,7 +75,11 @@ PyObject *DICT_COPY(PyThreadState *tstate, PyObject *dict_value) {
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
+#if PYTHON_VERSION < 0x3b0
             Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
+#else
+            Py_ssize_t size = dict_mp->ma_keys->dk_nentries + dict_mp->ma_keys->dk_usable;
+#endif
 
             PyDictValues *new_values = _Nuitka_PyDict_new_values(size);
             assert(new_values != NULL);
@@ -289,7 +293,11 @@ PyObject *DEEP_COPY_DICT(PyThreadState *tstate, PyObject *dict_value) {
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
+#if PYTHON_VERSION < 0x3b0
             Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
+#else
+            Py_ssize_t size = dict_mp->ma_keys->dk_nentries + dict_mp->ma_keys->dk_usable;
+#endif
 
             PyDictValues *new_values = _Nuitka_PyDict_new_values(size);
             assert(new_values != NULL);
@@ -514,8 +522,11 @@ static PyObject *COPY_DICT_KW(PyThreadState *tstate, PyObject *dict_value) {
             assert(result_mp != NULL);
             result = (PyObject *)result_mp;
 
+#if PYTHON_VERSION < 0x3b0
             Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
-
+#else
+            Py_ssize_t size = dict_mp->ma_keys->dk_nentries + dict_mp->ma_keys->dk_usable;
+#endif
 #if PYTHON_VERSION < 0x3b0
             for (Py_ssize_t i = 0; i < size; i++) {
                 PyDictKeyEntry *entry = &DK_ENTRIES(dict_mp->ma_keys)[i];

nuitka/build/static_src/HelpersFiles.c

@@ -246,7 +246,7 @@ extern PyObject *OS_LSTAT(PyThreadState *tstate, PyObject *path, PyObject *dir_f
 
     assert(path != NULL);
     assert(dir_fd == NULL);
-    PyObject *stat_func = LOOKUP_ATTRIBUTE(tstate, IMPORT_HARD_OS(), const_str_plain_stat);
+    PyObject *stat_func = LOOKUP_ATTRIBUTE(tstate, IMPORT_HARD_OS(), const_str_plain_lstat);
 
     result = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, stat_func, path);
 

nuitka/build/static_src/HelpersTuples.c

@@ -117,7 +117,7 @@ PyObject *TUPLE_COPY(PyThreadState *tstate, PyObject *tuple) {
     assert(PyTuple_CheckExact(tuple));
 
     Py_ssize_t size = PyTuple_GET_SIZE(tuple);
-    PyObject *result = MAKE_TUPLE_EMPTY(tstate, size);
+    PyObject *result = MAKE_TUPLE_EMPTY_VAR(tstate, size);
 
     if (unlikely(result == NULL)) {
         return NULL;

nuitka/build/static_src/MainProgram.c

@@ -16,6 +16,10 @@
 #include <windows.h>
 #endif
 
+#if defined(__APPLE__)
+#include <unistd.h>
+#endif
+
 #include "nuitka/prelude.h"
 
 #ifndef __IDE_ONLY__
@@ -1219,6 +1223,19 @@ int main(int argc, char **argv) {
     inheritAttachedConsole();
 #endif
 
+#ifdef _NUITKA_MACOS_BUNDLE
+    {
+        char *current_dir = getcwd(NULL, -1);
+
+        if (strcmp(current_dir, "/") == 0) {
+            chdir(getBinaryDirectoryHostEncoded(false));
+            chdir("../../../");
+        }
+
+        free(current_dir);
+    }
+#endif
+
     // Set up stdout/stderr according to user specification.
 #if NUITKA_STANDARD_HANDLES_EARLY == 1
 #if defined(NUITKA_FORCED_STDOUT_PATH)
@@ -1334,15 +1351,19 @@ int main(int argc, char **argv) {
     /* Initial command line handling only. */
 
 // Make sure, we use the absolute program path for argv[0]
-#if !defined(_NUITKA_ONEFILE_MODE) && _NUITKA_NATIVE_WCHAR_ARGV == 0
+#if _NUITKA_NATIVE_WCHAR_ARGV == 0
     original_argv0 = argv[0];
+#if !defined(_NUITKA_ONEFILE_MODE)
     argv[0] = (char *)getBinaryFilenameHostEncoded(false);
 #endif
+#endif
 
 #if defined(_NUITKA_ONEFILE_MODE)
     {
         environment_char_t const *parent_original_argv0 = getEnvironmentVariable("NUITKA_ORIGINAL_ARGV0");
 
+        // If forked from the parent process, it's set, otherwise fall back
+        // to standalone executable binary name as set above.
         if (parent_original_argv0 != NULL) {
             original_argv0 = strdupFilename(parent_original_argv0);
 
@@ -1362,9 +1383,9 @@ orig_argv = argv;
 #endif
 
 // Make sure, we use the absolute program path for argv[0]
-#if !defined(_NUITKA_ONEFILE_MODE) && _NUITKA_NATIVE_WCHAR_ARGV == 1
+#if _NUITKA_NATIVE_WCHAR_ARGV == 1
     original_argv0 = argv[0];
-#if PYTHON_VERSION >= 0x300
+#if PYTHON_VERSION >= 0x300 && !defined(_NUITKA_ONEFILE_MODE)
     orig_argv[0] = (wchar_t *)getBinaryFilenameWideChars(false);
 #endif
 #endif

nuitka/code_generation/templates/CodeTemplatesVariables.py

@@ -313,41 +313,44 @@ static PyObject *%(accessor_function_name)s(PyThreadState *tstate) {
     static Py_ssize_t cache_dk_index = 0;
 
     PyDictKeysObject *dk = moduledict_%(module_identifier)s->ma_keys;
-    assert(DK_IS_UNICODE(dk));
+    if (likely(DK_IS_UNICODE(dk))) {
 
 #if PYTHON_VERSION >= 0x3c0
-    uint32_t current_dk_version = _Nuitka_PyDictKeys_GetVersionForCurrentState(tstate->interp, dk);
+        uint32_t current_dk_version = _Nuitka_PyDictKeys_GetVersionForCurrentState(tstate->interp, dk);
 #else
-    uint32_t current_dk_version = _Nuitka_PyDictKeys_GetVersionForCurrentState(dk);
+        uint32_t current_dk_version = _Nuitka_PyDictKeys_GetVersionForCurrentState(dk);
 #endif
 
-    if (current_dk_version != dict_keys_version) {
-        dict_keys_version = current_dk_version;
-        Py_hash_t hash = ((Nuitka_StringObject *)%(var_name)s)->_base._base.hash;
-        assert(hash != -1);
+        if (current_dk_version != dict_keys_version) {
+            dict_keys_version = current_dk_version;
+            Py_hash_t hash = ((Nuitka_StringObject *)%(var_name)s)->_base._base.hash;
+            assert(hash != -1);
 
-        cache_dk_index = Nuitka_Py_unicodekeys_lookup_unicode(dk, %(var_name)s, hash);
-    }
+            cache_dk_index = Nuitka_Py_unicodekeys_lookup_unicode(dk, %(var_name)s, hash);
+        }
 
-    if (cache_dk_index >= 0) {
-        assert(dk->dk_kind != DICT_KEYS_SPLIT);
+        if (cache_dk_index >= 0) {
+            assert(dk->dk_kind != DICT_KEYS_SPLIT);
 
-        PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(dk);
+            PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(dk);
 
-        result = entries[cache_dk_index].me_value;
+            result = entries[cache_dk_index].me_value;
 
-        if (unlikely(result == NULL)) {
-            Py_hash_t hash = ((Nuitka_StringObject *)%(var_name)s)->_base._base.hash;
-            assert(hash != -1);
+            if (unlikely(result == NULL)) {
+                Py_hash_t hash = ((Nuitka_StringObject *)%(var_name)s)->_base._base.hash;
+                assert(hash != -1);
 
-            cache_dk_index = Nuitka_Py_unicodekeys_lookup_unicode(dk, %(var_name)s, hash);
+                cache_dk_index = Nuitka_Py_unicodekeys_lookup_unicode(dk, %(var_name)s, hash);
 
-            if (cache_dk_index >= 0) {
-                result = entries[cache_dk_index].me_value;
+                if (cache_dk_index >= 0) {
+                    result = entries[cache_dk_index].me_value;
+                }
             }
+        } else {
+            result = NULL;
         }
     } else {
-        result = NULL;
+        result = GET_STRING_DICT_VALUE(moduledict_%(module_identifier)s, (Nuitka_StringObject *)%(var_name)s);
     }
 #endif
 

nuitka/code_generation/templates_c/HelperDictionaryCopy.c.j2

@@ -41,8 +41,11 @@ else
         assert(result_mp != NULL);
         {{ result }} = (PyObject *)result_mp;
 
+#if PYTHON_VERSION < 0x3b0
         Py_ssize_t size = DK_ENTRIES_SIZE(dict_mp->ma_keys);
-
+#else
+        Py_ssize_t size = dict_mp->ma_keys->dk_nentries + dict_mp->ma_keys->dk_usable;
+#endif
 {% if per_key_code %}
 #if PYTHON_VERSION < 0x3b0
         for (Py_ssize_t i = 0; i < size; i++) {

nuitka/freezer/ImportDetection.py

@@ -137,7 +137,10 @@ print("\\n".join(sorted(
                     "_collections_abc.py",
                     "_collections_abc.pyc",
                 ):
-                    if python_version >= 0x3D0:
+                    # Note: This was only useful for 3.13.0, and 3.13.1 already
+                    # didn't need it anymore. So precise version check for a major
+                    # version is correct here.
+                    if python_version == 0x3D0:
                         detections.append((module_name, 2, "sourcefile", filename))
 
                     module_name = ModuleName("_collections_abc")

nuitka/freezer/IncludedDataFiles.py

@@ -27,7 +27,7 @@ from nuitka.Options import (
     shallMakeModule,
 )
 from nuitka.OutputDirectories import getStandaloneDirectoryPath
-from nuitka.Tracing import general, options_logger
+from nuitka.Tracing import general, inclusion_logger, options_logger
 from nuitka.utils.FileOperations import (
     areSamePaths,
     containsPathElements,
@@ -336,6 +336,15 @@ def addIncludedDataFile(included_datafile):
             ):
                 included_datafile.tags.add("external")
 
+                dest_path = getOutputPath(included_datafile.dest_path)
+
+                if areSamePaths(dest_path, included_datafile.source_path):
+                    inclusion_logger.sysexit(
+                        """\
+Error, when asking to copy files external data, you cannot output to\
+same directory and need to use '--output-dir' option."""
+                    )
+
     _included_data_files.append(included_datafile)
 
 

nuitka/freezer/Onefile.py

@@ -244,6 +244,7 @@ def packDistFolderToOnefileBootstrap(onefile_output_filename, dist_dir):
 
     if isMacOS():
         addMacOSCodeSignature(filenames=[onefile_output_filename])
+        assert payload_used_in_build
 
     if not payload_used_in_build:
         runOnefileCompressor(

nuitka/nodes/BuiltinIteratorNodes.py

@@ -20,7 +20,7 @@ from .NodeMakingHelpers import (
     makeRaiseTypeErrorExceptionReplacementFromTemplateAndValue,
     wrapExpressionWithSideEffects,
 )
-from .shapes.StandardShapes import tshape_iterator
+from .shapes.IteratorShapes import tshape_iterator
 from .StatementBasesGenerated import (
     StatementSpecialUnpackCheckBase,
     StatementSpecialUnpackCheckFromIteratedBase,

nuitka/nodes/DictionaryNodes.py

@@ -61,7 +61,7 @@ from .NodeMakingHelpers import (
     makeStatementOnlyNodesFromExpressions,
     wrapExpressionWithSideEffects,
 )
-from .shapes.StandardShapes import tshape_iterator
+from .shapes.IteratorShapes import tshape_iterator
 from .StatementBasesGenerated import (
     StatementDictOperationRemoveBase,
     StatementDictOperationSetBase,

nuitka/nodes/VariableAssignNodes.py

@@ -31,7 +31,8 @@ from .shapes.ControlFlowDescriptions import (
     ControlFlowDescriptionFullEscape,
     ControlFlowDescriptionNoEscape,
 )
-from .shapes.StandardShapes import tshape_iterator, tshape_unknown
+from .shapes.IteratorShapes import tshape_iterator
+from .shapes.StandardShapes import tshape_unknown
 from .StatementBasesGenerated import (
     StatementAssignmentVariableConstantImmutableBase,
     StatementAssignmentVariableConstantMutableBase,

nuitka/nodes/shapes/IteratorShapes.py

@@ -0,0 +1,71 @@
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
+""" Iterator shapes that commonly appear. """
+
+from .ControlFlowDescriptions import ControlFlowDescriptionFullEscape
+from .ShapeMixins import ShapeIteratorMixin
+from .StandardShapes import ShapeBase, tshape_unknown
+
+
+class ShapeIterator(ShapeBase, ShapeIteratorMixin):
+    """Iterator created by iter with 2 arguments, TODO: could be way more specific."""
+
+    __slots__ = ()
+
+    @staticmethod
+    def isShapeIterator():
+        return None
+
+    @staticmethod
+    def hasShapeSlotBool():
+        return None
+
+    @staticmethod
+    def hasShapeSlotLen():
+        return None
+
+    @staticmethod
+    def hasShapeSlotInt():
+        return None
+
+    @staticmethod
+    def hasShapeSlotLong():
+        return None
+
+    @staticmethod
+    def hasShapeSlotFloat():
+        return None
+
+    @staticmethod
+    def getShapeIter():
+        return tshape_iterator
+
+    @staticmethod
+    def getOperationUnaryReprEscape():
+        return ControlFlowDescriptionFullEscape
+
+    def getOperationUnaryAddShape(self):
+        # TODO: Move prepared values to separate module
+        return tshape_unknown, ControlFlowDescriptionFullEscape
+
+    def getOperationUnarySubShape(self):
+        return tshape_unknown, ControlFlowDescriptionFullEscape
+
+
+tshape_iterator = ShapeIterator()
+
+#     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/nodes/shapes/ShapeMixins.py

@@ -11,6 +11,7 @@ from .ControlFlowDescriptions import (
     ControlFlowDescriptionNoEscape,
     ControlFlowDescriptionSubUnsupported,
 )
+from .StandardShapes import tshape_unknown
 
 
 class ShapeContainerMixin(object):
@@ -140,11 +141,11 @@ class ShapeNotNumberMixin(object):
 
     @staticmethod
     def getOperationUnaryAddShape():
-        return None, ControlFlowDescriptionAddUnsupported
+        return tshape_unknown, ControlFlowDescriptionAddUnsupported
 
     @staticmethod
     def getOperationUnarySubShape():
-        return None, ControlFlowDescriptionSubUnsupported
+        return tshape_unknown, ControlFlowDescriptionSubUnsupported
 
 
 class ShapeNumberMixin(object):

nuitka/nodes/shapes/StandardShapes.py

@@ -15,7 +15,6 @@ from nuitka.code_generation.Reports import (
 from nuitka.utils.SlotMetaClasses import getMetaClassBase
 
 from .ControlFlowDescriptions import ControlFlowDescriptionFullEscape
-from .ShapeMixins import ShapeIteratorMixin
 
 
 class ShapeBase(getMetaClassBase("Shape", require_slots=True)):
@@ -130,7 +129,7 @@ class ShapeBase(getMetaClassBase("Shape", require_slots=True)):
             return operation_result_unknown
 
     # TODO: Change defaults to be "None" for easier catching of
-    # non-overloaders
+    # non-overloading cases.
     iadd_shapes = {}
 
     def getOperationInplaceAddShape(self, right_shape):
@@ -632,54 +631,6 @@ class ShapeLargeConstantValuePredictable(ShapeLargeConstantValue):
         self.predictor = predictor
 
 
-class ShapeIterator(ShapeBase, ShapeIteratorMixin):
-    """Iterator created by iter with 2 arguments, TODO: could be way more specific."""
-
-    __slots__ = ()
-
-    @staticmethod
-    def isShapeIterator():
-        return None
-
-    @staticmethod
-    def hasShapeSlotBool():
-        return None
-
-    @staticmethod
-    def hasShapeSlotLen():
-        return None
-
-    @staticmethod
-    def hasShapeSlotInt():
-        return None
-
-    @staticmethod
-    def hasShapeSlotLong():
-        return None
-
-    @staticmethod
-    def hasShapeSlotFloat():
-        return None
-
-    @staticmethod
-    def getShapeIter():
-        return tshape_iterator
-
-    @staticmethod
-    def getOperationUnaryReprEscape():
-        return ControlFlowDescriptionFullEscape
-
-    def getOperationUnaryAddShape(self):
-        # TODO: Move prepared values to separate module
-        return tshape_unknown, ControlFlowDescriptionFullEscape
-
-    def getOperationUnarySubShape(self):
-        return tshape_unknown, ControlFlowDescriptionFullEscape
-
-
-tshape_iterator = ShapeIterator()
-
-
 class ShapeLoopInitialAlternative(ShapeBase):
     """Merge of loop wrap around with loop start value.