Type infer_unary_op (#1664)

Co-authored-by: Marc Mueller <[email protected]>

Author: DanielNoord

astroid/nodes/node_classes.py

@@ -30,7 +30,11 @@
 from astroid.nodes import _base_nodes
 from astroid.nodes.const import OP_PRECEDENCE
 from astroid.nodes.node_ng import NodeNG
-from astroid.typing import InferenceResult, SuccessfulInferenceResult
+from astroid.typing import (
+    ConstFactoryResult,
+    InferenceResult,
+    SuccessfulInferenceResult,
+)
 
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -64,14 +68,15 @@ def _is_const(value):
     ],
     Any,
 ]
-InferLHS = Callable[
-    [_NodesT, Optional[InferenceContext]],
-    typing.Generator[InferenceResult, None, None],
-]
 InferBinaryOperation = Callable[
     [_NodesT, Optional[InferenceContext]],
     typing.Generator[Union[InferenceResult, _BadOpMessageT], None, None],
 ]
+InferLHS = Callable[
+    [_NodesT, Optional[InferenceContext]],
+    typing.Generator[InferenceResult, None, None],
+]
+InferUnaryOp = Callable[[_NodesT, str], ConstFactoryResult]
 
 
 @decorators.raise_if_nothing_inferred
@@ -1906,6 +1911,8 @@ def __init__(
             parent=parent,
         )
 
+    infer_unary_op: ClassVar[InferUnaryOp[Const]]
+
     def __getattr__(self, name):
         # This is needed because of Proxy's __getattr__ method.
         # Calling object.__new__ on this class without calling
@@ -2267,6 +2274,8 @@ def postinit(
         """
         self.items = items
 
+    infer_unary_op: ClassVar[InferUnaryOp[Dict]]
+
     @classmethod
     def from_elements(cls, items=None):
         """Create a :class:`Dict` of constants from a live dictionary.
@@ -3390,6 +3399,8 @@ def __init__(
     See astroid/protocols.py for actual implementation.
     """
 
+    infer_unary_op: ClassVar[InferUnaryOp[List]]
+
     def pytype(self):
         """Get the name of the type that this node represents.
 
@@ -3626,6 +3637,8 @@ class Set(BaseContainer):
     <Set.set l.1 at 0x7f23b2e71d68>
     """
 
+    infer_unary_op: ClassVar[InferUnaryOp[Set]]
+
     def pytype(self):
         """Get the name of the type that this node represents.
 
@@ -4152,6 +4165,8 @@ def __init__(
     See astroid/protocols.py for actual implementation.
     """
 
+    infer_unary_op: ClassVar[InferUnaryOp[Tuple]]
+
     def pytype(self):
         """Get the name of the type that this node represents.
 
@@ -5401,7 +5416,7 @@ def _create_dict_items(
     return elements
 
 
-def const_factory(value: Any) -> List | Set | Tuple | Dict | Const | EmptyNode:
+def const_factory(value: Any) -> ConstFactoryResult:
     """Return an astroid node for a python value."""
     assert not isinstance(value, NodeNG)
 

astroid/protocols.py

@@ -11,7 +11,7 @@
 import collections
 import itertools
 import operator as operator_mod
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 from typing import Any
 
 from astroid import arguments, bases, decorators, helpers, nodes, util
@@ -25,6 +25,7 @@
     NoDefault,
 )
 from astroid.nodes import node_classes
+from astroid.typing import ConstFactoryResult
 
 raw_building = util.lazy_import("raw_building")
 objects = util.lazy_import("objects")
@@ -68,15 +69,19 @@ def _augmented_name(name):
     "~": "__invert__",
     "not": None,  # XXX not '__nonzero__'
 }
-_UNARY_OPERATORS = {
+_UNARY_OPERATORS: dict[str, Callable[[Any], Any]] = {
     "+": operator_mod.pos,
     "-": operator_mod.neg,
     "~": operator_mod.invert,
     "not": operator_mod.not_,
 }
 
 
-def _infer_unary_op(obj, op):
+def _infer_unary_op(obj: Any, op: str) -> ConstFactoryResult:
+    """Perform unary operation on object.
+
+    Can raise TypeError if operation is unsupported.
+    """
     func = _UNARY_OPERATORS[op]
     value = func(obj)
     return nodes.const_factory(value)

astroid/typing.py

@@ -43,3 +43,12 @@ class AstroidManagerBrain(TypedDict):
 
 InferenceResult = Union["nodes.NodeNG", "type[util.Uninferable]", "bases.Proxy"]
 SuccessfulInferenceResult = Union["nodes.NodeNG", "bases.Proxy"]
+
+ConstFactoryResult = Union[
+    "nodes.List",
+    "nodes.Set",
+    "nodes.Tuple",
+    "nodes.Dict",
+    "nodes.Const",
+    "nodes.EmptyNode",
+]