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

nuitka/nodes/NodeMakingHelpers.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ These are just helpers to create nodes, often to replace existing nodes
 
 These are for use in optimizations and computations, and therefore cover
@@ -43,16 +29,18 @@ def makeConstantReplacementNode(constant, node, user_provided):
 
 
 def makeRaiseExceptionReplacementExpression(
-    expression, exception_type, exception_value
+    expression, exception_type, exception_value, no_warning=False
 ):
-    from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
-    from .ExceptionNodes import ExpressionRaiseException
+    from .ExceptionNodes import (
+        ExpressionRaiseException,
+        makeBuiltinMakeExceptionNode,
+    )
 
     source_ref = expression.source_ref
 
     assert type(exception_type) is str
 
-    if Options.shallWarnImplicitRaises():
+    if not no_warning and Options.shallWarnImplicitRaises():
         unusual_logger.warning(
             '%s: Will always raise exception: "%s(%s)"'
             % (
@@ -62,12 +50,22 @@ def makeRaiseExceptionReplacementExpression(
             )
         )
 
+    if type(exception_value) is not tuple:
+        exception_value = (exception_value,)
+
+    args = tuple(
+        makeConstantReplacementNode(
+            constant=element, node=expression, user_provided=False
+        )
+        for element in exception_value
+    )
+
     result = ExpressionRaiseException(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name=exception_type, source_ref=source_ref
-        ),
-        exception_value=makeConstantReplacementNode(
-            constant=exception_value, node=expression, user_provided=False
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name=exception_type,
+            args=args,
+            for_raise=False,
+            source_ref=source_ref,
         ),
         source_ref=source_ref,
     )
@@ -75,15 +73,19 @@ def makeRaiseExceptionReplacementExpression(
     return result
 
 
-def makeRaiseExceptionReplacementStatement(statement, exception_type, exception_value):
-    from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
-    from .ExceptionNodes import StatementRaiseExceptionImplicit
+def makeRaiseExceptionReplacementStatement(
+    statement, exception_type, exception_value, no_warning=False
+):
+    from .ExceptionNodes import (
+        StatementRaiseException,
+        makeBuiltinMakeExceptionNode,
+    )
 
     source_ref = statement.getSourceReference()
 
     assert type(exception_type) is str
 
-    if Options.shallWarnImplicitRaises():
+    if not no_warning and Options.shallWarnImplicitRaises():
         unusual_logger.warning(
             '%s: Will always raise exception: "%s(%s)"'
             % (
@@ -93,13 +95,18 @@ def makeRaiseExceptionReplacementStatement(statement, exception_type, exception_
             )
         )
 
-    result = StatementRaiseExceptionImplicit(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name=exception_type, source_ref=source_ref
-        ),
-        exception_value=makeConstantReplacementNode(
-            constant=exception_value, node=statement, user_provided=False
+    result = StatementRaiseException(
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name=exception_type,
+            args=(
+                makeConstantReplacementNode(
+                    constant=exception_value, node=statement, user_provided=False
+                ),
+            ),
+            for_raise=False,
+            source_ref=source_ref,
         ),
+        exception_value=None,
         exception_cause=None,
         exception_trace=None,
         source_ref=source_ref,
@@ -111,41 +118,35 @@ def makeRaiseExceptionReplacementStatement(statement, exception_type, exception_
 def makeRaiseExceptionReplacementExpressionFromInstance(expression, exception):
     assert isinstance(exception, Exception)
 
-    args = exception.args
-    if type(args) is tuple and len(args) == 1:
-        value = args[0]
-    else:
-        assert type(args) is tuple
-        value = args
-
     return makeRaiseExceptionReplacementExpression(
         expression=expression,
         exception_type=exception.__class__.__name__,
-        exception_value=value,
+        exception_value=exception.args,
     )
 
 
 def makeRaiseExceptionStatementFromInstance(exception, source_ref):
     assert isinstance(exception, Exception)
 
-    args = exception.args
-    if type(args) is tuple and len(args) == 1:
-        value = args[0]
-    else:
-        assert type(args) is tuple
-        value = args
-
-    from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
     from .ConstantRefNodes import makeConstantRefNode
-    from .ExceptionNodes import StatementRaiseExceptionImplicit
+    from .ExceptionNodes import (
+        StatementRaiseException,
+        makeBuiltinMakeExceptionNode,
+    )
 
-    return StatementRaiseExceptionImplicit(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name=exception.__class__.__name__, source_ref=source_ref
-        ),
-        exception_value=makeConstantRefNode(
-            constant=value, source_ref=source_ref, user_provided=False
+    args_value = tuple(
+        makeConstantRefNode(constant=arg, source_ref=source_ref, user_provided=False)
+        for arg in exception.args
+    )
+
+    return StatementRaiseException(
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name=exception.__class__.__name__,
+            args=args_value,
+            for_raise=False,
+            source_ref=source_ref,
         ),
+        exception_value=None,
         exception_cause=None,
         exception_trace=None,
         source_ref=source_ref,
@@ -155,10 +156,12 @@ def makeRaiseExceptionStatementFromInstance(exception, source_ref):
 def makeRaiseExceptionExpressionFromTemplate(
     exception_type, template, template_args, source_ref
 ):
-    from .BuiltinRefNodes import ExpressionBuiltinExceptionRef
     from .ConstantRefNodes import makeConstantRefNode
     from .ContainerMakingNodes import makeExpressionMakeTupleOrConstant
-    from .ExceptionNodes import ExpressionRaiseException
+    from .ExceptionNodes import (
+        ExpressionRaiseException,
+        makeBuiltinMakeExceptionNode,
+    )
     from .OperatorNodes import makeBinaryOperationNode
 
     if type(template_args) is tuple:
@@ -167,15 +170,19 @@ def makeRaiseExceptionExpressionFromTemplate(
         )
 
     return ExpressionRaiseException(
-        exception_type=ExpressionBuiltinExceptionRef(
-            exception_name=exception_type, source_ref=source_ref
-        ),
-        exception_value=makeBinaryOperationNode(
-            operator="Mod",
-            left=makeConstantRefNode(
-                constant=template, source_ref=source_ref, user_provided=True
+        exception_type=makeBuiltinMakeExceptionNode(
+            exception_name=exception_type,
+            args=(
+                makeBinaryOperationNode(
+                    operator="Mod",
+                    left=makeConstantRefNode(
+                        constant=template, source_ref=source_ref, user_provided=True
+                    ),
+                    right=template_args,
+                    source_ref=source_ref,
+                ),
             ),
-            right=template_args,
+            for_raise=False,
             source_ref=source_ref,
         ),
         source_ref=source_ref,
@@ -456,3 +463,19 @@ def makeRaiseImportErrorReplacementExpression(expression, module_name):
         exception_type="ImportError",
         exception_value=module_name.asString(),
     )
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/nodes/NodeMetaClasses.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Node meta classes.
 
 This provides meta classes for nodes, currently only one. These do all kinds
@@ -50,6 +36,16 @@ def _checkBases(name, bases):
             raise NuitkaNodeDesignError(name, "All bases must set __slots__.", base)
 
 
+@staticmethod
+def returnTrueShared():
+    return True
+
+
+@staticmethod
+def returnFalseShared():
+    return False
+
+
 class NodeCheckMetaClass(ABCMeta):
     kinds = {}
 
@@ -114,7 +110,7 @@ class NodeCheckMetaClass(ABCMeta):
 
             assert type(kind) is str, name
 
-            if kind in NodeCheckMetaClass.kinds and not "replaces" in dictionary:
+            if kind in NodeCheckMetaClass.kinds and "replaces" not in dictionary:
                 raise NuitkaNodeDesignError(
                     name, "Duplicate nodes for kind '%s'" % kind
                 )
@@ -127,22 +123,28 @@ class NodeCheckMetaClass(ABCMeta):
 
             # Automatically add checker methods for everything to the common
             # base class
-            checker_method = "is" + kind_to_name_part
+            checker_method_name = "is" + kind_to_name_part
 
-            # TODO: How about making these two functions, one to statically
-            # return True and False, and put one in the base class, and one
-            # in the new class, would be slightly faster.
-            def checkKind(self):
-                return self.kind == kind
-
-            # Add automatic checker methods to the node base class.
+            # Add automatic checker "False" to the node base class.
             from .NodeBases import NodeBase
 
-            if not hasattr(NodeBase, checker_method):
-                setattr(NodeBase, checker_method, checkKind)
+            if not hasattr(NodeBase, checker_method_name):
+                setattr(NodeBase, checker_method_name, returnFalseShared)
 
         ABCMeta.__init__(cls, name, bases, dictionary)
 
+        if not name.endswith(("Base", "Mixin")):
+            if kind.startswith("EXPRESSION_BUILTIN_"):
+                cls.isExpressionBuiltin = returnTrueShared
+
+            # Add automatic checker "True" to the node class.
+            if getattr(cls, checker_method_name) is returnFalseShared.__func__:
+
+                def checkKind(self):
+                    return self.kind == kind
+
+                setattr(cls, checker_method_name, checkKind)
+
 
 # For every node type, there is a test, and then some more members,
 
@@ -151,3 +153,18 @@ class NodeCheckMetaClass(ABCMeta):
 NodeMetaClassBase = NodeCheckMetaClass(
     "NodeMetaClassBase", (object,), {"__slots__": ()}
 )
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/nodes/OperatorNodes.py

@@ -1,20 +1,6 @@
-#     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-#
-#     Part of "Nuitka", an optimizing Python compiler that is compatible and
-#     integrates with CPython, but also works on its own.
-#
-#     Licensed under the Apache License, Version 2.0 (the "License");
-#     you may not use this file except in compliance with the License.
-#     You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#     Unless required by applicable law or agreed to in writing, software
-#     distributed under the License is distributed on an "AS IS" BASIS,
-#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#     See the License for the specific language governing permissions and
-#     limitations under the License.
-#
+#     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
+
 """ Nodes for unary and binary operations.
 
 No short-circuit involved, boolean 'not' is an unary operation like '-' is,
@@ -47,7 +33,7 @@ from .shapes.StandardShapes import (
 class ExpressionPropertiesFromTypeShapeMixin(object):
     """Given a self.type_shape, this can derive default properties from there."""
 
-    # Mixins are required to slots
+    # Mixins are required to define empty slots
     __slots__ = ()
 
     def isKnownToBeHashable(self):
@@ -627,7 +613,7 @@ if python_version >= 0x350:
             return left_shape.getOperationBinaryMatMultShape(right_shape)
 
 
-_operator2binary_operation_nodeclass = {
+_operator2binary_operation_node_class = {
     "Add": ExpressionOperationBinaryAdd,
     "Sub": ExpressionOperationBinarySub,
     "Mult": ExpressionOperationBinaryMult,
@@ -644,14 +630,14 @@ _operator2binary_operation_nodeclass = {
 }
 
 if python_version < 0x300:
-    _operator2binary_operation_nodeclass["OldDiv"] = ExpressionOperationBinaryOldDiv
+    _operator2binary_operation_node_class["OldDiv"] = ExpressionOperationBinaryOldDiv
 
 if python_version >= 0x350:
-    _operator2binary_operation_nodeclass["MatMult"] = ExpressionOperationBinaryMatMult
+    _operator2binary_operation_node_class["MatMult"] = ExpressionOperationBinaryMatMult
 
 
 def makeBinaryOperationNode(operator, left, right, source_ref):
-    node_class = _operator2binary_operation_nodeclass[operator]
+    node_class = _operator2binary_operation_node_class[operator]
 
     return node_class(left=left, right=right, source_ref=source_ref)
 
@@ -914,7 +900,7 @@ if python_version >= 0x350:
             return left_shape.getOperationBinaryMatMultShape(right_shape)
 
 
-_operator2binary_inplace_nodeclass = {
+_operator2binary_inplace_node_class = {
     "IAdd": ExpressionOperationInplaceAdd,
     "ISub": ExpressionOperationInplaceSub,
     "IMult": ExpressionOperationInplaceMult,
@@ -930,13 +916,29 @@ _operator2binary_inplace_nodeclass = {
 }
 
 if python_version < 0x300:
-    _operator2binary_inplace_nodeclass["IOldDiv"] = ExpressionOperationInplaceOldDiv
+    _operator2binary_inplace_node_class["IOldDiv"] = ExpressionOperationInplaceOldDiv
 
 if python_version >= 0x350:
-    _operator2binary_inplace_nodeclass["IMatMult"] = ExpressionOperationInplaceMatMult
+    _operator2binary_inplace_node_class["IMatMult"] = ExpressionOperationInplaceMatMult
 
 
 def makeExpressionOperationBinaryInplace(operator, left, right, source_ref):
-    node_class = _operator2binary_inplace_nodeclass[operator]
+    node_class = _operator2binary_inplace_node_class[operator]
 
     return node_class(left=left, right=right, source_ref=source_ref)
+
+
+#     Part of "Nuitka", an optimizing Python compiler that is compatible and
+#     integrates with CPython, but also works on its own.
+#
+#     Licensed under the Apache License, Version 2.0 (the "License");
+#     you may not use this file except in compliance with the License.
+#     You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.

nuitka/nodes/OperatorNodesUnary.py

@@ -1,25 +1,13 @@
-#     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
+
+
 """ Nodes for unary operations.
 
 Some of these come from built-ins, e.g. abs, some from syntax, and repr from both.
 """
+
 from nuitka import PythonOperators
+from nuitka.Errors import NuitkaAssumptionError
 
 from .ChildrenHavingMixins import ChildHavingOperandMixin
 from .ConstantRefNodes import makeConstantRefNode
@@ -28,6 +16,11 @@ from .ExpressionShapeMixins import (
     ExpressionBoolShapeExactMixin,
     ExpressionStrOrUnicodeDerivedShapeMixin,
 )
+from .NodeMakingHelpers import (
+    makeRaiseExceptionReplacementExpressionFromInstance,
+    wrapExpressionWithSideEffects,
+)
+from .shapes.StandardShapes import tshape_unknown
 
 
 class ExpressionOperationUnaryBase(ChildHavingOperandMixin, ExpressionBase):
@@ -44,10 +37,10 @@ class ExpressionOperationUnaryBase(ChildHavingOperandMixin, ExpressionBase):
         return self.operator
 
     def computeExpression(self, trace_collection):
-        operator = self.getOperator()
         operand = self.subnode_operand
 
         if operand.isCompileTimeConstant():
+            operator = self.getOperator()
             operand_value = operand.getCompileTimeConstant()
 
             return trace_collection.getCompileTimeComputationResult(
@@ -74,6 +67,10 @@ class ExpressionOperationUnaryBase(ChildHavingOperandMixin, ExpressionBase):
     def isExpressionOperationUnary():
         return True
 
+    @staticmethod
+    def mayRaiseExceptionOperation():
+        return True
+
 
 class ExpressionOperationUnaryRepr(  # TODO: Not exact
     ExpressionStrOrUnicodeDerivedShapeMixin, ExpressionOperationUnaryBase
@@ -117,7 +114,100 @@ class ExpressionOperationUnaryRepr(  # TODO: Not exact
         return self.escape_desc is None or self.escape_desc.isControlFlowEscape()
 
 
-class ExpressionOperationUnarySub(ExpressionOperationUnaryBase):
+# TODO: This should merge into base class.
+class ExpressionOperationUnaryMixin(object):
+    # Mixins are not allowed to specify slots, pylint: disable=assigning-non-slot
+    __slots__ = ()
+
+    def mayRaiseExceptionOperation(self):
+        return self.escape_desc.getExceptionExit() is not None
+
+    def mayRaiseException(self, exception_type):
+        # TODO: Match getExceptionExit() more precisely against exception type given
+        return (
+            self.escape_desc is None
+            or self.escape_desc.getExceptionExit() is not None
+            or self.subnode_operand.mayRaiseException(exception_type)
+        )
+
+    def getTypeShape(self):
+        return self.type_shape
+
+    def createUnsupportedException(self, operand_shape):
+        typical_value = operand_shape.typical_value
+
+        try:
+            self.simulator(typical_value)
+        except TypeError as e:
+            return e
+        except Exception as e:
+            raise NuitkaAssumptionError(
+                "Unexpected exception type doing operation simulation",
+                self.operator,
+                self.simulator,
+                operand_shape,
+                e,
+            )
+        else:
+            raise NuitkaAssumptionError(
+                "Unexpected no-exception doing operation simulation",
+                self.operator,
+                self.simulator,
+                operand_shape,
+            )
+
+    def computeExpression(self, trace_collection):
+        operand = self.subnode_operand
+
+        if operand.isCompileTimeConstant():
+            operand_value = operand.getCompileTimeConstant()
+            operator = self.getOperator()
+
+            return trace_collection.getCompileTimeComputationResult(
+                node=self,
+                computation=lambda: self.simulator(operand_value),
+                description="Operator '%s' with constant argument." % operator,
+            )
+        else:
+            operand_shape = operand.getTypeShape()
+
+            self.type_shape, self.escape_desc = self._getOperationShape(operand_shape)
+
+            if self.escape_desc.isUnsupported():
+                result = wrapExpressionWithSideEffects(
+                    new_node=makeRaiseExceptionReplacementExpressionFromInstance(
+                        expression=self,
+                        exception=self.createUnsupportedException(operand_shape),
+                    ),
+                    old_node=self,
+                    side_effects=(operand,),
+                )
+
+                return (
+                    result,
+                    "new_raise",
+                    "Replaced operator '%s' with %s arguments that cannot work."
+                    % (self.operator, operand_shape),
+                )
+
+            exception_raise_exit = self.escape_desc.getExceptionExit()
+            if exception_raise_exit is not None:
+                trace_collection.onExceptionRaiseExit(exception_raise_exit)
+
+            if self.escape_desc.isValueEscaping():
+                # The value of these nodes escaped and could change its contents.
+                trace_collection.removeKnowledge(operand)
+
+            if self.escape_desc.isControlFlowEscape():
+                # Any code could be run, note that.
+                trace_collection.onControlFlowEscape(self)
+
+            return self, None, None
+
+
+class ExpressionOperationUnarySub(
+    ExpressionOperationUnaryMixin, ExpressionOperationUnaryBase
+):
     """Python unary operator -"""
 
     kind = "EXPRESSION_OPERATION_UNARY_SUB"
@@ -125,13 +215,25 @@ class ExpressionOperationUnarySub(ExpressionOperationUnaryBase):
     operator = "USub"
     simulator = PythonOperators.unary_operator_functions[operator]
 
+    __slots__ = ("type_shape", "escape_desc")
+
     def __init__(self, operand, source_ref):
         ExpressionOperationUnaryBase.__init__(
             self, operand=operand, source_ref=source_ref
         )
 
+        self.type_shape = tshape_unknown
+
+        self.escape_desc = None
 
-class ExpressionOperationUnaryAdd(ExpressionOperationUnaryBase):
+    @staticmethod
+    def _getOperationShape(operand_shape):
+        return operand_shape.getOperationUnarySubShape()
+
+
+class ExpressionOperationUnaryAdd(
+    ExpressionOperationUnaryMixin, ExpressionOperationUnaryBase
+):
     """Python unary operator +"""
 
     kind = "EXPRESSION_OPERATION_UNARY_ADD"
@@ -139,11 +241,21 @@ class ExpressionOperationUnaryAdd(ExpressionOperationUnaryBase):
     operator = "UAdd"
     simulator = PythonOperators.unary_operator_functions[operator]
 
+    __slots__ = ("type_shape", "escape_desc")
+
     def __init__(self, operand, source_ref):
         ExpressionOperationUnaryBase.__init__(
             self, operand=operand, source_ref=source_ref
         )
 
+        self.type_shape = tshape_unknown
+
+        self.escape_desc = None
+
+    @staticmethod
+    def _getOperationShape(operand_shape):
+        return operand_shape.getOperationUnaryAddShape()
+
 
 class ExpressionOperationUnaryInvert(ExpressionOperationUnaryBase):
     """Python unary operator ~"""
@@ -273,3 +385,19 @@ def makeExpressionOperationUnary(operator, operand, source_ref):
             )
 
     return unary_class(operand=operand, source_ref=source_ref)
+
+
+#     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.