use cpp_parser::{CppParser, CppSyntaxKind, ParserConfig};
fn kinds(source: &str) -> Vec<CppSyntaxKind> {
CppParser::parse(source, ParserConfig::default())
.get_red_root()
.descendants()
.map(|node| CppSyntaxKind::from(node.kind()))
.collect()
}
fn count(source: &str, kind: CppSyntaxKind) -> usize {
kinds(source).into_iter().filter(|k| *k == kind).count()
}
fn parses(source: &str) {
let tree = CppParser::parse(source, ParserConfig::default());
assert_eq!(
tree.get_errors(),
[],
"{source:?} must parse cleanly, got {:?}",
tree.get_errors()
);
assert_eq!(tree.to_source_text(), source, "{source:?} stays lossless");
}
#[test]
fn a_global_qualified_name_in_parentheses_is_an_expression() {
for source in [
"void f() { (::x); }\n",
"void f() { auto y = (::x); }\n",
"void f() { (::x + 1); }\n",
"void f() { (::x()); }\n",
"int f(int x) { return (::abs(x) > 1); }\n",
"int f(int x) { return ((::abs(x)) > 1); }\n",
] {
parses(source);
assert!(
count(source, CppSyntaxKind::ParenExpr) >= 1,
"{source:?} is a parenthesised expression"
);
}
for source in [
"void f(void* p) { auto x = (::MyType*)p; }\n",
"void f(int x) { auto y = (::MyType)x; }\n",
"void f(int x) { auto y = (::std::string)x; }\n",
] {
parses(source);
assert!(
count(source, CppSyntaxKind::CastExpr) >= 1,
"{source:?} is a cast"
);
}
}
#[test]
fn a_functional_cast_with_a_keyword_type_is_a_cast() {
for source in [
"int f(int x) { return bool(x); }\n",
"void f(int x) { g(bool(x)); }\n",
"void f() { g(\"k\", bool(lint[\"s\"])); }\n",
"void f(int x) { if (bool(x)) { } }\n",
"void f(int x) { auto y = int(x) + double(x); }\n",
"void f(int x) { auto y = unsigned(x); }\n",
] {
parses(source);
assert!(
count(source, CppSyntaxKind::CastExpr) >= 1,
"{source:?} is a functional-notation conversion"
);
}
let declaration = "void f() { int(x); }\n";
parses(declaration);
assert_eq!(
count(declaration, CppSyntaxKind::CastExpr),
0,
"`int(x);` is a declaration, not a conversion"
);
}
#[test]
fn the_pointer_to_member_operators_are_binary_operators() {
for source in [
"struct C { };\nvoid f(C* c) { (c->*h)(1); }\n",
"struct C { };\nvoid f(C& c) { (c.*h)(1); }\n",
"struct C { };\nvoid f(C* c) { auto x = c->*h; }\n",
"struct C { };\nvoid f(C* c) { g(c->*h); }\n",
"struct S { void f() { (this->*h)(1); } };\n",
] {
parses(source);
assert!(
count(source, CppSyntaxKind::BinaryExpr) >= 1,
"{source:?} has a pointer-to-member expression in it"
);
}
}
#[test]
fn the_comma_operator_parses_where_a_comma_is_an_operator() {
for source in [
"void f() { auto x = (a, b); }\n",
"void f() { ((a, b)); }\n",
"void f() { x = 1, y = 2; }\n",
"void f() { for (a = 0, b = 0; ; ) {} }\n",
"void f() { return 1, 2; }\n",
"void f() { g(a, (b, c)); }\n",
"void f() { auto x = (a, b, c); }\n",
] {
parses(source);
}
}
#[test]
fn the_comma_operator_is_an_operator_inside_the_parentheses_and_not_outside() {
let source = "void f() { h(a, (b, c)); }\n";
assert_eq!(
count(source, CppSyntaxKind::BinaryExpr),
1,
"only the parenthesised comma is an operator"
);
assert_eq!(
count(source, CppSyntaxKind::ParenExpr),
1,
"and it is the parenthesised one"
);
}
#[test]
fn the_comma_operator_is_left_associative_and_looser_than_assignment() {
let source = "void f() { x = 1, y = 2; }\n";
assert_eq!(count(source, CppSyntaxKind::BinaryExpr), 3);
assert_eq!(
count(source, CppSyntaxKind::Initializer),
0,
"and it is a statement, not a declaration"
);
}
#[test]
fn a_comma_in_a_container_is_still_a_separator() {
for source in [
"void f() { g(a, b); }\n",
"void f() { g(a, b, c); }\n",
"void f() { g(f(x, y), z); }\n",
"void f() { int v[] = {1, 2}; }\n",
"void f() { auto p = std::pair<int, int>{1, 2}; }\n",
"void f() { Vec<int> v{1, 2, 3}; }\n",
"void f() { auto g = [a, b] { }; }\n",
"void f() { auto g = [&x, y] { }; }\n",
"void f() { auto g = [x = 1, y = 2] { }; }\n",
"void f() { Widget w(1, 2); }\n",
"struct S { S() : a(1), b(2) {} int a; int b; };\n",
"void f() { auto t = std::pair<int, char>(); }\n",
"template <typename A, typename B> void h();\n",
"void f() { g(args..., more); }\n",
"void f() { h(f(x)...); }\n",
] {
parses(source);
assert_eq!(
count(source, CppSyntaxKind::BinaryExpr),
0,
"{source:?} has no comma *operator* in it"
);
}
}
#[test]
fn a_call_keeps_its_argument_count() {
for source in [
"void f() { int a, b; }\n",
"void f() { int a = 1, b = 2; }\n",
"void f() { for (int i = 0, n = 3; i < n; ++i) {} }\n",
"void f() { auto [a, b] = p; }\n",
"void f(int a, int b);\n",
"struct S { void f(int a, int b); };\n",
] {
parses(source);
}
}
#[test]
fn the_container_call_sites_that_the_list_missed_are_fixed() {
for source in [
"struct S { unsigned flags : 1, spare : 7; };\n",
"struct S { int a : 3, b : 4, c : 5; };\n",
"template <typename T, int N = 3, typename... Rest> class Grid { };\n",
"template <typename T, int N = 3> class Grid { };\n",
"template <int A = 1, int B = 2> struct P { };\n",
"void f() { Grid<T, 3>::fill(x); }\n",
"void f() { A<B, C>::d = 1; }\n",
"template <typename T> void Grid<T, 3>::fill(const T& value) {}\n",
"void f() { A<(a, b)> x; }\n",
] {
parses(source);
}
}
#[test]
fn a_cast_with_a_pointer_or_reference_type_is_a_cast() {
for source in [
"void f() { auto d = (T*)p; }\n",
"void f() { auto d = (MyType*)p; }\n",
"void f() { auto d = (T&)x; }\n",
"void f() { auto d = (T&&)x; }\n",
"void f() { auto d = (ns::T*)p; }\n",
"void f() { auto d = (T<int>*)p; }\n",
"void f() { auto d = (const T*)p; }\n",
"void f() { auto d = (T* const)p; }\n",
"void f() { p = (T*)q->r; }\n",
"void f() { g((T*)p, (U*)q); }\n",
] {
parses(source);
assert!(
count(source, CppSyntaxKind::CastExpr) >= 1,
"{source:?} has a cast in it"
);
}
}
#[test]
fn a_cast_to_a_keyword_type_is_a_cast_and_binds_tighter_than_a_binary_operator() {
let source = "void f() { auto d = (T*)p + 1; }\n";
assert_eq!(count(source, CppSyntaxKind::CastExpr), 1);
assert_eq!(count(source, CppSyntaxKind::BinaryExpr), 1);
parses("void f() { auto d = (int)1.5; }\n");
assert_eq!(
count("void f() { auto d = (int)1.5; }\n", CppSyntaxKind::CastExpr),
1
);
}
#[test]
fn a_multiplication_in_parentheses_is_not_a_cast() {
for source in [
"void f() { auto d = (a * b); }\n",
"void f() { auto d = (a* b); }\n",
"void f() { auto d = (a *b); }\n",
"void f() { auto d = (a && b); }\n",
"void f() { auto d = (a & b); }\n",
] {
parses(source);
assert_eq!(
count(source, CppSyntaxKind::CastExpr),
0,
"{source:?} is a parenthesised expression"
);
assert_eq!(count(source, CppSyntaxKind::ParenExpr), 1);
}
}
#[test]
fn a_parenthesised_name_is_not_a_cast() {
for source in [
"void f() { x = (a); }\n",
"void f() { x = (a + b); }\n",
"void f() { x = ((a)); }\n",
"void f() { x = a * (b + c); }\n",
] {
parses(source);
assert_eq!(
count(source, CppSyntaxKind::CastExpr),
0,
"{source:?} is a parenthesised expression"
);
}
}
#[test]
fn a_call_of_a_parenthesised_expression_is_still_a_call() {
for source in [
"void f() { auto d = (f)(x); }\n",
"void f() { auto d = (T)(x); }\n",
] {
parses(source);
assert_eq!(
count(source, CppSyntaxKind::CallExpr),
1,
"{source:?} keeps its argument list"
);
}
}
#[test]
fn a_less_than_between_two_names_is_a_comparison() {
let templated = "void f() { if (n < 0 || n > 100000) { } }\n";
parses(templated);
assert_eq!(
count(templated, CppSyntaxKind::TemplateArgumentList),
0,
"no template-id in a range check"
);
assert_eq!(
count(templated, CppSyntaxKind::BinaryExpr),
3,
"three operators"
);
for source in [
"void f() { x = a < b > c; }\n",
"void f() { x = a < b || c > d; }\n",
"bool g() { return a < b || c > d; }\n",
"void f() { if (n < 0 || n > 100000) { } }\n",
"void f() { while (i < n && j > k) { } }\n",
"void f() { x = (a < b) ? 1 : 2; }\n",
"void f() { x = a.b < c > d; }\n",
"void f() { x = p->m < q > r; }\n",
"void f() { g(a < b, c > d); }\n",
"void f() { x = a < b; }\n",
"void f() { x = a < b && c > d; }\n",
] {
parses(source);
assert_eq!(
count(source, CppSyntaxKind::TemplateArgumentList),
0,
"{source:?} compares rather than instantiates"
);
}
let chained = "void f() { x = a < b > c; }\n";
assert_eq!(count(chained, CppSyntaxKind::BinaryExpr), 3);
}
#[test]
fn a_genuine_template_id_keeps_its_reading() {
for source in [
"void f() { auto n = A<B>::value; }\n",
"void f() { auto n = std::vector<int>::size_type{}; }\n",
"void f() { g<int>(1); }\n",
"void f() { x.template f<int>(1); }\n",
"void f() { auto p = new A<B>(); }\n",
"void f() { auto n = sizeof(A<B>); }\n",
"void f() { auto v = std::vector<int>{}; }\n",
"void f() { std::vector<int> v; }\n",
"void f() { Foo<int> x; }\n",
"void f() { auto n = f<A>(1) + g<B>(2); }\n",
"void f() { auto n = a < b; }\n",
"void f() { for (Foo<int> v : m) { } }\n",
] {
parses(source);
}
assert_eq!(
count(
"void f() { auto n = A<B>::value; }\n",
CppSyntaxKind::TemplateArgumentList
),
1
);
assert_eq!(
count("void f() { g<int>(1); }\n", CppSyntaxKind::CallExpr),
1,
"the call survives the decision"
);
assert_eq!(
count(
"void f() { std::vector<int> v; }\n",
CppSyntaxKind::Declaration
),
2,
"the function definition and the variable it declares"
);
}
#[test]
fn a_cast_to_a_name_the_file_never_declares_is_a_cast() {
for source in [
"void f() { auto d = (MyType)1.5; }\n",
"void f() { auto d = (MyType)x; }\n",
"void f() { auto d = (size_t)size; }\n",
"void f() { auto d = (size_t)size + 1; }\n",
"void f() { buf = (char *)malloc((size_t)size + 1); }\n",
"void f() { auto d = (MyType)new T; }\n",
"void f() { auto d = (MyType)sizeof(T); }\n",
"void f() { auto d = (MyType)!ok; }\n",
"void f() { auto d = (MyType)~mask; }\n",
"void f() { auto d = (MyType)'c'; }\n",
"void f() { auto d = (MyType)\"s\"; }\n",
"void f() { auto d = (MyType)true; }\n",
"void f() { auto d = (MyType)nullptr; }\n",
"void f() { auto d = (MyType)this; }\n",
"void f() { g((size_t)size, (char *)p); }\n",
"void f() { auto d = (size_t)size + (size_t)other; }\n",
] {
parses(source);
assert!(
count(source, CppSyntaxKind::CastExpr) >= 1,
"{source:?} is a cast"
);
}
}
#[test]
fn an_operand_after_the_parentheses_decides_the_cast_and_nothing_else_does() {
for source in [
"void f() { auto d = (a) - b; }\n",
"void f() { auto d = (a) + b; }\n",
"void f() { auto d = (a) * b; }\n",
"void f() { auto d = (a) & b; }\n",
"void f() { auto d = (a)[b]; }\n",
"void f() { auto d = (a)++ ; }\n",
"void f() { auto d = (a), b; }\n",
"void f() { auto d = (a)(b); }\n",
"void f() { auto d = (MyType)-1; }\n",
"void f() { auto d = (MyType)*p; }\n",
"void f() { auto d = (MyType)&x; }\n",
] {
parses(source);
assert_eq!(
count(source, CppSyntaxKind::CastExpr),
0,
"{source:?} is a parenthesised expression"
);
}
}