A few minor improvements to the stubgen (#1179)

* Generalized support for `types.ModuleType` to a few other interpreter
  internal types.
* Fixed rendering of ellipsis in expression context, e.g.
  `Alias = tuple[T, ...]`.

Author: superbobry

src/stubgen.py

@@ -93,6 +93,16 @@ class and repeatedly call ``.put()`` to register modules or contents within the
     "__firstlineno__", "__static_attributes__", "__annotations__", "__annotate__",
     "__annotate_func__"
 ]
+
+# Interpreter-internal types.
+TYPES_TYPES = {
+    getattr(types, name): name for name in [
+        "MethodDescriptorType",
+        "MemberDescriptorType",
+        "ModuleType",
+    ]
+}
+
 # fmt: on
 
 # This type is used to track per-module imports (``import name as desired_name``)
@@ -988,10 +998,9 @@ def expr_str(self, e: Any, abbrev: bool = True) -> Optional[str]:
         complicated.
         """
         tp = type(e)
-        for t in [bool, int, type(None), type(builtins.Ellipsis)]:
-            if issubclass(tp, t):
-                return repr(e)
-        if issubclass(tp, float):
+        if issubclass(tp, (bool, int, type(None), type(builtins.Ellipsis))):
+            return repr(e)
+        elif issubclass(tp, float):
             s = repr(e)
             if "inf" in s or "nan" in s:
                 return f"float('{s}')"
@@ -1140,8 +1149,10 @@ def type_str(self, tp: Union[List[Any], Tuple[Any, ...], Dict[Any, Any], Any]) -
                 + ", ".join(args_gen)
                 + "]"
             )
-        elif tp is types.ModuleType:
-            result = "types.ModuleType"
+        elif tp in TYPES_TYPES:
+            result = f"types.{TYPES_TYPES[tp]}"
+        elif tp is Ellipsis:
+            result = "..."
         elif isinstance(tp, type):
             result = tp.__module__ + "." + tp.__qualname__
         else:

tests/test_typing.cpp

@@ -57,7 +57,9 @@ NB_MODULE(test_typing_ext, m) {
 
     m.def("makeNestedClass", [] { return NestedClass(); });
 
-    // Aliases to local functoins and types
+    m.attr("AnyTuple") = nb::typing().attr("Tuple")[nb::make_tuple(nb::any_type(), nb::ellipsis())];
+
+    // Aliases to local functions and types
     m.attr("FooAlias") = m.attr("Foo");
     m.attr("f_alias") = m.attr("f");
     nb::type<Foo>().attr("lt_alias") = nb::type<Foo>().attr("__lt__");

tests/test_typing_ext.pyi.ref

@@ -1,6 +1,6 @@
 from collections.abc import Iterable
 import py_stub_test
-from typing import Generic, Optional, Self, TypeAlias, TypeVar
+from typing import Any, Generic, Optional, Self, TypeAlias, TypeVar
 
 from . import submodule as submodule
 from .submodule import F as F, f as f2
@@ -23,6 +23,8 @@ def f() -> None: ...
 
 def makeNestedClass() -> py_stub_test.AClass.NestedClass: ...
 
+AnyTuple: TypeAlias = tuple[Any, ...]
+
 FooAlias: TypeAlias = Foo
 
 f_alias = f