From 8bc797b6354794f3db409b253e87cb33b4e19395 Mon Sep 17 00:00:00 2001 From: Adam Turner <9087854+aa-turner@users.noreply.github.com> Date: Fri, 6 Dec 2024 14:42:55 +0000 Subject: [PATCH] Avoid using camelCase names in sphinx.domains.c --- sphinx/domains/c/_ast.py | 72 +++++----- sphinx/domains/c/_parser.py | 274 ++++++++++++++++++------------------ 2 files changed, 174 insertions(+), 172 deletions(-) diff --git a/sphinx/domains/c/_ast.py b/sphinx/domains/c/_ast.py index 14b89c477..5a7640c8b 100644 --- a/sphinx/domains/c/_ast.py +++ b/sphinx/domains/c/_ast.py @@ -80,18 +80,18 @@ class ASTIdentifier(ASTBaseBase): else: node = addnodes.desc_sig_name(self.name, self.name) if mode == 'markType': - targetText = prefix + self.name + target_text = prefix + self.name pnode = addnodes.pending_xref('', refdomain='c', reftype='identifier', - reftarget=targetText, modname=None, + reftarget=target_text, modname=None, classname=None) pnode['c:parent_key'] = symbol.get_lookup_key() pnode += node signode += pnode elif mode == 'lastIsName': - nameNode = addnodes.desc_name() - nameNode += node - signode += nameNode + name_node = addnodes.desc_name() + name_node += node + signode += name_node elif mode == 'noneIsName': signode += node else: @@ -952,9 +952,9 @@ class ASTDeclSpecsSimple(ASTBaseBase): if len(modifiers) != 0 and len(self.attrs) != 0: modifiers.append(addnodes.desc_sig_space()) - tempNode = nodes.TextElement() - self.attrs.describe_signature(tempNode) - modifiers.extend(tempNode.children) + temp_node = nodes.TextElement() + self.attrs.describe_signature(temp_node) + modifiers.extend(temp_node.children) if self.storage: _add(modifiers, self.storage) if self.threadLocal: @@ -1097,26 +1097,26 @@ class ASTArray(ASTBase): env: BuildEnvironment, symbol: Symbol) -> None: verify_description_mode(mode) signode += addnodes.desc_sig_punctuation('[', '[') - addSpace = False + add_space = False def _add(signode: TextElement, text: str) -> bool: - if addSpace: + if add_space: signode += addnodes.desc_sig_space() signode += addnodes.desc_sig_keyword(text, text) return True if self.static: - addSpace = _add(signode, 'static') + add_space = _add(signode, 'static') if self.restrict: - addSpace = _add(signode, 'restrict') + add_space = _add(signode, 'restrict') if self.volatile: - addSpace = _add(signode, 'volatile') + add_space = _add(signode, 'volatile') if self.const: - addSpace = _add(signode, 'const') + add_space = _add(signode, 'const') if self.vla: signode += addnodes.desc_sig_punctuation('*', '*') elif self.size: - if addSpace: + if add_space: signode += addnodes.desc_sig_space() self.size.describe_signature(signode, 'markType', env, symbol) signode += addnodes.desc_sig_punctuation(']', ']') @@ -1405,8 +1405,8 @@ class ASTBracedInitList(ASTBase): def _stringify(self, transform: StringifyTransform) -> str: exprs = ', '.join(transform(e) for e in self.exprs) - trailingComma = ',' if self.trailingComma else '' - return f'{{{exprs}{trailingComma}}}' + trailing_comma = ',' if self.trailingComma else '' + return f'{{{exprs}{trailing_comma}}}' def describe_signature(self, signode: TextElement, mode: str, env: BuildEnvironment, symbol: Symbol) -> None: @@ -1484,9 +1484,9 @@ class ASTType(ASTBase): def _stringify(self, transform: StringifyTransform) -> str: res = [] - declSpecs = transform(self.declSpecs) - res.append(declSpecs) - if self.decl.require_space_after_declSpecs() and len(declSpecs) > 0: + decl_specs = transform(self.declSpecs) + res.append(decl_specs) + if self.decl.require_space_after_declSpecs() and len(decl_specs) > 0: res.append(' ') res.append(transform(self.decl)) return ''.join(res) @@ -1831,32 +1831,32 @@ class ASTDeclaration(ASTBaseBase): # Always enable multiline: signode['is_multiline'] = True # Put each line in a desc_signature_line node. - mainDeclNode = addnodes.desc_signature_line() - mainDeclNode.sphinx_line_type = 'declarator' - mainDeclNode['add_permalink'] = not self.symbol.isRedeclaration - signode += mainDeclNode + main_decl_node = addnodes.desc_signature_line() + main_decl_node.sphinx_line_type = 'declarator' + main_decl_node['add_permalink'] = not self.symbol.isRedeclaration + signode += main_decl_node if self.objectType in {'member', 'function', 'macro'}: pass elif self.objectType == 'struct': - mainDeclNode += addnodes.desc_sig_keyword('struct', 'struct') - mainDeclNode += addnodes.desc_sig_space() + main_decl_node += addnodes.desc_sig_keyword('struct', 'struct') + main_decl_node += addnodes.desc_sig_space() elif self.objectType == 'union': - mainDeclNode += addnodes.desc_sig_keyword('union', 'union') - mainDeclNode += addnodes.desc_sig_space() + main_decl_node += addnodes.desc_sig_keyword('union', 'union') + main_decl_node += addnodes.desc_sig_space() elif self.objectType == 'enum': - mainDeclNode += addnodes.desc_sig_keyword('enum', 'enum') - mainDeclNode += addnodes.desc_sig_space() + main_decl_node += addnodes.desc_sig_keyword('enum', 'enum') + main_decl_node += addnodes.desc_sig_space() elif self.objectType == 'enumerator': - mainDeclNode += addnodes.desc_sig_keyword('enumerator', 'enumerator') - mainDeclNode += addnodes.desc_sig_space() + main_decl_node += addnodes.desc_sig_keyword('enumerator', 'enumerator') + main_decl_node += addnodes.desc_sig_space() elif self.objectType == 'type': decl = cast('ASTType', self.declaration) prefix = decl.get_type_declaration_prefix() - mainDeclNode += addnodes.desc_sig_keyword(prefix, prefix) - mainDeclNode += addnodes.desc_sig_space() + main_decl_node += addnodes.desc_sig_keyword(prefix, prefix) + main_decl_node += addnodes.desc_sig_space() else: raise AssertionError - self.declaration.describe_signature(mainDeclNode, mode, env, self.symbol) + self.declaration.describe_signature(main_decl_node, mode, env, self.symbol) if self.semicolon: - mainDeclNode += addnodes.desc_sig_punctuation(';', ';') + main_decl_node += addnodes.desc_sig_punctuation(';', ';') diff --git a/sphinx/domains/c/_parser.py b/sphinx/domains/c/_parser.py index d6afb24ad..8c8d930dd 100644 --- a/sphinx/domains/c/_parser.py +++ b/sphinx/domains/c/_parser.py @@ -100,7 +100,7 @@ class DefinitionParser(BaseParser): def _parse_string(self) -> str | None: if self.current_char != '"': return None - startPos = self.pos + start_pos = self.pos self.pos += 1 escape = False while True: @@ -114,7 +114,7 @@ class DefinitionParser(BaseParser): else: escape = False self.pos += 1 - return self.definition[startPos:self.pos] + return self.definition[start_pos:self.pos] def _parse_literal(self) -> ASTLiteral | None: # -> integer-literal @@ -194,7 +194,7 @@ class DefinitionParser(BaseParser): return [], False exprs = [] - trailingComma = False + trailing_comma = False while True: self.skip_ws() expr = self._parse_expression() @@ -207,9 +207,9 @@ class DefinitionParser(BaseParser): self.fail(f"Error in {name}, expected ',' or '{close}'.") if self.current_char == close == '}': self.pos += 1 - trailingComma = True + trailing_comma = True break - return exprs, trailingComma + return exprs, trailing_comma def _parse_paren_expression_list(self) -> ASTParenExprList | None: # -> '(' expression-list ')' @@ -218,7 +218,7 @@ 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 @@ -227,10 +227,10 @@ class DefinitionParser(BaseParser): def _parse_braced_init_list(self) -> ASTBracedInitList | None: # -> '{' initializer-list ','[opt] '}' # | '{' '}' - exprs, trailingComma = self._parse_initializer_list("braced-init-list", '{', '}') + exprs, trailing_comma = self._parse_initializer_list("braced-init-list", '{', '}') if exprs is None: return None - return ASTBracedInitList(exprs, trailingComma) + return ASTBracedInitList(exprs, trailing_comma) def _parse_postfix_expression(self) -> ASTPostfixExpr: # -> primary @@ -245,7 +245,7 @@ class DefinitionParser(BaseParser): prefix = self._parse_primary_expression() # and now parse postfixes - postFixes: list[ASTPostfixOp] = [] + post_fixes: list[ASTPostfixOp] = [] while True: self.skip_ws() if self.skip_string_and_ws('['): @@ -253,7 +253,7 @@ class DefinitionParser(BaseParser): self.skip_ws() if not self.skip_string(']'): self.fail("Expected ']' in end of postfix expression.") - postFixes.append(ASTPostfixArray(expr)) + post_fixes.append(ASTPostfixArray(expr)) continue if self.skip_string('->'): if self.skip_string('*'): @@ -261,20 +261,20 @@ class DefinitionParser(BaseParser): self.pos -= 3 else: name = self._parse_nested_name() - postFixes.append(ASTPostfixMemberOfPointer(name)) + post_fixes.append(ASTPostfixMemberOfPointer(name)) continue if self.skip_string('++'): - postFixes.append(ASTPostfixInc()) + post_fixes.append(ASTPostfixInc()) continue if self.skip_string('--'): - postFixes.append(ASTPostfixDec()) + post_fixes.append(ASTPostfixDec()) continue lst = self._parse_paren_expression_list() if lst is not None: - postFixes.append(ASTPostfixCallExpr(lst)) + post_fixes.append(ASTPostfixCallExpr(lst)) continue break - return ASTPostfixExpr(prefix, postFixes) + return ASTPostfixExpr(prefix, post_fixes) def _parse_unary_expression(self) -> ASTExpression: # -> postfix @@ -325,16 +325,16 @@ 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: + except DefinitionError as ex_unary: errs = [] - errs.append((exCast, "If type cast expression")) - errs.append((exUnary, "If unary expression")) + errs.append((ex_cast, "If type cast expression")) + errs.append((ex_unary, "If unary expression")) raise self._make_multi_error(errs, - "Error in cast expression.") from exUnary + "Error in cast expression.") from ex_unary else: return self._parse_unary_expression() @@ -350,21 +350,21 @@ class DefinitionParser(BaseParser): # additive = multiplicative +, - # multiplicative = pm *, /, % # pm = cast .*, ->* - def _parse_bin_op_expr(self: DefinitionParser, opId: int) -> ASTExpression: - if opId + 1 == len(_expression_bin_ops): + def _parse_bin_op_expr(self: DefinitionParser, op_id: int) -> ASTExpression: + if op_id + 1 == len(_expression_bin_ops): def parser() -> ASTExpression: return self._parse_cast_expression() else: def parser() -> ASTExpression: - return _parse_bin_op_expr(self, opId + 1) + return _parse_bin_op_expr(self, op_id + 1) exprs = [] ops = [] exprs.append(parser()) while True: self.skip_ws() pos = self.pos - oneMore = False - for op in _expression_bin_ops[opId]: + one_more = False + for op in _expression_bin_ops[op_id]: if op[0] in 'abcnox': if not self.skip_word(op): continue @@ -380,16 +380,16 @@ class DefinitionParser(BaseParser): expr = parser() exprs.append(expr) ops.append(op) - oneMore = True + one_more = True break except DefinitionError: self.pos = pos - if not oneMore: + if not one_more: break return ASTBinOpExpr(exprs, ops) # type: ignore[return-value] return _parse_bin_op_expr(self, 0) - def _parse_conditional_expression_tail(self, orExprHead: Any) -> ASTExpression | None: + def _parse_conditional_expression_tail(self, or_expr_head: Any) -> ASTExpression | None: # -> "?" expression ":" assignment-expression return None @@ -402,11 +402,11 @@ class DefinitionParser(BaseParser): # | logical-or-expression assignment-operator initializer-clause exprs = [] ops = [] - orExpr = self._parse_logical_or_expression() - exprs.append(orExpr) + or_expr = self._parse_logical_or_expression() + exprs.append(or_expr) # TODO: handle ternary with _parse_conditional_expression_tail while True: - oneMore = False + one_more = False self.skip_ws() for op in _expression_assignment_ops: if op[0] in 'abcnox': @@ -418,16 +418,16 @@ class DefinitionParser(BaseParser): expr = self._parse_logical_or_expression() exprs.append(expr) ops.append(op) - oneMore = True - if not oneMore: + one_more = True + if not one_more: break return ASTAssignmentExpr(exprs, ops) def _parse_constant_expression(self) -> ASTExpression: # -> conditional-expression - orExpr = self._parse_logical_or_expression() + or_expr = self._parse_logical_or_expression() # TODO: use _parse_conditional_expression_tail - return orExpr + return or_expr def _parse_expression(self) -> ASTExpression: # -> assignment-expression @@ -443,7 +443,7 @@ class DefinitionParser(BaseParser): # '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: @@ -453,11 +453,11 @@ class DefinitionParser(BaseParser): raise self.warn("Parsing of expression failed. Using fallback parser." " Error was:\n%s" % e) - self.pos = prevPos + 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: @@ -474,8 +474,8 @@ class DefinitionParser(BaseParser): 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() + % start_pos) + value = self.definition[start_pos:self.pos].strip() return ASTFallbackExpr(value.strip()) def _parse_nested_name(self) -> ASTNestedName: @@ -549,13 +549,13 @@ class DefinitionParser(BaseParser): prefix = k break - nestedName = self._parse_nested_name() - return ASTTrailingTypeSpecName(prefix, nestedName) + nested_name = self._parse_nested_name() + return ASTTrailingTypeSpecName(prefix, nested_name) - def _parse_parameters(self, paramMode: str) -> ASTParameters | None: + def _parse_parameters(self, param_mode: str) -> ASTParameters | None: self.skip_ws() if not self.skip_string('('): - if paramMode == 'function': + if param_mode == 'function': self.fail('Expecting "(" in parameters.') else: return None @@ -592,7 +592,7 @@ class DefinitionParser(BaseParser): ) -> ASTDeclSpecsSimple: """Just parse the simple ones.""" storage = None - threadLocal = None + thread_local = None inline = None restrict = None volatile = None @@ -615,12 +615,12 @@ class DefinitionParser(BaseParser): if self.skip_word('extern'): storage = 'extern' continue - if outer == 'member' and not threadLocal: + if outer == 'member' and not thread_local: if self.skip_word('thread_local'): - threadLocal = 'thread_local' + thread_local = 'thread_local' continue if self.skip_word('_Thread_local'): - threadLocal = '_Thread_local' + thread_local = '_Thread_local' continue if outer == 'function' and not inline: inline = self.skip_word('inline') @@ -644,25 +644,25 @@ class DefinitionParser(BaseParser): attrs.append(attr) continue break - return ASTDeclSpecsSimple(storage, threadLocal, inline, + return ASTDeclSpecsSimple(storage, thread_local, inline, restrict, volatile, const, ASTAttributeList(attrs)) def _parse_decl_specs(self, outer: str | None, typed: bool = True) -> ASTDeclSpecs: if outer: if outer not in {'type', 'member', 'function'}: raise Exception('Internal error, unknown outer "%s".' % outer) - leftSpecs = self._parse_decl_specs_simple(outer, typed) - rightSpecs = None + left_specs = self._parse_decl_specs_simple(outer, typed) + right_specs = None if typed: trailing = self._parse_trailing_type_spec() - rightSpecs = self._parse_decl_specs_simple(outer, typed) + right_specs = self._parse_decl_specs_simple(outer, typed) else: trailing = None - return ASTDeclSpecs(outer, leftSpecs, rightSpecs, trailing) + return ASTDeclSpecs(outer, left_specs, right_specs, trailing) def _parse_declarator_name_suffix( - self, named: bool | str, paramMode: str, typed: bool, + self, named: bool | str, param_mode: str, typed: bool, ) -> ASTDeclarator: assert named in {True, False, 'single'} # now we should parse the name, and then suffixes @@ -680,14 +680,14 @@ class DefinitionParser(BaseParser): self.fail(msg % (self.matched_text, str(self.config.c_extra_keywords))) identifier = ASTIdentifier(self.matched_text) - declId = ASTNestedName([identifier], rooted=False) + decl_id = ASTNestedName([identifier], rooted=False) else: - declId = None + decl_id = None elif named: - declId = self._parse_nested_name() + decl_id = self._parse_nested_name() else: - declId = None - arrayOps = [] + decl_id = None + array_ops = [] while 1: self.skip_ws() if typed and self.skip_string('['): @@ -730,27 +730,27 @@ class DefinitionParser(BaseParser): self.skip_ws() if not self.skip_string(']'): self.fail("Expected ']' in end of array operator.") - arrayOps.append(ASTArray(static, const, volatile, restrict, vla, size)) + array_ops.append(ASTArray(static, const, volatile, restrict, vla, size)) else: break - param = self._parse_parameters(paramMode) - if param is None and len(arrayOps) == 0: + param = self._parse_parameters(param_mode) + if param is None and len(array_ops) == 0: # perhaps a bit-field - if named and paramMode == 'type' and typed: + if named and param_mode == 'type' and typed: self.skip_ws() if self.skip_string(':'): size = self._parse_constant_expression() - return ASTDeclaratorNameBitField(declId=declId, size=size) - return ASTDeclaratorNameParam(declId=declId, arrayOps=arrayOps, + return ASTDeclaratorNameBitField(declId=decl_id, size=size) + return ASTDeclaratorNameParam(declId=decl_id, arrayOps=array_ops, param=param) - def _parse_declarator(self, named: bool | str, paramMode: str, + 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'}: + if param_mode not in {'type', 'function'}: raise Exception( - "Internal error, unknown paramMode '%s'." % paramMode) - prevErrors = [] + "Internal error, unknown param_mode '%s'." % param_mode) + prev_errors = [] self.skip_ws() if typed and self.skip_string('*'): self.skip_ws() @@ -776,7 +776,7 @@ class DefinitionParser(BaseParser): attrs.append(attr) continue break - next = self._parse_declarator(named, paramMode, typed) + next = self._parse_declarator(named, param_mode, typed) return ASTDeclaratorPtr(next=next, restrict=restrict, volatile=volatile, const=const, attrs=ASTAttributeList(attrs)) @@ -786,14 +786,14 @@ class DefinitionParser(BaseParser): pos = self.pos try: # assume this is params - res = self._parse_declarator_name_suffix(named, paramMode, + res = self._parse_declarator_name_suffix(named, param_mode, typed) return res - except DefinitionError as exParamQual: + except DefinitionError as ex_param_qual: msg = "If declarator-id with parameters" - if paramMode == 'function': + if param_mode == 'function': msg += " (e.g., 'void f(int arg)')" - prevErrors.append((exParamQual, msg)) + prev_errors.append((ex_param_qual, msg)) self.pos = pos try: assert self.current_char == '(' @@ -801,49 +801,49 @@ class DefinitionParser(BaseParser): # TODO: hmm, if there is a name, it must be in inner, right? # TODO: hmm, if there must be parameters, they must b # inside, right? - inner = self._parse_declarator(named, paramMode, typed) + inner = self._parse_declarator(named, param_mode, typed) if not self.skip_string(')'): self.fail("Expected ')' in \"( ptr-declarator )\"") next = self._parse_declarator(named=False, - paramMode="type", + param_mode="type", typed=typed) return ASTDeclaratorParen(inner=inner, next=next) - except DefinitionError as exNoPtrParen: + except DefinitionError as ex_no_ptr_paren: self.pos = pos msg = "If parenthesis in noptr-declarator" - if paramMode == 'function': + if param_mode == 'function': msg += " (e.g., 'void (*f(int arg))(double)')" - prevErrors.append((exNoPtrParen, msg)) + prev_errors.append((ex_no_ptr_paren, msg)) header = "Error in declarator" - raise self._make_multi_error(prevErrors, header) from exNoPtrParen + raise self._make_multi_error(prev_errors, header) from ex_no_ptr_paren pos = self.pos try: - return self._parse_declarator_name_suffix(named, paramMode, typed) + return self._parse_declarator_name_suffix(named, param_mode, typed) except DefinitionError as e: self.pos = pos - prevErrors.append((e, "If declarator-id")) + prev_errors.append((e, "If declarator-id")) header = "Error in declarator or parameters" - raise self._make_multi_error(prevErrors, header) from e + raise self._make_multi_error(prev_errors, header) from e - def _parse_initializer(self, outer: str | None = None, allowFallback: bool = True, + def _parse_initializer(self, outer: str | None = None, allow_fallback: bool = True, ) -> ASTInitializer | None: self.skip_ws() if outer == 'member' and False: # NoQA: SIM223 # TODO - bracedInit = self._parse_braced_init_list() - if bracedInit is not None: - return ASTInitializer(bracedInit, hasAssign=False) + braced_init = self._parse_braced_init_list() + if braced_init is not None: + return ASTInitializer(braced_init, hasAssign=False) if not self.skip_string('='): return None - bracedInit = self._parse_braced_init_list() - if bracedInit is not None: - return ASTInitializer(bracedInit) + braced_init = self._parse_braced_init_list() + if braced_init is not None: + return ASTInitializer(braced_init) if outer == 'member': - fallbackEnd: list[str] = [] + fallback_end: list[str] = [] elif outer is None: # function parameter - fallbackEnd = [',', ')'] + fallback_end = [',', ')'] else: self.fail("Internal error, initializer for outer '%s' not " "implemented." % outer) @@ -851,7 +851,7 @@ class DefinitionParser(BaseParser): def parser() -> ASTExpression: return self._parse_assignment_expression() - value = self._parse_expression_fallback(fallbackEnd, parser, allow=allowFallback) + value = self._parse_expression_fallback(fallback_end, parser, allow=allow_fallback) return ASTInitializer(value) def _parse_type(self, named: bool | str, outer: str | None = None) -> ASTType: @@ -866,52 +866,52 @@ class DefinitionParser(BaseParser): if outer == 'type': # We allow type objects to just be a name. - prevErrors = [] - startPos = self.pos + prev_errors = [] + start_pos = self.pos # first try without the type try: - declSpecs = self._parse_decl_specs(outer=outer, typed=False) - decl = self._parse_declarator(named=True, paramMode=outer, + decl_specs = self._parse_decl_specs(outer=outer, typed=False) + decl = self._parse_declarator(named=True, param_mode=outer, typed=False) self.assert_end(allowSemicolon=True) - except DefinitionError as exUntyped: + except DefinitionError as ex_untyped: desc = "If just a name" - prevErrors.append((exUntyped, desc)) - self.pos = startPos + 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 desc = "If typedef-like declaration" - prevErrors.append((exTyped, desc)) + prev_errors.append((ex_typed, desc)) # Retain the else branch for easier debugging. # TODO: it would be nice to save the previous stacktrace # and output it here. if True: header = "Type must be either just a name or a " header += "typedef-like declaration." - raise self._make_multi_error(prevErrors, header) from exTyped + raise self._make_multi_error(prev_errors, header) from ex_typed else: # NoQA: RET506 # 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, + decl_specs = self._parse_decl_specs(outer=outer, typed=typed) + decl = self._parse_declarator(named=True, param_mode=outer, typed=typed) elif outer == 'function': - declSpecs = self._parse_decl_specs(outer=outer) - decl = self._parse_declarator(named=True, paramMode=outer) + decl_specs = self._parse_decl_specs(outer=outer) + decl = self._parse_declarator(named=True, param_mode=outer) else: - paramMode = 'type' + param_mode = 'type' if outer == 'member': # i.e., member named = True - declSpecs = self._parse_decl_specs(outer=outer) - decl = self._parse_declarator(named=named, paramMode=paramMode) - return ASTType(declSpecs, decl) + decl_specs = self._parse_decl_specs(outer=outer) + decl = self._parse_declarator(named=named, param_mode=param_mode) + return ASTType(decl_specs, decl) def _parse_type_with_init(self, named: bool | str, outer: str | None) -> ASTTypeWithInit: if outer: @@ -982,43 +982,45 @@ class DefinitionParser(BaseParser): def parser() -> ASTExpression: return self._parse_constant_expression() - initVal = self._parse_expression_fallback([], parser) - init = ASTInitializer(initVal) + init_val = self._parse_expression_fallback([], parser) + init = ASTInitializer(init_val) return ASTEnumerator(name, init, attrs) def parse_declaration(self, objectType: str, directiveType: str) -> ASTDeclaration: - if objectType not in {'function', 'member', + object_type = objectType + directive_type = directiveType + if object_type not in {'function', 'member', 'macro', 'struct', 'union', 'enum', 'enumerator', 'type'}: - raise Exception('Internal error, unknown objectType "%s".' % objectType) - if directiveType not in {'function', 'member', 'var', + raise Exception('Internal error, unknown objectType "%s".' % object_type) + if directive_type not in {'function', 'member', 'var', 'macro', 'struct', 'union', 'enum', 'enumerator', 'type'}: - raise Exception('Internal error, unknown directiveType "%s".' % directiveType) + raise Exception('Internal error, unknown directiveType "%s".' % directive_type) declaration: DeclarationType | None = None - if objectType == 'member': + if object_type == 'member': declaration = self._parse_type_with_init(named=True, outer='member') - elif objectType == 'function': + elif object_type == 'function': declaration = self._parse_type(named=True, outer='function') - elif objectType == 'macro': + elif object_type == 'macro': declaration = self._parse_macro() - elif objectType == 'struct': + elif object_type == 'struct': declaration = self._parse_struct() - elif objectType == 'union': + elif object_type == 'union': declaration = self._parse_union() - elif objectType == 'enum': + elif object_type == 'enum': declaration = self._parse_enum() - elif objectType == 'enumerator': + elif object_type == 'enumerator': declaration = self._parse_enumerator() - elif objectType == 'type': + elif object_type == 'type': declaration = self._parse_type(named=True, outer='type') else: raise AssertionError - if objectType != 'macro': + if object_type != 'macro': self.skip_ws() semicolon = self.skip_string(';') else: semicolon = False - return ASTDeclaration(objectType, directiveType, declaration, semicolon) + return ASTDeclaration(object_type, directive_type, declaration, semicolon) def parse_namespace_object(self) -> ASTNestedName: return self._parse_nested_name() @@ -1038,16 +1040,16 @@ class DefinitionParser(BaseParser): res = self._parse_expression() self.skip_ws() self.assert_end() - except DefinitionError as exExpr: + except DefinitionError as ex_expr: self.pos = pos try: res = self._parse_type(False) self.skip_ws() self.assert_end() - except DefinitionError as exType: + except DefinitionError as ex_type: 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 + errs.append((ex_expr, "If expression")) + errs.append((ex_type, "If type")) + raise self._make_multi_error(errs, header) from ex_type return res