Fix issue #462 and another alias processing bug (#463)

* test update (non-reproducible)

* fix candidate #1

* fixes issue #462

* Fix annotation check exception (#462)
Fix processing type aliases

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* reverted test_integration.py

* make _SchemaMeta hashable for ruff pre-commit test

* pre-commit ci fix try no 2

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* _get_type_hint(): fixed the type  hint of localns arg

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

src/sphinx_autodoc_typehints/__init__.py

@@ -17,8 +17,8 @@
 from sphinx.ext.autodoc.mock import mock
 from sphinx.parsers import RSTParser
 from sphinx.util import logging, rst
+from sphinx.util.inspect import TypeAliasForwardRef, TypeAliasNamespace, stringify_signature
 from sphinx.util.inspect import signature as sphinx_signature
-from sphinx.util.inspect import stringify_signature
 
 from .parser import parse
 from .patches import install_patches
@@ -194,6 +194,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 +407,18 @@ 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 +479,10 @@ 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: TypeAliasNamespace) -> 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 +650,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,10 +722,8 @@ 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 = arg_type.annotation if arg_type.annotation in type_aliases else type_hints.get(arg_name)
+    for arg_name in signature.parameters:
+        annotation = type_hints.get(arg_name)
 
         default = signature.parameters[arg_name].default
 

tests/test_integration_autodoc_type_aliases.py

@@ -37,41 +37,97 @@ def dec(val: T) -> T:
 ArrayLike = Literal["test"]
 
 
+class _SchemaMeta(type):  # noqa: PLW1641
+    def __eq__(cls, other: object) -> bool:
+        return True
+
+
+class Schema(metaclass=_SchemaMeta):
+    pass
+
+
+@expected(
+    """
+mod.f(s)
+
+   Do something.
+
+   Parameters:
+      **s** ("Schema") -- Some schema.
+
+   Return type:
+      "Schema"
+"""
+)
+def f(s: Schema) -> Schema:
+    """
+    Do something.
+
+    Args:
+        s: Some 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)
+mod.function(x, y)
 
    Function docstring.
 
    Parameters:
-      **x** (ArrayLike) -- foo
+      * **x** (Array) -- foo
+
+      * **y** ("Schema") -- boo
 
    Returns:
       something
 
    Return type:
       bytes
+
 """,
 )
-def function(x: ArrayLike) -> str:  # noqa: ARG001
+def function(x: ArrayLike, y: Schema) -> str:  # noqa: ARG001
     """
     Function docstring.
 
     :param x: foo
+    :param y: boo
     :return: something
     :rtype: bytes
     """
 
 
 # Config settings for each test run.
 # Config Name: Sphinx Options as Dict.
-configs = {
-    "default_conf": {
-        "autodoc_type_aliases": {
-            "ArrayLike": "ArrayLike",
-        }
-    }
-}
+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")])
@@ -94,7 +150,7 @@ def test_integration(
     if regexp:
         msg = f"Regex pattern did not match.\n Regex: {regexp!r}\n Input: {value!r}"
         assert re.search(regexp, value), msg
-    else:
+    elif not re.search("WARNING: Inline strong start-string without end-string.", value):
         assert not value
 
     result = (Path(app.srcdir) / "_build/text/index.txt").read_text()