Fix annotation check exception (tox-dev#462)

Fix processing type aliases

Author: tikuma-lsuhsc

src/sphinx_autodoc_typehints/__init__.py

@@ -20,6 +20,9 @@
 from sphinx.util.inspect import signature as sphinx_signature
 from sphinx.util.inspect import stringify_signature
 
+from typing import get_type_hints
+from sphinx.util.inspect import TypeAliasNamespace, TypeAliasForwardRef
+
 from .parser import parse
 from .patches import install_patches
 from .version import __version__
@@ -194,6 +197,9 @@ def format_annotation(annotation: Any, config: Config) -> str:  # noqa: C901, PL
     if isinstance(annotation, tuple):
         return format_internal_tuple(annotation, config)
 
+    if isinstance(annotation, TypeAliasForwardRef):
+        return str(annotation)
+
     try:
         module = get_annotation_module(annotation)
         class_name = get_annotation_class_name(annotation, module)
@@ -404,16 +410,19 @@ def _future_annotations_imported(obj: Any) -> bool:
     return bool(_annotations.compiler_flag == future_annotations)
 
 
-def get_all_type_hints(autodoc_mock_imports: list[str], obj: Any, name: str) -> dict[str, Any]:
-    result = _get_type_hint(autodoc_mock_imports, name, obj)
+def get_all_type_hints(
+    autodoc_mock_imports: list[str], obj: Any, name: str, localns: TypeAliasNamespace
+) -> dict[str, Any]:
+
+    result = _get_type_hint(autodoc_mock_imports, name, obj, localns)
     if not result:
         result = backfill_type_hints(obj, name)
         try:
             obj.__annotations__ = result
         except (AttributeError, TypeError):
             pass
         else:
-            result = _get_type_hint(autodoc_mock_imports, name, obj)
+            result = _get_type_hint(autodoc_mock_imports, name, obj, localns)
     return result
 
 
@@ -474,10 +483,12 @@ def _resolve_type_guarded_imports(autodoc_mock_imports: list[str], obj: Any) ->
             _execute_guarded_code(autodoc_mock_imports, obj, module_code)
 
 
-def _get_type_hint(autodoc_mock_imports: list[str], name: str, obj: Any) -> dict[str, Any]:
+def _get_type_hint(
+    autodoc_mock_imports: list[str], name: str, obj: Any, localns: TypeAliasForwardRef
+) -> dict[str, Any]:
     _resolve_type_guarded_imports(autodoc_mock_imports, obj)
     try:
-        result = get_type_hints(obj)
+        result = get_type_hints(obj, None, localns)
     except (AttributeError, TypeError, RecursionError) as exc:
         # TypeError - slot wrapper, PEP-563 when part of new syntax not supported
         # RecursionError - some recursive type definitions https://github.com/python/typing/issues/574
@@ -645,7 +656,9 @@ def process_docstring(  # noqa: PLR0913, PLR0917
         signature = sphinx_signature(obj, type_aliases=app.config["autodoc_type_aliases"])
     except (ValueError, TypeError):
         signature = None
-    type_hints = get_all_type_hints(app.config.autodoc_mock_imports, obj, name)
+
+    localns = TypeAliasNamespace(app.config["autodoc_type_aliases"])
+    type_hints = get_all_type_hints(app.config.autodoc_mock_imports, obj, name, localns)
     app.config._annotation_globals = getattr(obj, "__globals__", {})  # type: ignore[attr-defined]  # noqa: SLF001
     try:
         _inject_types_to_docstring(type_hints, signature, original_obj, app, what, name, lines)
@@ -715,14 +728,9 @@ def _inject_signature(  # noqa: C901
     app: Sphinx,
     lines: list[str],
 ) -> None:
-    type_aliases = app.config["autodoc_type_aliases"]
 
     for arg_name, arg_type in signature.parameters.items():
-        annotation = (
-            ForwardRef(arg_type.annotation, is_argument=True, is_class=False)
-            if str(arg_type.annotation) in type_aliases
-            else type_hints.get(arg_name)
-        )
+        annotation = type_hints.get(arg_name)
 
         default = signature.parameters[arg_name].default
 

tests/test_integration_autodoc_type_aliases.py

@@ -34,9 +34,7 @@ def dec(val: T) -> T:
     return dec
 
 
-from numpy.typing import ArrayLike
-
-# ArrayLike = Literal["test"]
+ArrayLike = Literal["test"]
 
 
 class _SchemaMeta(type):
@@ -71,14 +69,40 @@ def f(s: Schema) -> Schema:
     return s
 
 
+class AliasedClass: ...
+
+
+@expected(
+    """
+mod.g(s)
+
+   Do something.
+
+   Parameters:
+      **s** ("Class Alias") -- Some schema.
+
+   Return type:
+      "Class Alias"
+"""
+)
+def g(s: AliasedClass) -> AliasedClass:
+    """
+    Do something.
+
+    Args:
+        s: Some schema.
+    """
+    return s
+
+
 @expected(
     """\
 mod.function(x, y)
 
    Function docstring.
 
    Parameters:
-      * **x** (ArrayLike) -- foo
+      * **x** (Array) -- foo
 
       * **y** ("Schema") -- boo
 
@@ -103,25 +127,7 @@ def function(x: ArrayLike, y: Schema) -> str:  # noqa: ARG001
 
 # Config settings for each test run.
 # Config Name: Sphinx Options as Dict.
-configs = {
-    "default_conf": {
-        "autodoc_type_aliases": {
-            "ArrayLike": "ArrayLike",
-        }
-    }
-}
-# typehints_use_signature
-# typehints_defaults
-# typehints_fully_qualified = False
-# always_document_param_types = False
-# always_use_bars_union = False
-# typehints_document_rtype = True
-# typehints_use_rtype = True
-# typehints_defaults = "comma"
-# simplify_optional_unions = True
-# typehints_formatter = None
-# typehints_use_signature = True
-# typehints_use_signature_return = True
+configs = {"default_conf": {"autodoc_type_aliases": {"ArrayLike": "Array", "AliasedClass": '"Class Alias"'}}}
 
 
 @pytest.mark.parametrize("val", [x for x in globals().values() if hasattr(x, "EXPECTED")])