Handle nested type nicknames

Author: lagru

pyproject.toml

@@ -119,8 +119,8 @@ run.source = ["docstub"]
 ".*maintenance.*" = "Maintenance"
 
 
-[tool.docstub.type_nicknames]
-Path = "pathlib.Path"
+[tool.docstub.types]
+Path = "pathlib"
 
 
 [tool.mypy]

src/docstub/_analysis.py

@@ -504,27 +504,57 @@ def __init__(
 
         self.current_file = None
 
-    def match(self, search_name):
+    def _resolve_nickname(self, name):
+        """Return intended name if `name` is a nickname.
+
+        Parameters
+        ----------
+        name : str
+
+        Returns
+        -------
+        resolved : str
+        """
+        original = name
+        resolved = name
+        for _ in range(1000):
+            name = self.type_nicknames.get(name)
+            if name is None:
+                break
+            resolved = name
+        else:
+            logger.warning(
+                "reached limit while resolving nicknames for %r in %s, using %r",
+                original,
+                self.current_file or "<file not known>",
+                resolved,
+            )
+        return resolved
+
+    def match(self, search):
         """Search for a known annotation name.
 
         Parameters
         ----------
-        search_name : str
+        search : str
         current_module : Path, optional
 
         Returns
         -------
         type_name : str | None
         py_import : PyImport | None
         """
+        original_search = search
         type_name = None
         py_import = None
 
         module = module_name_from_path(self.current_file) if self.current_file else None
 
-        if search_name.startswith("~."):
+        search = self._resolve_nickname(search)
+
+        if search.startswith("~."):
             # Sphinx like matching with abbreviated name
-            pattern = search_name.replace(".", r"\.")
+            pattern = search.replace(".", r"\.")
             pattern = pattern.replace("~", ".*")
             regex = re.compile(pattern + "$")
             # Might be slow, but works for now
@@ -539,43 +569,41 @@ def match(self, search_name):
                 py_import = matches[shortest_key]
                 type_name = shortest_key
                 logger.warning(
-                    "%r in %s matches multiple types %r, using %r",
-                    search_name,
+                    "%r (original %r) in %s matches multiple types %r, using %r",
+                    search,
+                    original_search,
                     self.current_file or "<file not known>",
                     matches.keys(),
                     shortest_key,
                 )
             elif len(matches) == 1:
                 type_name, py_import = matches.popitem()
             else:
-                search_name = search_name[2:]
+                search = search[2:]
                 logger.debug(
                     "couldn't match %r in %s",
-                    search_name,
+                    search,
                     self.current_file or "<file not known>",
                 )
 
-        # Replace alias
-        search_name = self.type_nicknames.get(search_name, search_name)
-
         if py_import is None and module:
             # Look for matching type in current module
-            py_import = self.types.get(f"{module}:{search_name}")
-            py_import = self.types.get(f"{module}.{search_name}", py_import)
+            py_import = self.types.get(f"{module}:{search}")
+            py_import = self.types.get(f"{module}.{search}", py_import)
             if py_import:
-                type_name = search_name
+                type_name = search
 
-        if py_import is None and search_name in self.types:
-            type_name = search_name
-            py_import = self.types[search_name]
+        if py_import is None and search in self.types:
+            type_name = search
+            py_import = self.types[search]
 
         if py_import is None:
             # Try a subset of the qualname (first 'a.b.c', then 'a.b' and 'a')
-            for partial_qualname in reversed(accumulate_qualname(search_name)):
+            for partial_qualname in reversed(accumulate_qualname(search)):
                 py_import = self.type_prefixes.get(f"{module}:{partial_qualname}")
                 py_import = self.type_prefixes.get(partial_qualname, py_import)
                 if py_import:
-                    type_name = search_name
+                    type_name = search
                     break
 
         if (
@@ -590,6 +618,6 @@ def match(self, search_name):
         if type_name is not None:
             self.successful_queries += 1
         else:
-            self.unknown_qualnames.append(search_name)
+            self.unknown_qualnames.append(search)
 
         return type_name, py_import

src/docstub/_cli.py

@@ -236,11 +236,14 @@ def run(root_path, out_dir, config_paths, ignore, group_errors, allow_errors, ve
     config = config.merge(Config(ignore_files=list(ignore)))
 
     types, type_prefixes = _collect_type_info(root_path, ignore=config.ignore_files)
+
+    # Add declared types from configuration
     types |= {
         type_name: PyImport(from_=module, import_=type_name)
         for type_name, module in config.types.items()
     }
 
+    # Add declared type prefixes from configuration
     type_prefixes |= {
         prefix: (
             PyImport(import_=module, as_=prefix)

tests/test_analysis.py

@@ -319,3 +319,37 @@ def test_scoped_type_prefix(self, module_factory):
         type_name, py_import = matcher.match("cal.January")
         assert type_name == "cal.January"
         assert py_import == PyImport(implicit="sub.module:cal")
+
+    def test_nested_nicknames(self, caplog):
+        types = {
+            "Foo": PyImport(implicit="Foo"),
+            "Bar": PyImport(implicit="Bar"),
+        }
+        type_nicknames = {
+            "Foo": "~.Baz",
+            "~.Baz": "B.i.k",
+            "B.i.k": "Bar",
+        }
+        matcher = TypeMatcher(types=types, type_nicknames=type_nicknames)
+
+        type_name, py_import = matcher.match("Foo")
+        assert type_name == "Bar"
+        assert py_import == PyImport(implicit="Bar")
+
+    def test_nickname_infinite_loop(self, caplog):
+        types = {
+            "Foo": PyImport(implicit="Foo"),
+            "Bar": PyImport(implicit="Bar"),
+        }
+        type_nicknames = {
+            "Foo": "Bar",
+            "Bar": "Foo",
+        }
+        matcher = TypeMatcher(types=types, type_nicknames=type_nicknames)
+
+        type_name, py_import = matcher.match("Foo")
+        assert len(caplog.records) == 1
+        assert "reached limit while resolving nicknames" in caplog.text
+
+        assert type_name == "Foo"
+        assert py_import == PyImport(implicit="Foo")