diff options
Diffstat (limited to 'sphinx/domains/cpp.py')
| -rw-r--r-- | sphinx/domains/cpp.py | 365 |
1 files changed, 231 insertions, 134 deletions
diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 7f7558cb3..dbb6d1a39 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -306,6 +306,7 @@ _operator_re = re.compile(r'''(?x) | ->\*? | \, | (<<|>>)=? | && | \|\| | [!<>=/*%+|&^~-]=? + | (\b(and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|xor|xor_eq)\b) ''') _fold_operator_re = re.compile(r'''(?x) ->\* | \.\* | \, @@ -464,37 +465,37 @@ _id_operator_v2 = { # '-(unary)' : 'ng', # '&(unary)' : 'ad', # '*(unary)' : 'de', - '~': 'co', + '~': 'co', 'compl': 'co', '+': 'pl', '-': 'mi', '*': 'ml', '/': 'dv', '%': 'rm', - '&': 'an', - '|': 'or', - '^': 'eo', + '&': 'an', 'bitand': 'an', + '|': 'or', 'bitor': 'or', + '^': 'eo', 'xor': 'eo', '=': 'aS', '+=': 'pL', '-=': 'mI', '*=': 'mL', '/=': 'dV', '%=': 'rM', - '&=': 'aN', - '|=': 'oR', - '^=': 'eO', + '&=': 'aN', 'and_eq': 'aN', + '|=': 'oR', 'or_eq': 'oR', + '^=': 'eO', 'xor_eq': 'eO', '<<': 'ls', '>>': 'rs', '<<=': 'lS', '>>=': 'rS', '==': 'eq', - '!=': 'ne', + '!=': 'ne', 'not_eq': 'ne', '<': 'lt', '>': 'gt', '<=': 'le', '>=': 'ge', - '!': 'nt', - '&&': 'aa', - '||': 'oo', + '!': 'nt', 'not': 'nt', + '&&': 'aa', 'and': 'aa', + '||': 'oo', 'or': 'oo', '++': 'pp', '--': 'mm', ',': 'cm', @@ -511,8 +512,8 @@ _id_operator_unary_v2 = { '&': 'ad', '+': 'ps', '-': 'ng', - '!': 'nt', - '~': 'co' + '!': 'nt', 'not': 'nt', + '~': 'co', 'compl': 'co' } _id_char_from_prefix = { None: 'c', 'u8': 'c', @@ -520,21 +521,21 @@ _id_char_from_prefix = { } # type: Dict[Any, str] # these are ordered by preceedence _expression_bin_ops = [ - ['||'], - ['&&'], - ['|'], - ['^'], - ['&'], - ['==', '!='], + ['||', 'or'], + ['&&', 'and'], + ['|', 'bitor'], + ['^', 'xor'], + ['&', 'bitand'], + ['==', '!=', 'not_eq'], ['<=', '>=', '<', '>'], ['<<', '>>'], ['+', '-'], ['*', '/', '%'], ['.*', '->*'] ] -_expression_unary_ops = ["++", "--", "*", "&", "+", "-", "!", "~"] +_expression_unary_ops = ["++", "--", "*", "&", "+", "-", "!", "not", "~", "compl"] _expression_assignment_ops = ["=", "*=", "/=", "%=", "+=", "-=", - ">>=", "<<=", "&=", "^=", "|="] + ">>=", "<<=", "&=", "and_eq", "^=", "|=", "xor_eq", "or_eq"] _id_explicit_cast = { 'dynamic_cast': 'dc', 'static_cast': 'sc', @@ -1260,7 +1261,10 @@ class ASTUnaryOpExpr(ASTExpression): self.expr = expr def _stringify(self, transform: StringifyTransform) -> str: - return transform(self.op) + transform(self.expr) + if self.op[0] in 'cn': + return transform(self.op) + " " + transform(self.expr) + else: + return transform(self.op) + transform(self.expr) def get_id(self, version: int) -> str: return _id_operator_unary_v2[self.op] + self.expr.get_id(version) @@ -1268,6 +1272,8 @@ class ASTUnaryOpExpr(ASTExpression): def describe_signature(self, signode: TextElement, mode: str, env: "BuildEnvironment", symbol: "Symbol") -> None: signode.append(nodes.Text(self.op)) + if self.op[0] in 'cn': + signode.append(nodes.Text(' ')) self.expr.describe_signature(signode, mode, env, symbol) @@ -1499,8 +1505,38 @@ class ASTBinOpExpr(ASTExpression): self.exprs[i].describe_signature(signode, mode, env, symbol) +class ASTBracedInitList(ASTBase): + def __init__(self, exprs: List[Union[ASTExpression, "ASTBracedInitList"]], + trailingComma: bool) -> None: + self.exprs = exprs + self.trailingComma = trailingComma + + def get_id(self, version: int) -> str: + return "il%sE" % ''.join(e.get_id(version) for e in self.exprs) + + def _stringify(self, transform: StringifyTransform) -> str: + exprs = [transform(e) for e in self.exprs] + trailingComma = ',' if self.trailingComma else '' + return '{%s%s}' % (', '.join(exprs), trailingComma) + + def describe_signature(self, signode: TextElement, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: + verify_description_mode(mode) + signode.append(nodes.Text('{')) + first = True + for e in self.exprs: + if not first: + signode.append(nodes.Text(', ')) + else: + first = False + e.describe_signature(signode, mode, env, symbol) + if self.trailingComma: + signode.append(nodes.Text(',')) + signode.append(nodes.Text('}')) + + class ASTAssignmentExpr(ASTExpression): - def __init__(self, exprs: List[ASTExpression], ops: List[str]): + def __init__(self, exprs: List[Union[ASTExpression, ASTBracedInitList]], ops: List[str]): assert len(exprs) > 0 assert len(exprs) == len(ops) + 1 self.exprs = exprs @@ -1534,6 +1570,31 @@ class ASTAssignmentExpr(ASTExpression): self.exprs[i].describe_signature(signode, mode, env, symbol) +class ASTCommaExpr(ASTExpression): + def __init__(self, exprs: List[ASTExpression]): + assert len(exprs) > 0 + self.exprs = exprs + + def _stringify(self, transform: StringifyTransform) -> str: + return ', '.join(transform(e) for e in self.exprs) + + def get_id(self, version: int) -> str: + id_ = _id_operator_v2[','] + res = [] + for i in range(len(self.exprs) - 1): + res.append(id_) + res.append(self.exprs[i].get_id(version)) + res.append(self.exprs[-1].get_id(version)) + return ''.join(res) + + def describe_signature(self, signode: TextElement, mode: str, + env: "BuildEnvironment", symbol: "Symbol") -> None: + self.exprs[0].describe_signature(signode, mode, env, symbol) + for i in range(1, len(self.exprs)): + signode.append(nodes.Text(', ')) + self.exprs[i].describe_signature(signode, mode, env, symbol) + + class ASTFallbackExpr(ASTExpression): def __init__(self, expr: str): self.expr = expr @@ -1584,6 +1645,8 @@ class ASTOperatorBuildIn(ASTOperator): def get_id(self, version: int) -> str: if version == 1: ids = _id_operator_v1 + if self.op not in ids: + raise NoOldIdError() else: ids = _id_operator_v2 if self.op not in ids: @@ -1592,7 +1655,7 @@ class ASTOperatorBuildIn(ASTOperator): return ids[self.op] def _stringify(self, transform: StringifyTransform) -> str: - if self.op in ('new', 'new[]', 'delete', 'delete[]'): + if self.op in ('new', 'new[]', 'delete', 'delete[]') or self.op[0] in "abcnox": return 'operator ' + self.op else: return 'operator' + self.op @@ -1650,9 +1713,11 @@ class ASTTemplateArgConstant(ASTBase): class ASTTemplateArgs(ASTBase): - def __init__(self, args: List[Union["ASTType", ASTTemplateArgConstant]]) -> None: + def __init__(self, args: List[Union["ASTType", ASTTemplateArgConstant]], + packExpansion: bool) -> None: assert args is not None self.args = args + self.packExpansion = packExpansion def get_id(self, version: int) -> str: if version == 1: @@ -1664,13 +1729,21 @@ class ASTTemplateArgs(ASTBase): res = [] res.append('I') - for a in self.args: - res.append(a.get_id(version)) + if len(self.args) > 0: + for a in self.args[:-1]: + res.append(a.get_id(version)) + if self.packExpansion: + res.append('J') + res.append(self.args[-1].get_id(version)) + if self.packExpansion: + res.append('E') res.append('E') return ''.join(res) def _stringify(self, transform: StringifyTransform) -> str: res = ', '.join(transform(a) for a in self.args) + if self.packExpansion: + res += '...' return '<' + res + '>' def describe_signature(self, signode: TextElement, mode: str, @@ -1683,6 +1756,8 @@ class ASTTemplateArgs(ASTBase): signode += nodes.Text(', ') first = False a.describe_signature(signode, 'markType', env, symbol=symbol) + if self.packExpansion: + signode += nodes.Text('...') signode += nodes.Text('>') @@ -2633,7 +2708,7 @@ class ASTDeclaratorParen(ASTDeclarator): ############################################################################################## class ASTPackExpansionExpr(ASTExpression): - def __init__(self, expr: ASTExpression): + def __init__(self, expr: Union[ASTExpression, ASTBracedInitList]): self.expr = expr def _stringify(self, transform: StringifyTransform) -> str: @@ -2650,7 +2725,7 @@ class ASTPackExpansionExpr(ASTExpression): class ASTParenExprList(ASTBase): - def __init__(self, exprs: List[ASTExpression]) -> None: + def __init__(self, exprs: List[Union[ASTExpression, ASTBracedInitList]]) -> None: self.exprs = exprs def get_id(self, version: int) -> str: @@ -2674,35 +2749,6 @@ class ASTParenExprList(ASTBase): signode.append(nodes.Text(')')) -class ASTBracedInitList(ASTBase): - def __init__(self, exprs: List[ASTExpression], trailingComma: bool) -> None: - self.exprs = exprs - self.trailingComma = trailingComma - - def get_id(self, version: int) -> str: - return "il%sE" % ''.join(e.get_id(version) for e in self.exprs) - - def _stringify(self, transform: StringifyTransform) -> str: - exprs = [transform(e) for e in self.exprs] - trailingComma = ',' if self.trailingComma else '' - return '{%s%s}' % (', '.join(exprs), trailingComma) - - def describe_signature(self, signode: TextElement, mode: str, - env: "BuildEnvironment", symbol: "Symbol") -> None: - verify_description_mode(mode) - signode.append(nodes.Text('{')) - first = True - for e in self.exprs: - if not first: - signode.append(nodes.Text(', ')) - else: - first = False - e.describe_signature(signode, mode, env, symbol) - if self.trailingComma: - signode.append(nodes.Text(',')) - signode.append(nodes.Text('}')) - - class ASTInitializer(ASTBase): def __init__(self, value: Union[ASTExpression, ASTBracedInitList], hasAssign: bool = True) -> None: @@ -4113,7 +4159,7 @@ class Symbol: ancestorLookupType=None, templateShorthand=False, matchSelf=False, - recurseInAnon=True, + recurseInAnon=False, correctPrimaryTemplateArgs=True, searchInSiblings=False) assert lookupResult is not None # we create symbols all the way, so that can't happen @@ -4568,6 +4614,10 @@ class DefinitionParser(BaseParser): super().__init__(definition, location=location) self.config = config + @property + def language(self) -> str: + return 'C++' + def _parse_string(self) -> str: if self.current_char != '"': return None @@ -4743,7 +4793,7 @@ class DefinitionParser(BaseParser): self.pos = pos # fall back to a paren expression try: - res = self._parse_expression(inTemplate=False) + res = self._parse_expression() self.skip_ws() if not self.skip_string(')'): self.fail("Expected ')' in end of parenthesized expression.") @@ -4791,7 +4841,9 @@ class DefinitionParser(BaseParser): return None def _parse_initializer_list(self, name: str, open: str, close: str - ) -> Tuple[List[ASTExpression], bool]: + ) -> Tuple[List[Union[ASTExpression, + ASTBracedInitList]], + bool]: # Parse open and close with the actual initializer-list inbetween # -> initializer-clause '...'[opt] # | initializer-list ',' initializer-clause '...'[opt] @@ -4801,11 +4853,11 @@ class DefinitionParser(BaseParser): if self.skip_string(close): return [], False - exprs = [] # type: List[ASTExpression] + exprs = [] # type: List[Union[ASTExpression, ASTBracedInitList]] trailingComma = False while True: self.skip_ws() - expr = self._parse_expression(inTemplate=False) + expr = self._parse_initializer_clause() self.skip_ws() if self.skip_string('...'): exprs.append(ASTPackExpansionExpr(expr)) @@ -4835,6 +4887,12 @@ class DefinitionParser(BaseParser): return None return ASTParenExprList(exprs) + def _parse_initializer_clause(self) -> Union[ASTExpression, ASTBracedInitList]: + bracedInitList = self._parse_braced_init_list() + if bracedInitList is not None: + return bracedInitList + return self._parse_assignment_expression(inTemplate=False) + def _parse_braced_init_list(self) -> ASTBracedInitList: # -> '{' initializer-list ','[opt] '}' # | '{' '}' @@ -4894,7 +4952,7 @@ class DefinitionParser(BaseParser): self.fail("Expected '(' in '%s'." % cast) def parser(): - return self._parse_expression(inTemplate=False) + return self._parse_expression() expr = self._parse_expression_fallback([')'], parser) self.skip_ws() if not self.skip_string(")"): @@ -4915,7 +4973,7 @@ class DefinitionParser(BaseParser): try: def parser(): - return self._parse_expression(inTemplate=False) + return self._parse_expression() expr = self._parse_expression_fallback([')'], parser) prefix = ASTTypeId(expr, isType=False) if not self.skip_string(')'): @@ -4962,7 +5020,7 @@ class DefinitionParser(BaseParser): self.skip_ws() if prefixType in ['expr', 'cast', 'typeid']: if self.skip_string_and_ws('['): - expr = self._parse_expression(inTemplate=False) + expr = self._parse_expression() self.skip_ws() if not self.skip_string(']'): self.fail("Expected ']' in end of postfix expression.") @@ -5016,7 +5074,11 @@ class DefinitionParser(BaseParser): self.skip_ws() for op in _expression_unary_ops: # TODO: hmm, should we be able to backtrack here? - if self.skip_string(op): + if op[0] in 'cn': + res = self.skip_word(op) + else: + res = self.skip_string(op) + if res: expr = self._parse_cast_expression() return ASTUnaryOpExpr(op, expr) if self.skip_word_and_ws('sizeof'): @@ -5049,7 +5111,7 @@ class DefinitionParser(BaseParser): if self.skip_word_and_ws('noexcept'): if not self.skip_string_and_ws('('): self.fail("Expecting '(' after 'noexcept'.") - expr = self._parse_expression(inTemplate=False) + expr = self._parse_expression() self.skip_ws() if not self.skip_string(')'): self.fail("Expecting ')' to end 'noexcept'.") @@ -5144,8 +5206,12 @@ class DefinitionParser(BaseParser): pos = self.pos oneMore = False for op in _expression_bin_ops[opId]: - if not self.skip_string(op): - continue + if op[0] in 'abcnox': + if not self.skip_word(op): + continue + else: + if not self.skip_string(op): + continue if op == '&' and self.current_char == '&': # don't split the && 'token' self.pos -= 1 @@ -5178,7 +5244,7 @@ class DefinitionParser(BaseParser): # logical-or-expression # | logical-or-expression "?" expression ":" assignment-expression # | logical-or-expression assignment-operator initializer-clause - exprs = [] + exprs = [] # type: List[Union[ASTExpression, ASTBracedInitList]] ops = [] orExpr = self._parse_logical_or_expression(inTemplate=inTemplate) exprs.append(orExpr) @@ -5187,9 +5253,13 @@ class DefinitionParser(BaseParser): oneMore = False self.skip_ws() for op in _expression_assignment_ops: - if not self.skip_string(op): - continue - expr = self._parse_logical_or_expression(False) + if op[0] in 'anox': + if not self.skip_word(op): + continue + else: + if not self.skip_string(op): + continue + expr = self._parse_initializer_clause() exprs.append(expr) ops.append(op) oneMore = True @@ -5206,11 +5276,19 @@ class DefinitionParser(BaseParser): # TODO: use _parse_conditional_expression_tail return orExpr - def _parse_expression(self, inTemplate: bool) -> ASTExpression: + def _parse_expression(self) -> ASTExpression: # -> assignment-expression # | expression "," assignment-expresion - # TODO: actually parse the second production - return self._parse_assignment_expression(inTemplate=inTemplate) + exprs = [self._parse_assignment_expression(inTemplate=False)] + while True: + self.skip_ws() + if not self.skip_string(','): + break + exprs.append(self._parse_assignment_expression(inTemplate=False)) + if len(exprs) == 1: + return exprs[0] + else: + return ASTCommaExpr(exprs) def _parse_expression_fallback(self, end: List[str], parser: Callable[[], ASTExpression], @@ -5289,13 +5367,21 @@ class DefinitionParser(BaseParser): return ASTOperatorType(type) def _parse_template_argument_list(self) -> ASTTemplateArgs: + # template-argument-list: (but we include the < and > here + # template-argument ...[opt] + # template-argument-list, template-argument ...[opt] + # template-argument: + # constant-expression + # type-id + # id-expression self.skip_ws() if not self.skip_string_and_ws('<'): return None if self.skip_string('>'): - return ASTTemplateArgs([]) + return ASTTemplateArgs([], False) prevErrors = [] templateArgs = [] # type: List[Union[ASTType, ASTTemplateArgConstant]] + packExpansion = False while 1: pos = self.pos parsedComma = False @@ -5303,31 +5389,35 @@ class DefinitionParser(BaseParser): try: type = self._parse_type(named=False) self.skip_ws() - if self.skip_string('>'): + if self.skip_string_and_ws('...'): + packExpansion = True + parsedEnd = True + if not self.skip_string('>'): + self.fail('Expected ">" after "..." in template argument list.') + elif self.skip_string('>'): parsedEnd = True elif self.skip_string(','): parsedComma = True else: - self.fail('Expected ">" or "," in template argument list.') + self.fail('Expected "...>", ">" or "," in template argument list.') templateArgs.append(type) except DefinitionError as e: prevErrors.append((e, "If type argument")) self.pos = pos try: - # actually here we shouldn't use the fallback parser (hence allow=False), - # because if actually took the < in an expression, then we _will_ fail, - # which is handled elsewhere. E.g., :cpp:expr:`A <= 0`. - def parser(): - return self._parse_constant_expression(inTemplate=True) - value = self._parse_expression_fallback( - [',', '>'], parser, allow=False) + value = self._parse_constant_expression(inTemplate=True) self.skip_ws() - if self.skip_string('>'): + if self.skip_string_and_ws('...'): + packExpansion = True + parsedEnd = True + if not self.skip_string('>'): + self.fail('Expected ">" after "..." in template argument list.') + elif self.skip_string('>'): parsedEnd = True elif self.skip_string(','): parsedComma = True else: - self.fail('Expected ">" or "," in template argument list.') + self.fail('Expected "...>", ">" or "," in template argument list.') templateArgs.append(ASTTemplateArgConstant(value)) except DefinitionError as e: self.pos = pos @@ -5337,7 +5427,9 @@ class DefinitionParser(BaseParser): if parsedEnd: assert not parsedComma break - return ASTTemplateArgs(templateArgs) + else: + assert not packExpansion + return ASTTemplateArgs(templateArgs, packExpansion) def _parse_nested_name(self, memberPointer: bool = False) -> ASTNestedName: names = [] # type: List[ASTNestedNameElement] @@ -5427,7 +5519,7 @@ class DefinitionParser(BaseParser): if not self.skip_string(')'): self.fail("Expected ')' after 'decltype(auto'.") return ASTTrailingTypeSpecDecltypeAuto() - expr = self._parse_expression(inTemplate=False) + expr = self._parse_expression() self.skip_ws() if not self.skip_string(')'): self.fail("Expected ')' after 'decltype(<expr>'.") @@ -5440,7 +5532,6 @@ class DefinitionParser(BaseParser): if self.skip_word_and_ws(k): prefix = k break - nestedName = self._parse_nested_name() return ASTTrailingTypeSpecName(prefix, nestedName) @@ -5450,7 +5541,7 @@ class DefinitionParser(BaseParser): self.skip_ws() if not self.skip_string('('): if paramMode == 'function': - self.fail('Expecting "(" in parameters_and_qualifiers.') + self.fail('Expecting "(" in parameters-and-qualifiers.') else: return None args = [] @@ -5463,7 +5554,7 @@ class DefinitionParser(BaseParser): self.skip_ws() if not self.skip_string(')'): self.fail('Expected ")" after "..." in ' - 'parameters_and_qualifiers.') + 'parameters-and-qualifiers.') break # note: it seems that function arguments can always be named, # even in function pointers and similar. @@ -5478,7 +5569,7 @@ class DefinitionParser(BaseParser): break else: self.fail( - 'Expecting "," or ")" in parameters_and_qualifiers, ' + 'Expecting "," or ")" in parameters-and-qualifiers, ' 'got "%s".' % self.current_char) # TODO: why did we have this bail-out? @@ -5509,7 +5600,7 @@ class DefinitionParser(BaseParser): exceptionSpec = 'noexcept' self.skip_ws() if self.skip_string('('): - self.fail('Parameterised "noexcept" not implemented.') + self.fail('Parameterised "noexcept" not yet implemented.') self.skip_ws() override = self.skip_word_and_ws('override') @@ -5672,7 +5763,7 @@ class DefinitionParser(BaseParser): continue def parser(): - return self._parse_expression(inTemplate=False) + return self._parse_expression() value = self._parse_expression_fallback([']'], parser) if not self.skip_string(']'): self.fail("Expected ']' in end of array operator.") @@ -5734,32 +5825,6 @@ class DefinitionParser(BaseParser): if typed and self.skip_string("..."): next = self._parse_declarator(named, paramMode, False) return ASTDeclaratorParamPack(next=next) - if typed: # pointer to member - pos = self.pos - try: - name = self._parse_nested_name(memberPointer=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")) - else: - volatile = False - const = False - while 1: - if not volatile: - volatile = self.skip_word_and_ws('volatile') - if volatile: - continue - if not const: - const = self.skip_word_and_ws('const') - if const: - continue - break - next = self._parse_declarator(named, paramMode, typed) - return ASTDeclaratorMemPtr(name, const, volatile, next=next) if typed and self.current_char == '(': # note: peeking, not skipping if paramMode == "operatorCast": # TODO: we should be able to parse cast operators which return @@ -5775,14 +5840,15 @@ class DefinitionParser(BaseParser): typed) return res except DefinitionError as exParamQual: - prevErrors.append((exParamQual, "If declId, parameters, and qualifiers")) + prevErrors.append((exParamQual, + "If declarator-id with parameters-and-qualifiers")) self.pos = pos try: assert self.current_char == '(' self.skip_string('(') # 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? + # TODO: hmm, if there must be parameters, they must be + # inside, right? inner = self._parse_declarator(named, paramMode, typed) if not self.skip_string(')'): self.fail("Expected ')' in \"( ptr-declarator )\"") @@ -5795,13 +5861,44 @@ class DefinitionParser(BaseParser): prevErrors.append((exNoPtrParen, "If parenthesis in noptr-declarator")) header = "Error in declarator" raise self._make_multi_error(prevErrors, header) + if typed: # pointer to member + pos = self.pos + try: + name = self._parse_nested_name(memberPointer=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")) + else: + volatile = False + const = False + while 1: + if not volatile: + volatile = self.skip_word_and_ws('volatile') + if volatile: + continue + if not const: + const = self.skip_word_and_ws('const') + if const: + continue + break + next = self._parse_declarator(named, paramMode, typed) + return ASTDeclaratorMemPtr(name, const, volatile, next=next) pos = self.pos try: - return self._parse_declarator_name_suffix(named, paramMode, typed) + res = self._parse_declarator_name_suffix(named, paramMode, 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, "")) + return res except DefinitionError as e: self.pos = pos prevErrors.append((e, "If declarator-id")) - header = "Error in declarator or parameters and qualifiers" + header = "Error in declarator or parameters-and-qualifiers" raise self._make_multi_error(prevErrors, header) def _parse_initializer(self, outer: str = None, allowFallback: bool = True @@ -5866,7 +5963,6 @@ class DefinitionParser(BaseParser): raise Exception('Internal error, unknown outer "%s".' % outer) if outer != 'operatorCast': assert named - if outer in ('type', 'function'): # We allow type objects to just be a name. # Some functions don't have normal return types: constructors, @@ -5974,10 +6070,10 @@ class DefinitionParser(BaseParser): if eExpr is None: raise eType errs = [] - errs.append((eExpr, "If default is an expression")) - errs.append((eType, "If default is a type")) + 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 constrianted template paramter." + msg += " or constrained template parameter." raise self._make_multi_error(errs, msg) def _parse_type_using(self) -> ASTTypeUsing: @@ -6060,8 +6156,8 @@ class DefinitionParser(BaseParser): self.skip_ws() if not self.skip_string("<"): self.fail("Expected '<' after 'template'") + prevErrors = [] while 1: - prevErrors = [] self.skip_ws() if self.skip_word('template'): # declare a tenplate template parameter @@ -6114,6 +6210,7 @@ class DefinitionParser(BaseParser): if self.skip_string('>'): return ASTTemplateParams(templateParams) elif self.skip_string(','): + prevErrors = [] continue else: header = "Error in template parameter list." @@ -6333,7 +6430,7 @@ class DefinitionParser(BaseParser): def parse_expression(self) -> Union[ASTExpression, ASTType]: pos = self.pos try: - expr = self._parse_expression(False) + expr = self._parse_expression() self.skip_ws() self.assert_end() return expr |