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

nuitka/nodes/ChildrenHavingMixins.py

@@ -1,33 +1,34 @@
-#     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
+
+
 # We are not avoiding these in generated code at all
-# pylint: disable=I0021,too-many-lines
-# pylint: disable=I0021,line-too-long
-# pylint: disable=I0021,too-many-instance-attributes
-# pylint: disable=I0021,too-many-return-statements
+# pylint: disable=I0021,line-too-long,too-many-instance-attributes,too-many-lines
+# pylint: disable=I0021,too-many-arguments,too-many-return-statements,too-many-statements
 
 
 """Children having mixins
 
 WARNING, this code is GENERATED. Modify the template ChildrenHavingMixin.py.j2 instead!
 
-spell-checker: ignore append capitalize casefold center clear copy count decode encode endswith expandtabs extend find format formatmap fromkeys get haskey index insert isalnum isalpha isascii isdecimal isdigit isidentifier islower isnumeric isprintable isspace istitle isupper items iteritems iterkeys itervalues join keys ljust lower lstrip maketrans partition pop popitem prepare remove replace reverse rfind rindex rjust rpartition rsplit rstrip setdefault sort split splitlines startswith strip swapcase title translate update upper values viewitems viewkeys viewvalues zfill
-spell-checker: ignore args chars count default delete encoding end errors fillchar index item iterable keepends key kwargs maxsplit new old pairs prefix sep start stop sub suffix table tabsize value width
+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 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
+spell-checker: ignore sort split splitlines start startswith stop strip sub suffix
+spell-checker: ignore swapcase table tabsize title translate update upper use_errno
+spell-checker: ignore use_last_error value values viewitems viewkeys viewvalues width
+spell-checker: ignore winmode zfill
 """
 
 
@@ -47,6 +48,7 @@ class ModuleChildrenHavingBodyOptionalStatementsOrNoneFunctionsTupleMixin(object
 
     # This is generated for use in
     #   CompiledPythonModule
+    #   CompiledPythonNamespacePackage
     #   CompiledPythonPackage
     #   PythonMainModule
 
@@ -141,9 +143,9 @@ class ModuleChildrenHavingBodyOptionalStatementsOrNoneFunctionsTupleMixin(object
         """
 
         values = {
-            "body": self.subnode_body.makeClone()
-            if self.subnode_body is not None
-            else None,
+            "body": (
+                self.subnode_body.makeClone() if self.subnode_body is not None else None
+            ),
             "functions": tuple(v.makeClone() for v in self.subnode_functions),
         }
 
@@ -176,6 +178,9 @@ class ModuleChildrenHavingBodyOptionalStatementsOrNoneFunctionsTupleMixin(object
 ChildrenCompiledPythonModuleMixin = (
     ModuleChildrenHavingBodyOptionalStatementsOrNoneFunctionsTupleMixin
 )
+ChildrenCompiledPythonNamespacePackageMixin = (
+    ModuleChildrenHavingBodyOptionalStatementsOrNoneFunctionsTupleMixin
+)
 ChildrenCompiledPythonPackageMixin = (
     ModuleChildrenHavingBodyOptionalStatementsOrNoneFunctionsTupleMixin
 )
@@ -281,8 +286,9 @@ class ChildHavingBodyOptionalMixin(object):
 
     # This is generated for use in
     #   ExpressionAsyncgenObjectBody
-    #   ExpressionClassBodyP2
-    #   ExpressionClassBodyP3
+    #   ExpressionClassDictBody
+    #   ExpressionClassDictBodyP2
+    #   ExpressionClassMappingBody
     #   ExpressionCoroutineObjectBody
     #   ExpressionFunctionBody
     #   ExpressionFunctionPureBody
@@ -343,9 +349,9 @@ class ChildHavingBodyOptionalMixin(object):
         """
 
         values = {
-            "body": self.subnode_body.makeClone()
-            if self.subnode_body is not None
-            else None,
+            "body": (
+                self.subnode_body.makeClone() if self.subnode_body is not None else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -395,8 +401,9 @@ class ChildHavingBodyOptionalMixin(object):
 
 # Assign the names that are easier to import with a stable name.
 ChildrenExpressionAsyncgenObjectBodyMixin = ChildHavingBodyOptionalMixin
-ChildrenExpressionClassBodyP2Mixin = ChildHavingBodyOptionalMixin
-ChildrenExpressionClassBodyP3Mixin = ChildHavingBodyOptionalMixin
+ChildrenExpressionClassDictBodyMixin = ChildHavingBodyOptionalMixin
+ChildrenExpressionClassDictBodyP2Mixin = ChildHavingBodyOptionalMixin
+ChildrenExpressionClassMappingBodyMixin = ChildHavingBodyOptionalMixin
 ChildrenExpressionCoroutineObjectBodyMixin = ChildHavingBodyOptionalMixin
 ChildrenExpressionFunctionBodyMixin = ChildHavingBodyOptionalMixin
 ChildrenExpressionFunctionPureBodyMixin = ChildHavingBodyOptionalMixin
@@ -4828,12 +4835,16 @@ class ChildrenHavingDefaultsTupleKwDefaultsOptionalAnnotationsOptionalFunctionRe
 
         values = {
             "defaults": tuple(v.makeClone() for v in self.subnode_defaults),
-            "kw_defaults": self.subnode_kw_defaults.makeClone()
-            if self.subnode_kw_defaults is not None
-            else None,
-            "annotations": self.subnode_annotations.makeClone()
-            if self.subnode_annotations is not None
-            else None,
+            "kw_defaults": (
+                self.subnode_kw_defaults.makeClone()
+                if self.subnode_kw_defaults is not None
+                else None
+            ),
+            "annotations": (
+                self.subnode_annotations.makeClone()
+                if self.subnode_annotations is not None
+                else None
+            ),
             "function_ref": self.subnode_function_ref.makeClone(),
         }
 
@@ -6068,7 +6079,7 @@ ChildrenExpressionMakeSetLiteralMixin = ChildHavingElementsTupleMixin
 ChildrenExpressionMakeTupleMixin = ChildHavingElementsTupleMixin
 
 
-class ChildrenHavingExceptionTypeExceptionValueMixin(object):
+class ChildHavingExceptionTypeMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
@@ -6078,23 +6089,15 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
     def __init__(
         self,
         exception_type,
-        exception_value,
     ):
         exception_type.parent = self
 
         self.subnode_exception_type = exception_type
 
-        exception_value.parent = self
-
-        self.subnode_exception_value = exception_value
-
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
-        return (
-            self.subnode_exception_type,
-            self.subnode_exception_value,
-        )
+        return (self.subnode_exception_type,)
 
     def getVisitableNodesNamed(self):
         """Named children dictionary.
@@ -6102,10 +6105,7 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
         For use in cloning nodes, debugging and XML output.
         """
 
-        return (
-            ("exception_type", self.subnode_exception_type),
-            ("exception_value", self.subnode_exception_value),
-        )
+        return (("exception_type", self.subnode_exception_type),)
 
     def replaceChild(self, old_node, new_node):
         value = self.subnode_exception_type
@@ -6116,11 +6116,101 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
 
             return
 
-        value = self.subnode_exception_value
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "exception_type": self.subnode_exception_type.makeClone(),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        self.subnode_exception_type.finalize()
+        del self.subnode_exception_type
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expression, as they it's evaluated before.
+        expression = trace_collection.onExpression(self.subnode_exception_type)
+
+        if expression.willRaiseAnyException():
+            return (
+                expression,
+                "new_raise",
+                lambda: "For '%s' the child expression '%s' will raise."
+                % (self.getChildNameNice(), expression.getChildNameNice()),
+            )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        self.subnode_exception_type.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionRaiseExceptionMixin = ChildHavingExceptionTypeMixin
+
+
+class ChildHavingExitCodeOptionalMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionSysExit
+
+    def __init__(
+        self,
+        exit_code,
+    ):
+        if exit_code is not None:
+            exit_code.parent = self
+
+        self.subnode_exit_code = exit_code
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        value = self.subnode_exit_code
+
+        if value is None:
+            return ()
+        else:
+            return (value,)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (("exit_code", self.subnode_exit_code),)
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_exit_code
         if old_node is value:
-            new_node.parent = self
+            if new_node is not None:
+                new_node.parent = self
 
-            self.subnode_exception_value = new_node
+            self.subnode_exit_code = new_node
 
             return
 
@@ -6133,8 +6223,11 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
         """
 
         values = {
-            "exception_type": self.subnode_exception_type.makeClone(),
-            "exception_value": self.subnode_exception_value.makeClone(),
+            "exit_code": (
+                self.subnode_exit_code.makeClone()
+                if self.subnode_exit_code is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -6144,10 +6237,9 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
     def finalize(self):
         del self.parent
 
-        self.subnode_exception_type.finalize()
-        del self.subnode_exception_type
-        self.subnode_exception_value.finalize()
-        del self.subnode_exception_value
+        if self.subnode_exit_code is not None:
+            self.subnode_exit_code.finalize()
+        del self.subnode_exit_code
 
     def computeExpressionRaw(self, trace_collection):
         """Compute an expression.
@@ -6157,22 +6249,15 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
         be overloaded, e.g. conditional expressions.
         """
 
-        # First apply the sub-expressions, as they are evaluated before
-        # the actual operation.
-        for count, sub_expression in enumerate(self.getVisitableNodes()):
-            expression = trace_collection.onExpression(sub_expression)
-
-            if expression.willRaiseAnyException():
-                sub_expressions = self.getVisitableNodes()
+        # First apply the sub-expression, as they it's evaluated before.
+        expression = self.subnode_exit_code
 
-                wrapped_expression = wrapExpressionWithSideEffects(
-                    side_effects=sub_expressions[:count],
-                    old_node=sub_expression,
-                    new_node=expression,
-                )
+        if expression is not None:
+            expression = trace_collection.onExpression(expression)
 
+            if expression.willRaiseAnyException():
                 return (
-                    wrapped_expression,
+                    expression,
                     "new_raise",
                     lambda: "For '%s' the child expression '%s' will raise."
                     % (self.getChildNameNice(), expression.getChildNameNice()),
@@ -6184,12 +6269,14 @@ class ChildrenHavingExceptionTypeExceptionValueMixin(object):
     def collectVariableAccesses(self, emit_read, emit_write):
         """Collect variable reads and writes of child nodes."""
 
-        self.subnode_exception_type.collectVariableAccesses(emit_read, emit_write)
-        self.subnode_exception_value.collectVariableAccesses(emit_read, emit_write)
+        subnode_exit_code = self.subnode_exit_code
+
+        if subnode_exit_code is not None:
+            self.subnode_exit_code.collectVariableAccesses(emit_read, emit_write)
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionRaiseExceptionMixin = ChildrenHavingExceptionTypeExceptionValueMixin
+ChildrenExpressionSysExitMixin = ChildHavingExitCodeOptionalMixin
 
 
 class ChildHavingExpressionMixin(object):
@@ -6384,10 +6471,9 @@ class ChildHavingExpressionMixin(object):
     #   ExpressionAttributeLookupStrUpper
     #   ExpressionAttributeLookupStrZfill
     #   ExpressionAttributeLookupTypePrepare
-    #   ExpressionMatchArgs
     #   ExpressionYield
     #   ExpressionYieldFrom
-    #   ExpressionYieldFromWaitable
+    #   ExpressionYieldFromAwaitable
 
     def __init__(
         self,
@@ -6657,10 +6743,9 @@ ChildrenExpressionAttributeLookupStrTranslateMixin = ChildHavingExpressionMixin
 ChildrenExpressionAttributeLookupStrUpperMixin = ChildHavingExpressionMixin
 ChildrenExpressionAttributeLookupStrZfillMixin = ChildHavingExpressionMixin
 ChildrenExpressionAttributeLookupTypePrepareMixin = ChildHavingExpressionMixin
-ChildrenExpressionMatchArgsMixin = ChildHavingExpressionMixin
 ChildrenExpressionYieldMixin = ChildHavingExpressionMixin
 ChildrenExpressionYieldFromMixin = ChildHavingExpressionMixin
-ChildrenExpressionYieldFromWaitableMixin = ChildHavingExpressionMixin
+ChildrenExpressionYieldFromAwaitableMixin = ChildHavingExpressionMixin
 
 
 class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
@@ -6760,12 +6845,16 @@ class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
 
         values = {
             "expression": self.subnode_expression.makeClone(),
-            "lower": self.subnode_lower.makeClone()
-            if self.subnode_lower is not None
-            else None,
-            "upper": self.subnode_upper.makeClone()
-            if self.subnode_upper is not None
-            else None,
+            "lower": (
+                self.subnode_lower.makeClone()
+                if self.subnode_lower is not None
+                else None
+            ),
+            "upper": (
+                self.subnode_upper.makeClone()
+                if self.subnode_upper is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -6836,6 +6925,130 @@ ChildrenExpressionSliceLookupMixin = (
 )
 
 
+class ChildrenHavingExpressionMatchTypeMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionMatchArgs
+
+    def __init__(
+        self,
+        expression,
+        match_type,
+    ):
+        expression.parent = self
+
+        self.subnode_expression = expression
+
+        match_type.parent = self
+
+        self.subnode_match_type = match_type
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        return (
+            self.subnode_expression,
+            self.subnode_match_type,
+        )
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (
+            ("expression", self.subnode_expression),
+            ("match_type", self.subnode_match_type),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_expression
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_expression = new_node
+
+            return
+
+        value = self.subnode_match_type
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_match_type = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "expression": self.subnode_expression.makeClone(),
+            "match_type": self.subnode_match_type.makeClone(),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        self.subnode_expression.finalize()
+        del self.subnode_expression
+        self.subnode_match_type.finalize()
+        del self.subnode_match_type
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
+
+            if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
+                return (
+                    wrapped_expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        self.subnode_expression.collectVariableAccesses(emit_read, emit_write)
+        self.subnode_match_type.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionMatchArgsMixin = ChildrenHavingExpressionMatchTypeMixin
+
+
 class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
@@ -6924,9 +7137,11 @@ class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
         values = {
             "expression": self.subnode_expression.makeClone(),
             "name": self.subnode_name.makeClone(),
-            "default": self.subnode_default.makeClone()
-            if self.subnode_default is not None
-            else None,
+            "default": (
+                self.subnode_default.makeClone()
+                if self.subnode_default is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -7139,7 +7354,7 @@ class ChildrenHavingExpressionSubscriptMixin(object):
     __slots__ = ()
 
     # This is generated for use in
-    #   ExpressionSubscriptCheck
+    #   ExpressionMatchSubscriptCheck
     #   ExpressionSubscriptLookup
     #   ExpressionSubscriptLookupForUnpack
 
@@ -7257,7 +7472,7 @@ class ChildrenHavingExpressionSubscriptMixin(object):
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionSubscriptCheckMixin = ChildrenHavingExpressionSubscriptMixin
+ChildrenExpressionMatchSubscriptCheckMixin = ChildrenHavingExpressionSubscriptMixin
 ChildrenExpressionSubscriptLookupMixin = ChildrenHavingExpressionSubscriptMixin
 ChildrenExpressionSubscriptLookupForUnpackMixin = ChildrenHavingExpressionSubscriptMixin
 
@@ -7448,12 +7663,14 @@ class ChildrenHavingFilenameModeOptionalBufferingOptionalMixin(object):
 
         values = {
             "filename": self.subnode_filename.makeClone(),
-            "mode": self.subnode_mode.makeClone()
-            if self.subnode_mode is not None
-            else None,
-            "buffering": self.subnode_buffering.makeClone()
-            if self.subnode_buffering is not None
-            else None,
+            "mode": (
+                self.subnode_mode.makeClone() if self.subnode_mode is not None else None
+            ),
+            "buffering": (
+                self.subnode_buffering.makeClone()
+                if self.subnode_buffering is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -7724,27 +7941,39 @@ class ChildrenHavingFilenameModeOptionalBufferingOptionalEncodingOptionalErrorsO
 
         values = {
             "filename": self.subnode_filename.makeClone(),
-            "mode": self.subnode_mode.makeClone()
-            if self.subnode_mode is not None
-            else None,
-            "buffering": self.subnode_buffering.makeClone()
-            if self.subnode_buffering is not None
-            else None,
-            "encoding": self.subnode_encoding.makeClone()
-            if self.subnode_encoding is not None
-            else None,
-            "errors": self.subnode_errors.makeClone()
-            if self.subnode_errors is not None
-            else None,
-            "newline": self.subnode_newline.makeClone()
-            if self.subnode_newline is not None
-            else None,
-            "closefd": self.subnode_closefd.makeClone()
-            if self.subnode_closefd is not None
-            else None,
-            "opener": self.subnode_opener.makeClone()
-            if self.subnode_opener is not None
-            else None,
+            "mode": (
+                self.subnode_mode.makeClone() if self.subnode_mode is not None else None
+            ),
+            "buffering": (
+                self.subnode_buffering.makeClone()
+                if self.subnode_buffering is not None
+                else None
+            ),
+            "encoding": (
+                self.subnode_encoding.makeClone()
+                if self.subnode_encoding is not None
+                else None
+            ),
+            "errors": (
+                self.subnode_errors.makeClone()
+                if self.subnode_errors is not None
+                else None
+            ),
+            "newline": (
+                self.subnode_newline.makeClone()
+                if self.subnode_newline is not None
+                else None
+            ),
+            "closefd": (
+                self.subnode_closefd.makeClone()
+                if self.subnode_closefd is not None
+                else None
+            ),
+            "opener": (
+                self.subnode_opener.makeClone()
+                if self.subnode_opener is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -7848,30 +8077,503 @@ class ChildrenHavingFilenameModeOptionalBufferingOptionalEncodingOptionalErrorsO
 ChildrenExpressionBuiltinOpenP3Mixin = ChildrenHavingFilenameModeOptionalBufferingOptionalEncodingOptionalErrorsOptionalNewlineOptionalClosefdOptionalOpenerOptionalMixin
 
 
-class ChildrenHavingFunctionValuesTupleMixin(object):
+class ChildrenHavingFuncOptionalInputSignatureOptionalAutographOptionalJitCompileOptionalReduceRetracingOptionalExperimentalImplementsOptionalExperimentalAutographOptionsOptionalExperimentalAttributesOptionalExperimentalRelaxShapesOptionalExperimentalCompileOptionalExperimentalFollowTypeHintsOptionalMixin(
+    object
+):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
     # This is generated for use in
-    #   ExpressionFunctionCall
+    #   ExpressionTensorflowFunction
+    #   ExpressionTensorflowFunctionCall
 
     def __init__(
         self,
-        function,
-        values,
+        func,
+        input_signature,
+        autograph,
+        jit_compile,
+        reduce_retracing,
+        experimental_implements,
+        experimental_autograph_options,
+        experimental_attributes,
+        experimental_relax_shapes,
+        experimental_compile,
+        experimental_follow_type_hints,
     ):
-        function.parent = self
+        if func is not None:
+            func.parent = self
 
-        self.subnode_function = function
+        self.subnode_func = func
 
-        assert type(values) is tuple
+        if input_signature is not None:
+            input_signature.parent = self
 
-        for val in values:
-            val.parent = self
+        self.subnode_input_signature = input_signature
 
-        self.subnode_values = values
+        if autograph is not None:
+            autograph.parent = self
 
-    def getVisitableNodes(self):
+        self.subnode_autograph = autograph
+
+        if jit_compile is not None:
+            jit_compile.parent = self
+
+        self.subnode_jit_compile = jit_compile
+
+        if reduce_retracing is not None:
+            reduce_retracing.parent = self
+
+        self.subnode_reduce_retracing = reduce_retracing
+
+        if experimental_implements is not None:
+            experimental_implements.parent = self
+
+        self.subnode_experimental_implements = experimental_implements
+
+        if experimental_autograph_options is not None:
+            experimental_autograph_options.parent = self
+
+        self.subnode_experimental_autograph_options = experimental_autograph_options
+
+        if experimental_attributes is not None:
+            experimental_attributes.parent = self
+
+        self.subnode_experimental_attributes = experimental_attributes
+
+        if experimental_relax_shapes is not None:
+            experimental_relax_shapes.parent = self
+
+        self.subnode_experimental_relax_shapes = experimental_relax_shapes
+
+        if experimental_compile is not None:
+            experimental_compile.parent = self
+
+        self.subnode_experimental_compile = experimental_compile
+
+        if experimental_follow_type_hints is not None:
+            experimental_follow_type_hints.parent = self
+
+        self.subnode_experimental_follow_type_hints = experimental_follow_type_hints
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        result = []
+        value = self.subnode_func
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_input_signature
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_autograph
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_jit_compile
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_reduce_retracing
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_experimental_implements
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_experimental_autograph_options
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_experimental_attributes
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_experimental_relax_shapes
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_experimental_compile
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_experimental_follow_type_hints
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        return tuple(result)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (
+            ("func", self.subnode_func),
+            ("input_signature", self.subnode_input_signature),
+            ("autograph", self.subnode_autograph),
+            ("jit_compile", self.subnode_jit_compile),
+            ("reduce_retracing", self.subnode_reduce_retracing),
+            ("experimental_implements", self.subnode_experimental_implements),
+            (
+                "experimental_autograph_options",
+                self.subnode_experimental_autograph_options,
+            ),
+            ("experimental_attributes", self.subnode_experimental_attributes),
+            ("experimental_relax_shapes", self.subnode_experimental_relax_shapes),
+            ("experimental_compile", self.subnode_experimental_compile),
+            (
+                "experimental_follow_type_hints",
+                self.subnode_experimental_follow_type_hints,
+            ),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_func
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_func = new_node
+
+            return
+
+        value = self.subnode_input_signature
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_input_signature = new_node
+
+            return
+
+        value = self.subnode_autograph
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_autograph = new_node
+
+            return
+
+        value = self.subnode_jit_compile
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_jit_compile = new_node
+
+            return
+
+        value = self.subnode_reduce_retracing
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_reduce_retracing = new_node
+
+            return
+
+        value = self.subnode_experimental_implements
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_experimental_implements = new_node
+
+            return
+
+        value = self.subnode_experimental_autograph_options
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_experimental_autograph_options = new_node
+
+            return
+
+        value = self.subnode_experimental_attributes
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_experimental_attributes = new_node
+
+            return
+
+        value = self.subnode_experimental_relax_shapes
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_experimental_relax_shapes = new_node
+
+            return
+
+        value = self.subnode_experimental_compile
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_experimental_compile = new_node
+
+            return
+
+        value = self.subnode_experimental_follow_type_hints
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_experimental_follow_type_hints = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "func": (
+                self.subnode_func.makeClone() if self.subnode_func is not None else None
+            ),
+            "input_signature": (
+                self.subnode_input_signature.makeClone()
+                if self.subnode_input_signature is not None
+                else None
+            ),
+            "autograph": (
+                self.subnode_autograph.makeClone()
+                if self.subnode_autograph is not None
+                else None
+            ),
+            "jit_compile": (
+                self.subnode_jit_compile.makeClone()
+                if self.subnode_jit_compile is not None
+                else None
+            ),
+            "reduce_retracing": (
+                self.subnode_reduce_retracing.makeClone()
+                if self.subnode_reduce_retracing is not None
+                else None
+            ),
+            "experimental_implements": (
+                self.subnode_experimental_implements.makeClone()
+                if self.subnode_experimental_implements is not None
+                else None
+            ),
+            "experimental_autograph_options": (
+                self.subnode_experimental_autograph_options.makeClone()
+                if self.subnode_experimental_autograph_options is not None
+                else None
+            ),
+            "experimental_attributes": (
+                self.subnode_experimental_attributes.makeClone()
+                if self.subnode_experimental_attributes is not None
+                else None
+            ),
+            "experimental_relax_shapes": (
+                self.subnode_experimental_relax_shapes.makeClone()
+                if self.subnode_experimental_relax_shapes is not None
+                else None
+            ),
+            "experimental_compile": (
+                self.subnode_experimental_compile.makeClone()
+                if self.subnode_experimental_compile is not None
+                else None
+            ),
+            "experimental_follow_type_hints": (
+                self.subnode_experimental_follow_type_hints.makeClone()
+                if self.subnode_experimental_follow_type_hints is not None
+                else None
+            ),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        if self.subnode_func is not None:
+            self.subnode_func.finalize()
+        del self.subnode_func
+        if self.subnode_input_signature is not None:
+            self.subnode_input_signature.finalize()
+        del self.subnode_input_signature
+        if self.subnode_autograph is not None:
+            self.subnode_autograph.finalize()
+        del self.subnode_autograph
+        if self.subnode_jit_compile is not None:
+            self.subnode_jit_compile.finalize()
+        del self.subnode_jit_compile
+        if self.subnode_reduce_retracing is not None:
+            self.subnode_reduce_retracing.finalize()
+        del self.subnode_reduce_retracing
+        if self.subnode_experimental_implements is not None:
+            self.subnode_experimental_implements.finalize()
+        del self.subnode_experimental_implements
+        if self.subnode_experimental_autograph_options is not None:
+            self.subnode_experimental_autograph_options.finalize()
+        del self.subnode_experimental_autograph_options
+        if self.subnode_experimental_attributes is not None:
+            self.subnode_experimental_attributes.finalize()
+        del self.subnode_experimental_attributes
+        if self.subnode_experimental_relax_shapes is not None:
+            self.subnode_experimental_relax_shapes.finalize()
+        del self.subnode_experimental_relax_shapes
+        if self.subnode_experimental_compile is not None:
+            self.subnode_experimental_compile.finalize()
+        del self.subnode_experimental_compile
+        if self.subnode_experimental_follow_type_hints is not None:
+            self.subnode_experimental_follow_type_hints.finalize()
+        del self.subnode_experimental_follow_type_hints
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
+
+            if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
+                return (
+                    wrapped_expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        subnode_func = self.subnode_func
+
+        if subnode_func is not None:
+            self.subnode_func.collectVariableAccesses(emit_read, emit_write)
+        subnode_input_signature = self.subnode_input_signature
+
+        if subnode_input_signature is not None:
+            self.subnode_input_signature.collectVariableAccesses(emit_read, emit_write)
+        subnode_autograph = self.subnode_autograph
+
+        if subnode_autograph is not None:
+            self.subnode_autograph.collectVariableAccesses(emit_read, emit_write)
+        subnode_jit_compile = self.subnode_jit_compile
+
+        if subnode_jit_compile is not None:
+            self.subnode_jit_compile.collectVariableAccesses(emit_read, emit_write)
+        subnode_reduce_retracing = self.subnode_reduce_retracing
+
+        if subnode_reduce_retracing is not None:
+            self.subnode_reduce_retracing.collectVariableAccesses(emit_read, emit_write)
+        subnode_experimental_implements = self.subnode_experimental_implements
+
+        if subnode_experimental_implements is not None:
+            self.subnode_experimental_implements.collectVariableAccesses(
+                emit_read, emit_write
+            )
+        subnode_experimental_autograph_options = (
+            self.subnode_experimental_autograph_options
+        )
+
+        if subnode_experimental_autograph_options is not None:
+            self.subnode_experimental_autograph_options.collectVariableAccesses(
+                emit_read, emit_write
+            )
+        subnode_experimental_attributes = self.subnode_experimental_attributes
+
+        if subnode_experimental_attributes is not None:
+            self.subnode_experimental_attributes.collectVariableAccesses(
+                emit_read, emit_write
+            )
+        subnode_experimental_relax_shapes = self.subnode_experimental_relax_shapes
+
+        if subnode_experimental_relax_shapes is not None:
+            self.subnode_experimental_relax_shapes.collectVariableAccesses(
+                emit_read, emit_write
+            )
+        subnode_experimental_compile = self.subnode_experimental_compile
+
+        if subnode_experimental_compile is not None:
+            self.subnode_experimental_compile.collectVariableAccesses(
+                emit_read, emit_write
+            )
+        subnode_experimental_follow_type_hints = (
+            self.subnode_experimental_follow_type_hints
+        )
+
+        if subnode_experimental_follow_type_hints is not None:
+            self.subnode_experimental_follow_type_hints.collectVariableAccesses(
+                emit_read, emit_write
+            )
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionTensorflowFunctionMixin = ChildrenHavingFuncOptionalInputSignatureOptionalAutographOptionalJitCompileOptionalReduceRetracingOptionalExperimentalImplementsOptionalExperimentalAutographOptionsOptionalExperimentalAttributesOptionalExperimentalRelaxShapesOptionalExperimentalCompileOptionalExperimentalFollowTypeHintsOptionalMixin
+ChildrenExpressionTensorflowFunctionCallMixin = ChildrenHavingFuncOptionalInputSignatureOptionalAutographOptionalJitCompileOptionalReduceRetracingOptionalExperimentalImplementsOptionalExperimentalAutographOptionsOptionalExperimentalAttributesOptionalExperimentalRelaxShapesOptionalExperimentalCompileOptionalExperimentalFollowTypeHintsOptionalMixin
+
+
+class ChildrenHavingFunctionValuesTupleMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionFunctionCall
+
+    def __init__(
+        self,
+        function,
+        values,
+    ):
+        function.parent = self
+
+        self.subnode_function = function
+
+        assert type(values) is tuple
+
+        for val in values:
+            val.parent = self
+
+        self.subnode_values = values
+
+    def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
         result = []
@@ -8146,9 +8848,9 @@ class ChildrenHavingGroupNameOptionalMixin(object):
 
         values = {
             "group": self.subnode_group.makeClone(),
-            "name": self.subnode_name.makeClone()
-            if self.subnode_name is not None
-            else None,
+            "name": (
+                self.subnode_name.makeClone() if self.subnode_name is not None else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -9047,13 +9749,17 @@ class ChildrenHavingKwDefaultsOptionalDefaultsTupleAnnotationsOptionalFunctionRe
         """
 
         values = {
-            "kw_defaults": self.subnode_kw_defaults.makeClone()
-            if self.subnode_kw_defaults is not None
-            else None,
+            "kw_defaults": (
+                self.subnode_kw_defaults.makeClone()
+                if self.subnode_kw_defaults is not None
+                else None
+            ),
             "defaults": tuple(v.makeClone() for v in self.subnode_defaults),
-            "annotations": self.subnode_annotations.makeClone()
-            if self.subnode_annotations is not None
-            else None,
+            "annotations": (
+                self.subnode_annotations.makeClone()
+                if self.subnode_annotations is not None
+                else None
+            ),
             "function_ref": self.subnode_function_ref.makeClone(),
         }
 
@@ -9907,9 +10613,9 @@ class ChildrenHavingListArgKeyOptionalReverseMixin(object):
 
         values = {
             "list_arg": self.subnode_list_arg.makeClone(),
-            "key": self.subnode_key.makeClone()
-            if self.subnode_key is not None
-            else None,
+            "key": (
+                self.subnode_key.makeClone() if self.subnode_key is not None else None
+            ),
             "reverse": self.subnode_reverse.makeClone(),
         }
 
@@ -11131,18 +11837,26 @@ class ChildrenHavingNameGlobalsArgOptionalLocalsArgOptionalFromlistOptionalLevel
 
         values = {
             "name": self.subnode_name.makeClone(),
-            "globals_arg": self.subnode_globals_arg.makeClone()
-            if self.subnode_globals_arg is not None
-            else None,
-            "locals_arg": self.subnode_locals_arg.makeClone()
-            if self.subnode_locals_arg is not None
-            else None,
-            "fromlist": self.subnode_fromlist.makeClone()
-            if self.subnode_fromlist is not None
-            else None,
-            "level": self.subnode_level.makeClone()
-            if self.subnode_level is not None
-            else None,
+            "globals_arg": (
+                self.subnode_globals_arg.makeClone()
+                if self.subnode_globals_arg is not None
+                else None
+            ),
+            "locals_arg": (
+                self.subnode_locals_arg.makeClone()
+                if self.subnode_locals_arg is not None
+                else None
+            ),
+            "fromlist": (
+                self.subnode_fromlist.makeClone()
+                if self.subnode_fromlist is not None
+                else None
+            ),
+            "level": (
+                self.subnode_level.makeClone()
+                if self.subnode_level is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -11225,7 +11939,7 @@ class ChildrenHavingNameGlobalsArgOptionalLocalsArgOptionalFromlistOptionalLevel
 ChildrenExpressionBuiltinImportMixin = ChildrenHavingNameGlobalsArgOptionalLocalsArgOptionalFromlistOptionalLevelOptionalMixin
 
 
-class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalMixin(
+class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalMixin(
     object
 ):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
@@ -11240,7 +11954,7 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
         mode,
         handle,
         use_errno,
-        use_lasterror,
+        use_last_error,
     ):
         name.parent = self
 
@@ -11261,10 +11975,10 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
         self.subnode_use_errno = use_errno
 
-        if use_lasterror is not None:
-            use_lasterror.parent = self
+        if use_last_error is not None:
+            use_last_error.parent = self
 
-        self.subnode_use_lasterror = use_lasterror
+        self.subnode_use_last_error = use_last_error
 
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
@@ -11286,7 +12000,7 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
             pass
         else:
             result.append(value)
-        value = self.subnode_use_lasterror
+        value = self.subnode_use_last_error
         if value is None:
             pass
         else:
@@ -11304,7 +12018,7 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
             ("mode", self.subnode_mode),
             ("handle", self.subnode_handle),
             ("use_errno", self.subnode_use_errno),
-            ("use_lasterror", self.subnode_use_lasterror),
+            ("use_last_error", self.subnode_use_last_error),
         )
 
     def replaceChild(self, old_node, new_node):
@@ -11343,12 +12057,12 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
             return
 
-        value = self.subnode_use_lasterror
+        value = self.subnode_use_last_error
         if old_node is value:
             if new_node is not None:
                 new_node.parent = self
 
-            self.subnode_use_lasterror = new_node
+            self.subnode_use_last_error = new_node
 
             return
 
@@ -11362,18 +12076,24 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
         values = {
             "name": self.subnode_name.makeClone(),
-            "mode": self.subnode_mode.makeClone()
-            if self.subnode_mode is not None
-            else None,
-            "handle": self.subnode_handle.makeClone()
-            if self.subnode_handle is not None
-            else None,
-            "use_errno": self.subnode_use_errno.makeClone()
-            if self.subnode_use_errno is not None
-            else None,
-            "use_lasterror": self.subnode_use_lasterror.makeClone()
-            if self.subnode_use_lasterror is not None
-            else None,
+            "mode": (
+                self.subnode_mode.makeClone() if self.subnode_mode is not None else None
+            ),
+            "handle": (
+                self.subnode_handle.makeClone()
+                if self.subnode_handle is not None
+                else None
+            ),
+            "use_errno": (
+                self.subnode_use_errno.makeClone()
+                if self.subnode_use_errno is not None
+                else None
+            ),
+            "use_last_error": (
+                self.subnode_use_last_error.makeClone()
+                if self.subnode_use_last_error is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -11394,9 +12114,9 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
         if self.subnode_use_errno is not None:
             self.subnode_use_errno.finalize()
         del self.subnode_use_errno
-        if self.subnode_use_lasterror is not None:
-            self.subnode_use_lasterror.finalize()
-        del self.subnode_use_lasterror
+        if self.subnode_use_last_error is not None:
+            self.subnode_use_last_error.finalize()
+        del self.subnode_use_last_error
 
     def computeExpressionRaw(self, trace_collection):
         """Compute an expression.
@@ -11446,17 +12166,17 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
         if subnode_use_errno is not None:
             self.subnode_use_errno.collectVariableAccesses(emit_read, emit_write)
-        subnode_use_lasterror = self.subnode_use_lasterror
+        subnode_use_last_error = self.subnode_use_last_error
 
-        if subnode_use_lasterror is not None:
-            self.subnode_use_lasterror.collectVariableAccesses(emit_read, emit_write)
+        if subnode_use_last_error is not None:
+            self.subnode_use_last_error.collectVariableAccesses(emit_read, emit_write)
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionCtypesCdllMixin = ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalMixin
+ChildrenExpressionCtypesCdllMixin = ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalMixin
 
 
-class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalWinmodeOptionalMixin(
+class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalWinmodeOptionalMixin(
     object
 ):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
@@ -11471,7 +12191,7 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
         mode,
         handle,
         use_errno,
-        use_lasterror,
+        use_last_error,
         winmode,
     ):
         name.parent = self
@@ -11493,10 +12213,10 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
         self.subnode_use_errno = use_errno
 
-        if use_lasterror is not None:
-            use_lasterror.parent = self
+        if use_last_error is not None:
+            use_last_error.parent = self
 
-        self.subnode_use_lasterror = use_lasterror
+        self.subnode_use_last_error = use_last_error
 
         if winmode is not None:
             winmode.parent = self
@@ -11523,7 +12243,7 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
             pass
         else:
             result.append(value)
-        value = self.subnode_use_lasterror
+        value = self.subnode_use_last_error
         if value is None:
             pass
         else:
@@ -11546,7 +12266,7 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
             ("mode", self.subnode_mode),
             ("handle", self.subnode_handle),
             ("use_errno", self.subnode_use_errno),
-            ("use_lasterror", self.subnode_use_lasterror),
+            ("use_last_error", self.subnode_use_last_error),
             ("winmode", self.subnode_winmode),
         )
 
@@ -11586,12 +12306,12 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
             return
 
-        value = self.subnode_use_lasterror
+        value = self.subnode_use_last_error
         if old_node is value:
             if new_node is not None:
                 new_node.parent = self
 
-            self.subnode_use_lasterror = new_node
+            self.subnode_use_last_error = new_node
 
             return
 
@@ -11614,21 +12334,29 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
         values = {
             "name": self.subnode_name.makeClone(),
-            "mode": self.subnode_mode.makeClone()
-            if self.subnode_mode is not None
-            else None,
-            "handle": self.subnode_handle.makeClone()
-            if self.subnode_handle is not None
-            else None,
-            "use_errno": self.subnode_use_errno.makeClone()
-            if self.subnode_use_errno is not None
-            else None,
-            "use_lasterror": self.subnode_use_lasterror.makeClone()
-            if self.subnode_use_lasterror is not None
-            else None,
-            "winmode": self.subnode_winmode.makeClone()
-            if self.subnode_winmode is not None
-            else None,
+            "mode": (
+                self.subnode_mode.makeClone() if self.subnode_mode is not None else None
+            ),
+            "handle": (
+                self.subnode_handle.makeClone()
+                if self.subnode_handle is not None
+                else None
+            ),
+            "use_errno": (
+                self.subnode_use_errno.makeClone()
+                if self.subnode_use_errno is not None
+                else None
+            ),
+            "use_last_error": (
+                self.subnode_use_last_error.makeClone()
+                if self.subnode_use_last_error is not None
+                else None
+            ),
+            "winmode": (
+                self.subnode_winmode.makeClone()
+                if self.subnode_winmode is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -11649,9 +12377,9 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
         if self.subnode_use_errno is not None:
             self.subnode_use_errno.finalize()
         del self.subnode_use_errno
-        if self.subnode_use_lasterror is not None:
-            self.subnode_use_lasterror.finalize()
-        del self.subnode_use_lasterror
+        if self.subnode_use_last_error is not None:
+            self.subnode_use_last_error.finalize()
+        del self.subnode_use_last_error
         if self.subnode_winmode is not None:
             self.subnode_winmode.finalize()
         del self.subnode_winmode
@@ -11704,10 +12432,10 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
         if subnode_use_errno is not None:
             self.subnode_use_errno.collectVariableAccesses(emit_read, emit_write)
-        subnode_use_lasterror = self.subnode_use_lasterror
+        subnode_use_last_error = self.subnode_use_last_error
 
-        if subnode_use_lasterror is not None:
-            self.subnode_use_lasterror.collectVariableAccesses(emit_read, emit_write)
+        if subnode_use_last_error is not None:
+            self.subnode_use_last_error.collectVariableAccesses(emit_read, emit_write)
         subnode_winmode = self.subnode_winmode
 
         if subnode_winmode is not None:
@@ -11715,7 +12443,7 @@ class ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOp
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionCtypesCdllMixin = ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLasterrorOptionalWinmodeOptionalMixin
+ChildrenExpressionCtypesCdllMixin = ChildrenHavingNameModeOptionalHandleOptionalUseErrnoOptionalUseLastErrorOptionalWinmodeOptionalMixin
 
 
 class ChildrenHavingNamePackageOptionalMixin(object):
@@ -11790,9 +12518,11 @@ class ChildrenHavingNamePackageOptionalMixin(object):
 
         values = {
             "name": self.subnode_name.makeClone(),
-            "package": self.subnode_package.makeClone()
-            if self.subnode_package is not None
-            else None,
+            "package": (
+                self.subnode_package.makeClone()
+                if self.subnode_package is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -11963,6 +12693,7 @@ class ChildHavingPMixin(object):
 
     # This is generated for use in
     #   ExpressionOsPathBasename
+    #   ExpressionOsPathDirname
 
     def __init__(
         self,
@@ -12046,6 +12777,7 @@ class ChildHavingPMixin(object):
 
 # Assign the names that are easier to import with a stable name.
 ChildrenExpressionOsPathBasenameMixin = ChildHavingPMixin
+ChildrenExpressionOsPathDirnameMixin = ChildHavingPMixin
 
 
 class ChildHavingPackageMixin(object):
@@ -12397,12 +13129,16 @@ class ChildrenHavingPackageResourceEncodingOptionalErrorsOptionalMixin(object):
         values = {
             "package": self.subnode_package.makeClone(),
             "resource": self.subnode_resource.makeClone(),
-            "encoding": self.subnode_encoding.makeClone()
-            if self.subnode_encoding is not None
-            else None,
-            "errors": self.subnode_errors.makeClone()
-            if self.subnode_errors is not None
-            else None,
+            "encoding": (
+                self.subnode_encoding.makeClone()
+                if self.subnode_encoding is not None
+                else None
+            ),
+            "errors": (
+                self.subnode_errors.makeClone()
+                if self.subnode_errors is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -12872,6 +13608,7 @@ class ChildHavingPathMixin(object):
     #   ExpressionOsPathExists
     #   ExpressionOsPathIsdir
     #   ExpressionOsPathIsfile
+    #   ExpressionOsPathNormpath
 
     def __init__(
         self,
@@ -12958,6 +13695,7 @@ ChildrenExpressionOsPathAbspathMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathExistsMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathIsdirMixin = ChildHavingPathMixin
 ChildrenExpressionOsPathIsfileMixin = ChildHavingPathMixin
+ChildrenExpressionOsPathNormpathMixin = ChildHavingPathMixin
 
 
 class ChildHavingPathOptionalMixin(object):
@@ -12974,17 +13712,297 @@ class ChildHavingPathOptionalMixin(object):
         if path is not None:
             path.parent = self
 
-        self.subnode_path = path
+        self.subnode_path = path
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        value = self.subnode_path
+
+        if value is None:
+            return ()
+        else:
+            return (value,)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (("path", self.subnode_path),)
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_path
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_path = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "path": (
+                self.subnode_path.makeClone() if self.subnode_path is not None else None
+            ),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        if self.subnode_path is not None:
+            self.subnode_path.finalize()
+        del self.subnode_path
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expression, as they it's evaluated before.
+        expression = self.subnode_path
+
+        if expression is not None:
+            expression = trace_collection.onExpression(expression)
+
+            if expression.willRaiseAnyException():
+                return (
+                    expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        subnode_path = self.subnode_path
+
+        if subnode_path is not None:
+            self.subnode_path.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionOsListdirMixin = ChildHavingPathOptionalMixin
+
+
+class ChildrenHavingPathOptionalDirFdOptionalMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionOsLstat
+
+    def __init__(
+        self,
+        path,
+        dir_fd,
+    ):
+        if path is not None:
+            path.parent = self
+
+        self.subnode_path = path
+
+        if dir_fd is not None:
+            dir_fd.parent = self
+
+        self.subnode_dir_fd = dir_fd
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        result = []
+        value = self.subnode_path
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_dir_fd
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        return tuple(result)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (
+            ("path", self.subnode_path),
+            ("dir_fd", self.subnode_dir_fd),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_path
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_path = new_node
+
+            return
+
+        value = self.subnode_dir_fd
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_dir_fd = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "path": (
+                self.subnode_path.makeClone() if self.subnode_path is not None else None
+            ),
+            "dir_fd": (
+                self.subnode_dir_fd.makeClone()
+                if self.subnode_dir_fd is not None
+                else None
+            ),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        if self.subnode_path is not None:
+            self.subnode_path.finalize()
+        del self.subnode_path
+        if self.subnode_dir_fd is not None:
+            self.subnode_dir_fd.finalize()
+        del self.subnode_dir_fd
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
+
+            if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
+                return (
+                    wrapped_expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        subnode_path = self.subnode_path
+
+        if subnode_path is not None:
+            self.subnode_path.collectVariableAccesses(emit_read, emit_write)
+        subnode_dir_fd = self.subnode_dir_fd
+
+        if subnode_dir_fd is not None:
+            self.subnode_dir_fd.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionOsLstatMixin = ChildrenHavingPathOptionalDirFdOptionalMixin
+
+
+class ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionOsStat
+
+    def __init__(
+        self,
+        path,
+        dir_fd,
+        follow_symlinks,
+    ):
+        if path is not None:
+            path.parent = self
+
+        self.subnode_path = path
+
+        if dir_fd is not None:
+            dir_fd.parent = self
+
+        self.subnode_dir_fd = dir_fd
+
+        if follow_symlinks is not None:
+            follow_symlinks.parent = self
+
+        self.subnode_follow_symlinks = follow_symlinks
 
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
+        result = []
         value = self.subnode_path
-
         if value is None:
-            return ()
+            pass
         else:
-            return (value,)
+            result.append(value)
+        value = self.subnode_dir_fd
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_follow_symlinks
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        return tuple(result)
 
     def getVisitableNodesNamed(self):
         """Named children dictionary.
@@ -12992,7 +14010,11 @@ class ChildHavingPathOptionalMixin(object):
         For use in cloning nodes, debugging and XML output.
         """
 
-        return (("path", self.subnode_path),)
+        return (
+            ("path", self.subnode_path),
+            ("dir_fd", self.subnode_dir_fd),
+            ("follow_symlinks", self.subnode_follow_symlinks),
+        )
 
     def replaceChild(self, old_node, new_node):
         value = self.subnode_path
@@ -13004,6 +14026,24 @@ class ChildHavingPathOptionalMixin(object):
 
             return
 
+        value = self.subnode_dir_fd
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_dir_fd = new_node
+
+            return
+
+        value = self.subnode_follow_symlinks
+        if old_node is value:
+            if new_node is not None:
+                new_node.parent = self
+
+            self.subnode_follow_symlinks = new_node
+
+            return
+
         raise AssertionError("Didn't find child", old_node, "in", self)
 
     def getCloneArgs(self):
@@ -13013,9 +14053,19 @@ class ChildHavingPathOptionalMixin(object):
         """
 
         values = {
-            "path": self.subnode_path.makeClone()
-            if self.subnode_path is not None
-            else None,
+            "path": (
+                self.subnode_path.makeClone() if self.subnode_path is not None else None
+            ),
+            "dir_fd": (
+                self.subnode_dir_fd.makeClone()
+                if self.subnode_dir_fd is not None
+                else None
+            ),
+            "follow_symlinks": (
+                self.subnode_follow_symlinks.makeClone()
+                if self.subnode_follow_symlinks is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -13028,6 +14078,12 @@ class ChildHavingPathOptionalMixin(object):
         if self.subnode_path is not None:
             self.subnode_path.finalize()
         del self.subnode_path
+        if self.subnode_dir_fd is not None:
+            self.subnode_dir_fd.finalize()
+        del self.subnode_dir_fd
+        if self.subnode_follow_symlinks is not None:
+            self.subnode_follow_symlinks.finalize()
+        del self.subnode_follow_symlinks
 
     def computeExpressionRaw(self, trace_collection):
         """Compute an expression.
@@ -13037,15 +14093,22 @@ class ChildHavingPathOptionalMixin(object):
         be overloaded, e.g. conditional expressions.
         """
 
-        # First apply the sub-expression, as they it's evaluated before.
-        expression = self.subnode_path
-
-        if expression is not None:
-            expression = trace_collection.onExpression(expression)
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
 
             if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
                 return (
-                    expression,
+                    wrapped_expression,
                     "new_raise",
                     lambda: "For '%s' the child expression '%s' will raise."
                     % (self.getChildNameNice(), expression.getChildNameNice()),
@@ -13061,10 +14124,20 @@ class ChildHavingPathOptionalMixin(object):
 
         if subnode_path is not None:
             self.subnode_path.collectVariableAccesses(emit_read, emit_write)
+        subnode_dir_fd = self.subnode_dir_fd
+
+        if subnode_dir_fd is not None:
+            self.subnode_dir_fd.collectVariableAccesses(emit_read, emit_write)
+        subnode_follow_symlinks = self.subnode_follow_symlinks
+
+        if subnode_follow_symlinks is not None:
+            self.subnode_follow_symlinks.collectVariableAccesses(emit_read, emit_write)
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionOsListdirMixin = ChildHavingPathOptionalMixin
+ChildrenExpressionOsStatMixin = (
+    ChildrenHavingPathOptionalDirFdOptionalFollowSymlinksOptionalMixin
+)
 
 
 class ChildrenHavingPosArgOptionalPairsTupleMixin(object):
@@ -13146,9 +14219,11 @@ class ChildrenHavingPosArgOptionalPairsTupleMixin(object):
         """
 
         values = {
-            "pos_arg": self.subnode_pos_arg.makeClone()
-            if self.subnode_pos_arg is not None
-            else None,
+            "pos_arg": (
+                self.subnode_pos_arg.makeClone()
+                if self.subnode_pos_arg is not None
+                else None
+            ),
             "pairs": tuple(v.makeClone() for v in self.subnode_pairs),
         }
 
@@ -13284,9 +14359,9 @@ class ChildrenHavingRealOptionalImagMixin(object):
         """
 
         values = {
-            "real": self.subnode_real.makeClone()
-            if self.subnode_real is not None
-            else None,
+            "real": (
+                self.subnode_real.makeClone() if self.subnode_real is not None else None
+            ),
             "imag": self.subnode_imag.makeClone(),
         }
 
@@ -14284,15 +15359,21 @@ class ChildrenHavingSourceFilenameModeFlagsOptionalDontInheritOptionalOptimizeOp
             "source": self.subnode_source.makeClone(),
             "filename": self.subnode_filename.makeClone(),
             "mode": self.subnode_mode.makeClone(),
-            "flags": self.subnode_flags.makeClone()
-            if self.subnode_flags is not None
-            else None,
-            "dont_inherit": self.subnode_dont_inherit.makeClone()
-            if self.subnode_dont_inherit is not None
-            else None,
-            "optimize": self.subnode_optimize.makeClone()
-            if self.subnode_optimize is not None
-            else None,
+            "flags": (
+                self.subnode_flags.makeClone()
+                if self.subnode_flags is not None
+                else None
+            ),
+            "dont_inherit": (
+                self.subnode_dont_inherit.makeClone()
+                if self.subnode_dont_inherit is not None
+                else None
+            ),
+            "optimize": (
+                self.subnode_optimize.makeClone()
+                if self.subnode_optimize is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -14625,9 +15706,11 @@ class ChildrenHavingSourceCodeGlobalsArgLocalsArgClosureOptionalMixin(object):
             "source_code": self.subnode_source_code.makeClone(),
             "globals_arg": self.subnode_globals_arg.makeClone(),
             "locals_arg": self.subnode_locals_arg.makeClone(),
-            "closure": self.subnode_closure.makeClone()
-            if self.subnode_closure is not None
-            else None,
+            "closure": (
+                self.subnode_closure.makeClone()
+                if self.subnode_closure is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -18535,12 +19618,16 @@ class ChildrenHavingStringEncodingOptionalErrorsOptionalMixin(object):
 
         values = {
             "string": self.subnode_string.makeClone(),
-            "encoding": self.subnode_encoding.makeClone()
-            if self.subnode_encoding is not None
-            else None,
-            "errors": self.subnode_errors.makeClone()
-            if self.subnode_errors is not None
-            else None,
+            "encoding": (
+                self.subnode_encoding.makeClone()
+                if self.subnode_encoding is not None
+                else None
+            ),
+            "errors": (
+                self.subnode_errors.makeClone()
+                if self.subnode_errors is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -18795,12 +19882,14 @@ class ChildrenHavingTypeArgArgsOptionalKwargsOptionalMixin(object):
 
         values = {
             "type_arg": self.subnode_type_arg.makeClone(),
-            "args": self.subnode_args.makeClone()
-            if self.subnode_args is not None
-            else None,
-            "kwargs": self.subnode_kwargs.makeClone()
-            if self.subnode_kwargs is not None
-            else None,
+            "args": (
+                self.subnode_args.makeClone() if self.subnode_args is not None else None
+            ),
+            "kwargs": (
+                self.subnode_kwargs.makeClone()
+                if self.subnode_kwargs is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -19140,6 +20229,233 @@ class ChildrenHavingTypeNameBasesDictArgMixin(object):
 ChildrenExpressionBuiltinType3Mixin = ChildrenHavingTypeNameBasesDictArgMixin
 
 
+class ChildHavingTypeParamsMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionTypeMakeGeneric
+
+    def __init__(
+        self,
+        type_params,
+    ):
+        type_params.parent = self
+
+        self.subnode_type_params = type_params
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        return (self.subnode_type_params,)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (("type_params", self.subnode_type_params),)
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_type_params
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_type_params = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "type_params": self.subnode_type_params.makeClone(),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        self.subnode_type_params.finalize()
+        del self.subnode_type_params
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expression, as they it's evaluated before.
+        expression = trace_collection.onExpression(self.subnode_type_params)
+
+        if expression.willRaiseAnyException():
+            return (
+                expression,
+                "new_raise",
+                lambda: "For '%s' the child expression '%s' will raise."
+                % (self.getChildNameNice(), expression.getChildNameNice()),
+            )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        self.subnode_type_params.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionTypeMakeGenericMixin = ChildHavingTypeParamsMixin
+
+
+class ChildrenHavingTypeParamsTupleComputeValueMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionTypeAlias
+
+    def __init__(
+        self,
+        type_params,
+        compute_value,
+    ):
+        assert type(type_params) is tuple
+
+        for val in type_params:
+            val.parent = self
+
+        self.subnode_type_params = type_params
+
+        compute_value.parent = self
+
+        self.subnode_compute_value = compute_value
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        result = []
+        result.extend(self.subnode_type_params)
+        result.append(self.subnode_compute_value)
+        return tuple(result)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (
+            ("type_params", self.subnode_type_params),
+            ("compute_value", self.subnode_compute_value),
+        )
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_type_params
+        if old_node in value:
+            if new_node is not None:
+                new_node.parent = self
+
+                self.subnode_type_params = tuple(
+                    (val if val is not old_node else new_node) for val in value
+                )
+            else:
+                self.subnode_type_params = tuple(
+                    val for val in value if val is not old_node
+                )
+
+            return
+
+        value = self.subnode_compute_value
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_compute_value = new_node
+
+            return
+
+        raise AssertionError("Didn't find child", old_node, "in", self)
+
+    def getCloneArgs(self):
+        """Get clones of all children to pass for a new node.
+
+        Needs to make clones of child nodes too.
+        """
+
+        values = {
+            "type_params": tuple(v.makeClone() for v in self.subnode_type_params),
+            "compute_value": self.subnode_compute_value.makeClone(),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        for c in self.subnode_type_params:
+            c.finalize()
+        del self.subnode_type_params
+        self.subnode_compute_value.finalize()
+        del self.subnode_compute_value
+
+    def computeExpressionRaw(self, trace_collection):
+        """Compute an expression.
+
+        Default behavior is to just visit the child expressions first, and
+        then the node "computeExpression". For a few cases this needs to
+        be overloaded, e.g. conditional expressions.
+        """
+
+        # First apply the sub-expressions, as they are evaluated before
+        # the actual operation.
+        for count, sub_expression in enumerate(self.getVisitableNodes()):
+            expression = trace_collection.onExpression(sub_expression)
+
+            if expression.willRaiseAnyException():
+                sub_expressions = self.getVisitableNodes()
+
+                wrapped_expression = wrapExpressionWithSideEffects(
+                    side_effects=sub_expressions[:count],
+                    old_node=sub_expression,
+                    new_node=expression,
+                )
+
+                return (
+                    wrapped_expression,
+                    "new_raise",
+                    lambda: "For '%s' the child expression '%s' will raise."
+                    % (self.getChildNameNice(), expression.getChildNameNice()),
+                )
+
+        # Then ask ourselves to work on it.
+        return self.computeExpression(trace_collection)
+
+    def collectVariableAccesses(self, emit_read, emit_write):
+        """Collect variable reads and writes of child nodes."""
+
+        for element in self.subnode_type_params:
+            element.collectVariableAccesses(emit_read, emit_write)
+        self.subnode_compute_value.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionTypeAliasMixin = ChildrenHavingTypeParamsTupleComputeValueMixin
+
+
 class ChildHavingValueMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
@@ -19371,9 +20687,11 @@ class ChildrenHavingValueOptionalBaseMixin(object):
         """
 
         values = {
-            "value": self.subnode_value.makeClone()
-            if self.subnode_value is not None
-            else None,
+            "value": (
+                self.subnode_value.makeClone()
+                if self.subnode_value is not None
+                else None
+            ),
             "base": self.subnode_base.makeClone(),
         }
 
@@ -19537,15 +20855,21 @@ class ChildrenHavingValueOptionalEncodingOptionalErrorsOptionalMixin(object):
         """
 
         values = {
-            "value": self.subnode_value.makeClone()
-            if self.subnode_value is not None
-            else None,
-            "encoding": self.subnode_encoding.makeClone()
-            if self.subnode_encoding is not None
-            else None,
-            "errors": self.subnode_errors.makeClone()
-            if self.subnode_errors is not None
-            else None,
+            "value": (
+                self.subnode_value.makeClone()
+                if self.subnode_value is not None
+                else None
+            ),
+            "encoding": (
+                self.subnode_encoding.makeClone()
+                if self.subnode_encoding is not None
+                else None
+            ),
+            "errors": (
+                self.subnode_errors.makeClone()
+                if self.subnode_errors is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -19700,9 +21024,11 @@ class ChildrenHavingValueFormatSpecOptionalAutoNoneEmptyStrMixin(object):
 
         values = {
             "value": self.subnode_value.makeClone(),
-            "format_spec": self.subnode_format_spec.makeClone()
-            if self.subnode_format_spec is not None
-            else None,
+            "format_spec": (
+                self.subnode_format_spec.makeClone()
+                if self.subnode_format_spec is not None
+                else None
+            ),
         }
 
         values.update(self.getDetails())
@@ -20009,3 +21335,18 @@ class ChildHavingValuesTupleMixin(object):
 
 # Assign the names that are easier to import with a stable name.
 ChildrenExpressionStringConcatenationMixin = ChildHavingValuesTupleMixin
+
+#     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.