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

sphinx/domains/c/_parser.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from sphinx.domains.c._ast import (
     ASTAlignofExpr,
@@ -12,7 +12,6 @@ from sphinx.domains.c._ast import (
     ASTCastExpr,
     ASTCharLiteral,
     ASTDeclaration,
-    ASTDeclarator,
     ASTDeclaratorNameBitField,
     ASTDeclaratorNameParam,
     ASTDeclaratorParen,
@@ -21,13 +20,11 @@ from sphinx.domains.c._ast import (
     ASTDeclSpecsSimple,
     ASTEnum,
     ASTEnumerator,
-    ASTExpression,
     ASTFallbackExpr,
     ASTFunctionParameter,
     ASTIdentifier,
     ASTIdExpression,
     ASTInitializer,
-    ASTLiteral,
     ASTMacro,
     ASTMacroParameter,
     ASTNestedName,
@@ -41,12 +38,10 @@ from sphinx.domains.c._ast import (
     ASTPostfixExpr,
     ASTPostfixInc,
     ASTPostfixMemberOfPointer,
-    ASTPostfixOp,
     ASTSizeofExpr,
     ASTSizeofType,
     ASTStringLiteral,
     ASTStruct,
-    ASTTrailingTypeSpec,
     ASTTrailingTypeSpecFundamental,
     ASTTrailingTypeSpecName,
     ASTType,
@@ -80,8 +75,16 @@ from sphinx.util.cfamily import (
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
+    from typing import Any
 
-    from sphinx.domains.c._ast import DeclarationType
+    from sphinx.domains.c._ast import (
+        ASTDeclarator,
+        ASTExpression,
+        ASTLiteral,
+        ASTPostfixOp,
+        ASTTrailingTypeSpec,
+        DeclarationType,
+    )
 
 
 class DefinitionParser(BaseParser):
@@ -100,12 +103,12 @@ class DefinitionParser(BaseParser):
     def _parse_string(self) -> str | None:
         if self.current_char != '"':
             return None
-        startPos = self.pos
+        start_pos = self.pos
         self.pos += 1
         escape = False
         while True:
             if self.eof:
-                self.fail("Unexpected end during inside string.")
+                self.fail('Unexpected end during inside string.')
             elif self.current_char == '"' and not escape:
                 self.pos += 1
                 break
@@ -114,7 +117,7 @@ class DefinitionParser(BaseParser):
             else:
                 escape = False
             self.pos += 1
-        return self.definition[startPos:self.pos]
+        return self.definition[start_pos : self.pos]
 
     def _parse_literal(self) -> ASTLiteral | None:
         # -> integer-literal
@@ -130,12 +133,16 @@ class DefinitionParser(BaseParser):
         pos = self.pos
         if self.match(float_literal_re):
             self.match(float_literal_suffix_re)
-            return ASTNumberLiteral(self.definition[pos:self.pos])
-        for regex in (binary_literal_re, hex_literal_re,
-                      integer_literal_re, octal_literal_re):
+            return ASTNumberLiteral(self.definition[pos : self.pos])
+        for regex in (
+            binary_literal_re,
+            hex_literal_re,
+            integer_literal_re,
+            octal_literal_re,
+        ):
             if self.match(regex):
                 self.match(integers_literal_suffix_re)
-                return ASTNumberLiteral(self.definition[pos:self.pos])
+                return ASTNumberLiteral(self.definition[pos : self.pos])
 
         string = self._parse_string()
         if string is not None:
@@ -148,10 +155,14 @@ class DefinitionParser(BaseParser):
             try:
                 return ASTCharLiteral(prefix, data)
             except UnicodeDecodeError as e:
-                self.fail("Can not handle character literal. Internal error was: %s" % e)
+                self.fail(
+                    'Can not handle character literal. Internal error was: %s' % e
+                )
             except UnsupportedMultiCharacterCharLiteral:
-                self.fail("Can not handle character literal"
-                          " resulting in multiple decoded characters.")
+                self.fail(
+                    'Can not handle character literal'
+                    ' resulting in multiple decoded characters.'
+                )
         return None
 
     def _parse_paren_expression(self) -> ASTExpression | None:
@@ -181,8 +192,9 @@ class DefinitionParser(BaseParser):
             return ASTIdExpression(nn)
         return None
 
-    def _parse_initializer_list(self, name: str, open: str, close: str,
-                                ) -> tuple[list[ASTExpression] | None, bool | None]:
+    def _parse_initializer_list(
+        self, name: str, open: str, close: str
+    ) -> tuple[list[ASTExpression] | None, bool | None]:
         # Parse open and close with the actual initializer-list in between
         # -> initializer-clause '...'[opt]
         #  | initializer-list ',' initializer-clause '...'[opt]
@@ -194,7 +206,7 @@ class DefinitionParser(BaseParser):
             return [], False
 
         exprs = []
-        trailingComma = False
+        trailing_comma = False
         while True:
             self.skip_ws()
             expr = self._parse_expression()
@@ -207,9 +219,9 @@ class DefinitionParser(BaseParser):
                 self.fail(f"Error in {name}, expected ',' or '{close}'.")
             if self.current_char == close == '}':
                 self.pos += 1
-                trailingComma = True
+                trailing_comma = True
                 break
-        return exprs, trailingComma
+        return exprs, trailing_comma
 
     def _parse_paren_expression_list(self) -> ASTParenExprList | None:
         # -> '(' expression-list ')'
@@ -218,8 +230,9 @@ class DefinitionParser(BaseParser):
         #
         # expression-list
         # -> initializer-list
-        exprs, trailingComma = self._parse_initializer_list("parenthesized expression-list",
-                                                            '(', ')')
+        exprs, trailing_comma = self._parse_initializer_list(
+            'parenthesized expression-list', '(', ')'
+        )
         if exprs is None:
             return None
         return ASTParenExprList(exprs)
@@ -227,10 +240,12 @@ class DefinitionParser(BaseParser):
     def _parse_braced_init_list(self) -> ASTBracedInitList | None:
         # -> '{' initializer-list ','[opt] '}'
         #  | '{' '}'
-        exprs, trailingComma = self._parse_initializer_list("braced-init-list", '{', '}')
+        exprs, trailing_comma = self._parse_initializer_list(
+            'braced-init-list', '{', '}'
+        )
         if exprs is None:
             return None
-        return ASTBracedInitList(exprs, trailingComma)
+        return ASTBracedInitList(exprs, trailing_comma)
 
     def _parse_postfix_expression(self) -> ASTPostfixExpr:
         # -> primary
@@ -245,7 +260,7 @@ class DefinitionParser(BaseParser):
         prefix = self._parse_primary_expression()
 
         # and now parse postfixes
-        postFixes: list[ASTPostfixOp] = []
+        post_fixes: list[ASTPostfixOp] = []
         while True:
             self.skip_ws()
             if self.skip_string_and_ws('['):
@@ -253,7 +268,7 @@ class DefinitionParser(BaseParser):
                 self.skip_ws()
                 if not self.skip_string(']'):
                     self.fail("Expected ']' in end of postfix expression.")
-                postFixes.append(ASTPostfixArray(expr))
+                post_fixes.append(ASTPostfixArray(expr))
                 continue
             if self.skip_string('->'):
                 if self.skip_string('*'):
@@ -261,20 +276,20 @@ class DefinitionParser(BaseParser):
                     self.pos -= 3
                 else:
                     name = self._parse_nested_name()
-                    postFixes.append(ASTPostfixMemberOfPointer(name))
+                    post_fixes.append(ASTPostfixMemberOfPointer(name))
                     continue
             if self.skip_string('++'):
-                postFixes.append(ASTPostfixInc())
+                post_fixes.append(ASTPostfixInc())
                 continue
             if self.skip_string('--'):
-                postFixes.append(ASTPostfixDec())
+                post_fixes.append(ASTPostfixDec())
                 continue
             lst = self._parse_paren_expression_list()
             if lst is not None:
-                postFixes.append(ASTPostfixCallExpr(lst))
+                post_fixes.append(ASTPostfixCallExpr(lst))
                 continue
             break
-        return ASTPostfixExpr(prefix, postFixes)
+        return ASTPostfixExpr(prefix, post_fixes)
 
     def _parse_unary_expression(self) -> ASTExpression:
         # -> postfix
@@ -325,16 +340,18 @@ class DefinitionParser(BaseParser):
                     self.fail("Expected ')' in cast expression.")
                 expr = self._parse_cast_expression()
                 return ASTCastExpr(typ, expr)
-            except DefinitionError as exCast:
+            except DefinitionError as ex_cast:
                 self.pos = pos
                 try:
                     return self._parse_unary_expression()
-                except DefinitionError as exUnary:
-                    errs = []
-                    errs.append((exCast, "If type cast expression"))
-                    errs.append((exUnary, "If unary expression"))
-                    raise self._make_multi_error(errs,
-                                                 "Error in cast expression.") from exUnary
+                except DefinitionError as ex_unary:
+                    errs = [
+                        (ex_cast, 'If type cast expression'),
+                        (ex_unary, 'If unary expression'),
+                    ]
+                    raise self._make_multi_error(
+                        errs, 'Error in cast expression.'
+                    ) from ex_unary
         else:
             return self._parse_unary_expression()
 
@@ -350,21 +367,25 @@ class DefinitionParser(BaseParser):
         # additive       = multiplicative   +, -
         # multiplicative = pm               *, /, %
         # pm             = cast             .*, ->*
-        def _parse_bin_op_expr(self: DefinitionParser, opId: int) -> ASTExpression:
-            if opId + 1 == len(_expression_bin_ops):
+        def _parse_bin_op_expr(self: DefinitionParser, op_id: int) -> ASTExpression:
+            if op_id + 1 == len(_expression_bin_ops):
+
                 def parser() -> ASTExpression:
                     return self._parse_cast_expression()
+
             else:
+
                 def parser() -> ASTExpression:
-                    return _parse_bin_op_expr(self, opId + 1)
+                    return _parse_bin_op_expr(self, op_id + 1)
+
             exprs = []
             ops = []
             exprs.append(parser())
             while True:
                 self.skip_ws()
                 pos = self.pos
-                oneMore = False
-                for op in _expression_bin_ops[opId]:
+                one_more = False
+                for op in _expression_bin_ops[op_id]:
                     if op[0] in 'abcnox':
                         if not self.skip_word(op):
                             continue
@@ -380,16 +401,19 @@ class DefinitionParser(BaseParser):
                         expr = parser()
                         exprs.append(expr)
                         ops.append(op)
-                        oneMore = True
+                        one_more = True
                         break
                     except DefinitionError:
                         self.pos = pos
-                if not oneMore:
+                if not one_more:
                     break
             return ASTBinOpExpr(exprs, ops)  # type: ignore[return-value]
+
         return _parse_bin_op_expr(self, 0)
 
-    def _parse_conditional_expression_tail(self, orExprHead: Any) -> ASTExpression | None:
+    def _parse_conditional_expression_tail(
+        self, or_expr_head: Any
+    ) -> ASTExpression | None:
         # -> "?" expression ":" assignment-expression
         return None
 
@@ -402,11 +426,11 @@ class DefinitionParser(BaseParser):
         #   | logical-or-expression assignment-operator initializer-clause
         exprs = []
         ops = []
-        orExpr = self._parse_logical_or_expression()
-        exprs.append(orExpr)
+        or_expr = self._parse_logical_or_expression()
+        exprs.append(or_expr)
         # TODO: handle ternary with _parse_conditional_expression_tail
         while True:
-            oneMore = False
+            one_more = False
             self.skip_ws()
             for op in _expression_assignment_ops:
                 if op[0] in 'abcnox':
@@ -418,16 +442,16 @@ class DefinitionParser(BaseParser):
                 expr = self._parse_logical_or_expression()
                 exprs.append(expr)
                 ops.append(op)
-                oneMore = True
-            if not oneMore:
+                one_more = True
+            if not one_more:
                 break
         return ASTAssignmentExpr(exprs, ops)
 
     def _parse_constant_expression(self) -> ASTExpression:
         # -> conditional-expression
-        orExpr = self._parse_logical_or_expression()
+        or_expr = self._parse_logical_or_expression()
         # TODO: use _parse_conditional_expression_tail
-        return orExpr
+        return or_expr
 
     def _parse_expression(self) -> ASTExpression:
         # -> assignment-expression
@@ -436,14 +460,13 @@ class DefinitionParser(BaseParser):
         return self._parse_assignment_expression()
 
     def _parse_expression_fallback(
-            self, end: list[str],
-            parser: Callable[[], ASTExpression],
-            allow: bool = True) -> ASTExpression:
+        self, end: list[str], parser: Callable[[], ASTExpression], allow: bool = True
+    ) -> ASTExpression:
         # Stupidly "parse" an expression.
         # 'end' should be a list of characters which ends the expression.
 
         # first try to use the provided parser
-        prevPos = self.pos
+        prev_pos = self.pos
         try:
             return parser()
         except DefinitionError as e:
@@ -451,13 +474,15 @@ class DefinitionParser(BaseParser):
             # and for testing we may want to globally disable it
             if not allow or not self.allowFallbackExpressionParsing:
                 raise
-            self.warn("Parsing of expression failed. Using fallback parser."
-                      " Error was:\n%s" % e)
-            self.pos = prevPos
+            self.warn(
+                'Parsing of expression failed. Using fallback parser.'
+                ' Error was:\n%s' % e
+            )
+            self.pos = prev_pos
         # and then the fallback scanning
         assert end is not None
         self.skip_ws()
-        startPos = self.pos
+        start_pos = self.pos
         if self.match(_string_re):
             value = self.matched_text
         else:
@@ -465,7 +490,7 @@ class DefinitionParser(BaseParser):
             brackets = {'(': ')', '{': '}', '[': ']'}
             symbols: list[str] = []
             while not self.eof:
-                if (len(symbols) == 0 and self.current_char in end):
+                if len(symbols) == 0 and self.current_char in end:
                     break
                 if self.current_char in brackets:
                     symbols.append(brackets[self.current_char])
@@ -473,9 +498,10 @@ class DefinitionParser(BaseParser):
                     symbols.pop()
                 self.pos += 1
             if len(end) > 0 and self.eof:
-                self.fail("Could not find end of expression starting at %d."
-                          % startPos)
-            value = self.definition[startPos:self.pos].strip()
+                self.fail(
+                    'Could not find end of expression starting at %d.' % start_pos
+                )
+            value = self.definition[start_pos : self.pos].strip()
         return ASTFallbackExpr(value.strip())
 
     def _parse_nested_name(self) -> ASTNestedName:
@@ -488,20 +514,20 @@ class DefinitionParser(BaseParser):
         while 1:
             self.skip_ws()
             if not self.match(identifier_re):
-                self.fail("Expected identifier in nested name.")
+                self.fail('Expected identifier in nested name.')
             identifier = self.matched_text
             # make sure there isn't a keyword
             if identifier in _keywords:
-                self.fail("Expected identifier in nested name, "
-                          "got keyword: %s" % identifier)
+                self.fail(
+                    'Expected identifier in nested name, got keyword: %s' % identifier
+                )
             if self.matched_text in self.config.c_extra_keywords:
                 msg = (
                     'Expected identifier, got user-defined keyword: %s.'
                     ' Remove it from c_extra_keywords to allow it as identifier.\n'
                     'Currently c_extra_keywords is %s.'
                 )
-                self.fail(msg % (self.matched_text,
-                                 str(self.config.c_extra_keywords)))
+                self.fail(msg % (self.matched_text, str(self.config.c_extra_keywords)))
             ident = ASTIdentifier(identifier)
             names.append(ident)
 
@@ -549,13 +575,13 @@ class DefinitionParser(BaseParser):
                 prefix = k
                 break
 
-        nestedName = self._parse_nested_name()
-        return ASTTrailingTypeSpecName(prefix, nestedName)
+        nested_name = self._parse_nested_name()
+        return ASTTrailingTypeSpecName(prefix, nested_name)
 
-    def _parse_parameters(self, paramMode: str) -> ASTParameters | None:
+    def _parse_parameters(self, param_mode: str) -> ASTParameters | None:
         self.skip_ws()
         if not self.skip_string('('):
-            if paramMode == 'function':
+            if param_mode == 'function':
                 self.fail('Expecting "(" in parameters.')
             else:
                 return None
@@ -582,17 +608,19 @@ class DefinitionParser(BaseParser):
                     continue
                 if self.skip_string(')'):
                     break
-                self.fail(f'Expecting "," or ")" in parameters, got "{self.current_char}".')
+                self.fail(
+                    f'Expecting "," or ")" in parameters, got "{self.current_char}".'
+                )
 
         attrs = self._parse_attribute_list()
         return ASTParameters(args, attrs)
 
     def _parse_decl_specs_simple(
-        self, outer: str | None, typed: bool,
+        self, outer: str | None, typed: bool
     ) -> ASTDeclSpecsSimple:
         """Just parse the simple ones."""
         storage = None
-        threadLocal = None
+        thread_local = None
         inline = None
         restrict = None
         volatile = None
@@ -608,19 +636,19 @@ class DefinitionParser(BaseParser):
                     if self.skip_word('register'):
                         storage = 'register'
                         continue
-                if outer in ('member', 'function'):
+                if outer in {'member', 'function'}:
                     if self.skip_word('static'):
                         storage = 'static'
                         continue
                     if self.skip_word('extern'):
                         storage = 'extern'
                         continue
-            if outer == 'member' and not threadLocal:
+            if outer == 'member' and not thread_local:
                 if self.skip_word('thread_local'):
-                    threadLocal = 'thread_local'
+                    thread_local = 'thread_local'
                     continue
                 if self.skip_word('_Thread_local'):
-                    threadLocal = '_Thread_local'
+                    thread_local = '_Thread_local'
                     continue
             if outer == 'function' and not inline:
                 inline = self.skip_word('inline')
@@ -644,50 +672,59 @@ class DefinitionParser(BaseParser):
                 attrs.append(attr)
                 continue
             break
-        return ASTDeclSpecsSimple(storage, threadLocal, inline,
-                                  restrict, volatile, const, ASTAttributeList(attrs))
+        return ASTDeclSpecsSimple(
+            storage,
+            thread_local,
+            inline,
+            restrict,
+            volatile,
+            const,
+            ASTAttributeList(attrs),
+        )
 
     def _parse_decl_specs(self, outer: str | None, typed: bool = True) -> ASTDeclSpecs:
         if outer:
-            if outer not in ('type', 'member', 'function'):
+            if outer not in {'type', 'member', 'function'}:
                 raise Exception('Internal error, unknown outer "%s".' % outer)
-        leftSpecs = self._parse_decl_specs_simple(outer, typed)
-        rightSpecs = None
+        left_specs = self._parse_decl_specs_simple(outer, typed)
+        right_specs = None
 
         if typed:
             trailing = self._parse_trailing_type_spec()
-            rightSpecs = self._parse_decl_specs_simple(outer, typed)
+            right_specs = self._parse_decl_specs_simple(outer, typed)
         else:
             trailing = None
-        return ASTDeclSpecs(outer, leftSpecs, rightSpecs, trailing)
+        return ASTDeclSpecs(outer, left_specs, right_specs, trailing)
 
     def _parse_declarator_name_suffix(
-            self, named: bool | str, paramMode: str, typed: bool,
+        self, named: bool | str, param_mode: str, typed: bool
     ) -> ASTDeclarator:
-        assert named in (True, False, 'single')
+        assert named in {True, False, 'single'}
         # now we should parse the name, and then suffixes
         if named == 'single':
             if self.match(identifier_re):
                 if self.matched_text in _keywords:
-                    self.fail("Expected identifier, "
-                              "got keyword: %s" % self.matched_text)
+                    self.fail(
+                        'Expected identifier, got keyword: %s' % self.matched_text
+                    )
                 if self.matched_text in self.config.c_extra_keywords:
                     msg = (
                         'Expected identifier, got user-defined keyword: %s. '
                         'Remove it from c_extra_keywords to allow it as identifier.\n'
                         'Currently c_extra_keywords is %s.'
                     )
-                    self.fail(msg % (self.matched_text,
-                                     str(self.config.c_extra_keywords)))
+                    self.fail(
+                        msg % (self.matched_text, str(self.config.c_extra_keywords))
+                    )
                 identifier = ASTIdentifier(self.matched_text)
-                declId = ASTNestedName([identifier], rooted=False)
+                decl_id = ASTNestedName([identifier], rooted=False)
             else:
-                declId = None
+                decl_id = None
         elif named:
-            declId = self._parse_nested_name()
+            decl_id = self._parse_nested_name()
         else:
-            declId = None
-        arrayOps = []
+            decl_id = None
+        array_ops = []
         while 1:
             self.skip_ws()
             if typed and self.skip_string('['):
@@ -726,31 +763,31 @@ class DefinitionParser(BaseParser):
 
                         def parser() -> ASTExpression:
                             return self._parse_expression()
+
                         size = self._parse_expression_fallback([']'], parser)
                         self.skip_ws()
                         if not self.skip_string(']'):
                             self.fail("Expected ']' in end of array operator.")
-                arrayOps.append(ASTArray(static, const, volatile, restrict, vla, size))
+                array_ops.append(ASTArray(static, const, volatile, restrict, vla, size))
             else:
                 break
-        param = self._parse_parameters(paramMode)
-        if param is None and len(arrayOps) == 0:
+        param = self._parse_parameters(param_mode)
+        if param is None and len(array_ops) == 0:
             # perhaps a bit-field
-            if named and paramMode == 'type' and typed:
+            if named and param_mode == 'type' and typed:
                 self.skip_ws()
                 if self.skip_string(':'):
                     size = self._parse_constant_expression()
-                    return ASTDeclaratorNameBitField(declId=declId, size=size)
-        return ASTDeclaratorNameParam(declId=declId, arrayOps=arrayOps,
-                                      param=param)
+                    return ASTDeclaratorNameBitField(declId=decl_id, size=size)
+        return ASTDeclaratorNameParam(declId=decl_id, arrayOps=array_ops, param=param)
 
-    def _parse_declarator(self, named: bool | str, paramMode: str,
-                          typed: bool = True) -> ASTDeclarator:
+    def _parse_declarator(
+        self, named: bool | str, param_mode: str, typed: bool = True
+    ) -> ASTDeclarator:
         # 'typed' here means 'parse return type stuff'
-        if paramMode not in ('type', 'function'):
-            raise Exception(
-                "Internal error, unknown paramMode '%s'." % paramMode)
-        prevErrors = []
+        if param_mode not in {'type', 'function'}:
+            raise Exception("Internal error, unknown param_mode '%s'." % param_mode)
+        prev_errors = []
         self.skip_ws()
         if typed and self.skip_string('*'):
             self.skip_ws()
@@ -776,24 +813,27 @@ class DefinitionParser(BaseParser):
                     attrs.append(attr)
                     continue
                 break
-            next = self._parse_declarator(named, paramMode, typed)
-            return ASTDeclaratorPtr(next=next,
-                                    restrict=restrict, volatile=volatile, const=const,
-                                    attrs=ASTAttributeList(attrs))
+            next = self._parse_declarator(named, param_mode, typed)
+            return ASTDeclaratorPtr(
+                next=next,
+                restrict=restrict,
+                volatile=volatile,
+                const=const,
+                attrs=ASTAttributeList(attrs),
+            )
         if typed and self.current_char == '(':  # note: peeking, not skipping
             # maybe this is the beginning of params, try that first,
             # otherwise assume it's noptr->declarator > ( ptr-declarator )
             pos = self.pos
             try:
                 # assume this is params
-                res = self._parse_declarator_name_suffix(named, paramMode,
-                                                         typed)
+                res = self._parse_declarator_name_suffix(named, param_mode, typed)
                 return res
-            except DefinitionError as exParamQual:
-                msg = "If declarator-id with parameters"
-                if paramMode == 'function':
+            except DefinitionError as ex_param_qual:
+                msg = 'If declarator-id with parameters'
+                if param_mode == 'function':
                     msg += " (e.g., 'void f(int arg)')"
-                prevErrors.append((exParamQual, msg))
+                prev_errors.append((ex_param_qual, msg))
                 self.pos = pos
                 try:
                     assert self.current_char == '('
@@ -801,121 +841,128 @@ class DefinitionParser(BaseParser):
                     # TODO: hmm, if there is a name, it must be in inner, right?
                     # TODO: hmm, if there must be parameters, they must b
                     # inside, right?
-                    inner = self._parse_declarator(named, paramMode, typed)
+                    inner = self._parse_declarator(named, param_mode, typed)
                     if not self.skip_string(')'):
-                        self.fail("Expected ')' in \"( ptr-declarator )\"")
-                    next = self._parse_declarator(named=False,
-                                                  paramMode="type",
-                                                  typed=typed)
+                        self.fail('Expected \')\' in "( ptr-declarator )"')
+                    next = self._parse_declarator(
+                        named=False, param_mode='type', typed=typed
+                    )
                     return ASTDeclaratorParen(inner=inner, next=next)
-                except DefinitionError as exNoPtrParen:
+                except DefinitionError as ex_no_ptr_paren:
                     self.pos = pos
-                    msg = "If parenthesis in noptr-declarator"
-                    if paramMode == 'function':
+                    msg = 'If parenthesis in noptr-declarator'
+                    if param_mode == 'function':
                         msg += " (e.g., 'void (*f(int arg))(double)')"
-                    prevErrors.append((exNoPtrParen, msg))
-                    header = "Error in declarator"
-                    raise self._make_multi_error(prevErrors, header) from exNoPtrParen
+                    prev_errors.append((ex_no_ptr_paren, msg))
+                    header = 'Error in declarator'
+                    raise self._make_multi_error(
+                        prev_errors, header
+                    ) from ex_no_ptr_paren
         pos = self.pos
         try:
-            return self._parse_declarator_name_suffix(named, paramMode, typed)
+            return self._parse_declarator_name_suffix(named, param_mode, typed)
         except DefinitionError as e:
             self.pos = pos
-            prevErrors.append((e, "If declarator-id"))
-            header = "Error in declarator or parameters"
-            raise self._make_multi_error(prevErrors, header) from e
+            prev_errors.append((e, 'If declarator-id'))
+            header = 'Error in declarator or parameters'
+            raise self._make_multi_error(prev_errors, header) from e
 
-    def _parse_initializer(self, outer: str | None = None, allowFallback: bool = True,
-                           ) -> ASTInitializer | None:
+    def _parse_initializer(
+        self, outer: str | None = None, allow_fallback: bool = True
+    ) -> ASTInitializer | None:
         self.skip_ws()
-        if outer == 'member' and False:  # NoQA: SIM223  # TODO
-            bracedInit = self._parse_braced_init_list()
-            if bracedInit is not None:
-                return ASTInitializer(bracedInit, hasAssign=False)
+        if outer == 'member' and False:  # NoQA: SIM223,TD005  # TODO
+            braced_init = self._parse_braced_init_list()
+            if braced_init is not None:
+                return ASTInitializer(braced_init, hasAssign=False)
 
         if not self.skip_string('='):
             return None
 
-        bracedInit = self._parse_braced_init_list()
-        if bracedInit is not None:
-            return ASTInitializer(bracedInit)
+        braced_init = self._parse_braced_init_list()
+        if braced_init is not None:
+            return ASTInitializer(braced_init)
 
         if outer == 'member':
-            fallbackEnd: list[str] = []
+            fallback_end: list[str] = []
         elif outer is None:  # function parameter
-            fallbackEnd = [',', ')']
+            fallback_end = [',', ')']
         else:
-            self.fail("Internal error, initializer for outer '%s' not "
-                      "implemented." % outer)
+            self.fail(
+                "Internal error, initializer for outer '%s' not implemented." % outer
+            )
 
         def parser() -> ASTExpression:
             return self._parse_assignment_expression()
 
-        value = self._parse_expression_fallback(fallbackEnd, parser, allow=allowFallback)
+        value = self._parse_expression_fallback(
+            fallback_end, parser, allow=allow_fallback
+        )
         return ASTInitializer(value)
 
     def _parse_type(self, named: bool | str, outer: str | None = None) -> ASTType:
-        """
-        named=False|'single'|True: 'single' is e.g., for function objects which
+        """named=False|'single'|True: 'single' is e.g., for function objects which
         doesn't need to name the arguments, but otherwise is a single name
         """
         if outer:  # always named
-            if outer not in ('type', 'member', 'function'):
+            if outer not in {'type', 'member', 'function'}:
                 raise Exception('Internal error, unknown outer "%s".' % outer)
             assert named
 
         if outer == 'type':
             # We allow type objects to just be a name.
-            prevErrors = []
-            startPos = self.pos
+            prev_errors = []
+            start_pos = self.pos
             # first try without the type
             try:
-                declSpecs = self._parse_decl_specs(outer=outer, typed=False)
-                decl = self._parse_declarator(named=True, paramMode=outer,
-                                              typed=False)
+                decl_specs = self._parse_decl_specs(outer=outer, typed=False)
+                decl = self._parse_declarator(named=True, param_mode=outer, typed=False)
                 self.assert_end(allowSemicolon=True)
-            except DefinitionError as exUntyped:
-                desc = "If just a name"
-                prevErrors.append((exUntyped, desc))
-                self.pos = startPos
+            except DefinitionError as ex_untyped:
+                desc = 'If just a name'
+                prev_errors.append((ex_untyped, desc))
+                self.pos = start_pos
                 try:
-                    declSpecs = self._parse_decl_specs(outer=outer)
-                    decl = self._parse_declarator(named=True, paramMode=outer)
-                except DefinitionError as exTyped:
-                    self.pos = startPos
-                    desc = "If typedef-like declaration"
-                    prevErrors.append((exTyped, desc))
+                    decl_specs = self._parse_decl_specs(outer=outer)
+                    decl = self._parse_declarator(named=True, param_mode=outer)
+                except DefinitionError as ex_typed:
+                    self.pos = start_pos
+                    desc = 'If typedef-like declaration'
+                    prev_errors.append((ex_typed, desc))
                     # Retain the else branch for easier debugging.
                     # TODO: it would be nice to save the previous stacktrace
                     #       and output it here.
                     if True:
-                        header = "Type must be either just a name or a "
-                        header += "typedef-like declaration."
-                        raise self._make_multi_error(prevErrors, header) from exTyped
-                    else:  # NoQA: RET506
+                        header = 'Type must be either just a name or a '
+                        header += 'typedef-like declaration.'
+                        raise self._make_multi_error(prev_errors, header) from ex_typed
+                    else:
                         # For testing purposes.
                         # do it again to get the proper traceback (how do you
                         # reliably save a traceback when an exception is
                         # constructed?)
-                        self.pos = startPos
+                        self.pos = start_pos
                         typed = True
-                        declSpecs = self._parse_decl_specs(outer=outer, typed=typed)
-                        decl = self._parse_declarator(named=True, paramMode=outer,
-                                                      typed=typed)
+                        decl_specs = self._parse_decl_specs(outer=outer, typed=typed)
+                        decl = self._parse_declarator(
+                            named=True, param_mode=outer, typed=typed
+                        )
         elif outer == 'function':
-            declSpecs = self._parse_decl_specs(outer=outer)
-            decl = self._parse_declarator(named=True, paramMode=outer)
+            decl_specs = self._parse_decl_specs(outer=outer)
+            decl = self._parse_declarator(named=True, param_mode=outer)
         else:
-            paramMode = 'type'
+            param_mode = 'type'
             if outer == 'member':  # i.e., member
                 named = True
-            declSpecs = self._parse_decl_specs(outer=outer)
-            decl = self._parse_declarator(named=named, paramMode=paramMode)
-        return ASTType(declSpecs, decl)
+            decl_specs = self._parse_decl_specs(outer=outer)
+            decl = self._parse_declarator(named=named, param_mode=param_mode)
+        return ASTType(decl_specs, decl)
 
-    def _parse_type_with_init(self, named: bool | str, outer: str | None) -> ASTTypeWithInit:
+    def _parse_type_with_init(
+        self, named: bool | str, outer: str | None
+    ) -> ASTTypeWithInit:
         if outer:
-            assert outer in ('type', 'member', 'function')
+            assert outer in {'type', 'member', 'function'}
         type = self._parse_type(outer=outer, named=named)
         init = self._parse_initializer(outer=outer)
         return ASTTypeWithInit(type, init)
@@ -924,7 +971,7 @@ class DefinitionParser(BaseParser):
         self.skip_ws()
         ident = self._parse_nested_name()
         if ident is None:
-            self.fail("Expected identifier in macro definition.")
+            self.fail('Expected identifier in macro definition.')
         self.skip_ws()
         if not self.skip_string_and_ws('('):
             return ASTMacro(ident, None)
@@ -940,7 +987,7 @@ class DefinitionParser(BaseParser):
                     self.fail('Expected ")" after "..." in macro parameters.')
                 break
             if not self.match(identifier_re):
-                self.fail("Expected identifier in macro parameters.")
+                self.fail('Expected identifier in macro parameters.')
             nn = ASTNestedName([ASTIdentifier(self.matched_text)], rooted=False)
             # Allow named variadic args:
             # https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html
@@ -982,43 +1029,64 @@ class DefinitionParser(BaseParser):
             def parser() -> ASTExpression:
                 return self._parse_constant_expression()
 
-            initVal = self._parse_expression_fallback([], parser)
-            init = ASTInitializer(initVal)
+            init_val = self._parse_expression_fallback([], parser)
+            init = ASTInitializer(init_val)
         return ASTEnumerator(name, init, attrs)
 
     def parse_declaration(self, objectType: str, directiveType: str) -> ASTDeclaration:
-        if objectType not in ('function', 'member',
-                              'macro', 'struct', 'union', 'enum', 'enumerator', 'type'):
-            raise Exception('Internal error, unknown objectType "%s".' % objectType)
-        if directiveType not in ('function', 'member', 'var',
-                                 'macro', 'struct', 'union', 'enum', 'enumerator', 'type'):
-            raise Exception('Internal error, unknown directiveType "%s".' % directiveType)
+        object_type = objectType
+        directive_type = directiveType
+        if object_type not in {
+            'function',
+            'member',
+            'macro',
+            'struct',
+            'union',
+            'enum',
+            'enumerator',
+            'type',
+        }:
+            raise Exception('Internal error, unknown objectType "%s".' % object_type)
+        if directive_type not in {
+            'function',
+            'member',
+            'var',
+            'macro',
+            'struct',
+            'union',
+            'enum',
+            'enumerator',
+            'type',
+        }:
+            raise Exception(
+                'Internal error, unknown directiveType "%s".' % directive_type
+            )
 
         declaration: DeclarationType | None = None
-        if objectType == 'member':
+        if object_type == 'member':
             declaration = self._parse_type_with_init(named=True, outer='member')
-        elif objectType == 'function':
+        elif object_type == 'function':
             declaration = self._parse_type(named=True, outer='function')
-        elif objectType == 'macro':
+        elif object_type == 'macro':
             declaration = self._parse_macro()
-        elif objectType == 'struct':
+        elif object_type == 'struct':
             declaration = self._parse_struct()
-        elif objectType == 'union':
+        elif object_type == 'union':
             declaration = self._parse_union()
-        elif objectType == 'enum':
+        elif object_type == 'enum':
             declaration = self._parse_enum()
-        elif objectType == 'enumerator':
+        elif object_type == 'enumerator':
             declaration = self._parse_enumerator()
-        elif objectType == 'type':
+        elif object_type == 'type':
             declaration = self._parse_type(named=True, outer='type')
         else:
             raise AssertionError
-        if objectType != 'macro':
+        if object_type != 'macro':
             self.skip_ws()
             semicolon = self.skip_string(';')
         else:
             semicolon = False
-        return ASTDeclaration(objectType, directiveType, declaration, semicolon)
+        return ASTDeclaration(object_type, directive_type, declaration, semicolon)
 
     def parse_namespace_object(self) -> ASTNestedName:
         return self._parse_nested_name()
@@ -1038,16 +1106,17 @@ class DefinitionParser(BaseParser):
             res = self._parse_expression()
             self.skip_ws()
             self.assert_end()
-        except DefinitionError as exExpr:
+        except DefinitionError as ex_expr:
             self.pos = pos
             try:
                 res = self._parse_type(False)
                 self.skip_ws()
                 self.assert_end()
-            except DefinitionError as exType:
-                header = "Error when parsing (type) expression."
-                errs = []
-                errs.append((exExpr, "If expression"))
-                errs.append((exType, "If type"))
-                raise self._make_multi_error(errs, header) from exType
+            except DefinitionError as ex_type:
+                header = 'Error when parsing (type) expression.'
+                errs = [
+                    (ex_expr, 'If expression'),
+                    (ex_type, 'If type'),
+                ]
+                raise self._make_multi_error(errs, header) from ex_type
         return res