Sphinx 8.1.2__py3-none-any.whl → 8.2.0rc1__py3-none-any.whl

sphinx/domains/c/_ast.py

@@ -2,14 +2,13 @@ from __future__ import annotations
 
 import sys
 import warnings
-from typing import TYPE_CHECKING, Any, Union, cast
+from typing import TYPE_CHECKING, Union, cast
 
 from docutils import nodes
 
 from sphinx import addnodes
 from sphinx.domains.c._ids import _id_prefix, _max_id
 from sphinx.util.cfamily import (
-    ASTAttributeList,
     ASTBaseBase,
     ASTBaseParenExprList,
     UnsupportedMultiCharacterCharLiteral,
@@ -17,29 +16,39 @@ from sphinx.util.cfamily import (
 )
 
 if TYPE_CHECKING:
-    from typing import TypeAlias
+    from typing import Any, TypeAlias
 
     from docutils.nodes import Element, Node, TextElement
 
     from sphinx.domains.c._symbol import Symbol
     from sphinx.environment import BuildEnvironment
-    from sphinx.util.cfamily import StringifyTransform
-
-DeclarationType: TypeAlias = Union[  # NoQA: UP007
-    "ASTStruct", "ASTUnion", "ASTEnum", "ASTEnumerator",
-    "ASTType", "ASTTypeWithInit", "ASTMacro",
+    from sphinx.util.cfamily import (
+        ASTAttributeList,
+        StringifyTransform,
+    )
+
+DeclarationType: TypeAlias = Union[
+    'ASTStruct',
+    'ASTUnion',
+    'ASTEnum',
+    'ASTEnumerator',
+    'ASTType',
+    'ASTTypeWithInit',
+    'ASTMacro',
 ]
 
 
 class ASTBase(ASTBaseBase):
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         raise NotImplementedError(repr(self))
 
 
 # Names
 ################################################################################
 
+
 class ASTIdentifier(ASTBaseBase):
     def __init__(self, name: str) -> None:
         if not isinstance(name, str) or len(name) == 0:
@@ -54,6 +63,9 @@ class ASTIdentifier(ASTBaseBase):
             return NotImplemented
         return self.name == other.name
 
+    def __hash__(self) -> int:
+        return hash((self.name, self.is_anonymous))
+
     def is_anon(self) -> bool:
         return self.is_anonymous
 
@@ -63,29 +75,42 @@ class ASTIdentifier(ASTBaseBase):
         return self.name
 
     def get_display_string(self) -> str:
-        return "[anonymous]" if self.is_anonymous else self.name
+        return '[anonymous]' if self.is_anonymous else self.name
 
-    def describe_signature(self, signode: TextElement, mode: str, env: BuildEnvironment,
-                           prefix: str, symbol: Symbol) -> None:
+    def _stringify(self, transform: StringifyTransform) -> str:
+        return transform(self.get_display_string())
+
+    def describe_signature(
+        self,
+        signode: TextElement,
+        mode: str,
+        env: BuildEnvironment,
+        prefix: str,
+        symbol: Symbol,
+    ) -> None:
         # note: slightly different signature of describe_signature due to the prefix
         verify_description_mode(mode)
         if self.is_anonymous:
-            node = addnodes.desc_sig_name(text="[anonymous]")
+            node = addnodes.desc_sig_name(text='[anonymous]')
         else:
             node = addnodes.desc_sig_name(self.name, self.name)
         if mode == 'markType':
-            targetText = prefix + self.name
-            pnode = addnodes.pending_xref('', refdomain='c',
-                                          reftype='identifier',
-                                          reftarget=targetText, modname=None,
-                                          classname=None)
+            target_text = prefix + self.name
+            pnode = addnodes.pending_xref(
+                '',
+                refdomain='c',
+                reftype='identifier',
+                reftarget=target_text,
+                modname=None,
+                classname=None,
+            )
             pnode['c:parent_key'] = symbol.get_lookup_key()
             pnode += node
             signode += pnode
         elif mode == 'lastIsName':
-            nameNode = addnodes.desc_name()
-            nameNode += node
-            signode += nameNode
+            name_node = addnodes.desc_name()
+            name_node += node
+            signode += name_node
         elif mode == 'noneIsName':
             signode += node
         else:
@@ -95,7 +120,8 @@ class ASTIdentifier(ASTBaseBase):
     def identifier(self) -> str:
         warnings.warn(
             '`ASTIdentifier.identifier` is deprecated, use `ASTIdentifier.name` instead',
-            DeprecationWarning, stacklevel=2,
+            DeprecationWarning,
+            stacklevel=2,
         )
         return self.name
 
@@ -128,19 +154,20 @@ class ASTNestedName(ASTBase):
         else:
             return res
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         # just print the name part, with template args, not template params
         if mode == 'noneIsName':
             if self.rooted:
-                unreachable = "Can this happen?"
-                raise AssertionError(unreachable)  # TODO
+                unreachable = 'Can this happen?'
+                raise AssertionError(unreachable)  # TODO: Can this happen?
                 signode += nodes.Text('.')
             for i in range(len(self.names)):
                 if i != 0:
-                    unreachable = "Can this happen?"
-                    raise AssertionError(unreachable)  # TODO
+                    unreachable = 'Can this happen?'
+                    raise AssertionError(unreachable)  # TODO: Can this happen?
                     signode += nodes.Text('.')
                 n = self.names[i]
                 n.describe_signature(signode, mode, env, '', symbol)
@@ -148,7 +175,7 @@ class ASTNestedName(ASTBase):
             assert not self.rooted, str(self)
             assert len(self.names) == 1
             self.names[0].describe_signature(signode, 'noneIsName', env, '', symbol)
-        elif mode in ('markType', 'lastIsName', 'markName'):
+        elif mode in {'markType', 'lastIsName', 'markName'}:
             # Each element should be a pending xref targeting the complete
             # prefix.
             prefix = ''
@@ -175,7 +202,7 @@ class ASTNestedName(ASTBase):
                     prefix += '.'
                 first = False
                 txt_ident = str(ident)
-                if txt_ident != '':
+                if txt_ident:
                     ident.describe_signature(dest, 'markType', env, prefix, symbol)
                 prefix += txt_ident
             if mode == 'lastIsName':
@@ -191,6 +218,7 @@ class ASTNestedName(ASTBase):
 # Expressions
 ################################################################################
 
+
 class ASTExpression(ASTBase):
     pass
 
@@ -198,6 +226,7 @@ class ASTExpression(ASTBase):
 # Primary expressions
 ################################################################################
 
+
 class ASTLiteral(ASTExpression):
     pass
 
@@ -220,8 +249,9 @@ class ASTBooleanLiteral(ASTLiteral):
         else:
             return 'false'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         txt = str(self)
         signode += addnodes.desc_sig_keyword(txt, txt)
 
@@ -241,8 +271,9 @@ class ASTNumberLiteral(ASTLiteral):
     def _stringify(self, transform: StringifyTransform) -> str:
         return self.data
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         txt = str(self)
         signode += addnodes.desc_sig_literal_number(txt, txt)
 
@@ -260,10 +291,7 @@ class ASTCharLiteral(ASTLiteral):
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ASTCharLiteral):
             return NotImplemented
-        return (
-            self.prefix == other.prefix
-            and self.value == other.value
-        )
+        return self.prefix == other.prefix and self.value == other.value
 
     def __hash__(self) -> int:
         return hash((self.prefix, self.value))
@@ -274,8 +302,9 @@ class ASTCharLiteral(ASTLiteral):
         else:
             return self.prefix + "'" + self.data + "'"
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         txt = str(self)
         signode += addnodes.desc_sig_literal_char(txt, txt)
 
@@ -295,8 +324,9 @@ class ASTStringLiteral(ASTLiteral):
     def _stringify(self, transform: StringifyTransform) -> str:
         return self.data
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         txt = str(self)
         signode += addnodes.desc_sig_literal_string(txt, txt)
 
@@ -320,8 +350,9 @@ class ASTIdExpression(ASTExpression):
     def get_id(self, version: int) -> str:
         return self.name.get_id(version)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         self.name.describe_signature(signode, mode, env, symbol)
 
 
@@ -343,8 +374,9 @@ class ASTParenExpr(ASTExpression):
     def get_id(self, version: int) -> str:
         return self.expr.get_id(version)  # type: ignore[attr-defined]
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_punctuation('(', '(')
         self.expr.describe_signature(signode, mode, env, symbol)
         signode += addnodes.desc_sig_punctuation(')', ')')
@@ -353,6 +385,7 @@ class ASTParenExpr(ASTExpression):
 # Postfix expressions
 ################################################################################
 
+
 class ASTPostfixOp(ASTBase):
     pass
 
@@ -372,8 +405,9 @@ class ASTPostfixCallExpr(ASTPostfixOp):
     def _stringify(self, transform: StringifyTransform) -> str:
         return transform(self.lst)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         self.lst.describe_signature(signode, mode, env, symbol)
 
 
@@ -392,8 +426,9 @@ class ASTPostfixArray(ASTPostfixOp):
     def _stringify(self, transform: StringifyTransform) -> str:
         return '[' + transform(self.expr) + ']'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_punctuation('[', '[')
         self.expr.describe_signature(signode, mode, env, symbol)
         signode += addnodes.desc_sig_punctuation(']', ']')
@@ -403,8 +438,9 @@ class ASTPostfixInc(ASTPostfixOp):
     def _stringify(self, transform: StringifyTransform) -> str:
         return '++'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_operator('++', '++')
 
 
@@ -412,8 +448,9 @@ class ASTPostfixDec(ASTPostfixOp):
     def _stringify(self, transform: StringifyTransform) -> str:
         return '--'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_operator('--', '--')
 
 
@@ -432,8 +469,9 @@ class ASTPostfixMemberOfPointer(ASTPostfixOp):
     def _stringify(self, transform: StringifyTransform) -> str:
         return '->' + transform(self.name)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_operator('->', '->')
         self.name.describe_signature(signode, 'noneIsName', env, symbol)
 
@@ -452,10 +490,14 @@ class ASTPostfixExpr(ASTExpression):
         return hash((self.prefix, self.postFixes))
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        return ''.join([transform(self.prefix), *(transform(p) for p in self.postFixes)])
-
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+        return ''.join([
+            transform(self.prefix),
+            *(transform(p) for p in self.postFixes),
+        ])
+
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         self.prefix.describe_signature(signode, mode, env, symbol)
         for p in self.postFixes:
             p.describe_signature(signode, mode, env, symbol)
@@ -464,6 +506,7 @@ class ASTPostfixExpr(ASTExpression):
 # Unary expressions
 ################################################################################
 
+
 class ASTUnaryOpExpr(ASTExpression):
     def __init__(self, op: str, expr: ASTExpression) -> None:
         self.op = op
@@ -479,12 +522,13 @@ class ASTUnaryOpExpr(ASTExpression):
 
     def _stringify(self, transform: StringifyTransform) -> str:
         if self.op[0] in 'cn':
-            return self.op + " " + transform(self.expr)
+            return self.op + ' ' + transform(self.expr)
         else:
             return self.op + transform(self.expr)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         if self.op[0] in 'cn':
             signode += addnodes.desc_sig_keyword(self.op, self.op)
             signode += addnodes.desc_sig_space()
@@ -506,10 +550,11 @@ class ASTSizeofType(ASTExpression):
         return hash(self.typ)
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        return "sizeof(" + transform(self.typ) + ")"
+        return 'sizeof(' + transform(self.typ) + ')'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_keyword('sizeof', 'sizeof')
         signode += addnodes.desc_sig_punctuation('(', '(')
         self.typ.describe_signature(signode, mode, env, symbol)
@@ -529,10 +574,11 @@ class ASTSizeofExpr(ASTExpression):
         return hash(self.expr)
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        return "sizeof " + transform(self.expr)
+        return 'sizeof ' + transform(self.expr)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_keyword('sizeof', 'sizeof')
         signode += addnodes.desc_sig_space()
         self.expr.describe_signature(signode, mode, env, symbol)
@@ -551,10 +597,11 @@ class ASTAlignofExpr(ASTExpression):
         return hash(self.typ)
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        return "alignof(" + transform(self.typ) + ")"
+        return 'alignof(' + transform(self.typ) + ')'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_keyword('alignof', 'alignof')
         signode += addnodes.desc_sig_punctuation('(', '(')
         self.typ.describe_signature(signode, mode, env, symbol)
@@ -564,6 +611,7 @@ class ASTAlignofExpr(ASTExpression):
 # Other expressions
 ################################################################################
 
+
 class ASTCastExpr(ASTExpression):
     def __init__(self, typ: ASTType, expr: ASTExpression) -> None:
         self.typ = typ
@@ -572,23 +620,23 @@ class ASTCastExpr(ASTExpression):
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ASTCastExpr):
             return NotImplemented
-        return (
-            self.typ == other.typ
-            and self.expr == other.expr
-        )
+        return self.typ == other.typ and self.expr == other.expr
 
     def __hash__(self) -> int:
         return hash((self.typ, self.expr))
 
     def _stringify(self, transform: StringifyTransform) -> str:
         res = ['(']
-        res.append(transform(self.typ))
-        res.append(')')
-        res.append(transform(self.expr))
+        res.extend((
+            transform(self.typ),
+            ')',
+            transform(self.expr),
+        ))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += addnodes.desc_sig_punctuation('(', '(')
         self.typ.describe_signature(signode, mode, env, symbol)
         signode += addnodes.desc_sig_punctuation(')', ')')
@@ -605,26 +653,25 @@ class ASTBinOpExpr(ASTBase):
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ASTBinOpExpr):
             return NotImplemented
-        return (
-            self.exprs == other.exprs
-            and self.ops == other.ops
-        )
+        return self.exprs == other.exprs and self.ops == other.ops
 
     def __hash__(self) -> int:
         return hash((self.exprs, self.ops))
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = []
-        res.append(transform(self.exprs[0]))
+        res = [transform(self.exprs[0])]
         for i in range(1, len(self.exprs)):
-            res.append(' ')
-            res.append(self.ops[i - 1])
-            res.append(' ')
-            res.append(transform(self.exprs[i]))
+            res.extend((
+                ' ',
+                self.ops[i - 1],
+                ' ',
+                transform(self.exprs[i]),
+            ))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         self.exprs[0].describe_signature(signode, mode, env, symbol)
         for i in range(1, len(self.exprs)):
             signode += addnodes.desc_sig_space()
@@ -647,26 +694,25 @@ class ASTAssignmentExpr(ASTExpression):
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ASTAssignmentExpr):
             return NotImplemented
-        return (
-            self.exprs == other.exprs
-            and self.ops == other.ops
-        )
+        return self.exprs == other.exprs and self.ops == other.ops
 
     def __hash__(self) -> int:
         return hash((self.exprs, self.ops))
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = []
-        res.append(transform(self.exprs[0]))
+        res = [transform(self.exprs[0])]
         for i in range(1, len(self.exprs)):
-            res.append(' ')
-            res.append(self.ops[i - 1])
-            res.append(' ')
-            res.append(transform(self.exprs[i]))
+            res.extend((
+                ' ',
+                self.ops[i - 1],
+                ' ',
+                transform(self.exprs[i]),
+            ))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         self.exprs[0].describe_signature(signode, mode, env, symbol)
         for i in range(1, len(self.exprs)):
             signode += addnodes.desc_sig_space()
@@ -697,8 +743,9 @@ class ASTFallbackExpr(ASTExpression):
     def get_id(self, version: int) -> str:
         return str(self.expr)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         signode += nodes.literal(self.expr, self.expr)
 
 
@@ -706,6 +753,7 @@ class ASTFallbackExpr(ASTExpression):
 # Types
 ################################################################################
 
+
 class ASTTrailingTypeSpec(ASTBase):
     pass
 
@@ -726,8 +774,9 @@ class ASTTrailingTypeSpecFundamental(ASTTrailingTypeSpec):
     def _stringify(self, transform: StringifyTransform) -> str:
         return ' '.join(self.names)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         first = True
         for n in self.names:
             if not first:
@@ -745,10 +794,7 @@ class ASTTrailingTypeSpecName(ASTTrailingTypeSpec):
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ASTTrailingTypeSpecName):
             return NotImplemented
-        return (
-            self.prefix == other.prefix
-            and self.nestedName == other.nestedName
-        )
+        return self.prefix == other.prefix and self.nestedName == other.nestedName
 
     def __hash__(self) -> int:
         return hash((self.prefix, self.nestedName))
@@ -758,15 +804,15 @@ class ASTTrailingTypeSpecName(ASTTrailingTypeSpec):
         return self.nestedName
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = []
+        res: list[str] = []
         if self.prefix:
-            res.append(self.prefix)
-            res.append(' ')
+            res.extend((self.prefix, ' '))
         res.append(transform(self.nestedName))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         if self.prefix:
             signode += addnodes.desc_sig_keyword(self.prefix, self.prefix)
             signode += addnodes.desc_sig_space()
@@ -796,8 +842,9 @@ class ASTFunctionParameter(ASTBase):
         else:
             return transform(self.arg)
 
-    def describe_signature(self, signode: Any, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: Any, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         if self.ellipsis:
             signode += addnodes.desc_sig_punctuation('...', '...')
@@ -806,7 +853,9 @@ class ASTFunctionParameter(ASTBase):
 
 
 class ASTParameters(ASTBase):
-    def __init__(self, args: list[ASTFunctionParameter], attrs: ASTAttributeList) -> None:
+    def __init__(
+        self, args: list[ASTFunctionParameter], attrs: ASTAttributeList
+    ) -> None:
         self.args = args
         self.attrs = attrs
 
@@ -823,8 +872,7 @@ class ASTParameters(ASTBase):
         return self.args
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = []
-        res.append('(')
+        res = ['(']
         first = True
         for a in self.args:
             if not first:
@@ -833,12 +881,12 @@ class ASTParameters(ASTBase):
             res.append(str(a))
         res.append(')')
         if len(self.attrs) != 0:
-            res.append(' ')
-            res.append(transform(self.attrs))
+            res.extend((' ', transform(self.attrs)))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         multi_line_parameter_list = False
         test_node: Element = signode
@@ -846,7 +894,9 @@ class ASTParameters(ASTBase):
             if not isinstance(test_node, addnodes.desc_signature):
                 test_node = test_node.parent
                 continue
-            multi_line_parameter_list = test_node.get('multi_line_parameter_list', False)
+            multi_line_parameter_list = test_node.get(
+                'multi_line_parameter_list', False
+            )
             break
 
         # only use the desc_parameterlist for the outer list, not for inner lists
@@ -875,8 +925,16 @@ class ASTParameters(ASTBase):
 
 
 class ASTDeclSpecsSimple(ASTBaseBase):
-    def __init__(self, storage: str, threadLocal: str, inline: bool,
-                 restrict: bool, volatile: bool, const: bool, attrs: ASTAttributeList) -> None:
+    def __init__(
+        self,
+        storage: str,
+        threadLocal: str,
+        inline: bool,
+        restrict: bool,
+        volatile: bool,
+        const: bool,
+        attrs: ASTAttributeList,
+    ) -> None:
         self.storage = storage
         self.threadLocal = threadLocal
         self.inline = inline
@@ -912,13 +970,15 @@ class ASTDeclSpecsSimple(ASTBaseBase):
     def mergeWith(self, other: ASTDeclSpecsSimple) -> ASTDeclSpecsSimple:
         if not other:
             return self
-        return ASTDeclSpecsSimple(self.storage or other.storage,
-                                  self.threadLocal or other.threadLocal,
-                                  self.inline or other.inline,
-                                  self.volatile or other.volatile,
-                                  self.const or other.const,
-                                  self.restrict or other.restrict,
-                                  self.attrs + other.attrs)
+        return ASTDeclSpecsSimple(
+            self.storage or other.storage,
+            self.threadLocal or other.threadLocal,
+            self.inline or other.inline,
+            self.volatile or other.volatile,
+            self.const or other.const,
+            self.restrict or other.restrict,
+            self.attrs + other.attrs,
+        )
 
     def _stringify(self, transform: StringifyTransform) -> str:
         res: list[str] = []
@@ -946,9 +1006,9 @@ class ASTDeclSpecsSimple(ASTBaseBase):
 
         if len(modifiers) != 0 and len(self.attrs) != 0:
             modifiers.append(addnodes.desc_sig_space())
-        tempNode = nodes.TextElement()
-        self.attrs.describe_signature(tempNode)
-        modifiers.extend(tempNode.children)
+        temp_node = nodes.TextElement()
+        self.attrs.describe_signature(temp_node)
+        modifiers.extend(temp_node.children)
         if self.storage:
             _add(modifiers, self.storage)
         if self.threadLocal:
@@ -964,10 +1024,13 @@ class ASTDeclSpecsSimple(ASTBaseBase):
 
 
 class ASTDeclSpecs(ASTBase):
-    def __init__(self, outer: str,
-                 leftSpecs: ASTDeclSpecsSimple,
-                 rightSpecs: ASTDeclSpecsSimple,
-                 trailing: ASTTrailingTypeSpec) -> None:
+    def __init__(
+        self,
+        outer: str,
+        leftSpecs: ASTDeclSpecsSimple,
+        rightSpecs: ASTDeclSpecsSimple,
+        trailing: ASTTrailingTypeSpec,
+    ) -> None:
         # leftSpecs and rightSpecs are used for output
         # allSpecs are used for id generation TODO: remove?
         self.outer = outer
@@ -1001,17 +1064,18 @@ class ASTDeclSpecs(ASTBase):
             res.append(l)
         if self.trailingTypeSpec:
             if len(res) > 0:
-                res.append(" ")
+                res.append(' ')
             res.append(transform(self.trailingTypeSpec))
             r = str(self.rightSpecs)
             if len(r) > 0:
                 if len(res) > 0:
-                    res.append(" ")
+                    res.append(' ')
                 res.append(r)
-        return "".join(res)
+        return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         modifiers: list[Node] = []
 
@@ -1022,8 +1086,7 @@ class ASTDeclSpecs(ASTBase):
         if self.trailingTypeSpec:
             if len(modifiers) > 0:
                 signode += addnodes.desc_sig_space()
-            self.trailingTypeSpec.describe_signature(signode, mode, env,
-                                                     symbol=symbol)
+            self.trailingTypeSpec.describe_signature(signode, mode, env, symbol=symbol)
             modifiers = []
             self.rightSpecs.describe_signature(modifiers)
             if len(modifiers) > 0:
@@ -1035,9 +1098,17 @@ class ASTDeclSpecs(ASTBase):
 # Declarator
 ################################################################################
 
+
 class ASTArray(ASTBase):
-    def __init__(self, static: bool, const: bool, volatile: bool, restrict: bool,
-                 vla: bool, size: ASTExpression) -> None:
+    def __init__(
+        self,
+        static: bool,
+        const: bool,
+        volatile: bool,
+        restrict: bool,
+        vla: bool,
+        size: ASTExpression,
+    ) -> None:
         self.static = static
         self.const = const
         self.volatile = volatile
@@ -1087,30 +1158,31 @@ class ASTArray(ASTBase):
             el.append(transform(self.size))
         return '[' + ' '.join(el) + ']'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         signode += addnodes.desc_sig_punctuation('[', '[')
-        addSpace = False
+        add_space = False
 
         def _add(signode: TextElement, text: str) -> bool:
-            if addSpace:
+            if add_space:
                 signode += addnodes.desc_sig_space()
             signode += addnodes.desc_sig_keyword(text, text)
             return True
 
         if self.static:
-            addSpace = _add(signode, 'static')
+            add_space = _add(signode, 'static')
         if self.restrict:
-            addSpace = _add(signode, 'restrict')
+            add_space = _add(signode, 'restrict')
         if self.volatile:
-            addSpace = _add(signode, 'volatile')
+            add_space = _add(signode, 'volatile')
         if self.const:
-            addSpace = _add(signode, 'const')
+            add_space = _add(signode, 'const')
         if self.vla:
             signode += addnodes.desc_sig_punctuation('*', '*')
         elif self.size:
-            if addSpace:
+            if add_space:
                 signode += addnodes.desc_sig_space()
             self.size.describe_signature(signode, 'markType', env, symbol)
         signode += addnodes.desc_sig_punctuation(']', ']')
@@ -1130,8 +1202,9 @@ class ASTDeclarator(ASTBase):
 
 
 class ASTDeclaratorNameParam(ASTDeclarator):
-    def __init__(self, declId: ASTNestedName,
-                 arrayOps: list[ASTArray], param: ASTParameters) -> None:
+    def __init__(
+        self, declId: ASTNestedName, arrayOps: list[ASTArray], param: ASTParameters
+    ) -> None:
         self.declId = declId
         self.arrayOps = arrayOps
         self.param = param
@@ -1170,8 +1243,9 @@ class ASTDeclaratorNameParam(ASTDeclarator):
             res.append(transform(self.param))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         if self.declId:
             self.declId.describe_signature(signode, mode, env, symbol)
@@ -1207,12 +1281,12 @@ class ASTDeclaratorNameBitField(ASTDeclarator):
         res = []
         if self.declId:
             res.append(transform(self.declId))
-        res.append(" : ")
-        res.append(transform(self.size))
+        res.extend((' : ', transform(self.size)))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         if self.declId:
             self.declId.describe_signature(signode, mode, env, symbol)
@@ -1223,8 +1297,14 @@ class ASTDeclaratorNameBitField(ASTDeclarator):
 
 
 class ASTDeclaratorPtr(ASTDeclarator):
-    def __init__(self, next: ASTDeclarator, restrict: bool, volatile: bool, const: bool,
-                 attrs: ASTAttributeList) -> None:
+    def __init__(
+        self,
+        next: ASTDeclarator,
+        restrict: bool,
+        volatile: bool,
+        const: bool,
+        attrs: ASTAttributeList,
+    ) -> None:
         assert next
         self.next = next
         self.restrict = restrict
@@ -1255,13 +1335,16 @@ class ASTDeclaratorPtr(ASTDeclarator):
         return self.next.function_params
 
     def require_space_after_declSpecs(self) -> bool:
-        return self.const or self.volatile or self.restrict or \
-            len(self.attrs) > 0 or \
-            self.next.require_space_after_declSpecs()
+        return (
+            self.const
+            or self.volatile
+            or self.restrict
+            or len(self.attrs) > 0
+            or self.next.require_space_after_declSpecs()
+        )
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = ['*']
-        res.append(transform(self.attrs))
+        res = ['*', transform(self.attrs)]
         if len(self.attrs) != 0 and (self.restrict or self.volatile or self.const):
             res.append(' ')
         if self.restrict:
@@ -1280,8 +1363,9 @@ class ASTDeclaratorPtr(ASTDeclarator):
         res.append(transform(self.next))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         signode += addnodes.desc_sig_punctuation('*', '*')
         self.attrs.describe_signature(signode)
@@ -1336,23 +1420,27 @@ class ASTDeclaratorParen(ASTDeclarator):
 
     def _stringify(self, transform: StringifyTransform) -> str:
         res = ['(']
-        res.append(transform(self.inner))
-        res.append(')')
-        res.append(transform(self.next))
+        res.extend((
+            transform(self.inner),
+            ')',
+            transform(self.next),
+        ))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         signode += addnodes.desc_sig_punctuation('(', '(')
         self.inner.describe_signature(signode, mode, env, symbol)
         signode += addnodes.desc_sig_punctuation(')', ')')
-        self.next.describe_signature(signode, "noneIsName", env, symbol)
+        self.next.describe_signature(signode, 'noneIsName', env, symbol)
 
 
 # Initializer
 ################################################################################
 
+
 class ASTParenExprList(ASTBaseParenExprList):
     def __init__(self, exprs: list[ASTExpression]) -> None:
         self.exprs = exprs
@@ -1369,8 +1457,9 @@ class ASTParenExprList(ASTBaseParenExprList):
         exprs = [transform(e) for e in self.exprs]
         return '(%s)' % ', '.join(exprs)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         signode += addnodes.desc_sig_punctuation('(', '(')
         first = True
@@ -1399,11 +1488,12 @@ class ASTBracedInitList(ASTBase):
 
     def _stringify(self, transform: StringifyTransform) -> str:
         exprs = ', '.join(transform(e) for e in self.exprs)
-        trailingComma = ',' if self.trailingComma else ''
-        return f'{{{exprs}{trailingComma}}}'
+        trailing_comma = ',' if self.trailingComma else ''
+        return f'{{{exprs}{trailing_comma}}}'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         signode += addnodes.desc_sig_punctuation('{', '{')
         first = True
@@ -1420,8 +1510,9 @@ class ASTBracedInitList(ASTBase):
 
 
 class ASTInitializer(ASTBase):
-    def __init__(self, value: ASTBracedInitList | ASTExpression,
-                 hasAssign: bool = True) -> None:
+    def __init__(
+        self, value: ASTBracedInitList | ASTExpression, hasAssign: bool = True
+    ) -> None:
         self.value = value
         self.hasAssign = hasAssign
 
@@ -1440,8 +1531,9 @@ class ASTInitializer(ASTBase):
         else:
             return val
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         if self.hasAssign:
             signode += addnodes.desc_sig_space()
@@ -1478,9 +1570,9 @@ class ASTType(ASTBase):
 
     def _stringify(self, transform: StringifyTransform) -> str:
         res = []
-        declSpecs = transform(self.declSpecs)
-        res.append(declSpecs)
-        if self.decl.require_space_after_declSpecs() and len(declSpecs) > 0:
+        decl_specs = transform(self.declSpecs)
+        res.append(decl_specs)
+        if self.decl.require_space_after_declSpecs() and len(decl_specs) > 0:
             res.append(' ')
         res.append(transform(self.decl))
         return ''.join(res)
@@ -1491,12 +1583,12 @@ class ASTType(ASTBase):
         else:
             return 'type'
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         self.declSpecs.describe_signature(signode, 'markType', env, symbol)
-        if (self.decl.require_space_after_declSpecs() and
-                len(str(self.declSpecs)) > 0):
+        if self.decl.require_space_after_declSpecs() and len(str(self.declSpecs)) > 0:
             signode += addnodes.desc_sig_space()
         # for parameters that don't really declare new names we get 'markType',
         # this should not be propagated, but be 'noneIsName'.
@@ -1526,14 +1618,14 @@ class ASTTypeWithInit(ASTBase):
         return self.type.get_id(version, objectType, symbol)
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = []
-        res.append(transform(self.type))
+        res = [transform(self.type)]
         if self.init:
             res.append(transform(self.init))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         self.type.describe_signature(signode, mode, env, symbol)
         if self.init:
@@ -1541,8 +1633,9 @@ class ASTTypeWithInit(ASTBase):
 
 
 class ASTMacroParameter(ASTBase):
-    def __init__(self, arg: ASTNestedName | None, ellipsis: bool = False,
-                 variadic: bool = False) -> None:
+    def __init__(
+        self, arg: ASTNestedName | None, ellipsis: bool = False, variadic: bool = False
+    ) -> None:
         self.arg = arg
         self.ellipsis = ellipsis
         self.variadic = variadic
@@ -1567,8 +1660,9 @@ class ASTMacroParameter(ASTBase):
         else:
             return transform(self.arg)
 
-    def describe_signature(self, signode: Any, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: Any, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         if self.ellipsis:
             signode += addnodes.desc_sig_punctuation('...', '...')
@@ -1580,7 +1674,9 @@ class ASTMacroParameter(ASTBase):
 
 
 class ASTMacro(ASTBase):
-    def __init__(self, ident: ASTNestedName, args: list[ASTMacroParameter] | None) -> None:
+    def __init__(
+        self, ident: ASTNestedName, args: list[ASTMacroParameter] | None
+    ) -> None:
         self.ident = ident
         self.args = args
 
@@ -1600,8 +1696,7 @@ class ASTMacro(ASTBase):
         return symbol.get_full_nested_name().get_id(version)
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = []
-        res.append(transform(self.ident))
+        res = [transform(self.ident)]
         if self.args is not None:
             res.append('(')
             first = True
@@ -1613,8 +1708,9 @@ class ASTMacro(ASTBase):
             res.append(')')
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         self.ident.describe_signature(signode, mode, env, symbol)
         if self.args is None:
@@ -1645,8 +1741,9 @@ class ASTStruct(ASTBase):
     def _stringify(self, transform: StringifyTransform) -> str:
         return transform(self.name)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         self.name.describe_signature(signode, mode, env, symbol=symbol)
 
@@ -1669,8 +1766,9 @@ class ASTUnion(ASTBase):
     def _stringify(self, transform: StringifyTransform) -> str:
         return transform(self.name)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         self.name.describe_signature(signode, mode, env, symbol=symbol)
 
@@ -1693,15 +1791,17 @@ class ASTEnum(ASTBase):
     def _stringify(self, transform: StringifyTransform) -> str:
         return transform(self.name)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         self.name.describe_signature(signode, mode, env, symbol=symbol)
 
 
 class ASTEnumerator(ASTBase):
-    def __init__(self, name: ASTNestedName, init: ASTInitializer | None,
-                 attrs: ASTAttributeList) -> None:
+    def __init__(
+        self, name: ASTNestedName, init: ASTInitializer | None, attrs: ASTAttributeList
+    ) -> None:
         self.name = name
         self.init = init
         self.attrs = attrs
@@ -1722,17 +1822,16 @@ class ASTEnumerator(ASTBase):
         return symbol.get_full_nested_name().get_id(version)
 
     def _stringify(self, transform: StringifyTransform) -> str:
-        res = []
-        res.append(transform(self.name))
+        res = [transform(self.name)]
         if len(self.attrs) != 0:
-            res.append(' ')
-            res.append(transform(self.attrs))
+            res.extend((' ', transform(self.attrs)))
         if self.init:
             res.append(transform(self.init))
         return ''.join(res)
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, symbol: Symbol) -> None:
+    def describe_signature(
+        self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol
+    ) -> None:
         verify_description_mode(mode)
         self.name.describe_signature(signode, mode, env, symbol)
         if len(self.attrs) != 0:
@@ -1743,9 +1842,13 @@ class ASTEnumerator(ASTBase):
 
 
 class ASTDeclaration(ASTBaseBase):
-    def __init__(self, objectType: str, directiveType: str | None,
-                 declaration: DeclarationType | ASTFunctionParameter,
-                 semicolon: bool = False) -> None:
+    def __init__(
+        self,
+        objectType: str,
+        directiveType: str | None,
+        declaration: DeclarationType | ASTFunctionParameter,
+        semicolon: bool = False,
+    ) -> None:
         self.objectType = objectType
         self.directiveType = directiveType
         self.declaration = declaration
@@ -1771,20 +1874,34 @@ class ASTDeclaration(ASTBaseBase):
             and self.enumeratorScopedSymbol == other.enumeratorScopedSymbol
         )
 
+    def __hash__(self) -> int:
+        return hash((
+            self.objectType,
+            self.directiveType,
+            self.declaration,
+            self.semicolon,
+            self.symbol,
+            self.enumeratorScopedSymbol,
+        ))
+
     def clone(self) -> ASTDeclaration:
-        return ASTDeclaration(self.objectType, self.directiveType,
-                              self.declaration.clone(), self.semicolon)
+        return ASTDeclaration(
+            self.objectType,
+            self.directiveType,
+            self.declaration.clone(),
+            self.semicolon,
+        )
 
     @property
     def name(self) -> ASTNestedName:
-        decl = cast(DeclarationType, self.declaration)
+        decl = cast('DeclarationType', self.declaration)
         return decl.name
 
     @property
     def function_params(self) -> list[ASTFunctionParameter] | None:
         if self.objectType != 'function':
             return None
-        decl = cast(ASTType, self.declaration)
+        decl = cast('ASTType', self.declaration)
         return decl.function_params
 
     def get_id(self, version: int, prefixed: bool = True) -> str:
@@ -1807,40 +1924,45 @@ class ASTDeclaration(ASTBaseBase):
             res += ';'
         return res
 
-    def describe_signature(self, signode: TextElement, mode: str,
-                           env: BuildEnvironment, options: dict[str, bool]) -> None:
+    def describe_signature(
+        self,
+        signode: TextElement,
+        mode: str,
+        env: BuildEnvironment,
+        options: dict[str, bool],
+    ) -> None:
         verify_description_mode(mode)
         assert self.symbol
         # The caller of the domain added a desc_signature node.
         # Always enable multiline:
         signode['is_multiline'] = True
         # Put each line in a desc_signature_line node.
-        mainDeclNode = addnodes.desc_signature_line()
-        mainDeclNode.sphinx_line_type = 'declarator'
-        mainDeclNode['add_permalink'] = not self.symbol.isRedeclaration
-        signode += mainDeclNode
+        main_decl_node = addnodes.desc_signature_line()
+        main_decl_node.sphinx_line_type = 'declarator'
+        main_decl_node['add_permalink'] = not self.symbol.isRedeclaration
+        signode += main_decl_node
 
         if self.objectType in {'member', 'function', 'macro'}:
             pass
         elif self.objectType == 'struct':
-            mainDeclNode += addnodes.desc_sig_keyword('struct', 'struct')
-            mainDeclNode += addnodes.desc_sig_space()
+            main_decl_node += addnodes.desc_sig_keyword('struct', 'struct')
+            main_decl_node += addnodes.desc_sig_space()
         elif self.objectType == 'union':
-            mainDeclNode += addnodes.desc_sig_keyword('union', 'union')
-            mainDeclNode += addnodes.desc_sig_space()
+            main_decl_node += addnodes.desc_sig_keyword('union', 'union')
+            main_decl_node += addnodes.desc_sig_space()
         elif self.objectType == 'enum':
-            mainDeclNode += addnodes.desc_sig_keyword('enum', 'enum')
-            mainDeclNode += addnodes.desc_sig_space()
+            main_decl_node += addnodes.desc_sig_keyword('enum', 'enum')
+            main_decl_node += addnodes.desc_sig_space()
         elif self.objectType == 'enumerator':
-            mainDeclNode += addnodes.desc_sig_keyword('enumerator', 'enumerator')
-            mainDeclNode += addnodes.desc_sig_space()
+            main_decl_node += addnodes.desc_sig_keyword('enumerator', 'enumerator')
+            main_decl_node += addnodes.desc_sig_space()
         elif self.objectType == 'type':
-            decl = cast(ASTType, self.declaration)
+            decl = cast('ASTType', self.declaration)
             prefix = decl.get_type_declaration_prefix()
-            mainDeclNode += addnodes.desc_sig_keyword(prefix, prefix)
-            mainDeclNode += addnodes.desc_sig_space()
+            main_decl_node += addnodes.desc_sig_keyword(prefix, prefix)
+            main_decl_node += addnodes.desc_sig_space()
         else:
             raise AssertionError
-        self.declaration.describe_signature(mainDeclNode, mode, env, self.symbol)
+        self.declaration.describe_signature(main_decl_node, mode, env, self.symbol)
         if self.semicolon:
-            mainDeclNode += addnodes.desc_sig_punctuation(';', ';')
+            main_decl_node += addnodes.desc_sig_punctuation(';', ';')