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.

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,54 +1,64 @@
 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[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]))
@@ -67,10 +77,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 +99,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 +153,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)