Sphinx 7.1.1__py3-none-any.whl → 7.2.0__py3-none-any.whl

sphinx/ext/autodoc/__init__.py

@@ -9,25 +9,15 @@ from __future__ import annotations
 
 import re
 import sys
+import warnings
 from inspect import Parameter, Signature
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Iterator,
-    List,
-    Sequence,
-    Tuple,
-    TypeVar,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
 
 from docutils.statemachine import StringList
 
 import sphinx
-from sphinx.application import Sphinx
 from sphinx.config import ENUM, Config
-from sphinx.environment import BuildEnvironment
+from sphinx.deprecation import RemovedInSphinx80Warning
 from sphinx.ext.autodoc.importer import get_class_members, import_module, import_object
 from sphinx.ext.autodoc.mock import ismock, mock, undecorate
 from sphinx.locale import _, __
@@ -44,8 +34,11 @@ from sphinx.util.inspect import (
 from sphinx.util.typing import OptionSpec, get_type_hints, restify, stringify_annotation
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
     from types import ModuleType
 
+    from sphinx.application import Sphinx
+    from sphinx.environment import BuildEnvironment
     from sphinx.ext.autodoc.directive import DocumenterBridge
 
 logger = logging.getLogger(__name__)
@@ -260,7 +253,7 @@ class Options(dict):
             return None
 
 
-class ObjectMember(tuple):
+class ObjectMember:
     """A member of object.
 
     This is used for the result of `Documenter.get_module_members()` to
@@ -274,10 +267,7 @@ class ObjectMember(tuple):
        interface.
     """
 
-    def __new__(cls, name: str, obj: Any, **kwargs: Any) -> Any:
-        return super().__new__(cls, (name, obj))  # type: ignore
-
-    def __init__(self, name: str, obj: Any, docstring: str | None = None,
+    def __init__(self, name: str, obj: Any, *, docstring: str | None = None,
                  class_: Any = None, skipped: bool = False) -> None:
         self.__name__ = name
         self.object = obj
@@ -285,8 +275,11 @@ class ObjectMember(tuple):
         self.skipped = skipped
         self.class_ = class_
 
-
-ObjectMembers = Union[List[ObjectMember], List[Tuple[str, Any]]]
+    def __getitem__(self, index):
+        warnings.warn('The tuple interface of ObjectMember is deprecated. '
+                      'Use (obj.__name__, obj.object) instead.',
+                      RemovedInSphinx80Warning, stacklevel=2)
+        return (self.__name__, self.object)[index]
 
 
 class Documenter:
@@ -317,6 +310,7 @@ class Documenter:
     titles_allowed = True
 
     option_spec: OptionSpec = {
+        'no-index': bool_option,
         'noindex': bool_option,
     }
 
@@ -328,7 +322,8 @@ class Documenter:
     def can_document_member(cls, member: Any, membername: str, isattr: bool, parent: Any,
                             ) -> bool:
         """Called to see if a member can be documented by this Documenter."""
-        raise NotImplementedError('must be implemented in subclasses')
+        msg = 'must be implemented in subclasses'
+        raise NotImplementedError(msg)
 
     def __init__(self, directive: DocumenterBridge, name: str, indent: str = '') -> None:
         self.directive = directive
@@ -339,21 +334,21 @@ class Documenter:
         self.indent = indent
         # the module and object path within the module, and the fully
         # qualified name (all set after resolve_name succeeds)
-        self.modname: str = None
-        self.module: ModuleType = None
-        self.objpath: list[str] = None
-        self.fullname: str = None
+        self.modname: str = ''
+        self.module: ModuleType | None = None
+        self.objpath: list[str] = []
+        self.fullname = ''
         # extra signature items (arguments and return annotation,
         # also set after resolve_name succeeds)
-        self.args: str = None
-        self.retann: str = None
+        self.args: str | None = None
+        self.retann: str = ''
         # the object to document (set after import_object succeeds)
         self.object: Any = None
-        self.object_name: str = None
+        self.object_name = ''
         # the parent/owner of the object to document
         self.parent: Any = None
         # the module analyzer to get at attribute docs, or None
-        self.analyzer: ModuleAnalyzer = None
+        self.analyzer: ModuleAnalyzer | None = None
 
     @property
     def documenters(self) -> dict[str, type[Documenter]]:
@@ -367,8 +362,8 @@ class Documenter:
         else:
             self.directive.result.append('', source, *lineno)
 
-    def resolve_name(self, modname: str, parents: Any, path: str, base: Any,
-                     ) -> tuple[str, list[str]]:
+    def resolve_name(self, modname: str | None, parents: Any, path: str, base: str,
+                     ) -> tuple[str | None, list[str]]:
         """Resolve the module and name of the object to document given by the
         arguments and the current module/class.
 
@@ -376,7 +371,8 @@ class Documenter:
         example, it would return ``('zipfile', ['ZipFile', 'open'])`` for the
         ``zipfile.ZipFile.open`` method.
         """
-        raise NotImplementedError('must be implemented in subclasses')
+        msg = 'must be implemented in subclasses'
+        raise NotImplementedError(msg)
 
     def parse_name(self) -> bool:
         """Determine what module to import and what attribute to document.
@@ -389,6 +385,7 @@ class Documenter:
         # an autogenerated one
         try:
             matched = py_ext_sig_re.match(self.name)
+            assert matched is not None
             explicit_modname, path, base, tp_list, args, retann = matched.groups()
         except AttributeError:
             logger.warning(__('invalid signature for auto%s (%r)') % (self.objtype, self.name),
@@ -404,11 +401,12 @@ class Documenter:
             parents = []
 
         with mock(self.config.autodoc_mock_imports):
-            self.modname, self.objpath = self.resolve_name(modname, parents, path, base)
+            modname, self.objpath = self.resolve_name(modname, parents, path, base)
 
-        if not self.modname:
+        if not modname:
             return False
 
+        self.modname = modname
         self.args = args
         self.retann = retann
         self.fullname = ((self.modname or '') +
@@ -458,12 +456,12 @@ class Documenter:
             return False
         return True
 
-    def format_args(self, **kwargs: Any) -> str | None:
+    def format_args(self, **kwargs: Any) -> str:
         """Format the argument signature of *self.object*.
 
         Should return None if the object does not have a signature.
         """
-        pass
+        return ''
 
     def format_name(self) -> str:
         """Format the name of *self.object*.
@@ -476,7 +474,7 @@ class Documenter:
         # directives of course)
         return '.'.join(self.objpath) or self.modname
 
-    def _call_format_args(self, **kwargs: Any) -> str | None:
+    def _call_format_args(self, **kwargs: Any) -> str:
         if kwargs:
             try:
                 return self.format_args(**kwargs)
@@ -537,8 +535,8 @@ class Documenter:
             if i == 0:
                 prefix = " " * len(prefix)
 
-        if self.options.noindex:
-            self.add_line('   :noindex:', sourcename)
+        if self.options.no_index or self.options.noindex:
+            self.add_line('   :no-index:', sourcename)
         if self.objpath:
             # Be explicit about the module, this is necessary since .. class::
             # etc. don't support a prepended module name
@@ -600,9 +598,9 @@ class Documenter:
                     docstring = False
                     # make a copy of docstring for attributes to avoid cache
                     # the change of autodoc-process-docstring event.
-                    docstrings = [list(attr_docs[key])]
+                    attribute_docstrings = [list(attr_docs[key])]
 
-                    for i, line in enumerate(self.process_doc(docstrings)):
+                    for i, line in enumerate(self.process_doc(attribute_docstrings)):
                         self.add_line(line, sourcename, i)
 
         # add content from docstrings
@@ -625,16 +623,17 @@ class Documenter:
             for line, src in zip(more_content.data, more_content.items):
                 self.add_line(line, src[0], src[1])
 
-    def get_object_members(self, want_all: bool) -> tuple[bool, ObjectMembers]:
+    def get_object_members(self, want_all: bool) -> tuple[bool, list[ObjectMember]]:
         """Return `(members_check_module, members)` where `members` is a
         list of `(membername, member)` pairs of the members of *self.object*.
 
         If *want_all* is True, return all members.  Else, only return those
         members given by *self.options.members* (which may also be None).
         """
-        raise NotImplementedError('must be implemented in subclasses')
+        msg = 'must be implemented in subclasses'
+        raise NotImplementedError(msg)
 
-    def filter_members(self, members: ObjectMembers, want_all: bool,
+    def filter_members(self, members: list[ObjectMember], want_all: bool,
                        ) -> list[tuple[str, Any, bool]]:
         """Filter the given member list.
 
@@ -679,7 +678,8 @@ class Documenter:
         # process members and determine which to skip
         for obj in members:
             try:
-                membername, member = obj
+                membername = obj.__name__
+                member = obj.object
                 # if isattr is True, the member is documented as an attribute
                 isattr = member is INSTANCEATTR or (namespace, membername) in attr_docs
 
@@ -813,7 +813,7 @@ class Documenter:
             classes.sort(key=lambda cls: cls.priority)
             # give explicitly separated module name, so that members
             # of inner classes can be documented
-            full_mname = self.modname + '::' + '.'.join(self.objpath + [mname])
+            full_mname = f'{self.modname}::' + '.'.join((*self.objpath, mname))
             documenter = classes[-1](self.directive, full_mname, self.indent)
             memberdocumenters.append((documenter, isattr))
 
@@ -898,8 +898,8 @@ class Documenter:
             # no source file -- e.g. for builtin and C modules
             self.analyzer = None
             # at least add the module.__file__ as a dependency
-            if hasattr(self.module, '__file__') and self.module.__file__:
-                self.directive.record_dependencies.add(self.module.__file__)
+            if module___file__ := getattr(self.module, '__file__', ''):
+                self.directive.record_dependencies.add(module___file__)
         else:
             self.directive.record_dependencies.add(self.analyzer.srcname)
 
@@ -960,13 +960,14 @@ class ModuleDocumenter(Documenter):
 
     option_spec: OptionSpec = {
         'members': members_option, 'undoc-members': bool_option,
-        'noindex': bool_option, 'inherited-members': inherited_members_option,
+        'no-index': bool_option, 'inherited-members': inherited_members_option,
         'show-inheritance': bool_option, 'synopsis': identity,
         'platform': identity, 'deprecated': bool_option,
         'member-order': member_order_option, 'exclude-members': exclude_members_option,
         'private-members': members_option, 'special-members': members_option,
         'imported-members': bool_option, 'ignore-module-all': bool_option,
         'no-value': bool_option,
+        'noindex': bool_option,
     }
 
     def __init__(self, *args: Any) -> None:
@@ -989,8 +990,8 @@ class ModuleDocumenter(Documenter):
         # don't document submodules automatically
         return False
 
-    def resolve_name(self, modname: str, parents: Any, path: str, base: Any,
-                     ) -> tuple[str, list[str]]:
+    def resolve_name(self, modname: str | None, parents: Any, path: str, base: str,
+                     ) -> tuple[str | None, list[str]]:
         if modname is not None:
             logger.warning(__('"::" in automodule name doesn\'t make sense'),
                            type='autodoc')
@@ -1058,7 +1059,7 @@ class ModuleDocumenter(Documenter):
 
         return members
 
-    def get_object_members(self, want_all: bool) -> tuple[bool, ObjectMembers]:
+    def get_object_members(self, want_all: bool) -> tuple[bool, list[ObjectMember]]:
         members = self.get_module_members()
         if want_all:
             if self.__all__ is None:
@@ -1087,16 +1088,21 @@ class ModuleDocumenter(Documenter):
     def sort_members(self, documenters: list[tuple[Documenter, bool]],
                      order: str) -> list[tuple[Documenter, bool]]:
         if order == 'bysource' and self.__all__:
+            assert self.__all__ is not None
+            module_all = self.__all__
+            module_all_set = set(module_all)
+            module_all_len = len(module_all)
+
             # Sort alphabetically first (for members not listed on the __all__)
             documenters.sort(key=lambda e: e[0].name)
 
             # Sort by __all__
             def keyfunc(entry: tuple[Documenter, bool]) -> int:
                 name = entry[0].name.split('::')[1]
-                if self.__all__ and name in self.__all__:
-                    return self.__all__.index(name)
+                if name in module_all_set:
+                    return module_all.index(name)
                 else:
-                    return len(self.__all__)
+                    return module_all_len
             documenters.sort(key=keyfunc)
 
             return documenters
@@ -1109,19 +1115,21 @@ class ModuleLevelDocumenter(Documenter):
     Specialized Documenter subclass for objects on module level (functions,
     classes, data/constants).
     """
-    def resolve_name(self, modname: str, parents: Any, path: str, base: Any,
-                     ) -> tuple[str, list[str]]:
-        if modname is None:
-            if path:
-                modname = path.rstrip('.')
-            else:
-                # if documenting a toplevel object without explicit module,
-                # it can be contained in another auto directive ...
-                modname = self.env.temp_data.get('autodoc:module')
-                # ... or in the scope of a module directive
-                if not modname:
-                    modname = self.env.ref_context.get('py:module')
-                # ... else, it stays None, which means invalid
+    def resolve_name(self, modname: str | None, parents: Any, path: str, base: str,
+                     ) -> tuple[str | None, list[str]]:
+        if modname is not None:
+            return modname, parents + [base]
+        if path:
+            modname = path.rstrip('.')
+            return modname, parents + [base]
+
+        # if documenting a toplevel object without explicit module,
+        # it can be contained in another auto directive ...
+        modname = self.env.temp_data.get('autodoc:module')
+        # ... or in the scope of a module directive
+        if not modname:
+            modname = self.env.ref_context.get('py:module')
+        # ... else, it stays None, which means invalid
         return modname, parents + [base]
 
 
@@ -1130,31 +1138,33 @@ class ClassLevelDocumenter(Documenter):
     Specialized Documenter subclass for objects on class level (methods,
     attributes).
     """
-    def resolve_name(self, modname: str, parents: Any, path: str, base: Any,
-                     ) -> tuple[str, list[str]]:
-        if modname is None:
-            if path:
-                mod_cls = path.rstrip('.')
-            else:
-                mod_cls = None
-                # if documenting a class-level object without path,
-                # there must be a current class, either from a parent
-                # auto directive ...
-                mod_cls = self.env.temp_data.get('autodoc:class')
-                # ... or from a class directive
-                if mod_cls is None:
-                    mod_cls = self.env.ref_context.get('py:class')
+    def resolve_name(self, modname: str | None, parents: Any, path: str, base: str,
+                     ) -> tuple[str | None, list[str]]:
+        if modname is not None:
+            return modname, parents + [base]
+
+        if path:
+            mod_cls = path.rstrip('.')
+        else:
+            # if documenting a class-level object without path,
+            # there must be a current class, either from a parent
+            # auto directive ...
+            mod_cls_ = self.env.temp_data.get('autodoc:class')
+            # ... or from a class directive
+            if mod_cls_ is None:
+                mod_cls_ = self.env.ref_context.get('py:class')
                 # ... if still None, there's no way to know
-                if mod_cls is None:
+                if mod_cls_ is None:
                     return None, []
-            modname, sep, cls = mod_cls.rpartition('.')
-            parents = [cls]
-            # if the module name is still missing, get it like above
-            if not modname:
-                modname = self.env.temp_data.get('autodoc:module')
-            if not modname:
-                modname = self.env.ref_context.get('py:module')
-            # ... else, it stays None, which means invalid
+            mod_cls = mod_cls_
+        modname, sep, cls = mod_cls.rpartition('.')
+        parents = [cls]
+        # if the module name is still missing, get it like above
+        if not modname:
+            modname = self.env.temp_data.get('autodoc:module')
+        if not modname:
+            modname = self.env.ref_context.get('py:module')
+        # ... else, it stays None, which means invalid
         return modname, parents + [base]
 
 
@@ -1163,12 +1173,12 @@ class DocstringSignatureMixin:
     Mixin for FunctionDocumenter and MethodDocumenter to provide the
     feature of reading the signature from the docstring.
     """
-    _new_docstrings: list[list[str]] = None
-    _signatures: list[str] = None
+    _new_docstrings: list[list[str]] | None = None
+    _signatures: list[str] = []
 
-    def _find_signature(self) -> tuple[str | None, str | None]:
+    def _find_signature(self) -> tuple[str | None, str | None] | None:
         # candidates of the object name
-        valid_names = [self.objpath[-1]]  # type: ignore
+        valid_names = [self.objpath[-1]]  # type: ignore[attr-defined]
         if isinstance(self, ClassDocumenter):
             valid_names.append('__init__')
             if hasattr(self.object, '__mro__'):
@@ -1200,7 +1210,8 @@ class DocstringSignatureMixin:
                     break
 
                 # re-prepare docstring to ignore more leading indentation
-                tab_width = self.directive.state.document.settings.tab_width  # type: ignore
+                directive = self.directive  # type: ignore[attr-defined]
+                tab_width = directive.state.document.settings.tab_width
                 self._new_docstrings[i] = prepare_docstring('\n'.join(doclines[j + 1:]),
                                                             tab_width)
 
@@ -1211,25 +1222,27 @@ class DocstringSignatureMixin:
                     # subsequent signatures
                     self._signatures.append(f"({args}) -> {retann}")
 
-            if result:
+            if result is not None:
                 # finish the loop when signature found
                 break
 
         return result
 
-    def get_doc(self) -> list[list[str]]:
+    def get_doc(self) -> list[list[str]] | None:
         if self._new_docstrings is not None:
             return self._new_docstrings
         return super().get_doc()  # type: ignore[misc]
 
     def format_signature(self, **kwargs: Any) -> str:
-        if self.args is None and self.config.autodoc_docstring_signature:  # type: ignore
+        self.args: str | None
+        if (self.args is None
+                and self.config.autodoc_docstring_signature):  # type: ignore[attr-defined]
             # only act if a signature is not explicitly given already, and if
             # the feature is enabled
             result = self._find_signature()
             if result is not None:
                 self.args, self.retann = result
-        sig = super().format_signature(**kwargs)  # type: ignore
+        sig = super().format_signature(**kwargs)  # type: ignore[misc]
         if self._signatures:
             return "\n".join([sig] + self._signatures)
         else:
@@ -1257,7 +1270,7 @@ class DocstringStripSignatureMixin(DocstringSignatureMixin):
         return super().format_signature(**kwargs)
 
 
-class FunctionDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type: ignore
+class FunctionDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type: ignore[misc]
     """
     Specialized Documenter subclass for functions.
     """
@@ -1271,7 +1284,7 @@ class FunctionDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # typ
         return (inspect.isfunction(member) or inspect.isbuiltin(member) or
                 (inspect.isroutine(member) and isinstance(parent, ModuleDocumenter)))
 
-    def format_args(self, **kwargs: Any) -> str | None:
+    def format_args(self, **kwargs: Any) -> str:
         if self.config.autodoc_typehints in ('none', 'description'):
             kwargs.setdefault('show_annotation', False)
         if self.config.autodoc_typehints_format == "short":
@@ -1284,7 +1297,7 @@ class FunctionDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # typ
         except TypeError as exc:
             logger.warning(__("Failed to get a function signature for %s: %s"),
                            self.fullname, exc)
-            return None
+            return ''
         except ValueError:
             args = ''
 
@@ -1328,13 +1341,13 @@ class FunctionDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # typ
                     if dispatchfunc:
                         documenter = FunctionDocumenter(self.directive, '')
                         documenter.object = dispatchfunc
-                        documenter.objpath = [None]
+                        documenter.objpath = ['']
                         sigs.append(documenter.format_signature())
-        if overloaded:
+        if overloaded and self.analyzer is not None:
             actual = inspect.signature(self.object,
                                        type_aliases=self.config.autodoc_type_aliases)
             __globals__ = safe_getattr(self.object, '__globals__', {})
-            for overload in self.analyzer.overloads.get('.'.join(self.objpath)):
+            for overload in self.analyzer.overloads['.'.join(self.objpath)]:
                 overload = self.merge_default_value(actual, overload)
                 overload = evaluate_signature(overload, __globals__,
                                               self.config.autodoc_type_aliases)
@@ -1375,7 +1388,8 @@ class FunctionDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # typ
         if params[0].annotation is Parameter.empty:
             params[0] = params[0].replace(annotation=typ)
             try:
-                dummy.__signature__ = sig.replace(parameters=params)  # type: ignore
+                dummy.__signature__ = sig.replace(  # type: ignore[attr-defined]
+                    parameters=params)
                 return dummy
             except (AttributeError, TypeError):
                 # failed to update signature (ex. built-in or extension types)
@@ -1393,12 +1407,12 @@ class DecoratorDocumenter(FunctionDocumenter):
     # must be lower than FunctionDocumenter
     priority = -1
 
-    def format_args(self, **kwargs: Any) -> Any:
+    def format_args(self, **kwargs: Any) -> str:
         args = super().format_args(**kwargs)
         if ',' in args:
             return args
         else:
-            return None
+            return ''
 
 
 # Types which have confusing metaclass signatures it would be best not to show.
@@ -1415,7 +1429,7 @@ _CLASS_NEW_BLACKLIST = [
 ]
 
 
-class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type: ignore
+class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type: ignore[misc]
     """
     Specialized Documenter subclass for classes.
     """
@@ -1423,11 +1437,12 @@ class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type:
     member_order = 20
     option_spec: OptionSpec = {
         'members': members_option, 'undoc-members': bool_option,
-        'noindex': bool_option, 'inherited-members': inherited_members_option,
+        'no-index': bool_option, 'inherited-members': inherited_members_option,
         'show-inheritance': bool_option, 'member-order': member_order_option,
         'exclude-members': exclude_members_option,
         'private-members': members_option, 'special-members': members_option,
         'class-doc-from': class_doc_from_option,
+        'noindex': bool_option,
     }
 
     # Must be higher than FunctionDocumenter, ClassDocumenter, and
@@ -1436,7 +1451,7 @@ class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type:
     priority = 15
 
     _signature_class: Any = None
-    _signature_method_name: str = None
+    _signature_method_name: str = ''
 
     def __init__(self, *args: Any) -> None:
         super().__init__(*args)
@@ -1558,26 +1573,27 @@ class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type:
         # with __init__ in C and no `__text_signature__`.
         return None, None, None
 
-    def format_args(self, **kwargs: Any) -> str | None:
+    def format_args(self, **kwargs: Any) -> str:
         if self.config.autodoc_typehints in ('none', 'description'):
             kwargs.setdefault('show_annotation', False)
         if self.config.autodoc_typehints_format == "short":
             kwargs.setdefault('unqualified_typehints', True)
 
         try:
-            self._signature_class, self._signature_method_name, sig = self._get_signature()
+            self._signature_class, _signature_method_name, sig = self._get_signature()
         except TypeError as exc:
             # __signature__ attribute contained junk
             logger.warning(__("Failed to get a constructor signature for %s: %s"),
                            self.fullname, exc)
-            return None
+            return ''
+        self._signature_method_name = _signature_method_name or ''
 
         if sig is None:
-            return None
+            return ''
 
         return stringify_signature(sig, show_return_annotation=False, **kwargs)
 
-    def _find_signature(self) -> tuple[str, str]:
+    def _find_signature(self) -> tuple[str | None, str | None] | None:
         result = super()._find_signature()
         if result is not None:
             # Strip a return value from signature of constructor in docstring (first entry)
@@ -1696,12 +1712,12 @@ class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type:
             self.add_line('', sourcename)
             self.add_line('   ' + _('Bases: %s') % ', '.join(base_classes), sourcename)
 
-    def get_object_members(self, want_all: bool) -> tuple[bool, ObjectMembers]:
+    def get_object_members(self, want_all: bool) -> tuple[bool, list[ObjectMember]]:
         members = get_class_members(self.object, self.objpath, self.get_attr,
                                     self.config.autodoc_inherit_docstrings)
         if not want_all:
             if not self.options.members:
-                return False, []  # type: ignore
+                return False, []
             # specific members given
             selected = []
             for name in self.options.members:
@@ -1740,8 +1756,7 @@ class ClassDocumenter(DocstringSignatureMixin, ModuleLevelDocumenter):  # type:
                         pass
         if self.doc_as_attr:
             # Don't show the docstring of the class when it is an alias.
-            comment = self.get_variable_comment()
-            if comment:
+            if self.get_variable_comment():
                 return []
             else:
                 return None
@@ -1891,12 +1906,12 @@ class ExceptionDocumenter(ClassDocumenter):
 
 class DataDocumenterMixinBase:
     # define types of instance variables
-    config: Config = None
-    env: BuildEnvironment = None
-    modname: str = None
-    parent: Any = None
-    object: Any = None
-    objpath: list[str] = None
+    config: Config
+    env: BuildEnvironment
+    modname: str
+    parent: Any
+    object: Any
+    objpath: list[str]
 
     def should_suppress_directive_header(self) -> bool:
         """Check directive header should be suppressed."""
@@ -1942,7 +1957,7 @@ class UninitializedGlobalVariableMixin(DataDocumenterMixinBase):
 
     def import_object(self, raiseerror: bool = False) -> bool:
         try:
-            return super().import_object(raiseerror=True)  # type: ignore
+            return super().import_object(raiseerror=True)  # type: ignore[misc]
         except ImportError as exc:
             # annotation only instance variable (PEP-526)
             try:
@@ -1971,7 +1986,7 @@ class UninitializedGlobalVariableMixin(DataDocumenterMixinBase):
         if self.object is UNINITIALIZED_ATTR:
             return []
         else:
-            return super().get_doc()  # type: ignore
+            return super().get_doc()  # type: ignore[misc]
 
 
 class DataDocumenter(GenericAliasMixin,
@@ -2016,7 +2031,7 @@ class DataDocumenter(GenericAliasMixin,
         if super().should_suppress_value_header():
             return True
         else:
-            doc = self.get_doc()
+            doc = self.get_doc() or []
             docstring, metadata = separate_metadata('\n'.join(sum(doc, [])))
             if 'hide-value' in metadata:
                 return True
@@ -2094,7 +2109,7 @@ class DataDocumenter(GenericAliasMixin,
         super().add_content(more_content)
 
 
-class MethodDocumenter(DocstringSignatureMixin, ClassLevelDocumenter):  # type: ignore
+class MethodDocumenter(DocstringSignatureMixin, ClassLevelDocumenter):  # type: ignore[misc]
     """
     Specialized Documenter subclass for methods (normal, static and class).
     """
@@ -2125,7 +2140,7 @@ class MethodDocumenter(DocstringSignatureMixin, ClassLevelDocumenter):  # type:
 
         return ret
 
-    def format_args(self, **kwargs: Any) -> str | None:
+    def format_args(self, **kwargs: Any) -> str:
         if self.config.autodoc_typehints in ('none', 'description'):
             kwargs.setdefault('show_annotation', False)
         if self.config.autodoc_typehints_format == "short":
@@ -2151,7 +2166,7 @@ class MethodDocumenter(DocstringSignatureMixin, ClassLevelDocumenter):  # type:
         except TypeError as exc:
             logger.warning(__("Failed to get a method signature for %s: %s"),
                            self.fullname, exc)
-            return None
+            return ''
         except ValueError:
             args = ''
 
@@ -2206,9 +2221,9 @@ class MethodDocumenter(DocstringSignatureMixin, ClassLevelDocumenter):  # type:
                         documenter = MethodDocumenter(self.directive, '')
                         documenter.parent = self.parent
                         documenter.object = dispatchmeth
-                        documenter.objpath = [None]
+                        documenter.objpath = ['']
                         sigs.append(documenter.format_signature())
-        if overloaded:
+        if overloaded and self.analyzer is not None:
             if inspect.isstaticmethod(self.object, cls=self.parent, name=self.object_name):
                 actual = inspect.signature(self.object, bound_method=False,
                                            type_aliases=self.config.autodoc_type_aliases)
@@ -2217,7 +2232,7 @@ class MethodDocumenter(DocstringSignatureMixin, ClassLevelDocumenter):  # type:
                                            type_aliases=self.config.autodoc_type_aliases)
 
             __globals__ = safe_getattr(self.object, '__globals__', {})
-            for overload in self.analyzer.overloads.get('.'.join(self.objpath)):
+            for overload in self.analyzer.overloads['.'.join(self.objpath)]:
                 overload = self.merge_default_value(actual, overload)
                 overload = evaluate_signature(overload, __globals__,
                                               self.config.autodoc_type_aliases)
@@ -2262,7 +2277,8 @@ class MethodDocumenter(DocstringSignatureMixin, ClassLevelDocumenter):  # type:
         if params[1].annotation is Parameter.empty:
             params[1] = params[1].replace(annotation=typ)
             try:
-                dummy.__signature__ = sig.replace(parameters=params)  # type: ignore
+                dummy.__signature__ = sig.replace(  # type: ignore[attr-defined]
+                    parameters=params)
                 return dummy
             except (AttributeError, TypeError):
                 # failed to update signature (ex. built-in or extension types)
@@ -2317,7 +2333,7 @@ class NonDataDescriptorMixin(DataDocumenterMixinBase):
     """
 
     def import_object(self, raiseerror: bool = False) -> bool:
-        ret = super().import_object(raiseerror)  # type: ignore
+        ret = super().import_object(raiseerror)  # type: ignore[misc]
         if ret and not inspect.isattributedescriptor(self.object):
             self.non_data_descriptor = True
         else:
@@ -2335,7 +2351,7 @@ class NonDataDescriptorMixin(DataDocumenterMixinBase):
             # to display
             return None
         else:
-            return super().get_doc()  # type: ignore
+            return super().get_doc()  # type: ignore[misc]
 
 
 class SlotsMixin(DataDocumenterMixinBase):
@@ -2346,13 +2362,15 @@ class SlotsMixin(DataDocumenterMixinBase):
     def isslotsattribute(self) -> bool:
         """Check the subject is an attribute in __slots__."""
         try:
-            __slots__ = inspect.getslots(self.parent)
-            return bool(__slots__) and self.objpath[-1] in __slots__
+            if parent___slots__ := inspect.getslots(self.parent):
+                return self.objpath[-1] in parent___slots__
+            else:
+                return False
         except (ValueError, TypeError):
             return False
 
     def import_object(self, raiseerror: bool = False) -> bool:
-        ret = super().import_object(raiseerror)  # type: ignore
+        ret = super().import_object(raiseerror)  # type: ignore[misc]
         if self.isslotsattribute():
             self.object = SLOTSATTR
 
@@ -2367,9 +2385,9 @@ class SlotsMixin(DataDocumenterMixinBase):
     def get_doc(self) -> list[list[str]] | None:
         if self.object is SLOTSATTR:
             try:
-                __slots__ = inspect.getslots(self.parent)
-                if __slots__ and __slots__.get(self.objpath[-1]):
-                    docstring = prepare_docstring(__slots__[self.objpath[-1]])
+                parent___slots__ = inspect.getslots(self.parent)
+                if parent___slots__ and parent___slots__.get(self.objpath[-1]):
+                    docstring = prepare_docstring(parent___slots__[self.objpath[-1]])
                     return [docstring]
                 else:
                     return []
@@ -2378,7 +2396,7 @@ class SlotsMixin(DataDocumenterMixinBase):
                                (self.parent.__qualname__, exc), type='autodoc')
                 return []
         else:
-            return super().get_doc()  # type: ignore
+            return super().get_doc()  # type: ignore[misc]
 
 
 class RuntimeInstanceAttributeMixin(DataDocumenterMixinBase):
@@ -2398,7 +2416,7 @@ class RuntimeInstanceAttributeMixin(DataDocumenterMixinBase):
     def is_runtime_instance_attribute(self, parent: Any) -> bool:
         """Check the subject is an attribute defined in __init__()."""
         # An instance variable defined in __init__().
-        if self.get_attribute_comment(parent, self.objpath[-1]):  # type: ignore
+        if self.get_attribute_comment(parent, self.objpath[-1]):  # type: ignore[attr-defined]
             return True
         if self.is_runtime_instance_attribute_not_commented(parent):
             return True
@@ -2420,18 +2438,18 @@ class RuntimeInstanceAttributeMixin(DataDocumenterMixinBase):
             except (AttributeError, PycodeError):
                 pass
 
-        return None
+        return False
 
     def import_object(self, raiseerror: bool = False) -> bool:
         """Check the existence of runtime instance attribute after failing to import the
         attribute."""
         try:
-            return super().import_object(raiseerror=True)  # type: ignore
+            return super().import_object(raiseerror=True)  # type: ignore[misc]
         except ImportError as exc:
             try:
                 with mock(self.config.autodoc_mock_imports):
                     ret = import_object(self.modname, self.objpath[:-1], 'class',
-                                        attrgetter=self.get_attr,  # type: ignore
+                                        attrgetter=self.get_attr,  # type: ignore[attr-defined]
                                         warningiserror=self.config.autodoc_warningiserror)
                     parent = ret[3]
                     if self.is_runtime_instance_attribute(parent):
@@ -2456,7 +2474,7 @@ class RuntimeInstanceAttributeMixin(DataDocumenterMixinBase):
                 self.is_runtime_instance_attribute_not_commented(self.parent)):
             return None
         else:
-            return super().get_doc()  # type: ignore
+            return super().get_doc()  # type: ignore[misc]
 
 
 class UninitializedInstanceAttributeMixin(DataDocumenterMixinBase):
@@ -2479,11 +2497,11 @@ class UninitializedInstanceAttributeMixin(DataDocumenterMixinBase):
         """Check the exisitence of uninitialized instance attribute when failed to import
         the attribute."""
         try:
-            return super().import_object(raiseerror=True)  # type: ignore
+            return super().import_object(raiseerror=True)  # type: ignore[misc]
         except ImportError as exc:
             try:
                 ret = import_object(self.modname, self.objpath[:-1], 'class',
-                                    attrgetter=self.get_attr,  # type: ignore
+                                    attrgetter=self.get_attr,  # type: ignore[attr-defined]
                                     warningiserror=self.config.autodoc_warningiserror)
                 parent = ret[3]
                 if self.is_uninitialized_instance_attribute(parent):
@@ -2506,11 +2524,10 @@ class UninitializedInstanceAttributeMixin(DataDocumenterMixinBase):
     def get_doc(self) -> list[list[str]] | None:
         if self.object is UNINITIALIZED_ATTR:
             return None
-        else:
-            return super().get_doc()  # type: ignore
+        return super().get_doc()  # type: ignore[misc]
 
 
-class AttributeDocumenter(GenericAliasMixin, SlotsMixin,  # type: ignore
+class AttributeDocumenter(GenericAliasMixin, SlotsMixin,  # type: ignore[misc]
                           RuntimeInstanceAttributeMixin,
                           UninitializedInstanceAttributeMixin, NonDataDescriptorMixin,
                           DocstringStripSignatureMixin, ClassLevelDocumenter):
@@ -2651,10 +2668,10 @@ class AttributeDocumenter(GenericAliasMixin, SlotsMixin,  # type: ignore
             # a docstring from the value which descriptor returns unexpectedly.
             # ref: https://github.com/sphinx-doc/sphinx/issues/7805
             orig = self.config.autodoc_inherit_docstrings
-            self.config.autodoc_inherit_docstrings = False  # type: ignore
+            self.config.autodoc_inherit_docstrings = False  # type: ignore[attr-defined]
             return super().get_doc()
         finally:
-            self.config.autodoc_inherit_docstrings = orig  # type: ignore
+            self.config.autodoc_inherit_docstrings = orig  # type: ignore[attr-defined]
 
     def add_content(self, more_content: StringList | None) -> None:
         # Disable analyzing attribute comment on Documenter.add_content() to control it on
@@ -2667,7 +2684,8 @@ class AttributeDocumenter(GenericAliasMixin, SlotsMixin,  # type: ignore
         super().add_content(more_content)
 
 
-class PropertyDocumenter(DocstringStripSignatureMixin, ClassLevelDocumenter):  # type: ignore
+class PropertyDocumenter(DocstringStripSignatureMixin,  # type: ignore[misc]
+                         ClassLevelDocumenter):
     """
     Specialized Documenter subclass for properties.
     """
@@ -2707,10 +2725,10 @@ class PropertyDocumenter(DocstringStripSignatureMixin, ClassLevelDocumenter):  #
         self.isclassmethod = False
         return ret
 
-    def format_args(self, **kwargs: Any) -> str | None:
+    def format_args(self, **kwargs: Any) -> str:
         func = self._get_property_getter()
         if func is None:
-            return None
+            return ''
 
         # update the annotations of the property getter
         self.env.app.emit('autodoc-before-process-signature', func, False)