mewin/cxxheaderparser
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #80 from robotpy/cpp20

Browse Source 
Add various C++20 features
This commit is contained in:
Dustin Spicuzza 2023-10-13 02:37:46 -04:00 committed by GitHub
commit 9883a4e247
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 1431 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cxxheaderparser/lexer.py
View File

@ -83,6 +83,7 @@ class PlyLexer:
"char16_t", "char16_t",
"char32_t", "char32_t",
"class", "class",
"concept",
"const", "const",
"constexpr", "constexpr",
"const_cast", "const_cast",
@ -121,6 +122,7 @@ class PlyLexer:
"public", "public",
"register", "register",
"reinterpret_cast", "reinterpret_cast",
"requires",
"return", "return",
"short", "short",
"signed", "signed",
@ -186,6 +188,7 @@ class PlyLexer:
"DBL_RBRACKET", "DBL_RBRACKET",
"DBL_COLON", "DBL_COLON",
"DBL_AMP", "DBL_AMP",
"DBL_PIPE",
"ARROW", "ARROW",
"SHIFT_LEFT", "SHIFT_LEFT",
] + list(keywords) ] + list(keywords)
@ -471,6 +474,7 @@ class PlyLexer:
t_DBL_RBRACKET = r"\]\]" t_DBL_RBRACKET = r"\]\]"
t_DBL_COLON = r"::" t_DBL_COLON = r"::"
t_DBL_AMP = r"&&" t_DBL_AMP = r"&&"
t_DBL_PIPE = r"\|\|"
t_ARROW = r"->" t_ARROW = r"->"
t_SHIFT_LEFT = r"<<" t_SHIFT_LEFT = r"<<"
# SHIFT_RIGHT introduces ambiguity # SHIFT_RIGHT introduces ambiguity

222
cxxheaderparser/parser.py
View File

@ -22,6 +22,7 @@ from .types import (
AutoSpecifier, AutoSpecifier,
BaseClass, BaseClass,
ClassDecl, ClassDecl,
Concept,
DecltypeSpecifier, DecltypeSpecifier,
DecoratedType, DecoratedType,
EnumDecl, EnumDecl,
@ -537,7 +538,7 @@ class CxxParser:
self._finish_class_decl(old_state) self._finish_class_decl(old_state)
# #
# Template parsing # Template and concept parsing
# #
def _parse_template_type_parameter( def _parse_template_type_parameter(
@ -605,9 +606,13 @@ class CxxParser:
lex.return_token(ptok) lex.return_token(ptok)
param = self._parse_template_type_parameter(tok, None) param = self._parse_template_type_parameter(tok, None)
else: else:
param = self._parse_parameter(ptok, TemplateNonTypeParam, ">") param, _ = self._parse_parameter(
ptok, TemplateNonTypeParam, False, ">"
)
else: else:
param = self._parse_parameter(tok, TemplateNonTypeParam, ">") param, _ = self._parse_parameter(
tok, TemplateNonTypeParam, concept_ok=False, end=">"
)
params.append(param) params.append(param)
@ -640,6 +645,11 @@ class CxxParser:
self._parse_using(tok, doxygen, template) self._parse_using(tok, doxygen, template)
elif tok.type == "friend": elif tok.type == "friend":
self._parse_friend_decl(tok, doxygen, template) self._parse_friend_decl(tok, doxygen, template)
elif tok.type == "concept":
self._parse_concept(tok, doxygen, template)
elif tok.type == "requires":
template.raw_requires_pre = self._parse_requires(tok)
self._parse_declarations(self.lex.token(), doxygen, template)
else: else:
self._parse_declarations(tok, doxygen, template) self._parse_declarations(tok, doxygen, template)
@ -750,6 +760,117 @@ class CxxParser:
self.state, TemplateInst(typename, extern, doxygen) self.state, TemplateInst(typename, extern, doxygen)
) )
def _parse_concept(
self,
tok: LexToken,
doxygen: typing.Optional[str],
template: TemplateDecl,
) -> None:
name = self._next_token_must_be("NAME")
self._next_token_must_be("=")
# not trying to understand this for now
raw_constraint = self._create_value(self._consume_value_until([], ",", ";"))
state = self.state
if isinstance(state, ClassBlockState):
raise CxxParseError("concept cannot be defined in a class")
self.visitor.on_concept(
state,
Concept(
template=template,
name=name.value,
raw_constraint=raw_constraint,
doxygen=doxygen,
),
)
# fmt: off
_expr_operators = {
"<", ">", "|", "%", "^", "!", "*", "-", "+", "&", "=",
"&&", "||", "<<"
}
# fmt: on
def _parse_requires(
self,
tok: LexToken,
) -> Value:
tok = self.lex.token()
rawtoks: typing.List[LexToken] = []
# The easier case -- requires requires
if tok.type == "requires":
rawtoks.append(tok)
for tt in ("(", "{"):
tok = self._next_token_must_be(tt)
rawtoks.extend(self._consume_balanced_tokens(tok))
# .. and that's it?
# this is either a parenthesized expression or a primary clause
elif tok.type == "(":
rawtoks.extend(self._consume_balanced_tokens(tok))
else:
while True:
if tok.type == "(":
rawtoks.extend(self._consume_balanced_tokens(tok))
else:
tok = self._parse_requires_segment(tok, rawtoks)
# If this is not an operator of some kind, we don't know how
# to proceed so let the next parser figure it out
if tok.value not in self._expr_operators:
break
rawtoks.append(tok)
# check once more for compound operator?
tok = self.lex.token()
if tok.value in self._expr_operators:
rawtoks.append(tok)
tok = self.lex.token()
self.lex.return_token(tok)
return self._create_value(rawtoks)
def _parse_requires_segment(
self, tok: LexToken, rawtoks: typing.List[LexToken]
) -> LexToken:
# first token could be a name or ::
if tok.type == "DBL_COLON":
rawtoks.append(tok)
tok = self.lex.token()
while True:
# This token has to be a name or some other valid name-like thing
if tok.value == "decltype":
rawtoks.append(tok)
tok = self._next_token_must_be("(")
rawtoks.extend(self._consume_balanced_tokens(tok))
elif tok.type == "NAME":
rawtoks.append(tok)
else:
# not sure what I expected, but I didn't find it
raise self._parse_error(tok)
tok = self.lex.token()
# Maybe there's a specialization
if tok.value == "<":
rawtoks.extend(self._consume_balanced_tokens(tok))
tok = self.lex.token()
# Maybe we keep trying to parse this name
if tok.type == "DBL_COLON":
tok = self.lex.token()
continue
# Let the caller decide
return tok
# #
# Attributes # Attributes
# #
@ -1615,23 +1736,43 @@ class CxxParser:
# #
def _parse_parameter( def _parse_parameter(
self, tok: typing.Optional[LexToken], cls: typing.Type[PT], end: str = ")" self,
) -> PT: tok: typing.Optional[LexToken],
cls: typing.Type[PT],
concept_ok: bool,
end: str = ")",
) -> typing.Tuple[PT, typing.Optional[Type]]:
""" """
Parses a single parameter (excluding vararg parameters). Also used Parses a single parameter (excluding vararg parameters). Also used
to parse template non-type parameters to parse template non-type parameters
Returns parameter type, abbreviated template type
""" """
param_name = None param_name = None
default = None default = None
param_pack = False param_pack = False
parsed_type: typing.Optional[Type]
at_type: typing.Optional[Type] = None
# required typename + decorators if not tok:
parsed_type, mods = self._parse_type(tok) tok = self.lex.token()
if parsed_type is None:
raise self._parse_error(None)
mods.validate(var_ok=False, meth_ok=False, msg="parsing parameter") # placeholder type, skip typename
if tok.type == "auto":
at_type = parsed_type = Type(PQName([AutoSpecifier()]))
else:
# required typename + decorators
parsed_type, mods = self._parse_type(tok)
if parsed_type is None:
raise self._parse_error(None)
mods.validate(var_ok=False, meth_ok=False, msg="parsing parameter")
# Could be a concept
if concept_ok and self.lex.token_if("auto"):
at_type = Type(parsed_type.typename)
parsed_type.typename = PQName([AutoSpecifier()])
dtype = self._parse_cv_ptr(parsed_type) dtype = self._parse_cv_ptr(parsed_type)
@ -1659,23 +1800,32 @@ class CxxParser:
if self.lex.token_if("="): if self.lex.token_if("="):
default = self._create_value(self._consume_value_until([], ",", end)) default = self._create_value(self._consume_value_until([], ",", end))
# abbreviated template pack
if at_type and self.lex.token_if("ELLIPSIS"):
param_pack = True
param = cls(type=dtype, name=param_name, default=default, param_pack=param_pack) param = cls(type=dtype, name=param_name, default=default, param_pack=param_pack)
self.debug_print("parameter: %s", param) self.debug_print("parameter: %s", param)
return param return param, at_type
def _parse_parameters(self) -> typing.Tuple[typing.List[Parameter], bool]: def _parse_parameters(
self, concept_ok: bool
) -> typing.Tuple[typing.List[Parameter], bool, typing.List[TemplateParam]]:
""" """
Consumes function parameters and returns them, and vararg if found Consumes function parameters and returns them, and vararg if found, and
promotes abbreviated template parameters to actual template parameters
if concept_ok is True
""" """
# starting at a ( # starting at a (
# special case: zero parameters # special case: zero parameters
if self.lex.token_if(")"): if self.lex.token_if(")"):
return [], False return [], False, []
params: typing.List[Parameter] = [] params: typing.List[Parameter] = []
vararg = False vararg = False
at_params: typing.List[TemplateParam] = []
while True: while True:
if self.lex.token_if("ELLIPSIS"): if self.lex.token_if("ELLIPSIS"):
@ -1683,8 +1833,17 @@ class CxxParser:
self._next_token_must_be(")") self._next_token_must_be(")")
break break
param = self._parse_parameter(None, Parameter) param, at_type = self._parse_parameter(None, Parameter, concept_ok)
params.append(param) params.append(param)
if at_type:
at_params.append(
TemplateNonTypeParam(
type=at_type,
param_idx=len(params) - 1,
param_pack=param.param_pack,
)
)
tok = self._next_token_must_be(",", ")") tok = self._next_token_must_be(",", ")")
if tok.value == ")": if tok.value == ")":
break break
@ -1699,7 +1858,7 @@ class CxxParser:
): ):
params = [] params = []
return params, vararg return params, vararg, at_params
_auto_return_typename = PQName([AutoSpecifier()]) _auto_return_typename = PQName([AutoSpecifier()])
@ -1745,6 +1904,15 @@ class CxxParser:
if otok: if otok:
toks = self._consume_balanced_tokens(otok)[1:-1] toks = self._consume_balanced_tokens(otok)[1:-1]
fn.noexcept = self._create_value(toks) fn.noexcept = self._create_value(toks)
else:
rtok = self.lex.token_if("requires")
if rtok:
fn_template = fn.template
if fn_template is None:
raise self._parse_error(rtok)
elif isinstance(fn_template, list):
fn_template = fn_template[0]
fn_template.raw_requires_post = self._parse_requires(rtok)
if self.lex.token_if("{"): if self.lex.token_if("{"):
self._discard_contents("{", "}") self._discard_contents("{", "}")
@ -1805,6 +1973,13 @@ class CxxParser:
if otok: if otok:
toks = self._consume_balanced_tokens(otok)[1:-1] toks = self._consume_balanced_tokens(otok)[1:-1]
method.noexcept = self._create_value(toks) method.noexcept = self._create_value(toks)
elif tok_value == "requires":
method_template = method.template
if method_template is None:
raise self._parse_error(tok)
elif isinstance(method_template, list):
method_template = method_template[0]
method_template.raw_requires_post = self._parse_requires(tok)
else: else:
self.lex.return_token(tok) self.lex.return_token(tok)
break break
@ -1846,7 +2021,16 @@ class CxxParser:
state.location = location state.location = location
is_class_block = isinstance(state, ClassBlockState) is_class_block = isinstance(state, ClassBlockState)
params, vararg = self._parse_parameters() params, vararg, at_params = self._parse_parameters(True)
# Promote abbreviated template parameters
if at_params:
if template is None:
template = TemplateDecl(at_params)
elif isinstance(template, TemplateDecl):
template.params.extend(at_params)
else:
template[-1].params.extend(at_params)
# A method outside of a class has multiple name segments # A method outside of a class has multiple name segments
multiple_name_segments = len(pqname.segments) > 1 multiple_name_segments = len(pqname.segments) > 1
@ -2019,7 +2203,7 @@ class CxxParser:
toks = self._consume_balanced_tokens(gtok) toks = self._consume_balanced_tokens(gtok)
self.lex.return_tokens(toks[1:-1]) self.lex.return_tokens(toks[1:-1])
fn_params, vararg = self._parse_parameters() fn_params, vararg, _ = self._parse_parameters(False)
assert not isinstance(dtype, FunctionType) assert not isinstance(dtype, FunctionType)
dtype = dtype_fn = FunctionType(dtype, fn_params, vararg) dtype = dtype_fn = FunctionType(dtype, fn_params, vararg)
@ -2047,7 +2231,7 @@ class CxxParser:
assert not isinstance(dtype, FunctionType) assert not isinstance(dtype, FunctionType)
dtype = self._parse_array_type(aptok, dtype) dtype = self._parse_array_type(aptok, dtype)
elif aptok.type == "(": elif aptok.type == "(":
fn_params, vararg = self._parse_parameters() fn_params, vararg, _ = self._parse_parameters(False)
# the type we already have is the return type of the function pointer # the type we already have is the return type of the function pointer
assert not isinstance(dtype, FunctionType) assert not isinstance(dtype, FunctionType)

7
cxxheaderparser/simple.py
View File

@ -34,6 +34,7 @@ from dataclasses import dataclass, field
from .types import ( from .types import (
ClassDecl, ClassDecl,
Concept,
EnumDecl, EnumDecl,
Field, Field,
ForwardDecl, ForwardDecl,
@ -113,6 +114,9 @@ class NamespaceScope:
using_alias: typing.List[UsingAlias] = field(default_factory=list) using_alias: typing.List[UsingAlias] = field(default_factory=list)
ns_alias: typing.List[NamespaceAlias] = field(default_factory=list) ns_alias: typing.List[NamespaceAlias] = field(default_factory=list)
#: Concepts
concepts: typing.List[Concept] = field(default_factory=list)
#: Explicit template instantiations #: Explicit template instantiations
template_insts: typing.List[TemplateInst] = field(default_factory=list) template_insts: typing.List[TemplateInst] = field(default_factory=list)
@ -243,6 +247,9 @@ class SimpleCxxVisitor:
def on_namespace_end(self, state: SNamespaceBlockState) -> None: def on_namespace_end(self, state: SNamespaceBlockState) -> None:
pass pass
def on_concept(self, state: SNonClassBlockState, concept: Concept) -> None:
state.user_data.concepts.append(concept)
def on_namespace_alias( def on_namespace_alias(
self, state: SNonClassBlockState, alias: NamespaceAlias self, state: SNonClassBlockState, alias: NamespaceAlias
) -> None: ) -> None:

41
cxxheaderparser/types.py
View File

@ -454,12 +454,19 @@ class TemplateNonTypeParam:
template <auto T> template <auto T>
~~~~~~ ~~~~~~
// abbreviated template parameters are converted to this and param_idx is set
void fn(C auto p)
~~~~~~
""" """
type: DecoratedType type: DecoratedType
name: typing.Optional[str] = None name: typing.Optional[str] = None
default: typing.Optional[Value] = None default: typing.Optional[Value] = None
#: If this was promoted, the parameter index that this corresponds with
param_idx: typing.Optional[int] = None
#: Contains a ``...`` #: Contains a ``...``
param_pack: bool = False param_pack: bool = False
@ -513,6 +520,15 @@ class TemplateDecl:
params: typing.List[TemplateParam] = field(default_factory=list) params: typing.List[TemplateParam] = field(default_factory=list)
# Currently don't interpret requires, if that changes in the future
# then this API will change.
#: template <typename T> requires ...
raw_requires_pre: typing.Optional[Value] = None
#: template <typename T> int main() requires ...
raw_requires_post: typing.Optional[Value] = None
#: If no template, this is None. This is a TemplateDecl if this there is a single #: If no template, this is None. This is a TemplateDecl if this there is a single
#: declaration: #: declaration:
@ -551,6 +567,31 @@ class TemplateInst:
doxygen: typing.Optional[str] = None doxygen: typing.Optional[str] = None
@dataclass
class Concept:
"""
Preliminary support for consuming headers that contain concepts, but
not trying to actually make sense of them at this time. If this is
something you care about, pull requests are welcomed!
.. code-block:: c++
template <class T>
concept Meowable = is_meowable<T>;
template<typename T>
concept Addable = requires (T x) { x + x; };
"""
template: TemplateDecl
name: str
#: In the future this will be removed if we fully parse the expression
raw_constraint: Value
doxygen: typing.Optional[str] = None
@dataclass @dataclass
class ForwardDecl: class ForwardDecl:
""" """

12
cxxheaderparser/visitor.py
View File

@ -8,6 +8,7 @@ else:
from .types import ( from .types import (
Concept,
EnumDecl, EnumDecl,
Field, Field,
ForwardDecl, ForwardDecl,
@ -89,6 +90,14 @@ class CxxVisitor(Protocol):
Called when a ``namespace`` alias is encountered Called when a ``namespace`` alias is encountered
""" """
def on_concept(self, state: NonClassBlockState, concept: Concept) -> None:
"""
.. code-block:: c++
template <class T>
concept Meowable = is_meowable<T>;
"""
def on_forward_decl(self, state: State, fdecl: ForwardDecl) -> None: def on_forward_decl(self, state: State, fdecl: ForwardDecl) -> None:
""" """
Called when a forward declaration is encountered Called when a forward declaration is encountered
@ -254,6 +263,9 @@ class NullVisitor:
def on_namespace_end(self, state: NamespaceBlockState) -> None: def on_namespace_end(self, state: NamespaceBlockState) -> None:
return None return None
def on_concept(self, state: NonClassBlockState, concept: Concept) -> None:
return None
def on_namespace_alias( def on_namespace_alias(
self, state: NonClassBlockState, alias: NamespaceAlias self, state: NonClassBlockState, alias: NamespaceAlias
) -> None: ) -> None:

353
tests/test_abv_template.py Normal file
View File

@ -0,0 +1,353 @@
# Note: testcases generated via `python -m cxxheaderparser.gentest`
#
# Tests various aspects of abbreviated function templates
#
from cxxheaderparser.simple import NamespaceScope, ParsedData, parse_string
from cxxheaderparser.types import (
AutoSpecifier,
Function,
FundamentalSpecifier,
NameSpecifier,
PQName,
Parameter,
Pointer,
Reference,
TemplateDecl,
TemplateNonTypeParam,
Type,
)
def test_abv_template_f1() -> None:
content = """
void f1(auto); // same as template<class T> void f1(T)
void f1p(auto p);
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f1")]),
parameters=[
Parameter(
type=Type(typename=PQName(segments=[AutoSpecifier()]))
)
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(typename=PQName(segments=[AutoSpecifier()])),
param_idx=0,
)
]
),
),
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f1p")]),
parameters=[
Parameter(
type=Type(typename=PQName(segments=[AutoSpecifier()])),
name="p",
)
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(typename=PQName(segments=[AutoSpecifier()])),
param_idx=0,
)
]
),
),
]
)
)
def test_abv_template_f2() -> None:
content = """
void f2(C1 auto); // same as template<C1 T> void f2(T), if C1 is a concept
void f2p(C1 auto p);
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f2")]),
parameters=[
Parameter(
type=Type(typename=PQName(segments=[AutoSpecifier()]))
)
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(segments=[NameSpecifier(name="C1")])
),
param_idx=0,
)
]
),
),
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f2p")]),
parameters=[
Parameter(
type=Type(typename=PQName(segments=[AutoSpecifier()])),
name="p",
)
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(segments=[NameSpecifier(name="C1")])
),
param_idx=0,
)
]
),
),
]
)
)
def test_abv_template_f3() -> None:
content = """
void f3(C2 auto...); // same as template<C2... Ts> void f3(Ts...), if C2 is a
// concept
void f3p(C2 auto p...);
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f3")]),
parameters=[
Parameter(
type=Type(typename=PQName(segments=[AutoSpecifier()])),
param_pack=True,
)
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(segments=[NameSpecifier(name="C2")])
),
param_idx=0,
param_pack=True,
)
]
),
),
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f3p")]),
parameters=[
Parameter(
type=Type(typename=PQName(segments=[AutoSpecifier()])),
name="p",
param_pack=True,
)
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(segments=[NameSpecifier(name="C2")])
),
param_idx=0,
param_pack=True,
)
]
),
),
]
)
)
def test_abv_template_f4() -> None:
content = """
void f4(C2 auto, ...); // same as template<C2 T> void f4(T...), if C2 is a concept
void f4p(C2 auto p,...);
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f4")]),
parameters=[
Parameter(
type=Type(typename=PQName(segments=[AutoSpecifier()]))
)
],
vararg=True,
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(segments=[NameSpecifier(name="C2")])
),
param_idx=0,
)
]
),
),
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f4p")]),
parameters=[
Parameter(
type=Type(typename=PQName(segments=[AutoSpecifier()])),
name="p",
)
],
vararg=True,
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(segments=[NameSpecifier(name="C2")])
),
param_idx=0,
)
]
),
),
]
)
)
def test_abv_template_f5() -> None:
content = """
void f5(const C3 auto *, C4 auto &); // same as template<C3 T, C4 U> void f5(const T*, U&);
void f5p(const C3 auto * p1, C4 auto &p2);
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f5")]),
parameters=[
Parameter(
type=Pointer(
ptr_to=Type(
typename=PQName(
segments=[AutoSpecifier()],
),
const=True,
)
)
),
Parameter(
type=Reference(
ref_to=Type(typename=PQName(segments=[AutoSpecifier()]))
)
),
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(
segments=[NameSpecifier(name="C3")]
),
),
param_idx=0,
),
TemplateNonTypeParam(
type=Type(
typename=PQName(segments=[NameSpecifier(name="C4")])
),
param_idx=1,
),
]
),
),
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f5p")]),
parameters=[
Parameter(
type=Pointer(
ptr_to=Type(
typename=PQName(
segments=[AutoSpecifier()],
),
const=True,
)
),
name="p1",
),
Parameter(
type=Reference(
ref_to=Type(typename=PQName(segments=[AutoSpecifier()]))
),
name="p2",
),
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(
segments=[NameSpecifier(name="C3")]
),
),
param_idx=0,
),
TemplateNonTypeParam(
type=Type(
typename=PQName(segments=[NameSpecifier(name="C4")])
),
param_idx=1,
),
]
),
),
]
)
)

811
tests/test_concepts.py Normal file
View File

@ -0,0 +1,811 @@
from cxxheaderparser.simple import ClassScope, NamespaceScope, ParsedData, parse_string
from cxxheaderparser.tokfmt import Token
from cxxheaderparser.types import (
AutoSpecifier,
ClassDecl,
Concept,
Function,
FundamentalSpecifier,
MoveReference,
NameSpecifier,
PQName,
Parameter,
TemplateArgument,
TemplateDecl,
TemplateNonTypeParam,
TemplateSpecialization,
TemplateTypeParam,
Type,
Value,
Variable,
)
def test_concept_basic_constraint() -> None:
content = """
template <class T, class U>
concept Derived = std::is_base_of<U, T>::value;
template <Derived<Base> T> void f(T); // T is constrained by Derived<T, Base>
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f")]),
parameters=[
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
)
)
],
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(
segments=[
NameSpecifier(
name="Derived",
specialization=TemplateSpecialization(
args=[
TemplateArgument(
arg=Type(
typename=PQName(
segments=[
NameSpecifier(
name="Base"
)
]
)
)
)
]
),
)
]
)
),
name="T",
)
]
),
)
],
concepts=[
Concept(
template=TemplateDecl(
params=[
TemplateTypeParam(typekey="class", name="T"),
TemplateTypeParam(typekey="class", name="U"),
]
),
name="Derived",
raw_constraint=Value(
tokens=[
Token(value="std"),
Token(value="::"),
Token(value="is_base_of"),
Token(value="<"),
Token(value="U"),
Token(value=","),
Token(value="T"),
Token(value=">"),
Token(value="::"),
Token(value="value"),
]
),
)
],
)
)
def test_concept_basic_constraint2() -> None:
content = """
template <class T> constexpr bool is_meowable = true;
template <class T> constexpr bool is_cat = true;
template <class T>
concept Meowable = is_meowable<T>;
template <class T>
concept BadMeowableCat = is_meowable<T> && is_cat<T>;
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
variables=[
Variable(
name=PQName(segments=[NameSpecifier(name="is_meowable")]),
type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="bool")])
),
value=Value(tokens=[Token(value="true")]),
constexpr=True,
template=TemplateDecl(
params=[TemplateTypeParam(typekey="class", name="T")]
),
),
Variable(
name=PQName(segments=[NameSpecifier(name="is_cat")]),
type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="bool")])
),
value=Value(tokens=[Token(value="true")]),
constexpr=True,
template=TemplateDecl(
params=[TemplateTypeParam(typekey="class", name="T")]
),
),
],
concepts=[
Concept(
template=TemplateDecl(
params=[TemplateTypeParam(typekey="class", name="T")]
),
name="Meowable",
raw_constraint=Value(
tokens=[
Token(value="is_meowable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
),
Concept(
template=TemplateDecl(
params=[TemplateTypeParam(typekey="class", name="T")]
),
name="BadMeowableCat",
raw_constraint=Value(
tokens=[
Token(value="is_meowable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="&&"),
Token(value="is_cat"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
),
],
)
)
def test_concept_basic_requires() -> None:
content = """
template <typename T>
concept Hashable = requires(T a) {
{ std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
};
template <Hashable T> void f(T) {}
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f")]),
parameters=[
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
)
)
],
has_body=True,
template=TemplateDecl(
params=[
TemplateNonTypeParam(
type=Type(
typename=PQName(
segments=[NameSpecifier(name="Hashable")]
)
),
name="T",
)
]
),
)
],
concepts=[
Concept(
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")]
),
name="Hashable",
raw_constraint=Value(
tokens=[
Token(value="requires"),
Token(value="("),
Token(value="T"),
Token(value="a"),
Token(value=")"),
Token(value="{"),
Token(value="{"),
Token(value="std"),
Token(value="::"),
Token(value="hash"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="{"),
Token(value="}"),
Token(value="("),
Token(value="a"),
Token(value=")"),
Token(value="}"),
Token(value="->"),
Token(value="std"),
Token(value="::"),
Token(value="convertible_to"),
Token(value="<"),
Token(value="std"),
Token(value="::"),
Token(value="size_t"),
Token(value=">"),
Token(value=";"),
Token(value="}"),
]
),
)
],
)
)
def test_concept_nested_requirements() -> None:
content = """
template<class T>
concept Semiregular = DefaultConstructible<T> &&
CopyConstructible<T> && CopyAssignable<T> && Destructible<T> &&
requires(T a, std::size_t n)
{
requires Same<T*, decltype(&a)>; // nested: "Same<...> evaluates to true"
{ a.~T() } noexcept; // compound: "a.~T()" is a valid expression that doesn't throw
requires Same<T*, decltype(new T)>; // nested: "Same<...> evaluates to true"
requires Same<T*, decltype(new T[n])>; // nested
{ delete new T }; // compound
{ delete new T[n] }; // compound
};
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
concepts=[
Concept(
template=TemplateDecl(
params=[TemplateTypeParam(typekey="class", name="T")]
),
name="Semiregular",
raw_constraint=Value(
tokens=[
Token(value="DefaultConstructible"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="&&"),
Token(value="CopyConstructible"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="&&"),
Token(value="CopyAssignable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="&&"),
Token(value="Destructible"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="&&"),
Token(value="requires"),
Token(value="("),
Token(value="T"),
Token(value="a"),
Token(value=","),
Token(value="std"),
Token(value="::"),
Token(value="size_t"),
Token(value="n"),
Token(value=")"),
Token(value="{"),
Token(value="requires"),
Token(value="Same"),
Token(value="<"),
Token(value="T"),
Token(value="*"),
Token(value=","),
Token(value="decltype"),
Token(value="("),
Token(value="&"),
Token(value="a"),
Token(value=")"),
Token(value=">"),
Token(value=";"),
Token(value="{"),
Token(value="a"),
Token(value="."),
Token(value="~T"),
Token(value="("),
Token(value=")"),
Token(value="}"),
Token(value="noexcept"),
Token(value=";"),
Token(value="requires"),
Token(value="Same"),
Token(value="<"),
Token(value="T"),
Token(value="*"),
Token(value=","),
Token(value="decltype"),
Token(value="("),
Token(value="new"),
Token(value="T"),
Token(value=")"),
Token(value=">"),
Token(value=";"),
Token(value="requires"),
Token(value="Same"),
Token(value="<"),
Token(value="T"),
Token(value="*"),
Token(value=","),
Token(value="decltype"),
Token(value="("),
Token(value="new"),
Token(value="T"),
Token(value="["),
Token(value="n"),
Token(value="]"),
Token(value=")"),
Token(value=">"),
Token(value=";"),
Token(value="{"),
Token(value="delete"),
Token(value="new"),
Token(value="T"),
Token(value="}"),
Token(value=";"),
Token(value="{"),
Token(value="delete"),
Token(value="new"),
Token(value="T"),
Token(value="["),
Token(value="n"),
Token(value="]"),
Token(value="}"),
Token(value=";"),
Token(value="}"),
]
),
)
]
)
)
def test_concept_requires_class() -> None:
content = """
// clang-format off
template <typename T>
concept Number = std::integral<T> || std::floating_point<T>;
template <typename T>
requires Number<T>
struct WrappedNumber {};
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
classes=[
ClassScope(
class_decl=ClassDecl(
typename=PQName(
segments=[NameSpecifier(name="WrappedNumber")],
classkey="struct",
),
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")],
raw_requires_pre=Value(
tokens=[
Token(value="Number"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
),
)
)
],
concepts=[
Concept(
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")]
),
name="Number",
raw_constraint=Value(
tokens=[
Token(value="std"),
Token(value="::"),
Token(value="integral"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="||"),
Token(value="std"),
Token(value="::"),
Token(value="floating_point"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
)
],
)
)
def test_requires_last_elem() -> None:
content = """
template<typename T>
void f(T&&) requires Eq<T>; // can appear as the last element of a function declarator
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="f")]),
parameters=[
Parameter(
type=MoveReference(
moveref_to=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
)
)
)
],
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")],
raw_requires_post=Value(
tokens=[
Token(value="Eq"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
),
)
]
)
)
def test_requires_first_elem1() -> None:
content = """
template<typename T> requires Addable<T> // or right after a template parameter list
T add(T a, T b) { return a + b; }
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name=PQName(segments=[NameSpecifier(name="add")]),
parameters=[
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="a",
),
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="b",
),
],
has_body=True,
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")],
raw_requires_pre=Value(
tokens=[
Token(value="Addable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
),
)
]
)
)
def test_requires_first_elem2() -> None:
content = """
template<typename T> requires std::is_arithmetic_v<T>
T add(T a, T b) { return a + b; }
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name=PQName(segments=[NameSpecifier(name="add")]),
parameters=[
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="a",
),
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="b",
),
],
has_body=True,
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")],
raw_requires_pre=Value(
tokens=[
Token(value="std"),
Token(value="is_arithmetic_v"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
),
)
]
)
)
def test_requires_compound() -> None:
content = """
template<typename T> requires Addable<T> || Subtractable<T>
T add(T a, T b) { return a + b; }
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name=PQName(segments=[NameSpecifier(name="add")]),
parameters=[
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="a",
),
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="b",
),
],
has_body=True,
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")],
raw_requires_pre=Value(
tokens=[
Token(value="Addable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="||"),
Token(value="Subtractable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
),
)
]
)
)
def test_requires_ad_hoc() -> None:
content = """
template<typename T>
requires requires (T x) { x + x; } // ad-hoc constraint, note keyword used twice
T add(T a, T b) { return a + b; }
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name=PQName(segments=[NameSpecifier(name="add")]),
parameters=[
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="a",
),
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="b",
),
],
has_body=True,
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")],
raw_requires_pre=Value(
tokens=[
Token(value="requires"),
Token(value="("),
Token(value="T"),
Token(value="x"),
Token(value=")"),
Token(value="{"),
Token(value="x"),
Token(value="+"),
Token(value="x"),
Token(value=";"),
Token(value="}"),
]
),
),
)
]
)
)
def test_requires_both() -> None:
content = """
// clang-format off
template<typename T>
requires Addable<T>
auto f1(T a, T b) requires Subtractable<T>;
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(typename=PQName(segments=[AutoSpecifier()])),
name=PQName(segments=[NameSpecifier(name="f1")]),
parameters=[
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="a",
),
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
),
name="b",
),
],
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")],
raw_requires_pre=Value(
tokens=[
Token(value="Addable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
raw_requires_post=Value(
tokens=[
Token(value="Subtractable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
]
),
),
)
]
)
)
def test_requires_paren() -> None:
content = """
// clang-format off
template<class T>
void h(T) requires (is_purrable<T>());
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="h")]),
parameters=[
Parameter(
type=Type(
typename=PQName(segments=[NameSpecifier(name="T")])
)
)
],
template=TemplateDecl(
params=[TemplateTypeParam(typekey="class", name="T")],
raw_requires_post=Value(
tokens=[
Token(value="("),
Token(value="is_purrable"),
Token(value="<"),
Token(value="T"),
Token(value=">"),
Token(value="("),
Token(value=")"),
Token(value=")"),
]
),
),
)
]
)
)