Fix and narrow repr.py typing

First of many stabs at eliminating Any and # type: ignore from the
codebase. Here we eliminated several different type ignores; the
remaining # type: ignore is just a mypy limitation.

I also narrowed the typing of RichReprResult from Iterable[Any|...]] to
Iterable[object] since after inspection of the code this is what's
really required.

There's one particularly nasty cast that's needed. It's definitely a
mypy bug that it's not throwing an error for us here. See:
python/mypy#1178 and I've opened a similar
issue for pyright. There's an open PR for mypy that would resolve this,
but at least until this is fixed we need to be casting.

In order to correctly type the auto_repr function, I introduced a
SupportsRichRepr protocol; we could also have made this runtimecheckable
and replaced a hasattr check in the code with it, but it seemed
unnecessary so I opted not to.

Author: GBeauregard

rich/repr.py

@@ -1,59 +1,79 @@
 from functools import partial
 import inspect
+import sys
 
 from typing import (
-    Any,
     Callable,
     Iterable,
     List,
     Optional,
-    overload,
-    Union,
     Tuple,
     Type,
     TypeVar,
+    Union,
+    cast,
+    overload,
 )
 
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+else:
+    from typing_extensions import Protocol  # pragma: no cover
+
 
 T = TypeVar("T")
 
 
-Result = Iterable[Union[Any, Tuple[Any], Tuple[str, Any], Tuple[str, Any, Any]]]
+Result = Iterable[
+    Union[object, Tuple[object], Tuple[str, object], Tuple[str, object, object]]
+]
 RichReprResult = Result
 
 
 class ReprError(Exception):
     """An error occurred when attempting to build a repr."""
 
 
+class SupportsRichRepr(Protocol):
+    def __rich_repr__(self) -> Result:  # pragma: no cover
+        ...
+
+
 @overload
-def auto(cls: Optional[T]) -> T:
+def auto(cls: Optional[Type[T]]) -> Type[T]:
     ...
 
 
 @overload
-def auto(*, angular: bool = False) -> Callable[[T], T]:
+def auto(*, angular: bool) -> Callable[[Type[T]], Type[T]]:
     ...
 
 
 def auto(
-    cls: Optional[T] = None, *, angular: Optional[bool] = None
-) -> Union[T, Callable[[T], T]]:
+    cls: Optional[Type[T]] = None, *, angular: Optional[bool] = None
+) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
     """Class decorator to create __repr__ from __rich_repr__"""
 
     def do_replace(cls: Type[T], angular: Optional[bool] = None) -> Type[T]:
-        def auto_repr(self: Type[T]) -> str:
+        def auto_repr(self: SupportsRichRepr) -> str:
             """Create repr string from __rich_repr__"""
             repr_str: List[str] = []
             append = repr_str.append
 
-            angular = getattr(self.__rich_repr__, "angular", False)  # type: ignore
-            for arg in self.__rich_repr__():  # type: ignore
+            angular = getattr(self.__rich_repr__, "angular", False)
+            for arg in self.__rich_repr__():
                 if isinstance(arg, tuple):
                     if len(arg) == 1:
                         append(repr(arg[0]))
                     else:
-                        key, value, *default = arg
+                        key, value, *default = cast(
+                            Union[
+                                Tuple[object, ...],
+                                Tuple[str, object],
+                                Tuple[str, object, object],
+                            ],
+                            arg,
+                        )
                         if key is None:
                             append(repr(value))
                         else:
@@ -67,10 +87,10 @@ def auto_repr(self: Type[T]) -> str:
             else:
                 return f"{self.__class__.__name__}({', '.join(repr_str)})"
 
-        def auto_rich_repr(self: Type[T]) -> Result:
-            """Auto generate __rich_rep__ from signature of __init__"""
+        def auto_rich_repr(self: T) -> Result:
+            """Auto generate __rich_repr__ from signature of __init__"""
             try:
-                signature = inspect.signature(self.__init__)  ## type: ignore
+                signature = inspect.signature(self.__init__)  # type: ignore[misc]
                 for name, param in signature.parameters.items():
                     if param.kind == param.POSITIONAL_ONLY:
                         yield getattr(self, name)
@@ -89,33 +109,33 @@ def auto_rich_repr(self: Type[T]) -> Result:
 
         if not hasattr(cls, "__rich_repr__"):
             auto_rich_repr.__doc__ = "Build a rich repr"
-            cls.__rich_repr__ = auto_rich_repr  # type: ignore
+            setattr(cls, "__rich_repr__", auto_rich_repr)
 
         auto_repr.__doc__ = "Return repr(self)"
-        cls.__repr__ = auto_repr  # type: ignore
+        setattr(cls, "__repr__", auto_repr)
         if angular is not None:
-            cls.__rich_repr__.angular = angular  # type: ignore
+            setattr(cast(SupportsRichRepr, cls).__rich_repr__, "angular", angular)
         return cls
 
     if cls is None:
-        return partial(do_replace, angular=angular)  # type: ignore
+        return partial(do_replace, angular=angular)
     else:
-        return do_replace(cls, angular=angular)  # type: ignore
+        return do_replace(cls, angular=angular)
 
 
 @overload
-def rich_repr(cls: Optional[T]) -> T:
+def rich_repr(cls: Optional[Type[T]]) -> Type[T]:
     ...
 
 
 @overload
-def rich_repr(*, angular: bool = False) -> Callable[[T], T]:
+def rich_repr(*, angular: bool = False) -> Callable[[Type[T]], Type[T]]:
     ...
 
 
 def rich_repr(
-    cls: Optional[T] = None, *, angular: bool = False
-) -> Union[T, Callable[[T], T]]:
+    cls: Optional[Type[T]] = None, *, angular: bool = False
+) -> Union[Type[T], Callable[[Type[T]], Type[T]]]:
     if cls is None:
         return auto(angular=angular)
     else:
@@ -143,7 +163,7 @@ def __rich_repr__(self) -> Result:
     console.print(foo, width=30)
 
     console.rule("Angular repr")
-    Foo.__rich_repr__.angular = True  # type: ignore
+    setattr(Foo.__rich_repr__, "angular", True)
 
     console.print(foo)