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

sphinx/domains/cpp/_parser.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from sphinx.domains.cpp._ast import (
     ASTAlignofExpr,
@@ -18,7 +18,6 @@ from sphinx.domains.cpp._ast import (
     ASTConcept,
     ASTConditionalExpr,
     ASTDeclaration,
-    ASTDeclarator,
     ASTDeclaratorMemPtr,
     ASTDeclaratorNameBitField,
     ASTDeclaratorNameParamQual,
@@ -33,14 +32,12 @@ from sphinx.domains.cpp._ast import (
     ASTEnumerator,
     ASTExplicitCast,
     ASTExplicitSpec,
-    ASTExpression,
     ASTFallbackExpr,
     ASTFoldExpr,
     ASTFunctionParameter,
     ASTIdentifier,
     ASTIdExpression,
     ASTInitializer,
-    ASTLiteral,
     ASTNamespace,
     ASTNestedName,
     ASTNestedNameElement,
@@ -48,7 +45,6 @@ from sphinx.domains.cpp._ast import (
     ASTNoexceptExpr,
     ASTNoexceptSpec,
     ASTNumberLiteral,
-    ASTOperator,
     ASTOperatorBuildIn,
     ASTOperatorLiteral,
     ASTOperatorType,
@@ -64,7 +60,6 @@ from sphinx.domains.cpp._ast import (
     ASTPostfixInc,
     ASTPostfixMember,
     ASTPostfixMemberOfPointer,
-    ASTPostfixOp,
     ASTRequiresClause,
     ASTSizeofExpr,
     ASTSizeofParamPack,
@@ -76,14 +71,12 @@ from sphinx.domains.cpp._ast import (
     ASTTemplateIntroduction,
     ASTTemplateIntroductionParameter,
     ASTTemplateKeyParamPackIdDefault,
-    ASTTemplateParam,
     ASTTemplateParamConstrainedTypeWithInit,
     ASTTemplateParamNonType,
     ASTTemplateParams,
     ASTTemplateParamTemplateType,
     ASTTemplateParamType,
     ASTThisLiteral,
-    ASTTrailingTypeSpec,
     ASTTrailingTypeSpecDecltype,
     ASTTrailingTypeSpecDecltypeAuto,
     ASTTrailingTypeSpecFundamental,
@@ -128,6 +121,17 @@ from sphinx.util.cfamily import (
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
+    from typing import Any
+
+    from sphinx.domains.cpp._ast import (
+        ASTDeclarator,
+        ASTExpression,
+        ASTLiteral,
+        ASTOperator,
+        ASTPostfixOp,
+        ASTTemplateParam,
+        ASTTrailingTypeSpec,
+    )
 
 logger = logging.getLogger(__name__)
 
@@ -148,12 +152,12 @@ class DefinitionParser(BaseParser):
     def _parse_string(self) -> str:
         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
@@ -162,7 +166,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:
         # -> integer-literal
@@ -190,21 +194,25 @@ class DefinitionParser(BaseParser):
             return ASTBooleanLiteral(False)
         pos = self.pos
         if self.match(float_literal_re):
-            hasSuffix = self.match(float_literal_suffix_re)
-            floatLit = ASTNumberLiteral(self.definition[pos:self.pos])
-            if hasSuffix:
-                return floatLit
+            has_suffix = self.match(float_literal_suffix_re)
+            float_lit = ASTNumberLiteral(self.definition[pos : self.pos])
+            if has_suffix:
+                return float_lit
             else:
-                return _udl(floatLit)
-        for regex in (binary_literal_re, hex_literal_re,
-                      integer_literal_re, octal_literal_re):
+                return _udl(float_lit)
+        for regex in (
+            binary_literal_re,
+            hex_literal_re,
+            integer_literal_re,
+            octal_literal_re,
+        ):
             if self.match(regex):
-                hasSuffix = self.match(integers_literal_suffix_re)
-                intLit = ASTNumberLiteral(self.definition[pos:self.pos])
-                if hasSuffix:
-                    return intLit
+                has_suffix = self.match(integers_literal_suffix_re)
+                int_lit = ASTNumberLiteral(self.definition[pos : self.pos])
+                if has_suffix:
+                    return int_lit
                 else:
-                    return _udl(intLit)
+                    return _udl(int_lit)
 
         string = self._parse_string()
         if string is not None:
@@ -215,13 +223,17 @@ class DefinitionParser(BaseParser):
             prefix = self.last_match.group(1)  # may be None when no prefix
             data = self.last_match.group(2)
             try:
-                charLit = ASTCharLiteral(prefix, data)
+                char_lit = 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.")
-            return _udl(charLit)
+                self.fail(
+                    'Can not handle character literal'
+                    ' resulting in multiple decoded characters.'
+                )
+            return _udl(char_lit)
         return None
 
     def _parse_fold_or_paren_expression(self) -> ASTExpression | None:
@@ -234,28 +246,30 @@ class DefinitionParser(BaseParser):
             return None
         self.pos += 1
         self.skip_ws()
-        if self.skip_string_and_ws("..."):
+        if self.skip_string_and_ws('...'):
             # ( ... fold-operator cast-expression )
             if not self.match(_fold_operator_re):
                 self.fail("Expected fold operator after '...' in fold expression.")
             op = self.matched_text
-            rightExpr = self._parse_cast_expression()
+            right_expr = self._parse_cast_expression()
             if not self.skip_string(')'):
                 self.fail("Expected ')' in end of fold expression.")
-            return ASTFoldExpr(None, op, rightExpr)
+            return ASTFoldExpr(None, op, right_expr)
         # try first parsing a unary right fold, or a binary fold
         pos = self.pos
         try:
             self.skip_ws()
-            leftExpr = self._parse_cast_expression()
+            left_expr = self._parse_cast_expression()
             self.skip_ws()
             if not self.match(_fold_operator_re):
-                self.fail("Expected fold operator after left expression in fold expression.")
+                self.fail(
+                    'Expected fold operator after left expression in fold expression.'
+                )
             op = self.matched_text
             self.skip_ws()
             if not self.skip_string_and_ws('...'):
                 self.fail("Expected '...' after fold operator in fold expression.")
-        except DefinitionError as eFold:
+        except DefinitionError as e_fold:
             self.pos = pos
             # fall back to a paren expression
             try:
@@ -263,25 +277,30 @@ class DefinitionParser(BaseParser):
                 self.skip_ws()
                 if not self.skip_string(')'):
                     self.fail("Expected ')' in end of parenthesized expression.")
-            except DefinitionError as eExpr:
-                raise self._make_multi_error([
-                    (eFold, "If fold expression"),
-                    (eExpr, "If parenthesized expression"),
-                ], "Error in fold expression or parenthesized expression.") from eExpr
+            except DefinitionError as e_expr:
+                raise self._make_multi_error(
+                    [
+                        (e_fold, 'If fold expression'),
+                        (e_expr, 'If parenthesized expression'),
+                    ],
+                    'Error in fold expression or parenthesized expression.',
+                ) from e_expr
             return ASTParenExpr(res)
         # now it definitely is a fold expression
         if self.skip_string(')'):
-            return ASTFoldExpr(leftExpr, op, None)
+            return ASTFoldExpr(left_expr, op, None)
         if not self.match(_fold_operator_re):
             self.fail("Expected fold operator or ')' after '...' in fold expression.")
         if op != self.matched_text:
-            self.fail("Operators are different in binary fold: '%s' and '%s'."
-                      % (op, self.matched_text))
-        rightExpr = self._parse_cast_expression()
+            self.fail(
+                "Operators are different in binary fold: '%s' and '%s'."
+                % (op, self.matched_text)
+            )
+        right_expr = self._parse_cast_expression()
         self.skip_ws()
         if not self.skip_string(')'):
             self.fail("Expected ')' to end binary fold expression.")
-        return ASTFoldExpr(leftExpr, op, rightExpr)
+        return ASTFoldExpr(left_expr, op, right_expr)
 
     def _parse_primary_expression(self) -> ASTExpression:
         # literal
@@ -295,7 +314,7 @@ class DefinitionParser(BaseParser):
         if res is not None:
             return res
         self.skip_ws()
-        if self.skip_word("this"):
+        if self.skip_word('this'):
             return ASTThisLiteral()
         # TODO: try lambda expression
         res = self._parse_fold_or_paren_expression()
@@ -306,9 +325,9 @@ class DefinitionParser(BaseParser):
             return ASTIdExpression(nn)
         return None
 
-    def _parse_initializer_list(self, name: str, open: str, close: str,
-                                ) -> tuple[list[ASTExpression | ASTBracedInitList],
-                                           bool]:
+    def _parse_initializer_list(
+        self, name: str, open: str, close: str
+    ) -> tuple[list[ASTExpression | ASTBracedInitList], bool]:
         # Parse open and close with the actual initializer-list in between
         # -> initializer-clause '...'[opt]
         #  | initializer-list ',' initializer-clause '...'[opt]
@@ -319,7 +338,7 @@ class DefinitionParser(BaseParser):
             return [], False
 
         exprs: list[ASTExpression | ASTBracedInitList] = []
-        trailingComma = False
+        trailing_comma = False
         while True:
             self.skip_ws()
             expr = self._parse_initializer_clause()
@@ -335,9 +354,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:
         # -> '(' expression-list ')'
@@ -346,25 +365,28 @@ 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)
 
     def _parse_initializer_clause(self) -> ASTExpression | ASTBracedInitList:
-        bracedInitList = self._parse_braced_init_list()
-        if bracedInitList is not None:
-            return bracedInitList
-        return self._parse_assignment_expression(inTemplate=False)
+        braced_init_list = self._parse_braced_init_list()
+        if braced_init_list is not None:
+            return braced_init_list
+        return self._parse_assignment_expression(in_template=False)
 
     def _parse_braced_init_list(self) -> ASTBracedInitList:
         # -> '{' 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_expression_list_or_braced_init_list(
         self,
@@ -396,7 +418,7 @@ class DefinitionParser(BaseParser):
         #  | "typeid" "(" expression ")"
         #  | "typeid" "(" type-id ")"
 
-        prefixType = None
+        prefix_type = None
         prefix: Any = None
         self.skip_ws()
 
@@ -406,25 +428,26 @@ class DefinitionParser(BaseParser):
                 cast = c
                 break
         if cast is not None:
-            prefixType = "cast"
-            if not self.skip_string("<"):
+            prefix_type = 'cast'
+            if not self.skip_string('<'):
                 self.fail("Expected '<' after '%s'." % cast)
             typ = self._parse_type(False)
             self.skip_ws()
-            if not self.skip_string_and_ws(">"):
+            if not self.skip_string_and_ws('>'):
                 self.fail("Expected '>' after type in '%s'." % cast)
-            if not self.skip_string("("):
+            if not self.skip_string('('):
                 self.fail("Expected '(' in '%s'." % cast)
 
             def parser() -> ASTExpression:
                 return self._parse_expression()
+
             expr = self._parse_expression_fallback([')'], parser)
             self.skip_ws()
-            if not self.skip_string(")"):
+            if not self.skip_string(')'):
                 self.fail("Expected ')' to end '%s'." % cast)
             prefix = ASTExplicitCast(cast, typ, expr)
-        elif self.skip_word_and_ws("typeid"):
-            prefixType = "typeid"
+        elif self.skip_word_and_ws('typeid'):
+            prefix_type = 'typeid'
             if not self.skip_string_and_ws('('):
                 self.fail("Expected '(' after 'typeid'.")
             pos = self.pos
@@ -433,63 +456,66 @@ class DefinitionParser(BaseParser):
                 prefix = ASTTypeId(typ, isType=True)
                 if not self.skip_string(')'):
                     self.fail("Expected ')' to end 'typeid' of type.")
-            except DefinitionError as eType:
+            except DefinitionError as e_type:
                 self.pos = pos
                 try:
 
                     def parser() -> ASTExpression:
                         return self._parse_expression()
+
                     expr = self._parse_expression_fallback([')'], parser)
                     prefix = ASTTypeId(expr, isType=False)
                     if not self.skip_string(')'):
                         self.fail("Expected ')' to end 'typeid' of expression.")
-                except DefinitionError as eExpr:
+                except DefinitionError as e_expr:
                     self.pos = pos
                     header = "Error in 'typeid(...)'."
-                    header += " Expected type or expression."
-                    errors = []
-                    errors.append((eType, "If type"))
-                    errors.append((eExpr, "If expression"))
-                    raise self._make_multi_error(errors, header) from eExpr
+                    header += ' Expected type or expression.'
+                    errors = [
+                        (e_type, 'If type'),
+                        (e_expr, 'If expression'),
+                    ]
+                    raise self._make_multi_error(errors, header) from e_expr
         else:  # a primary expression or a type
             pos = self.pos
             try:
                 prefix = self._parse_primary_expression()
-                prefixType = 'expr'
-            except DefinitionError as eOuter:
+                prefix_type = 'expr'
+            except DefinitionError as e_outer:
                 self.pos = pos
                 try:
                     # we are potentially casting, so save parens for us
                     # TODO: hmm, would we need to try both with operatorCast and with None?
                     prefix = self._parse_type(False, 'operatorCast')
-                    prefixType = 'typeOperatorCast'
+                    prefix_type = 'typeOperatorCast'
                     #  | simple-type-specifier "(" expression-list [opt] ")"
                     #  | simple-type-specifier braced-init-list
                     #  | typename-specifier "(" expression-list [opt] ")"
                     #  | typename-specifier braced-init-list
                     self.skip_ws()
-                    if self.current_char != '(' and self.current_char != '{':
+                    if self.current_char not in {'(', '{'}:
                         self.fail("Expecting '(' or '{' after type in cast expression.")
-                except DefinitionError as eInner:
+                except DefinitionError as e_inner:
                     self.pos = pos
-                    header = "Error in postfix expression,"
-                    header += " expected primary expression or type."
-                    errors = []
-                    errors.append((eOuter, "If primary expression"))
-                    errors.append((eInner, "If type"))
-                    raise self._make_multi_error(errors, header) from eInner
+                    header = 'Error in postfix expression,'
+                    header += ' expected primary expression or type.'
+                    errors = [
+                        (e_outer, 'If primary expression'),
+                        (e_inner, 'If type'),
+                    ]
+                    raise self._make_multi_error(errors, header) from e_inner
 
         # and now parse postfixes
-        postFixes: list[ASTPostfixOp] = []
+        post_fixes: list[ASTPostfixOp] = []
         while True:
             self.skip_ws()
-            if prefixType in ('expr', 'cast', 'typeid'):
+            if prefix_type in {'expr', 'cast', 'typeid'}:
                 if self.skip_string_and_ws('['):
                     expr = self._parse_expression()
                     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('*'):
@@ -500,7 +526,7 @@ class DefinitionParser(BaseParser):
                         self.pos -= 3
                     else:
                         name = self._parse_nested_name()
-                        postFixes.append(ASTPostfixMember(name))
+                        post_fixes.append(ASTPostfixMember(name))
                         continue
                 if self.skip_string('->'):
                     if self.skip_string('*'):
@@ -508,20 +534,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_expression_list_or_braced_init_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
@@ -554,7 +580,7 @@ class DefinitionParser(BaseParser):
                     self.fail("Expecting identifier for 'sizeof...'.")
                 ident = ASTIdentifier(self.matched_text)
                 self.skip_ws()
-                if not self.skip_string(")"):
+                if not self.skip_string(')'):
                     self.fail("Expecting ')' to end 'sizeof...'.")
                 return ASTSizeofParamPack(ident)
             if self.skip_string_and_ws('('):
@@ -590,20 +616,24 @@ class DefinitionParser(BaseParser):
         else:
             # new-placement[opt] new-type-id new-initializer[opt]
             # new-placement[opt] ( type-id ) new-initializer[opt]
-            isNewTypeId = True
+            is_new_type_id = True
             if self.skip_string_and_ws('('):
                 # either this is a new-placement or it's the second production
                 # without placement, and it's actually the ( type-id ) part
-                self.fail("Sorry, neither new-placement nor parenthesised type-id "
-                          "in new-epression is supported yet.")
-                # set isNewTypeId = False if it's (type-id)
-            if isNewTypeId:
-                declSpecs = self._parse_decl_specs(outer=None)
-                decl = self._parse_declarator(named=False, paramMode="new")
+                self.fail(
+                    'Sorry, neither new-placement nor parenthesised type-id '
+                    'in new-epression is supported yet.'
+                )
+                # set is_new_type_id = False if it's (type-id)
+            if is_new_type_id:
+                decl_specs = self._parse_decl_specs(outer=None)
+                decl = self._parse_declarator(named=False, param_mode='new')
             else:
-                self.fail("Sorry, parenthesised type-id in new expression not yet supported.")
+                self.fail(
+                    'Sorry, parenthesised type-id in new expression not yet supported.'
+                )
             lst = self._parse_expression_list_or_braced_init_list()
-            return ASTNewExpr(rooted, isNewTypeId, ASTType(declSpecs, decl), lst)
+            return ASTNewExpr(rooted, is_new_type_id, ASTType(decl_specs, decl), lst)
         # delete-expression
         pos = self.pos
         rooted = self.skip_string('::')
@@ -629,20 +659,22 @@ 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()
 
-    def _parse_logical_or_expression(self, inTemplate: bool) -> ASTExpression:
+    def _parse_logical_or_expression(self, in_template: bool) -> ASTExpression:
         # logical-or     = logical-and      ||
         # logical-and    = inclusive-or     &&
         # inclusive-or   = exclusive-or     |
@@ -654,24 +686,29 @@ class DefinitionParser(BaseParser):
         # additive       = multiplicative   +, -
         # multiplicative = pm               *, /, %
         # pm             = cast             .*, ->*
-        def _parse_bin_op_expr(self: DefinitionParser,
-                               opId: int, inTemplate: bool) -> ASTExpression:
-            if opId + 1 == len(_expression_bin_ops):
-                def parser(inTemplate: bool) -> ASTExpression:
+        def _parse_bin_op_expr(
+            self: DefinitionParser, op_id: int, in_template: bool
+        ) -> ASTExpression:
+            if op_id + 1 == len(_expression_bin_ops):
+
+                def parser(in_template: bool) -> ASTExpression:
                     return self._parse_cast_expression()
+
             else:
-                def parser(inTemplate: bool) -> ASTExpression:
-                    return _parse_bin_op_expr(self, opId + 1, inTemplate=inTemplate)
+
+                def parser(in_template: bool) -> ASTExpression:
+                    return _parse_bin_op_expr(self, op_id + 1, in_template=in_template)
+
             exprs = []
             ops = []
-            exprs.append(parser(inTemplate=inTemplate))
+            exprs.append(parser(in_template=in_template))
             while True:
                 self.skip_ws()
-                if inTemplate and self.current_char == '>':
+                if in_template and self.current_char == '>':
                     break
                 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
@@ -684,34 +721,36 @@ class DefinitionParser(BaseParser):
                         # and btw. && has lower precedence, so we are done
                         break
                     try:
-                        expr = parser(inTemplate=inTemplate)
+                        expr = parser(in_template=in_template)
                         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)
-        return _parse_bin_op_expr(self, 0, inTemplate=inTemplate)
 
-    def _parse_conditional_expression_tail(self, orExprHead: ASTExpression,
-                                           inTemplate: bool) -> ASTConditionalExpr | None:
-        # Consumes the orExprHead on success.
+        return _parse_bin_op_expr(self, 0, in_template=in_template)
+
+    def _parse_conditional_expression_tail(
+        self, or_expr_head: ASTExpression, in_template: bool
+    ) -> ASTConditionalExpr | None:
+        # Consumes the or_expr_head on success.
 
         # -> "?" expression ":" assignment-expression
         self.skip_ws()
-        if not self.skip_string("?"):
+        if not self.skip_string('?'):
             return None
-        thenExpr = self._parse_expression()
+        then_expr = self._parse_expression()
         self.skip_ws()
-        if not self.skip_string(":"):
+        if not self.skip_string(':'):
             self.fail('Expected ":" after then-expression in conditional expression.')
-        elseExpr = self._parse_assignment_expression(inTemplate)
-        return ASTConditionalExpr(orExprHead, thenExpr, elseExpr)
+        else_expr = self._parse_assignment_expression(in_template)
+        return ASTConditionalExpr(or_expr_head, then_expr, else_expr)
 
-    def _parse_assignment_expression(self, inTemplate: bool) -> ASTExpression:
+    def _parse_assignment_expression(self, in_template: bool) -> ASTExpression:
         # -> conditional-expression
         #  | logical-or-expression assignment-operator initializer-clause
         #  | yield-expression -> "co_yield" assignment-expression
@@ -724,11 +763,11 @@ class DefinitionParser(BaseParser):
         #     logical-or-expression
         #   | logical-or-expression "?" expression ":" assignment-expression
         #   | logical-or-expression assignment-operator initializer-clause
-        leftExpr = self._parse_logical_or_expression(inTemplate=inTemplate)
+        left_expr = self._parse_logical_or_expression(in_template=in_template)
         # the ternary operator
-        condExpr = self._parse_conditional_expression_tail(leftExpr, inTemplate)
-        if condExpr is not None:
-            return condExpr
+        cond_expr = self._parse_conditional_expression_tail(left_expr, in_template)
+        if cond_expr is not None:
+            return cond_expr
         # and actual assignment
         for op in _expression_assignment_ops:
             if op[0] in 'anox':
@@ -737,43 +776,43 @@ class DefinitionParser(BaseParser):
             else:
                 if not self.skip_string(op):
                     continue
-            rightExpr = self._parse_initializer_clause()
-            return ASTAssignmentExpr(leftExpr, op, rightExpr)
+            right_expr = self._parse_initializer_clause()
+            return ASTAssignmentExpr(left_expr, op, right_expr)
         # just a logical-or-expression
-        return leftExpr
+        return left_expr
 
-    def _parse_constant_expression(self, inTemplate: bool) -> ASTExpression:
+    def _parse_constant_expression(self, in_template: bool) -> ASTExpression:
         # -> conditional-expression ->
         #    logical-or-expression
         #  | logical-or-expression "?" expression ":" assignment-expression
-        orExpr = self._parse_logical_or_expression(inTemplate=inTemplate)
-        condExpr = self._parse_conditional_expression_tail(orExpr, inTemplate)
-        if condExpr is not None:
-            return condExpr
-        return orExpr
+        or_expr = self._parse_logical_or_expression(in_template=in_template)
+        cond_expr = self._parse_conditional_expression_tail(or_expr, in_template)
+        if cond_expr is not None:
+            return cond_expr
+        return or_expr
 
     def _parse_expression(self) -> ASTExpression:
         # -> assignment-expression
         #  | expression "," assignment-expression
-        exprs = [self._parse_assignment_expression(inTemplate=False)]
+        exprs = [self._parse_assignment_expression(in_template=False)]
         while True:
             self.skip_ws()
             if not self.skip_string(','):
                 break
-            exprs.append(self._parse_assignment_expression(inTemplate=False))
+            exprs.append(self._parse_assignment_expression(in_template=False))
         if len(exprs) == 1:
             return exprs[0]
         else:
             return ASTCommaExpr(exprs)
 
-    def _parse_expression_fallback(self, end: list[str],
-                                   parser: Callable[[], ASTExpression],
-                                   allow: bool = True) -> ASTExpression:
+    def _parse_expression_fallback(
+        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:
@@ -781,13 +820,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:
@@ -795,7 +836,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])
@@ -803,9 +844,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())
 
     # ==========================================================================
@@ -833,13 +875,13 @@ class DefinitionParser(BaseParser):
         if self.skip_string('""'):
             self.skip_ws()
             if not self.match(identifier_re):
-                self.fail("Expected user-defined literal suffix.")
+                self.fail('Expected user-defined literal suffix.')
             identifier = ASTIdentifier(self.matched_text)
             return ASTOperatorLiteral(identifier)
 
         # oh well, looks like a cast operator definition.
         # In that case, eat another type.
-        type = self._parse_type(named=False, outer="operatorCast")
+        type = self._parse_type(named=False, outer='operatorCast')
         return ASTOperatorType(type)
 
     def _parse_template_argument_list(self) -> ASTTemplateArgs:
@@ -855,58 +897,62 @@ class DefinitionParser(BaseParser):
             return None
         if self.skip_string('>'):
             return ASTTemplateArgs([], False)
-        prevErrors = []
-        templateArgs: list[ASTType | ASTTemplateArgConstant] = []
-        packExpansion = False
+        prev_errors = []
+        template_args: list[ASTType | ASTTemplateArgConstant] = []
+        pack_expansion = False
         while 1:
             pos = self.pos
-            parsedComma = False
-            parsedEnd = False
+            parsed_comma = False
+            parsed_end = False
             try:
                 type = self._parse_type(named=False)
                 self.skip_ws()
                 if self.skip_string_and_ws('...'):
-                    packExpansion = True
-                    parsedEnd = True
+                    pack_expansion = True
+                    parsed_end = True
                     if not self.skip_string('>'):
                         self.fail('Expected ">" after "..." in template argument list.')
                 elif self.skip_string('>'):
-                    parsedEnd = True
+                    parsed_end = True
                 elif self.skip_string(','):
-                    parsedComma = True
+                    parsed_comma = True
                 else:
                     self.fail('Expected "...>", ">" or "," in template argument list.')
-                templateArgs.append(type)
+                template_args.append(type)
             except DefinitionError as e:
-                prevErrors.append((e, "If type argument"))
+                prev_errors.append((e, 'If type argument'))
                 self.pos = pos
                 try:
-                    value = self._parse_constant_expression(inTemplate=True)
+                    value = self._parse_constant_expression(in_template=True)
                     self.skip_ws()
                     if self.skip_string_and_ws('...'):
-                        packExpansion = True
-                        parsedEnd = True
+                        pack_expansion = True
+                        parsed_end = True
                         if not self.skip_string('>'):
-                            self.fail('Expected ">" after "..." in template argument list.')
+                            self.fail(
+                                'Expected ">" after "..." in template argument list.'
+                            )
                     elif self.skip_string('>'):
-                        parsedEnd = True
+                        parsed_end = True
                     elif self.skip_string(','):
-                        parsedComma = True
+                        parsed_comma = True
                     else:
-                        self.fail('Expected "...>", ">" or "," in template argument list.')
-                    templateArgs.append(ASTTemplateArgConstant(value))
+                        self.fail(
+                            'Expected "...>", ">" or "," in template argument list.'
+                        )
+                    template_args.append(ASTTemplateArgConstant(value))
                 except DefinitionError as e:
                     self.pos = pos
-                    prevErrors.append((e, "If non-type argument"))
-                    header = "Error in parsing template argument list."
-                    raise self._make_multi_error(prevErrors, header) from e
-            if parsedEnd:
-                assert not parsedComma
+                    prev_errors.append((e, 'If non-type argument'))
+                    header = 'Error in parsing template argument list.'
+                    raise self._make_multi_error(prev_errors, header) from e
+            if parsed_end:
+                assert not parsed_comma
                 break
-            assert not packExpansion
-        return ASTTemplateArgs(templateArgs, packExpansion)
+            assert not pack_expansion
+        return ASTTemplateArgs(template_args, pack_expansion)
 
-    def _parse_nested_name(self, memberPointer: bool = False) -> ASTNestedName:
+    def _parse_nested_name(self, member_pointer: bool = False) -> ASTNestedName:
         names: list[ASTNestedNameElement] = []
         templates: list[bool] = []
 
@@ -921,35 +967,37 @@ class DefinitionParser(BaseParser):
             else:
                 template = False
             templates.append(template)
-            identOrOp: ASTIdentifier | ASTOperator | None = None
+            ident_or_op: ASTIdentifier | ASTOperator | None = None
             if self.skip_word_and_ws('operator'):
-                identOrOp = self._parse_operator()
+                ident_or_op = self._parse_operator()
             else:
                 if not self.match(identifier_re):
-                    if memberPointer and len(names) > 0:
+                    if member_pointer and len(names) > 0:
                         templates.pop()
                         break
-                    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)
-                identOrOp = ASTIdentifier(identifier)
+                    self.fail(
+                        'Expected identifier in nested name, '
+                        'got keyword: %s' % identifier
+                    )
+                ident_or_op = ASTIdentifier(identifier)
             # try greedily to get template arguments,
             # but otherwise a < might be because we are in an expression
             pos = self.pos
             try:
-                templateArgs = self._parse_template_argument_list()
+                template_args = self._parse_template_argument_list()
             except DefinitionError as ex:
                 self.pos = pos
-                templateArgs = None
+                template_args = None
                 self.otherErrors.append(ex)
-            names.append(ASTNestedNameElement(identOrOp, templateArgs))
+            names.append(ASTNestedNameElement(ident_or_op, template_args))
 
             self.skip_ws()
             if not self.skip_string('::'):
-                if memberPointer:
+                if member_pointer:
                     self.fail("Expected '::' in pointer to member (function).")
                 break
         return ASTNestedName(names, templates, rooted)
@@ -967,84 +1015,88 @@ class DefinitionParser(BaseParser):
         while self.match(_simple_type_specifiers_re):
             t = self.matched_text
             names.append(t)
-            if t in ('auto', 'void', 'bool',
-                     'char', 'wchar_t', 'char8_t', 'char16_t', 'char32_t',
-                     'int', '__int64', '__int128',
-                     'float', 'double',
-                     '__float80', '_Float64x', '__float128', '_Float128'):
+            if t in {
+                'auto', 'void', 'bool',
+                'char', 'wchar_t', 'char8_t', 'char16_t', 'char32_t',
+                'int', '__int64', '__int128',
+                'float', 'double',
+                '__float80', '_Float64x', '__float128', '_Float128',
+            }:  # fmt: skip
                 if typ is not None:
-                    self.fail(f"Can not have both {t} and {typ}.")
+                    self.fail(f'Can not have both {t} and {typ}.')
                 typ = t
-            elif t in ('signed', 'unsigned'):
+            elif t in {'signed', 'unsigned'}:
                 if signedness is not None:
-                    self.fail(f"Can not have both {t} and {signedness}.")
+                    self.fail(f'Can not have both {t} and {signedness}.')
                 signedness = t
             elif t == 'short':
                 if len(width) != 0:
-                    self.fail(f"Can not have both {t} and {width[0]}.")
+                    self.fail(f'Can not have both {t} and {width[0]}.')
                 width.append(t)
             elif t == 'long':
                 if len(width) != 0 and width[0] != 'long':
-                    self.fail(f"Can not have both {t} and {width[0]}.")
+                    self.fail(f'Can not have both {t} and {width[0]}.')
                 width.append(t)
-            elif t in ('_Imaginary', '_Complex'):
+            elif t in {'_Imaginary', '_Complex'}:
                 if modifier is not None:
-                    self.fail(f"Can not have both {t} and {modifier}.")
+                    self.fail(f'Can not have both {t} and {modifier}.')
                 modifier = t
             self.skip_ws()
         if len(names) == 0:
             return None
 
-        if typ in ('auto', 'void', 'bool',
-                   'wchar_t', 'char8_t', 'char16_t', 'char32_t',
-                   '__float80', '_Float64x', '__float128', '_Float128'):
+        if typ in {
+            'auto', 'void', 'bool',
+            'wchar_t', 'char8_t', 'char16_t', 'char32_t',
+            '__float80', '_Float64x', '__float128', '_Float128',
+        }:  # fmt: skip
             if modifier is not None:
-                self.fail(f"Can not have both {typ} and {modifier}.")
+                self.fail(f'Can not have both {typ} and {modifier}.')
             if signedness is not None:
-                self.fail(f"Can not have both {typ} and {signedness}.")
+                self.fail(f'Can not have both {typ} and {signedness}.')
             if len(width) != 0:
-                self.fail(f"Can not have both {typ} and {' '.join(width)}.")
+                self.fail(f'Can not have both {typ} and {" ".join(width)}.')
         elif typ == 'char':
             if modifier is not None:
-                self.fail(f"Can not have both {typ} and {modifier}.")
+                self.fail(f'Can not have both {typ} and {modifier}.')
             if len(width) != 0:
-                self.fail(f"Can not have both {typ} and {' '.join(width)}.")
+                self.fail(f'Can not have both {typ} and {" ".join(width)}.')
         elif typ == 'int':
             if modifier is not None:
-                self.fail(f"Can not have both {typ} and {modifier}.")
-        elif typ in ('__int64', '__int128'):
+                self.fail(f'Can not have both {typ} and {modifier}.')
+        elif typ in {'__int64', '__int128'}:
             if modifier is not None:
-                self.fail(f"Can not have both {typ} and {modifier}.")
+                self.fail(f'Can not have both {typ} and {modifier}.')
             if len(width) != 0:
-                self.fail(f"Can not have both {typ} and {' '.join(width)}.")
+                self.fail(f'Can not have both {typ} and {" ".join(width)}.')
         elif typ == 'float':
             if signedness is not None:
-                self.fail(f"Can not have both {typ} and {signedness}.")
+                self.fail(f'Can not have both {typ} and {signedness}.')
             if len(width) != 0:
-                self.fail(f"Can not have both {typ} and {' '.join(width)}.")
+                self.fail(f'Can not have both {typ} and {" ".join(width)}.')
         elif typ == 'double':
             if signedness is not None:
-                self.fail(f"Can not have both {typ} and {signedness}.")
+                self.fail(f'Can not have both {typ} and {signedness}.')
             if len(width) > 1:
-                self.fail(f"Can not have both {typ} and {' '.join(width)}.")
+                self.fail(f'Can not have both {typ} and {" ".join(width)}.')
             if len(width) == 1 and width[0] != 'long':
-                self.fail(f"Can not have both {typ} and {' '.join(width)}.")
+                self.fail(f'Can not have both {typ} and {" ".join(width)}.')
         elif typ is None:
             if modifier is not None:
-                self.fail(f"Can not have {modifier} without a floating point type.")
+                self.fail(f'Can not have {modifier} without a floating point type.')
         else:
             msg = f'Unhandled type {typ}'
             raise AssertionError(msg)
 
-        canonNames: list[str] = []
+        canon_names: list[str] = []
         if modifier is not None:
-            canonNames.append(modifier)
+            canon_names.append(modifier)
         if signedness is not None:
-            canonNames.append(signedness)
-        canonNames.extend(width)
+            canon_names.append(signedness)
+        canon_names.extend(width)
         if typ is not None:
-            canonNames.append(typ)
-        return ASTTrailingTypeSpecFundamental(names, canonNames)
+            canon_names.append(typ)
+        return ASTTrailingTypeSpecFundamental(names, canon_names)
 
     def _parse_trailing_type_spec(self) -> ASTTrailingTypeSpec:
         # fundamental types, https://en.cppreference.com/w/cpp/language/type
@@ -1076,29 +1128,35 @@ class DefinitionParser(BaseParser):
             if self.skip_word_and_ws(k):
                 prefix = k
                 break
-        nestedName = self._parse_nested_name()
+        nested_name = self._parse_nested_name()
         self.skip_ws()
-        placeholderType = None
+        placeholder_type = None
         if self.skip_word('auto'):
-            placeholderType = 'auto'
+            placeholder_type = 'auto'
         elif self.skip_word_and_ws('decltype'):
             if not self.skip_string_and_ws('('):
-                self.fail("Expected '(' after 'decltype' in placeholder type specifier.")
+                self.fail(
+                    "Expected '(' after 'decltype' in placeholder type specifier."
+                )
             if not self.skip_word_and_ws('auto'):
-                self.fail("Expected 'auto' after 'decltype(' in placeholder type specifier.")
+                self.fail(
+                    "Expected 'auto' after 'decltype(' in placeholder type specifier."
+                )
             if not self.skip_string_and_ws(')'):
-                self.fail("Expected ')' after 'decltype(auto' in placeholder type specifier.")
-            placeholderType = 'decltype(auto)'
-        return ASTTrailingTypeSpecName(prefix, nestedName, placeholderType)
+                self.fail(
+                    "Expected ')' after 'decltype(auto' in placeholder type specifier."
+                )
+            placeholder_type = 'decltype(auto)'
+        return ASTTrailingTypeSpecName(prefix, nested_name, placeholder_type)
 
     def _parse_parameters_and_qualifiers(
-        self, paramMode: str,
+        self, param_mode: str
     ) -> ASTParametersQualifiers | None:
-        if paramMode == 'new':
+        if param_mode == 'new':
             return None
         self.skip_ws()
         if not self.skip_string('('):
-            if paramMode == 'function':
+            if param_mode == 'function':
                 self.fail('Expecting "(" in parameters-and-qualifiers.')
             else:
                 return None
@@ -1111,8 +1169,9 @@ class DefinitionParser(BaseParser):
                     args.append(ASTFunctionParameter(None, True))
                     self.skip_ws()
                     if not self.skip_string(')'):
-                        self.fail('Expected ")" after "..." in '
-                                  'parameters-and-qualifiers.')
+                        self.fail(
+                            'Expected ")" after "..." in parameters-and-qualifiers.'
+                        )
                     break
                 # note: it seems that function arguments can always be named,
                 # even in function pointers and similar.
@@ -1125,8 +1184,10 @@ class DefinitionParser(BaseParser):
                     continue
                 if self.skip_string(')'):
                     break
-                self.fail('Expecting "," or ")" in parameters-and-qualifiers, '
-                          f'got "{self.current_char}".')
+                self.fail(
+                    'Expecting "," or ")" in parameters-and-qualifiers, '
+                    f'got "{self.current_char}".'
+                )
 
         self.skip_ws()
         const = self.skip_word_and_ws('const')
@@ -1134,13 +1195,13 @@ class DefinitionParser(BaseParser):
         if not const:  # the can be permuted
             const = self.skip_word_and_ws('const')
 
-        refQual = None
+        ref_qual = None
         if self.skip_string('&&'):
-            refQual = '&&'
-        if not refQual and self.skip_string('&'):
-            refQual = '&'
+            ref_qual = '&&'
+        if not ref_qual and self.skip_string('&'):
+            ref_qual = '&'
 
-        exceptionSpec = None
+        exception_spec = None
         self.skip_ws()
         if self.skip_string('noexcept'):
             if self.skip_string_and_ws('('):
@@ -1148,29 +1209,28 @@ class DefinitionParser(BaseParser):
                 self.skip_ws()
                 if not self.skip_string(')'):
                     self.fail("Expecting ')' to end 'noexcept'.")
-                exceptionSpec = ASTNoexceptSpec(expr)
+                exception_spec = ASTNoexceptSpec(expr)
             else:
-                exceptionSpec = ASTNoexceptSpec(None)
+                exception_spec = ASTNoexceptSpec(None)
 
         self.skip_ws()
         if self.skip_string('->'):
-            trailingReturn = self._parse_type(named=False)
+            trailing_return = self._parse_type(named=False)
         else:
-            trailingReturn = None
+            trailing_return = None
 
         self.skip_ws()
         override = self.skip_word_and_ws('override')
         final = self.skip_word_and_ws('final')
         if not override:
-            override = self.skip_word_and_ws(
-                'override')  # they can be permuted
+            override = self.skip_word_and_ws('override')  # they can be permuted
 
         attrs = self._parse_attribute_list()
 
         self.skip_ws()
         initializer = None
         # if this is a function pointer we should not swallow an initializer
-        if paramMode == 'function' and self.skip_string('='):
+        if param_mode == 'function' and self.skip_string('='):
             self.skip_ws()
             valid = ('0', 'delete', 'default')
             for w in valid:
@@ -1179,20 +1239,29 @@ class DefinitionParser(BaseParser):
                     break
             if not initializer:
                 self.fail(
-                    'Expected "%s" in initializer-specifier.'
-                    % '" or "'.join(valid))
+                    'Expected "%s" in initializer-specifier.' % '" or "'.join(valid)
+                )
 
         return ASTParametersQualifiers(
-            args, volatile, const, refQual, exceptionSpec, trailingReturn,
-            override, final, attrs, initializer)
+            args,
+            volatile,
+            const,
+            ref_qual,
+            exception_spec,
+            trailing_return,
+            override,
+            final,
+            attrs,
+            initializer,
+        )
 
     def _parse_decl_specs_simple(self, outer: str, typed: bool) -> ASTDeclSpecsSimple:
         """Just parse the simple ones."""
         storage = None
-        threadLocal = None
+        thread_local = None
         inline = None
         virtual = None
-        explicitSpec = None
+        explicit_spec = None
         consteval = None
         constexpr = None
         constinit = None
@@ -1211,7 +1280,7 @@ class DefinitionParser(BaseParser):
                 if volatile:
                     continue
             if not storage:
-                if outer in ('member', 'function'):
+                if outer in {'member', 'function'}:
                     if self.skip_word('static'):
                         storage = 'static'
                         continue
@@ -1225,12 +1294,12 @@ class DefinitionParser(BaseParser):
                 if self.skip_word('register'):
                     storage = 'register'
                     continue
-            if not inline and outer in ('function', 'member'):
+            if not inline and outer in {'function', 'member'}:
                 inline = self.skip_word('inline')
                 if inline:
                     continue
-            if not constexpr and outer in ('member', 'function'):
-                constexpr = self.skip_word("constexpr")
+            if not constexpr and outer in {'member', 'function'}:
+                constexpr = self.skip_word('constexpr')
                 if constexpr:
                     continue
 
@@ -1239,9 +1308,9 @@ class DefinitionParser(BaseParser):
                     constinit = self.skip_word('constinit')
                     if constinit:
                         continue
-                if not threadLocal:
-                    threadLocal = self.skip_word('thread_local')
-                    if threadLocal:
+                if not thread_local:
+                    thread_local = self.skip_word('thread_local')
+                    if thread_local:
                         continue
             if outer == 'function':
                 if not consteval:
@@ -1256,32 +1325,45 @@ class DefinitionParser(BaseParser):
                     virtual = self.skip_word('virtual')
                     if virtual:
                         continue
-                if not explicitSpec:
+                if not explicit_spec:
                     explicit = self.skip_word_and_ws('explicit')
                     if explicit:
                         expr: ASTExpression = None
                         if self.skip_string('('):
-                            expr = self._parse_constant_expression(inTemplate=False)
+                            expr = self._parse_constant_expression(in_template=False)
                             if not expr:
-                                self.fail("Expected constant expression after '('"
-                                          " in explicit specifier.")
+                                self.fail(
+                                    "Expected constant expression after '('"
+                                    ' in explicit specifier.'
+                                )
                             self.skip_ws()
                             if not self.skip_string(')'):
                                 self.fail("Expected ')' to end explicit specifier.")
-                        explicitSpec = ASTExplicitSpec(expr)
+                        explicit_spec = ASTExplicitSpec(expr)
                         continue
             attr = self._parse_attribute()
             if attr:
                 attrs.append(attr)
                 continue
             break
-        return ASTDeclSpecsSimple(storage, threadLocal, inline, virtual,
-                                  explicitSpec, consteval, constexpr, constinit,
-                                  volatile, const, friend, ASTAttributeList(attrs))
+        return ASTDeclSpecsSimple(
+            storage,
+            thread_local,
+            inline,
+            virtual,
+            explicit_spec,
+            consteval,
+            constexpr,
+            constinit,
+            volatile,
+            const,
+            friend,
+            ASTAttributeList(attrs),
+        )
 
     def _parse_decl_specs(self, outer: str, typed: bool = True) -> ASTDeclSpecs:
         if outer:
-            if outer not in ('type', 'member', 'function', 'templateParam'):
+            if outer not in {'type', 'member', 'function', 'templateParam'}:
                 raise Exception('Internal error, unknown outer "%s".' % outer)
         """
         storage-class-specifier function-specifier "constexpr"
@@ -1296,84 +1378,85 @@ class DefinitionParser(BaseParser):
 
         "constexpr" (only for member_object and function_object)
         """
-        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
     ) -> ASTDeclaratorNameParamQual | ASTDeclaratorNameBitField:
         # now we should parse the name, and then suffixes
         if named == 'maybe':
             pos = self.pos
             try:
-                declId = self._parse_nested_name()
+                decl_id = self._parse_nested_name()
             except DefinitionError:
                 self.pos = pos
-                declId = None
+                decl_id = None
         elif named == 'single':
             if self.match(identifier_re):
                 identifier = ASTIdentifier(self.matched_text)
                 nne = ASTNestedNameElement(identifier, None)
-                declId = ASTNestedName([nne], [False], rooted=False)
+                decl_id = ASTNestedName([nne], [False], rooted=False)
                 # if it's a member pointer, we may have '::', which should be an error
                 self.skip_ws()
                 if self.current_char == ':':
                     self.fail("Unexpected ':' after identifier.")
             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('['):
                 self.skip_ws()
                 if self.skip_string(']'):
-                    arrayOps.append(ASTArray(None))
+                    array_ops.append(ASTArray(None))
                     continue
 
                 def parser() -> ASTExpression:
                     return self._parse_expression()
+
                 value = self._parse_expression_fallback([']'], parser)
                 if not self.skip_string(']'):
                     self.fail("Expected ']' in end of array operator.")
-                arrayOps.append(ASTArray(value))
+                array_ops.append(ASTArray(value))
                 continue
             break
-        paramQual = self._parse_parameters_and_qualifiers(paramMode)
-        if paramQual is None and len(arrayOps) == 0:
+        param_qual = self._parse_parameters_and_qualifiers(param_mode)
+        if param_qual 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(inTemplate=False)
-                    return ASTDeclaratorNameBitField(declId=declId, size=size)
-        return ASTDeclaratorNameParamQual(declId=declId, arrayOps=arrayOps,
-                                          paramQual=paramQual)
-
-    def _parse_declarator(self, named: bool | str, paramMode: str,
-                          typed: bool = True,
-                          ) -> ASTDeclarator:
+                    size = self._parse_constant_expression(in_template=False)
+                    return ASTDeclaratorNameBitField(declId=decl_id, size=size)
+        return ASTDeclaratorNameParamQual(
+            declId=decl_id, arrayOps=array_ops, paramQual=param_qual
+        )
+
+    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', 'operatorCast', 'new'):
-            raise Exception(
-                "Internal error, unknown paramMode '%s'." % paramMode)
-        prevErrors = []
+        if param_mode not in {'type', 'function', 'operatorCast', 'new'}:
+            raise Exception("Internal error, unknown param_mode '%s'." % param_mode)
+        prev_errors = []
         self.skip_ws()
         if typed and self.skip_string('*'):
             self.skip_ws()
             volatile = False
             const = False
-            attrList = []
+            attr_list = []
             while 1:
                 if not volatile:
                     volatile = self.skip_word_and_ws('volatile')
@@ -1385,37 +1468,43 @@ class DefinitionParser(BaseParser):
                         continue
                 attr = self._parse_attribute()
                 if attr is not None:
-                    attrList.append(attr)
+                    attr_list.append(attr)
                     continue
                 break
-            next = self._parse_declarator(named, paramMode, typed)
-            return ASTDeclaratorPtr(next=next, volatile=volatile, const=const,
-                                    attrs=ASTAttributeList(attrList))
+            next = self._parse_declarator(named, param_mode, typed)
+            return ASTDeclaratorPtr(
+                next=next,
+                volatile=volatile,
+                const=const,
+                attrs=ASTAttributeList(attr_list),
+            )
         # TODO: shouldn't we parse an R-value ref here first?
-        if typed and self.skip_string("&"):
+        if typed and self.skip_string('&'):
             attrs = self._parse_attribute_list()
-            next = self._parse_declarator(named, paramMode, typed)
+            next = self._parse_declarator(named, param_mode, typed)
             return ASTDeclaratorRef(next=next, attrs=attrs)
-        if typed and self.skip_string("..."):
-            next = self._parse_declarator(named, paramMode, False)
+        if typed and self.skip_string('...'):
+            next = self._parse_declarator(named, param_mode, False)
             return ASTDeclaratorParamPack(next=next)
         if typed and self.current_char == '(':  # note: peeking, not skipping
-            if paramMode == "operatorCast":
+            if param_mode == 'operatorCast':
                 # TODO: we should be able to parse cast operators which return
                 # function pointers. For now, just hax it and ignore.
-                return ASTDeclaratorNameParamQual(declId=None, arrayOps=[],
-                                                  paramQual=None)
+                return ASTDeclaratorNameParamQual(
+                    declId=None, arrayOps=[], paramQual=None
+                )
             # maybe this is the beginning of params and quals,try that first,
             # otherwise assume it's noptr->declarator > ( ptr-declarator )
             pos = self.pos
             try:
                 # assume this is params and quals
-                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:
-                prevErrors.append((exParamQual,
-                                   "If declarator-id with parameters-and-qualifiers"))
+            except DefinitionError as ex_param_qual:
+                prev_errors.append((
+                    ex_param_qual,
+                    'If declarator-id with parameters-and-qualifiers',
+                ))
                 self.pos = pos
                 try:
                     assert self.current_char == '('
@@ -1423,29 +1512,34 @@ 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 be
                     #       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
-                    prevErrors.append((exNoPtrParen, "If parenthesis in noptr-declarator"))
-                    header = "Error in declarator"
-                    raise self._make_multi_error(prevErrors, header) from exNoPtrParen
+                    prev_errors.append((
+                        ex_no_ptr_paren,
+                        'If parenthesis in noptr-declarator',
+                    ))
+                    header = 'Error in declarator'
+                    raise self._make_multi_error(
+                        prev_errors, header
+                    ) from ex_no_ptr_paren
         if typed:  # pointer to member
             pos = self.pos
             try:
-                name = self._parse_nested_name(memberPointer=True)
+                name = self._parse_nested_name(member_pointer=True)
                 self.skip_ws()
                 if not self.skip_string('*'):
                     self.fail("Expected '*' in pointer to member declarator.")
                 self.skip_ws()
             except DefinitionError as e:
                 self.pos = pos
-                prevErrors.append((e, "If pointer to member declarator"))
+                prev_errors.append((e, 'If pointer to member declarator'))
             else:
                 volatile = False
                 const = False
@@ -1459,24 +1553,25 @@ class DefinitionParser(BaseParser):
                         if const:
                             continue
                     break
-                next = self._parse_declarator(named, paramMode, typed)
+                next = self._parse_declarator(named, param_mode, typed)
                 return ASTDeclaratorMemPtr(name, const, volatile, next=next)
         pos = self.pos
         try:
-            res = self._parse_declarator_name_suffix(named, paramMode, typed)
+            res = self._parse_declarator_name_suffix(named, param_mode, typed)
             # this is a heuristic for error messages, for when there is a < after a
             # nested name, but it was not a successful template argument list
             if self.current_char == '<':
-                self.otherErrors.append(self._make_multi_error(prevErrors, ""))
+                self.otherErrors.append(self._make_multi_error(prev_errors, ''))
             return res
         except DefinitionError as e:
             self.pos = pos
-            prevErrors.append((e, "If declarator-id"))
-            header = "Error in declarator or parameters-and-qualifiers"
-            raise self._make_multi_error(prevErrors, header) from e
+            prev_errors.append((e, 'If declarator-id'))
+            header = 'Error in declarator or parameters-and-qualifiers'
+            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:
         # initializer                           # global vars
         # -> brace-or-equal-initializer
         #  | '(' expression-list ')'
@@ -1496,143 +1591,151 @@ class DefinitionParser(BaseParser):
         #  | '=' braced-init-list
         self.skip_ws()
         if outer == 'member':
-            bracedInit = self._parse_braced_init_list()
-            if bracedInit is not None:
-                return ASTInitializer(bracedInit, hasAssign=False)
+            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 == 'templateParam':
-            fallbackEnd = [',', '>']
+            fallback_end = [',', '>']
         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
+            )
 
-        inTemplate = outer == 'templateParam'
+        in_template = outer == 'templateParam'
 
         def parser() -> ASTExpression:
-            return self._parse_assignment_expression(inTemplate=inTemplate)
-        value = self._parse_expression_fallback(fallbackEnd, parser, allow=allowFallback)
+            return self._parse_assignment_expression(in_template=in_template)
+
+        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|'maybe'|True: 'maybe' is e.g., for function objects which
+        """named=False|'maybe'|True: 'maybe' is e.g., for function objects which
         doesn't need to name the arguments
 
         outer == operatorCast: annoying case, we should not take the params
         """
         if outer:  # always named
-            if outer not in ('type', 'member', 'function',
-                             'operatorCast', 'templateParam'):
+            if outer not in {
+                'type',
+                'member',
+                'function',
+                'operatorCast',
+                'templateParam',
+            }:
                 raise Exception('Internal error, unknown outer "%s".' % outer)
             if outer != 'operatorCast':
                 assert named
-        if outer in ('type', 'function'):
+        if outer in {'type', 'function'}:
             # We allow type objects to just be a name.
             # Some functions don't have normal return types: constructors,
             # destructors, cast operators
-            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)
-                mustEnd = True
+                decl_specs = self._parse_decl_specs(outer=outer, typed=False)
+                decl = self._parse_declarator(named=True, param_mode=outer, typed=False)
+                must_end = True
                 if outer == 'function':
                     # Allow trailing requires on functions.
                     self.skip_ws()
                     if re.compile(r'requires\b').match(self.definition, self.pos):
-                        mustEnd = False
-                if mustEnd:
+                        must_end = False
+                if must_end:
                     self.assert_end(allowSemicolon=True)
-            except DefinitionError as exUntyped:
+            except DefinitionError as ex_untyped:
                 if outer == 'type':
-                    desc = "If just a name"
+                    desc = 'If just a name'
                 elif outer == 'function':
-                    desc = "If the function has no return type"
+                    desc = 'If the function has no return type'
                 else:
-                    raise AssertionError from exUntyped
-                prevErrors.append((exUntyped, desc))
-                self.pos = startPos
+                    raise AssertionError from ex_untyped
+                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
+                    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
                     if outer == 'type':
-                        desc = "If typedef-like declaration"
+                        desc = 'If typedef-like declaration'
                     elif outer == 'function':
-                        desc = "If the function has a return type"
+                        desc = 'If the function has a return type'
                     else:
-                        raise AssertionError from exUntyped
-                    prevErrors.append((exTyped, desc))
+                        raise AssertionError from ex_untyped
+                    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:
                         if outer == 'type':
-                            header = "Type must be either just a name or a "
-                            header += "typedef-like declaration."
+                            header = 'Type must be either just a name or a '
+                            header += 'typedef-like declaration.'
                         elif outer == 'function':
-                            header = "Error when parsing function declaration."
+                            header = 'Error when parsing function declaration.'
                         else:
-                            raise AssertionError from exUntyped
-                        raise self._make_multi_error(prevErrors, header) from exTyped
-                    else:  # NoQA: RET506
+                            raise AssertionError from ex_untyped
+                        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
+                        )
         else:
-            paramMode = 'type'
+            param_mode = 'type'
             if outer == 'member':
                 named = True
             elif outer == 'operatorCast':
-                paramMode = 'operatorCast'
+                param_mode = 'operatorCast'
                 outer = None
             elif outer == 'templateParam':
                 named = 'single'
-            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) -> ASTTypeWithInit | ASTTemplateParamConstrainedTypeWithInit:
+        self, named: bool | str, outer: str
+    ) -> ASTTypeWithInit | ASTTemplateParamConstrainedTypeWithInit:
         if outer:
-            assert outer in ('type', 'member', 'function', 'templateParam')
+            assert outer in {'type', 'member', 'function', 'templateParam'}
         type = self._parse_type(outer=outer, named=named)
         if outer != 'templateParam':
             init = self._parse_initializer(outer=outer)
             return ASTTypeWithInit(type, init)
         # it could also be a constrained type parameter, e.g., C T = int&
         pos = self.pos
-        eExpr = None
+        e_expr = None
         try:
-            init = self._parse_initializer(outer=outer, allowFallback=False)
+            init = self._parse_initializer(outer=outer, allow_fallback=False)
             # note: init may be None if there is no =
             if init is None:
                 return ASTTypeWithInit(type, None)
             # we parsed an expression, so we must have a , or a >,
             # otherwise the expression didn't get everything
             self.skip_ws()
-            if self.current_char != ',' and self.current_char != '>':
+            if self.current_char not in {',', '>'}:
                 # pretend it didn't happen
                 self.pos = pos
                 init = None
@@ -1641,21 +1744,22 @@ class DefinitionParser(BaseParser):
                 return ASTTypeWithInit(type, init)
         except DefinitionError as e:
             self.pos = pos
-            eExpr = e
-        if not self.skip_string("="):
+            e_expr = e
+        if not self.skip_string('='):
             return ASTTypeWithInit(type, None)
         try:
-            typeInit = self._parse_type(named=False, outer=None)
-            return ASTTemplateParamConstrainedTypeWithInit(type, typeInit)
-        except DefinitionError as eType:
-            if eExpr is None:
+            type_init = self._parse_type(named=False, outer=None)
+            return ASTTemplateParamConstrainedTypeWithInit(type, type_init)
+        except DefinitionError as e_type:
+            if e_expr is None:
                 raise
-            errs = []
-            errs.append((eExpr, "If default template argument is an expression"))
-            errs.append((eType, "If default template argument is a type"))
-            msg = "Error in non-type template parameter"
-            msg += " or constrained template parameter."
-            raise self._make_multi_error(errs, msg) from eType
+            errs = [
+                (e_expr, 'If default template argument is an expression'),
+                (e_type, 'If default template argument is a type'),
+            ]
+            msg = 'Error in non-type template parameter'
+            msg += ' or constrained template parameter.'
+            raise self._make_multi_error(errs, msg) from e_type
 
     def _parse_type_using(self) -> ASTTypeUsing:
         name = self._parse_nested_name()
@@ -1666,10 +1770,10 @@ class DefinitionParser(BaseParser):
         return ASTTypeUsing(name, type)
 
     def _parse_concept(self) -> ASTConcept:
-        nestedName = self._parse_nested_name()
+        nested_name = self._parse_nested_name()
         self.skip_ws()
         initializer = self._parse_initializer('member')
-        return ASTConcept(nestedName, initializer)
+        return ASTConcept(nested_name, initializer)
 
     def _parse_class(self) -> ASTClass:
         attrs = self._parse_attribute_list()
@@ -1691,10 +1795,10 @@ class DefinitionParser(BaseParser):
                     self.skip_ws()
                 if not virtual and self.skip_word_and_ws('virtual'):
                     virtual = True
-                baseName = self._parse_nested_name()
+                base_name = self._parse_nested_name()
                 self.skip_ws()
                 pack = self.skip_string('...')
-                bases.append(ASTBaseClass(baseName, visibility, virtual, pack))
+                bases.append(ASTBaseClass(base_name, visibility, virtual, pack))
                 self.skip_ws()
                 if self.skip_string(','):
                     continue
@@ -1711,10 +1815,10 @@ class DefinitionParser(BaseParser):
         attrs = self._parse_attribute_list()
         name = self._parse_nested_name()
         self.skip_ws()
-        underlyingType = None
+        underlying_type = None
         if self.skip_string(':'):
-            underlyingType = self._parse_type(named=False)
-        return ASTEnum(name, scoped, underlyingType, attrs)
+            underlying_type = self._parse_type(named=False)
+        return ASTEnum(name, scoped, underlying_type, attrs)
 
     def _parse_enumerator(self) -> ASTEnumerator:
         name = self._parse_nested_name()
@@ -1725,9 +1829,10 @@ class DefinitionParser(BaseParser):
             self.skip_ws()
 
             def parser() -> ASTExpression:
-                return self._parse_constant_expression(inTemplate=False)
-            initVal = self._parse_expression_fallback([], parser)
-            init = ASTInitializer(initVal)
+                return self._parse_constant_expression(in_template=False)
+
+            init_val = self._parse_expression_fallback([], parser)
+            init = ASTInitializer(init_val)
         return ASTEnumerator(name, init, attrs)
 
     # ==========================================================================
@@ -1736,9 +1841,9 @@ class DefinitionParser(BaseParser):
         self.skip_ws()
         if self.skip_word('template'):
             # declare a template template parameter
-            nestedParams = self._parse_template_parameter_list()
+            nested_params = self._parse_template_parameter_list()
         else:
-            nestedParams = None
+            nested_params = None
 
         pos = self.pos
         try:
@@ -1749,83 +1854,93 @@ class DefinitionParser(BaseParser):
                 key = 'typename'
             elif self.skip_word_and_ws('class'):
                 key = 'class'
-            elif nestedParams:
-                self.fail("Expected 'typename' or 'class' after "
-                          "template template parameter list.")
+            elif nested_params:
+                self.fail(
+                    "Expected 'typename' or 'class' after "
+                    'template template parameter list.'
+                )
             else:
-                self.fail("Expected 'typename' or 'class' in the "
-                          "beginning of template type parameter.")
+                self.fail(
+                    "Expected 'typename' or 'class' in the "
+                    'beginning of template type parameter.'
+                )
             self.skip_ws()
-            parameterPack = self.skip_string('...')
+            parameter_pack = self.skip_string('...')
             self.skip_ws()
             if self.match(identifier_re):
                 identifier = ASTIdentifier(self.matched_text)
             else:
                 identifier = None
             self.skip_ws()
-            if not parameterPack and self.skip_string('='):
+            if not parameter_pack and self.skip_string('='):
                 default = self._parse_type(named=False, outer=None)
             else:
                 default = None
                 if self.current_char not in ',>':
                     self.fail('Expected "," or ">" after (template) type parameter.')
-            data = ASTTemplateKeyParamPackIdDefault(key, identifier,
-                                                    parameterPack, default)
-            if nestedParams:
-                return ASTTemplateParamTemplateType(nestedParams, data)
+            data = ASTTemplateKeyParamPackIdDefault(
+                key, identifier, parameter_pack, default
+            )
+            if nested_params:
+                return ASTTemplateParamTemplateType(nested_params, data)
             else:
                 return ASTTemplateParamType(data)
-        except DefinitionError as eType:
-            if nestedParams:
+        except DefinitionError as e_type:
+            if nested_params:
                 raise
             try:
                 # non-type parameter or constrained type parameter
                 self.pos = pos
                 param = self._parse_type_with_init('maybe', 'templateParam')
                 self.skip_ws()
-                parameterPack = self.skip_string('...')
-                return ASTTemplateParamNonType(param, parameterPack)
-            except DefinitionError as eNonType:
+                parameter_pack = self.skip_string('...')
+                return ASTTemplateParamNonType(param, parameter_pack)
+            except DefinitionError as e_non_type:
                 self.pos = pos
-                header = "Error when parsing template parameter."
-                errs = []
-                errs.append(
-                    (eType, "If unconstrained type parameter or template type parameter"))
-                errs.append(
-                    (eNonType, "If constrained type parameter or non-type parameter"))
+                header = 'Error when parsing template parameter.'
+                errs = [
+                    (
+                        e_type,
+                        'If unconstrained type parameter or template type parameter',
+                    ),
+                    (
+                        e_non_type,
+                        'If constrained type parameter or non-type parameter',
+                    ),
+                ]
                 raise self._make_multi_error(errs, header) from None
 
     def _parse_template_parameter_list(self) -> ASTTemplateParams:
         # only: '<' parameter-list '>'
         # we assume that 'template' has just been parsed
-        templateParams: list[ASTTemplateParam] = []
+        template_params: list[ASTTemplateParam] = []
         self.skip_ws()
-        if not self.skip_string("<"):
+        if not self.skip_string('<'):
             self.fail("Expected '<' after 'template'")
-        while 1:
+        while True:
             pos = self.pos
             err = None
             try:
                 param = self._parse_template_parameter()
-                templateParams.append(param)
-            except DefinitionError as eParam:
+                template_params.append(param)
+            except DefinitionError as e_param:
                 self.pos = pos
-                err = eParam
+                err = e_param
             self.skip_ws()
             if self.skip_string('>'):
-                requiresClause = self._parse_requires_clause()
-                return ASTTemplateParams(templateParams, requiresClause)
+                requires_clause = self._parse_requires_clause()
+                return ASTTemplateParams(template_params, requires_clause)
             elif self.skip_string(','):
                 continue
             else:
-                header = "Error in template parameter list."
+                header = 'Error in template parameter list.'
                 errs = []
                 if err:
-                    errs.append((err, "If parameter"))
+                    errs.append((err, 'If parameter'))
                 try:
                     self.fail('Expected "," or ">".')
                 except DefinitionError as e:
-                    errs.append((e, "If no parameter"))
+                    errs.append((e, 'If no parameter'))
                 logger.debug(errs)
                 raise self._make_multi_error(errs, header)
 
@@ -1845,17 +1960,19 @@ class DefinitionParser(BaseParser):
         params = []
         while 1:
             self.skip_ws()
-            parameterPack = self.skip_string('...')
+            parameter_pack = self.skip_string('...')
             self.skip_ws()
             if not self.match(identifier_re):
-                self.fail("Expected identifier in template introduction list.")
+                self.fail('Expected identifier in template introduction list.')
             txt_identifier = self.matched_text
             # make sure there isn't a keyword
             if txt_identifier in _keywords:
-                self.fail("Expected identifier in template introduction list, "
-                          "got keyword: %s" % txt_identifier)
+                self.fail(
+                    'Expected identifier in template introduction list, '
+                    'got keyword: %s' % txt_identifier
+                )
             identifier = ASTIdentifier(txt_identifier)
-            params.append(ASTTemplateIntroductionParameter(identifier, parameterPack))
+            params.append(ASTTemplateIntroductionParameter(identifier, parameter_pack))
 
             self.skip_ws()
             if self.skip_string('}'):
@@ -1878,148 +1995,176 @@ class DefinitionParser(BaseParser):
             return None
 
         def parse_and_expr(self: DefinitionParser) -> ASTExpression:
-            andExprs = []
+            and_exprs = []
             ops = []
-            andExprs.append(self._parse_primary_expression())
+            and_exprs.append(self._parse_primary_expression())
             while True:
                 self.skip_ws()
-                oneMore = False
+                one_more = False
                 if self.skip_string('&&'):
-                    oneMore = True
+                    one_more = True
                     ops.append('&&')
                 elif self.skip_word('and'):
-                    oneMore = True
+                    one_more = True
                     ops.append('and')
-                if not oneMore:
+                if not one_more:
                     break
-                andExprs.append(self._parse_primary_expression())
-            if len(andExprs) == 1:
-                return andExprs[0]
+                and_exprs.append(self._parse_primary_expression())
+            if len(and_exprs) == 1:
+                return and_exprs[0]
             else:
-                return ASTBinOpExpr(andExprs, ops)
+                return ASTBinOpExpr(and_exprs, ops)
 
-        orExprs = []
+        or_exprs = []
         ops = []
-        orExprs.append(parse_and_expr(self))
+        or_exprs.append(parse_and_expr(self))
         while True:
             self.skip_ws()
-            oneMore = False
+            one_more = False
             if self.skip_string('||'):
-                oneMore = True
+                one_more = True
                 ops.append('||')
             elif self.skip_word('or'):
-                oneMore = True
+                one_more = True
                 ops.append('or')
-            if not oneMore:
+            if not one_more:
                 break
-            orExprs.append(parse_and_expr(self))
-        if len(orExprs) == 1:
-            return ASTRequiresClause(orExprs[0])
+            or_exprs.append(parse_and_expr(self))
+        if len(or_exprs) == 1:
+            return ASTRequiresClause(or_exprs[0])
         else:
-            return ASTRequiresClause(ASTBinOpExpr(orExprs, ops))
+            return ASTRequiresClause(ASTBinOpExpr(or_exprs, ops))
 
-    def _parse_template_declaration_prefix(self, objectType: str,
-                                           ) -> ASTTemplateDeclarationPrefix | None:
+    def _parse_template_declaration_prefix(
+        self, object_type: str
+    ) -> ASTTemplateDeclarationPrefix | None:
         templates: list[ASTTemplateParams | ASTTemplateIntroduction] = []
         while 1:
             self.skip_ws()
             # the saved position is only used to provide a better error message
             params: ASTTemplateParams | ASTTemplateIntroduction | None = None
             pos = self.pos
-            if self.skip_word("template"):
+            if self.skip_word('template'):
                 try:
                     params = self._parse_template_parameter_list()
                 except DefinitionError as e:
-                    if objectType == 'member' and len(templates) == 0:
+                    if object_type == 'member' and len(templates) == 0:
                         return ASTTemplateDeclarationPrefix(None)
                     else:
-                        raise e
-                if objectType == 'concept' and params.requiresClause is not None:
+                        raise
+                if object_type == 'concept' and params.requiresClause is not None:
                     self.fail('requires-clause not allowed for concept')
             else:
                 params = self._parse_template_introduction()
                 if not params:
                     break
-            if objectType == 'concept' and len(templates) > 0:
+            if object_type == 'concept' and len(templates) > 0:
                 self.pos = pos
-                self.fail("More than 1 template parameter list for concept.")
+                self.fail('More than 1 template parameter list for concept.')
             templates.append(params)
-        if len(templates) == 0 and objectType == 'concept':
+        if len(templates) == 0 and object_type == 'concept':
             self.fail('Missing template parameter list for concept.')
         if len(templates) == 0:
             return None
         else:
             return ASTTemplateDeclarationPrefix(templates)
 
-    def _check_template_consistency(self, nestedName: ASTNestedName,
-                                    templatePrefix: ASTTemplateDeclarationPrefix,
-                                    fullSpecShorthand: bool, isMember: bool = False,
-                                    ) -> ASTTemplateDeclarationPrefix:
-        numArgs = nestedName.num_templates()
-        isMemberInstantiation = False
-        if not templatePrefix:
-            numParams = 0
+    def _check_template_consistency(
+        self,
+        nested_name: ASTNestedName,
+        template_prefix: ASTTemplateDeclarationPrefix,
+        full_spec_shorthand: bool,
+        is_member: bool = False,
+    ) -> ASTTemplateDeclarationPrefix:
+        num_args = nested_name.num_templates()
+        is_member_instantiation = False
+        if not template_prefix:
+            num_params = 0
         else:
-            if isMember and templatePrefix.templates is None:
-                numParams = 0
-                isMemberInstantiation = True
+            if is_member and template_prefix.templates is None:
+                num_params = 0
+                is_member_instantiation = True
             else:
-                numParams = len(templatePrefix.templates)
-        if numArgs + 1 < numParams:
-            self.fail("Too few template argument lists compared to parameter"
-                      " lists. Argument lists: %d, Parameter lists: %d."
-                      % (numArgs, numParams))
-        if numArgs > numParams:
-            numExtra = numArgs - numParams
-            if not fullSpecShorthand and not isMemberInstantiation:
+                num_params = len(template_prefix.templates)
+        if num_args + 1 < num_params:
+            self.fail(
+                'Too few template argument lists compared to parameter'
+                ' lists. Argument lists: %d, Parameter lists: %d.'
+                % (num_args, num_params)
+            )
+        if num_args > num_params:
+            num_extra = num_args - num_params
+            if not full_spec_shorthand and not is_member_instantiation:
                 msg = (
                     f'Too many template argument lists compared to parameter lists. '
-                    f'Argument lists: {numArgs:d}, Parameter lists: {numParams:d}, '
-                    f'Extra empty parameters lists prepended: {numExtra:d}. '
+                    f'Argument lists: {num_args:d}, Parameter lists: {num_params:d}, '
+                    f'Extra empty parameters lists prepended: {num_extra:d}. '
                     'Declaration:\n\t'
                 )
-                if templatePrefix:
-                    msg += f"{templatePrefix}\n\t"
-                msg += str(nestedName)
+                if template_prefix:
+                    msg += f'{template_prefix}\n\t'
+                msg += str(nested_name)
                 self.warn(msg)
 
-            newTemplates: list[ASTTemplateParams | ASTTemplateIntroduction] = [
-                ASTTemplateParams([], requiresClause=None)
-                for _i in range(numExtra)
+            new_templates: list[ASTTemplateParams | ASTTemplateIntroduction] = [
+                ASTTemplateParams([], requiresClause=None) for _i in range(num_extra)
             ]
-            if templatePrefix and not isMemberInstantiation:
-                newTemplates.extend(templatePrefix.templates)
-            templatePrefix = ASTTemplateDeclarationPrefix(newTemplates)
-        return templatePrefix
+            if template_prefix and not is_member_instantiation:
+                new_templates.extend(template_prefix.templates)
+            template_prefix = ASTTemplateDeclarationPrefix(new_templates)
+        return template_prefix
 
     def parse_declaration(self, objectType: str, directiveType: str) -> ASTDeclaration:
-        if objectType not in ('class', 'union', 'function', 'member', 'type',
-                              'concept', 'enum', 'enumerator'):
-            raise Exception('Internal error, unknown objectType "%s".' % objectType)
-        if directiveType not in ('class', 'struct', 'union', 'function', 'member', 'var',
-                                 'type', 'concept',
-                                 'enum', 'enum-struct', 'enum-class', 'enumerator'):
-            raise Exception('Internal error, unknown directiveType "%s".' % directiveType)
+        object_type = objectType
+        directive_type = directiveType
+        if object_type not in {
+            'class',
+            'union',
+            'function',
+            'member',
+            'type',
+            'concept',
+            'enum',
+            'enumerator',
+        }:
+            raise Exception('Internal error, unknown objectType "%s".' % object_type)
+        if directive_type not in {
+            'class',
+            'struct',
+            'union',
+            'function',
+            'member',
+            'var',
+            'type',
+            'concept',
+            'enum',
+            'enum-struct',
+            'enum-class',
+            'enumerator',
+        }:
+            raise Exception(
+                'Internal error, unknown directiveType "%s".' % directive_type
+            )
         visibility = None
-        templatePrefix = None
-        trailingRequiresClause = None
+        template_prefix = None
+        trailing_requires_clause = None
         declaration: Any = None
 
         self.skip_ws()
         if self.match(_visibility_re):
             visibility = self.matched_text
 
-        if objectType in ('type', 'concept', 'member', 'function', 'class', 'union'):
-            templatePrefix = self._parse_template_declaration_prefix(objectType)
+        if object_type in {'type', 'concept', 'member', 'function', 'class', 'union'}:
+            template_prefix = self._parse_template_declaration_prefix(object_type)
 
-        if objectType == 'type':
-            prevErrors = []
+        if object_type == 'type':
+            prev_errors = []
             pos = self.pos
             try:
-                if not templatePrefix:
+                if not template_prefix:
                     declaration = self._parse_type(named=True, outer='type')
             except DefinitionError as e:
-                prevErrors.append((e, "If typedef-like declaration"))
+                prev_errors.append((e, 'If typedef-like declaration'))
                 self.pos = pos
             pos = self.pos
             try:
@@ -2027,57 +2172,71 @@ class DefinitionParser(BaseParser):
                     declaration = self._parse_type_using()
             except DefinitionError as e:
                 self.pos = pos
-                prevErrors.append((e, "If type alias or template alias"))
-                header = "Error in type declaration."
-                raise self._make_multi_error(prevErrors, header) from e
-        elif objectType == 'concept':
+                prev_errors.append((e, 'If type alias or template alias'))
+                header = 'Error in type declaration.'
+                raise self._make_multi_error(prev_errors, header) from e
+        elif object_type == 'concept':
             declaration = self._parse_concept()
-        elif objectType == 'member':
+        elif 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')
-            trailingRequiresClause = self._parse_requires_clause()
-        elif objectType == 'class':
+            trailing_requires_clause = self._parse_requires_clause()
+        elif object_type == 'class':
             declaration = self._parse_class()
-        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()
         else:
             raise AssertionError
-        templatePrefix = self._check_template_consistency(declaration.name,
-                                                          templatePrefix,
-                                                          fullSpecShorthand=False,
-                                                          isMember=objectType == 'member')
+        template_prefix = self._check_template_consistency(
+            declaration.name,
+            template_prefix,
+            full_spec_shorthand=False,
+            is_member=object_type == 'member',
+        )
         self.skip_ws()
         semicolon = self.skip_string(';')
-        return ASTDeclaration(objectType, directiveType, visibility,
-                              templatePrefix, declaration,
-                              trailingRequiresClause, semicolon)
+        return ASTDeclaration(
+            object_type,
+            directive_type,
+            visibility,
+            template_prefix,
+            declaration,
+            trailing_requires_clause,
+            semicolon,
+        )
 
     def parse_namespace_object(self) -> ASTNamespace:
-        templatePrefix = self._parse_template_declaration_prefix(objectType="namespace")
+        template_prefix = self._parse_template_declaration_prefix(
+            object_type='namespace'
+        )
         name = self._parse_nested_name()
-        templatePrefix = self._check_template_consistency(name, templatePrefix,
-                                                          fullSpecShorthand=False)
-        res = ASTNamespace(name, templatePrefix)
+        template_prefix = self._check_template_consistency(
+            name, template_prefix, full_spec_shorthand=False
+        )
+        res = ASTNamespace(name, template_prefix)
         res.objectType = 'namespace'  # type: ignore[attr-defined]
         return res
 
     def parse_xref_object(self) -> tuple[ASTNamespace | ASTDeclaration, bool]:
         pos = self.pos
         try:
-            templatePrefix = self._parse_template_declaration_prefix(objectType="xref")
+            template_prefix = self._parse_template_declaration_prefix(
+                object_type='xref'
+            )
             name = self._parse_nested_name()
             # if there are '()' left, just skip them
             self.skip_ws()
             self.skip_string('()')
             self.assert_end()
-            templatePrefix = self._check_template_consistency(name, templatePrefix,
-                                                              fullSpecShorthand=True)
-            res1 = ASTNamespace(name, templatePrefix)
+            template_prefix = self._check_template_consistency(
+                name, template_prefix, full_spec_shorthand=True
+            )
+            res1 = ASTNamespace(name, template_prefix)
             res1.objectType = 'xref'  # type: ignore[attr-defined]
             return res1, True
         except DefinitionError as e1:
@@ -2090,10 +2249,11 @@ class DefinitionParser(BaseParser):
                 self.assert_end()
                 return res2, False
             except DefinitionError as e2:
-                errs = []
-                errs.append((e1, "If shorthand ref"))
-                errs.append((e2, "If full function ref"))
-                msg = "Error in cross-reference."
+                errs = [
+                    (e1, 'If shorthand ref'),
+                    (e2, 'If full function ref'),
+                ]
+                msg = 'Error in cross-reference.'
                 raise self._make_multi_error(errs, msg) from e2
 
     def parse_expression(self) -> ASTExpression | ASTType:
@@ -2103,16 +2263,14 @@ class DefinitionParser(BaseParser):
             self.skip_ws()
             self.assert_end()
             return expr
-        except DefinitionError as exExpr:
+        except DefinitionError as ex_expr:
             self.pos = pos
             try:
                 typ = self._parse_type(False)
                 self.skip_ws()
                 self.assert_end()
                 return typ
-            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