Nuitka-winsvc 1.6.6__cp310-cp310-win_amd64.whl → 1.7.5__cp310-cp310-win_amd64.whl

nuitka/nodes/ChildrenHavingMixins.py

@@ -6663,163 +6663,51 @@ ChildrenExpressionYieldFromMixin = ChildHavingExpressionMixin
 ChildrenExpressionYieldFromWaitableMixin = ChildHavingExpressionMixin
 
 
-class ChildrenHavingExpressionAttributeMixin(object):
-    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
-    __slots__ = ()
-
-    # This is generated for use in
-    #   ExpressionBuiltinHasattr
-
-    def __init__(
-        self,
-        expression,
-        attribute,
-    ):
-        expression.parent = self
-
-        self.subnode_expression = expression
-
-        attribute.parent = self
-
-        self.subnode_attribute = attribute
-
-    def getVisitableNodes(self):
-        """The visitable nodes, with tuple values flattened."""
-
-        return (
-            self.subnode_expression,
-            self.subnode_attribute,
-        )
-
-    def getVisitableNodesNamed(self):
-        """Named children dictionary.
-
-        For use in cloning nodes, debugging and XML output.
-        """
-
-        return (
-            ("expression", self.subnode_expression),
-            ("attribute", self.subnode_attribute),
-        )
-
-    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_attribute
-        if old_node is value:
-            new_node.parent = self
-
-            self.subnode_attribute = 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(),
-            "attribute": self.subnode_attribute.makeClone(),
-        }
-
-        values.update(self.getDetails())
-
-        return values
-
-    def finalize(self):
-        del self.parent
-
-        self.subnode_expression.finalize()
-        del self.subnode_expression
-        self.subnode_attribute.finalize()
-        del self.subnode_attribute
-
-    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_attribute.collectVariableAccesses(emit_read, emit_write)
-
-
-# Assign the names that are easier to import with a stable name.
-ChildrenExpressionBuiltinHasattrMixin = ChildrenHavingExpressionAttributeMixin
-
-
-class ChildrenHavingExpressionAttributeValueMixin(object):
+class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
     # This is generated for use in
-    #   ExpressionBuiltinSetattr
+    #   ExpressionSliceLookup
 
     def __init__(
         self,
         expression,
-        attribute,
-        value,
+        lower,
+        upper,
     ):
         expression.parent = self
 
         self.subnode_expression = expression
 
-        attribute.parent = self
+        lower = convertNoneConstantToNone(lower)
+        if lower is not None:
+            lower.parent = self
 
-        self.subnode_attribute = attribute
+        self.subnode_lower = lower
 
-        value.parent = self
+        upper = convertNoneConstantToNone(upper)
+        if upper is not None:
+            upper.parent = self
 
-        self.subnode_value = value
+        self.subnode_upper = upper
 
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
-        return (
-            self.subnode_expression,
-            self.subnode_attribute,
-            self.subnode_value,
-        )
+        result = []
+        result.append(self.subnode_expression)
+        value = self.subnode_lower
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        value = self.subnode_upper
+        if value is None:
+            pass
+        else:
+            result.append(value)
+        return tuple(result)
 
     def getVisitableNodesNamed(self):
         """Named children dictionary.
@@ -6829,8 +6717,8 @@ class ChildrenHavingExpressionAttributeValueMixin(object):
 
         return (
             ("expression", self.subnode_expression),
-            ("attribute", self.subnode_attribute),
-            ("value", self.subnode_value),
+            ("lower", self.subnode_lower),
+            ("upper", self.subnode_upper),
         )
 
     def replaceChild(self, old_node, new_node):
@@ -6842,19 +6730,23 @@ class ChildrenHavingExpressionAttributeValueMixin(object):
 
             return
 
-        value = self.subnode_attribute
+        value = self.subnode_lower
         if old_node is value:
-            new_node.parent = self
+            new_node = convertNoneConstantToNone(new_node)
+            if new_node is not None:
+                new_node.parent = self
 
-            self.subnode_attribute = new_node
+            self.subnode_lower = new_node
 
             return
 
-        value = self.subnode_value
+        value = self.subnode_upper
         if old_node is value:
-            new_node.parent = self
+            new_node = convertNoneConstantToNone(new_node)
+            if new_node is not None:
+                new_node.parent = self
 
-            self.subnode_value = new_node
+            self.subnode_upper = new_node
 
             return
 
@@ -6868,8 +6760,12 @@ class ChildrenHavingExpressionAttributeValueMixin(object):
 
         values = {
             "expression": self.subnode_expression.makeClone(),
-            "attribute": self.subnode_attribute.makeClone(),
-            "value": self.subnode_value.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,
         }
 
         values.update(self.getDetails())
@@ -6881,10 +6777,12 @@ class ChildrenHavingExpressionAttributeValueMixin(object):
 
         self.subnode_expression.finalize()
         del self.subnode_expression
-        self.subnode_attribute.finalize()
-        del self.subnode_attribute
-        self.subnode_value.finalize()
-        del self.subnode_value
+        if self.subnode_lower is not None:
+            self.subnode_lower.finalize()
+        del self.subnode_lower
+        if self.subnode_upper is not None:
+            self.subnode_upper.finalize()
+        del self.subnode_upper
 
     def computeExpressionRaw(self, trace_collection):
         """Compute an expression.
@@ -6922,54 +6820,55 @@ class ChildrenHavingExpressionAttributeValueMixin(object):
         """Collect variable reads and writes of child nodes."""
 
         self.subnode_expression.collectVariableAccesses(emit_read, emit_write)
-        self.subnode_attribute.collectVariableAccesses(emit_read, emit_write)
-        self.subnode_value.collectVariableAccesses(emit_read, emit_write)
+        subnode_lower = self.subnode_lower
+
+        if subnode_lower is not None:
+            self.subnode_lower.collectVariableAccesses(emit_read, emit_write)
+        subnode_upper = self.subnode_upper
+
+        if subnode_upper is not None:
+            self.subnode_upper.collectVariableAccesses(emit_read, emit_write)
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionBuiltinSetattrMixin = ChildrenHavingExpressionAttributeValueMixin
+ChildrenExpressionSliceLookupMixin = (
+    ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin
+)
 
 
-class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
+class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
     # This is generated for use in
-    #   ExpressionSliceLookup
+    #   ExpressionBuiltinGetattr
 
     def __init__(
         self,
         expression,
-        lower,
-        upper,
+        name,
+        default,
     ):
         expression.parent = self
 
         self.subnode_expression = expression
 
-        lower = convertNoneConstantToNone(lower)
-        if lower is not None:
-            lower.parent = self
+        name.parent = self
 
-        self.subnode_lower = lower
+        self.subnode_name = name
 
-        upper = convertNoneConstantToNone(upper)
-        if upper is not None:
-            upper.parent = self
+        if default is not None:
+            default.parent = self
 
-        self.subnode_upper = upper
+        self.subnode_default = default
 
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
         result = []
         result.append(self.subnode_expression)
-        value = self.subnode_lower
-        if value is None:
-            pass
-        else:
-            result.append(value)
-        value = self.subnode_upper
+        result.append(self.subnode_name)
+        value = self.subnode_default
         if value is None:
             pass
         else:
@@ -6984,8 +6883,8 @@ class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
 
         return (
             ("expression", self.subnode_expression),
-            ("lower", self.subnode_lower),
-            ("upper", self.subnode_upper),
+            ("name", self.subnode_name),
+            ("default", self.subnode_default),
         )
 
     def replaceChild(self, old_node, new_node):
@@ -6997,23 +6896,20 @@ class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
 
             return
 
-        value = self.subnode_lower
+        value = self.subnode_name
         if old_node is value:
-            new_node = convertNoneConstantToNone(new_node)
-            if new_node is not None:
-                new_node.parent = self
+            new_node.parent = self
 
-            self.subnode_lower = new_node
+            self.subnode_name = new_node
 
             return
 
-        value = self.subnode_upper
+        value = self.subnode_default
         if old_node is value:
-            new_node = convertNoneConstantToNone(new_node)
             if new_node is not None:
                 new_node.parent = self
 
-            self.subnode_upper = new_node
+            self.subnode_default = new_node
 
             return
 
@@ -7027,11 +6923,9 @@ 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
+            "name": self.subnode_name.makeClone(),
+            "default": self.subnode_default.makeClone()
+            if self.subnode_default is not None
             else None,
         }
 
@@ -7044,12 +6938,11 @@ class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
 
         self.subnode_expression.finalize()
         del self.subnode_expression
-        if self.subnode_lower is not None:
-            self.subnode_lower.finalize()
-        del self.subnode_lower
-        if self.subnode_upper is not None:
-            self.subnode_upper.finalize()
-        del self.subnode_upper
+        self.subnode_name.finalize()
+        del self.subnode_name
+        if self.subnode_default is not None:
+            self.subnode_default.finalize()
+        del self.subnode_default
 
     def computeExpressionRaw(self, trace_collection):
         """Compute an expression.
@@ -7087,34 +6980,29 @@ class ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin(object):
         """Collect variable reads and writes of child nodes."""
 
         self.subnode_expression.collectVariableAccesses(emit_read, emit_write)
-        subnode_lower = self.subnode_lower
-
-        if subnode_lower is not None:
-            self.subnode_lower.collectVariableAccesses(emit_read, emit_write)
-        subnode_upper = self.subnode_upper
+        self.subnode_name.collectVariableAccesses(emit_read, emit_write)
+        subnode_default = self.subnode_default
 
-        if subnode_upper is not None:
-            self.subnode_upper.collectVariableAccesses(emit_read, emit_write)
+        if subnode_default is not None:
+            self.subnode_default.collectVariableAccesses(emit_read, emit_write)
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionSliceLookupMixin = (
-    ChildrenHavingExpressionLowerAutoNoneUpperAutoNoneMixin
-)
+ChildrenExpressionBuiltinGetattrMixin = ChildrenHavingExpressionNameDefaultOptionalMixin
 
 
-class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
+class ChildrenHavingExpressionNameValueMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()
 
     # This is generated for use in
-    #   ExpressionBuiltinGetattr
+    #   ExpressionBuiltinSetattr
 
     def __init__(
         self,
         expression,
         name,
-        default,
+        value,
     ):
         expression.parent = self
 
@@ -7124,23 +7012,18 @@ class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
 
         self.subnode_name = name
 
-        if default is not None:
-            default.parent = self
+        value.parent = self
 
-        self.subnode_default = default
+        self.subnode_value = value
 
     def getVisitableNodes(self):
         """The visitable nodes, with tuple values flattened."""
 
-        result = []
-        result.append(self.subnode_expression)
-        result.append(self.subnode_name)
-        value = self.subnode_default
-        if value is None:
-            pass
-        else:
-            result.append(value)
-        return tuple(result)
+        return (
+            self.subnode_expression,
+            self.subnode_name,
+            self.subnode_value,
+        )
 
     def getVisitableNodesNamed(self):
         """Named children dictionary.
@@ -7151,7 +7034,7 @@ class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
         return (
             ("expression", self.subnode_expression),
             ("name", self.subnode_name),
-            ("default", self.subnode_default),
+            ("value", self.subnode_value),
         )
 
     def replaceChild(self, old_node, new_node):
@@ -7171,12 +7054,11 @@ class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
 
             return
 
-        value = self.subnode_default
+        value = self.subnode_value
         if old_node is value:
-            if new_node is not None:
-                new_node.parent = self
+            new_node.parent = self
 
-            self.subnode_default = new_node
+            self.subnode_value = new_node
 
             return
 
@@ -7191,9 +7073,7 @@ 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,
+            "value": self.subnode_value.makeClone(),
         }
 
         values.update(self.getDetails())
@@ -7207,9 +7087,8 @@ class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
         del self.subnode_expression
         self.subnode_name.finalize()
         del self.subnode_name
-        if self.subnode_default is not None:
-            self.subnode_default.finalize()
-        del self.subnode_default
+        self.subnode_value.finalize()
+        del self.subnode_value
 
     def computeExpressionRaw(self, trace_collection):
         """Compute an expression.
@@ -7248,14 +7127,11 @@ class ChildrenHavingExpressionNameDefaultOptionalMixin(object):
 
         self.subnode_expression.collectVariableAccesses(emit_read, emit_write)
         self.subnode_name.collectVariableAccesses(emit_read, emit_write)
-        subnode_default = self.subnode_default
-
-        if subnode_default is not None:
-            self.subnode_default.collectVariableAccesses(emit_read, emit_write)
+        self.subnode_value.collectVariableAccesses(emit_read, emit_write)
 
 
 # Assign the names that are easier to import with a stable name.
-ChildrenExpressionBuiltinGetattrMixin = ChildrenHavingExpressionNameDefaultOptionalMixin
+ChildrenExpressionBuiltinSetattrMixin = ChildrenHavingExpressionNameValueMixin
 
 
 class ChildrenHavingExpressionSubscriptMixin(object):
@@ -12172,6 +12048,99 @@ class ChildHavingPMixin(object):
 ChildrenExpressionOsPathBasenameMixin = ChildHavingPMixin
 
 
+class ChildHavingPackageMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    # This is generated for use in
+    #   ExpressionImportlibResourcesFiles
+    #   ExpressionImportlibResourcesFilesCall
+
+    def __init__(
+        self,
+        package,
+    ):
+        package.parent = self
+
+        self.subnode_package = package
+
+    def getVisitableNodes(self):
+        """The visitable nodes, with tuple values flattened."""
+
+        return (self.subnode_package,)
+
+    def getVisitableNodesNamed(self):
+        """Named children dictionary.
+
+        For use in cloning nodes, debugging and XML output.
+        """
+
+        return (("package", self.subnode_package),)
+
+    def replaceChild(self, old_node, new_node):
+        value = self.subnode_package
+        if old_node is value:
+            new_node.parent = self
+
+            self.subnode_package = 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 = {
+            "package": self.subnode_package.makeClone(),
+        }
+
+        values.update(self.getDetails())
+
+        return values
+
+    def finalize(self):
+        del self.parent
+
+        self.subnode_package.finalize()
+        del self.subnode_package
+
+    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_package)
+
+        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_package.collectVariableAccesses(emit_read, emit_write)
+
+
+# Assign the names that are easier to import with a stable name.
+ChildrenExpressionImportlibResourcesFilesMixin = ChildHavingPackageMixin
+ChildrenExpressionImportlibResourcesFilesCallMixin = ChildHavingPackageMixin
+
+
 class ChildrenHavingPackageResourceMixin(object):
     # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
     __slots__ = ()