This is an archive of the discontinued LLVM Phabricator instance.

Differential D81150

Use libClangTesting in the unittest for AST matchers
ClosedPublic

Authored by gribozavr on Jun 4 2020, 5:24 AM.

Details

Reviewers
jdoerfert
hlopko
Commits
rGb5fc1deb5ba1: Use libClangTesting in the unittest for AST matchers
Summary

The unittest for AST matchers has its own way to specify language
standards. I unified it with the shared infrastructure from
libClangTesting.

Diff Detail

Event Timeline

gribozavr created this revision.Jun 4 2020, 5:24 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJun 4 2020, 5:24 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, sstefan1, mgorny. · View Herald Transcript
gribozavr2 added a reviewer: hlopko.Jun 4 2020, 5:24 AM
gribozavr updated this revision to Diff 268440.Jun 4 2020, 5:32 AM

Changed C++20-only tests to C++20-or-later.

hlopko accepted this revision.Jun 4 2020, 6:54 AM

Nice! :)

This revision is now accepted and ready to land.Jun 4 2020, 6:54 AM
Harbormaster failed remote builds in B59052: Diff 268434!Jun 4 2020, 7:04 AM
Harbormaster failed remote builds in B59054: Diff 268440!Jun 4 2020, 8:45 AM
Closed by commit rGb5fc1deb5ba1: Use libClangTesting in the unittest for AST matchers (authored by gribozavr). · Explain WhyJun 4 2020, 8:48 AM
This revision was automatically updated to reflect the committed changes.
njames93 added a subscriber: njames93.Jun 4 2020, 10:24 AM
njames93 added inline comments.
clang/unittests/ASTMatchers/ASTMatchersTest.h
62

Bit late, but surely these should have been const arrays instead of vectors.

gribozavr2 marked an inline comment as done.Jun 4 2020, 11:22 AM
gribozavr2 added a subscriber: gribozavr2.
gribozavr2 added inline comments.
clang/unittests/ASTMatchers/ASTMatchersTest.h
62

Thanks! https://reviews.llvm.org/D81180

Revision Contents

PathSize
clang/
include/
clang/
Testing/
4 lines
lib/
Testing/
21 lines
unittests/
ASTMatchers/
14 lines
83 lines
75 lines
120 lines
199 lines
1 line
Dynamic/
1 line
Sema/
1 line

Diff 268495

clang/include/clang/Testing/CommandLineArgs.h

//===--- CommandLineArgs.h ------------------------------------------------===// //===--- CommandLineArgs.h ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines language options for Clang unittests. // This file defines language options for Clang unittests.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TESTING_COMMANDLINEARGS_H #ifndef LLVM_CLANG_TESTING_COMMANDLINEARGS_H
#define LLVM_CLANG_TESTING_COMMANDLINEARGS_H #define LLVM_CLANG_TESTING_COMMANDLINEARGS_H
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/StringRef.h"
#include <string> #include <string>
#include <vector> #include <vector>
namespace clang { namespace clang {
enum TestLanguage { enum TestLanguage {
Lang_C89, Lang_C89,
Lang_C99, Lang_C99,
Lang_CXX03, Lang_CXX03,
Lang_CXX11, Lang_CXX11,
Lang_CXX14, Lang_CXX14,
Lang_CXX17, Lang_CXX17,
Lang_CXX20, Lang_CXX20,
Lang_OpenCL, Lang_OpenCL,
Lang_OBJCXX Lang_OBJCXX
}; };
std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang); std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang);
StringRef getFilenameForTesting(TestLanguage Lang);
} // end namespace clang } // end namespace clang
#endif #endif

clang/lib/Testing/CommandLineArgs.cpp

Show All 39 Lines case Lang_OBJCXX:
Args = {"-x", "objective-c++", "-frtti"}; Args = {"-x", "objective-c++", "-frtti"};
break; break;
case Lang_OpenCL: case Lang_OpenCL:
llvm_unreachable("Not implemented yet!"); llvm_unreachable("Not implemented yet!");
} }
return Args; return Args;
} }
StringRef getFilenameForTesting(TestLanguage Lang) {
switch (Lang) {
case Lang_C89:
case Lang_C99:
return "input.c";
case Lang_CXX03:
case Lang_CXX11:
case Lang_CXX14:
case Lang_CXX17:
case Lang_CXX20:
return "input.cc";
case Lang_OpenCL:
return "input.cl";
case Lang_OBJCXX:
return "input.mm";
}
}
} // end namespace clang } // end namespace clang

clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp

Show First 20 Lines • Show All 206 Lines • ▼ Show 20 Lines
TEST(Matcher, IsExpansionInMainFileMatcher) { TEST(Matcher, IsExpansionInMainFileMatcher) {
EXPECT_TRUE(matches("class X {};", EXPECT_TRUE(matches("class X {};",
recordDecl(hasName("X"), isExpansionInMainFile()))); recordDecl(hasName("X"), isExpansionInMainFile())));
EXPECT_TRUE(notMatches("", recordDecl(isExpansionInMainFile()))); EXPECT_TRUE(notMatches("", recordDecl(isExpansionInMainFile())));
FileContentMappings M; FileContentMappings M;
M.push_back(std::make_pair("/other", "class X {};")); M.push_back(std::make_pair("/other", "class X {};"));
EXPECT_TRUE(matchesConditionally("#include <other>\n", EXPECT_TRUE(matchesConditionally("#include <other>\n",
recordDecl(isExpansionInMainFile()), false, recordDecl(isExpansionInMainFile()), false,
"-isystem/", M)); {"-isystem/"}, M));
} }
TEST(Matcher, IsExpansionInSystemHeader) { TEST(Matcher, IsExpansionInSystemHeader) {
FileContentMappings M; FileContentMappings M;
M.push_back(std::make_pair("/other", "class X {};")); M.push_back(std::make_pair("/other", "class X {};"));
EXPECT_TRUE(matchesConditionally(
"#include \"other\"\n", recordDecl(isExpansionInSystemHeader()), true,
"-isystem/", M));
EXPECT_TRUE(matchesConditionally("#include \"other\"\n", EXPECT_TRUE(matchesConditionally("#include \"other\"\n",
recordDecl(isExpansionInSystemHeader()), recordDecl(isExpansionInSystemHeader()),
false, "-I/", M)); true, {"-isystem/"}, M));
EXPECT_TRUE(matchesConditionally("#include \"other\"\n",
recordDecl(isExpansionInSystemHeader()),
false, {"-I/"}, M));
EXPECT_TRUE(notMatches("class X {};", EXPECT_TRUE(notMatches("class X {};",
recordDecl(isExpansionInSystemHeader()))); recordDecl(isExpansionInSystemHeader())));
EXPECT_TRUE(notMatches("", recordDecl(isExpansionInSystemHeader()))); EXPECT_TRUE(notMatches("", recordDecl(isExpansionInSystemHeader())));
} }
TEST(Matcher, IsExpansionInFileMatching) { TEST(Matcher, IsExpansionInFileMatching) {
FileContentMappings M; FileContentMappings M;
M.push_back(std::make_pair("/foo", "class A {};")); M.push_back(std::make_pair("/foo", "class A {};"));
M.push_back(std::make_pair("/bar", "class B {};")); M.push_back(std::make_pair("/bar", "class B {};"));
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(matchesConditionally(
"#include <foo>\n" "#include <foo>\n"
"#include <bar>\n" "#include <bar>\n"
"class X {};", "class X {};",
recordDecl(isExpansionInFileMatching("b.*"), hasName("B")), true, recordDecl(isExpansionInFileMatching("b.*"), hasName("B")), true,
"-isystem/", M)); {"-isystem/"}, M));
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(matchesConditionally(
"#include <foo>\n" "#include <foo>\n"
"#include <bar>\n" "#include <bar>\n"
"class X {};", "class X {};",
recordDecl(isExpansionInFileMatching("f.*"), hasName("X")), false, recordDecl(isExpansionInFileMatching("f.*"), hasName("X")), false,
"-isystem/", M)); {"-isystem/"}, M));
} }
#endif // _WIN32 #endif // _WIN32
} // end namespace ast_matchers } // end namespace ast_matchers
} // end namespace clang } // end namespace clang

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

Show First 20 Lines • Show All 1,095 Lines • ▼ Show 20 Lines EXPECT_TRUE(
unresolvedMemberExpr(isArrow()))); unresolvedMemberExpr(isArrow())));
} }
TEST(ConversionDeclaration, IsExplicit) { TEST(ConversionDeclaration, IsExplicit) {
EXPECT_TRUE(matches("struct S { explicit operator int(); };", EXPECT_TRUE(matches("struct S { explicit operator int(); };",
cxxConversionDecl(isExplicit()))); cxxConversionDecl(isExplicit())));
EXPECT_TRUE(notMatches("struct S { operator int(); };", EXPECT_TRUE(notMatches("struct S { operator int(); };",
cxxConversionDecl(isExplicit()))); cxxConversionDecl(isExplicit())));
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(
"template<bool b> struct S { explicit(b) operator int(); };", notMatches("template<bool b> struct S { explicit(b) operator int(); };",
cxxConversionDecl(isExplicit()), false, "-std=c++2a")); cxxConversionDecl(isExplicit()), langCxx20OrLater()));
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(matches("struct S { explicit(true) operator int(); };",
"struct S { explicit(true) operator int(); };", cxxConversionDecl(isExplicit()), langCxx20OrLater()));
cxxConversionDecl(isExplicit()), true, "-std=c++2a")); EXPECT_TRUE(notMatches("struct S { explicit(false) operator int(); };",
EXPECT_TRUE(matchesConditionally( cxxConversionDecl(isExplicit()), langCxx20OrLater()));
"struct S { explicit(false) operator int(); };",
cxxConversionDecl(isExplicit()), false, "-std=c++2a"));
} }
TEST(Matcher, ArgumentCount) { TEST(Matcher, ArgumentCount) {
StatementMatcher Call1Arg = callExpr(argumentCountIs(1)); StatementMatcher Call1Arg = callExpr(argumentCountIs(1));
EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg)); EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg));
EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg)); EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg));
EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg)); EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg));
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
} }
TEST(isConstexpr, MatchesConstexprDeclarations) { TEST(isConstexpr, MatchesConstexprDeclarations) {
EXPECT_TRUE(matches("constexpr int foo = 42;", EXPECT_TRUE(matches("constexpr int foo = 42;",
varDecl(hasName("foo"), isConstexpr()))); varDecl(hasName("foo"), isConstexpr())));
EXPECT_TRUE(matches("constexpr int bar();", EXPECT_TRUE(matches("constexpr int bar();",
functionDecl(hasName("bar"), isConstexpr()))); functionDecl(hasName("bar"), isConstexpr())));
EXPECT_TRUE(matches("void baz() { if constexpr(1 > 0) {} }", EXPECT_TRUE(matches("void baz() { if constexpr(1 > 0) {} }",
ifStmt(isConstexpr()), LanguageMode::Cxx17OrLater)); ifStmt(isConstexpr()), langCxx17OrLater()));
EXPECT_TRUE(notMatches("void baz() { if (1 > 0) {} }", ifStmt(isConstexpr()), EXPECT_TRUE(notMatches("void baz() { if (1 > 0) {} }", ifStmt(isConstexpr()),
LanguageMode::Cxx17OrLater)); langCxx17OrLater()));
} }
TEST(hasInitStatement, MatchesSelectionInitializers) { TEST(hasInitStatement, MatchesSelectionInitializers) {
EXPECT_TRUE(matches("void baz() { if (int i = 1; i > 0) {} }", EXPECT_TRUE(matches("void baz() { if (int i = 1; i > 0) {} }",
ifStmt(hasInitStatement(anything())), ifStmt(hasInitStatement(anything())),
LanguageMode::Cxx17OrLater)); langCxx17OrLater()));
EXPECT_TRUE(notMatches("void baz() { if (int i = 1) {} }", EXPECT_TRUE(notMatches("void baz() { if (int i = 1) {} }",
ifStmt(hasInitStatement(anything())))); ifStmt(hasInitStatement(anything()))));
EXPECT_TRUE(notMatches("void baz() { if (1 > 0) {} }", EXPECT_TRUE(notMatches("void baz() { if (1 > 0) {} }",
ifStmt(hasInitStatement(anything())))); ifStmt(hasInitStatement(anything()))));
EXPECT_TRUE(matches( EXPECT_TRUE(
"void baz(int i) { switch (int j = i; j) { default: break; } }", matches("void baz(int i) { switch (int j = i; j) { default: break; } }",
switchStmt(hasInitStatement(anything())), LanguageMode::Cxx17OrLater)); switchStmt(hasInitStatement(anything())), langCxx17OrLater()));
EXPECT_TRUE(notMatches("void baz(int i) { switch (i) { default: break; } }", EXPECT_TRUE(notMatches("void baz(int i) { switch (i) { default: break; } }",
switchStmt(hasInitStatement(anything())))); switchStmt(hasInitStatement(anything()))));
} }
TEST(hasInitStatement, MatchesRangeForInitializers) { TEST(hasInitStatement, MatchesRangeForInitializers) {
EXPECT_TRUE(matches("void baz() {" EXPECT_TRUE(matches("void baz() {"
"int items[] = {};" "int items[] = {};"
"for (auto &arr = items; auto &item : arr) {}" "for (auto &arr = items; auto &item : arr) {}"
"}", "}",
cxxForRangeStmt(hasInitStatement(anything())), cxxForRangeStmt(hasInitStatement(anything())),
LanguageMode::Cxx2aOrLater)); langCxx20OrLater()));
EXPECT_TRUE(notMatches("void baz() {" EXPECT_TRUE(notMatches("void baz() {"
"int items[] = {};" "int items[] = {};"
"for (auto &item : items) {}" "for (auto &item : items) {}"
"}", "}",
cxxForRangeStmt(hasInitStatement(anything())))); cxxForRangeStmt(hasInitStatement(anything()))));
} }
TEST(TemplateArgumentCountIs, Matches) { TEST(TemplateArgumentCountIs, Matches) {
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Lines EXPECT_TRUE(matches("struct A { int x; } a = {0}, b = a; void f() { a = b; }",
cxxMethodDecl(isImplicit(), hasName("operator=")))); cxxMethodDecl(isImplicit(), hasName("operator="))));
} }
TEST(ConstructorDeclaration, IsExplicit) { TEST(ConstructorDeclaration, IsExplicit) {
EXPECT_TRUE(matches("struct S { explicit S(int); };", EXPECT_TRUE(matches("struct S { explicit S(int); };",
cxxConstructorDecl(isExplicit()))); cxxConstructorDecl(isExplicit())));
EXPECT_TRUE(notMatches("struct S { S(int); };", EXPECT_TRUE(notMatches("struct S { S(int); };",
cxxConstructorDecl(isExplicit()))); cxxConstructorDecl(isExplicit())));
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(notMatches("template<bool b> struct S { explicit(b) S(int);};",
"template<bool b> struct S { explicit(b) S(int);};", cxxConstructorDecl(isExplicit()), langCxx20OrLater()));
cxxConstructorDecl(isExplicit()), false, "-std=c++2a")); EXPECT_TRUE(matches("struct S { explicit(true) S(int);};",
EXPECT_TRUE(matchesConditionally("struct S { explicit(true) S(int);};", cxxConstructorDecl(isExplicit()), langCxx20OrLater()));
cxxConstructorDecl(isExplicit()), true, EXPECT_TRUE(notMatches("struct S { explicit(false) S(int);};",
"-std=c++2a")); cxxConstructorDecl(isExplicit()), langCxx20OrLater()));
EXPECT_TRUE(matchesConditionally("struct S { explicit(false) S(int);};",
cxxConstructorDecl(isExplicit()), false,
"-std=c++2a"));
} }
TEST(DeductionGuideDeclaration, IsExplicit) { TEST(DeductionGuideDeclaration, IsExplicit) {
EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int);};" EXPECT_TRUE(notMatches("template<typename T> struct S { S(int);};"
"S(int) -> S<int>;", "S(int) -> S<int>;",
cxxDeductionGuideDecl(isExplicit()), false, cxxDeductionGuideDecl(isExplicit()),
"-std=c++17")); langCxx17OrLater()));
EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int);};" EXPECT_TRUE(matches("template<typename T> struct S { S(int);};"
"explicit S(int) -> S<int>;", "explicit S(int) -> S<int>;",
cxxDeductionGuideDecl(isExplicit()), true, cxxDeductionGuideDecl(isExplicit()), langCxx17OrLater()));
"-std=c++17")); EXPECT_TRUE(matches("template<typename T> struct S { S(int);};"
EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int);};"
"explicit(true) S(int) -> S<int>;", "explicit(true) S(int) -> S<int>;",
cxxDeductionGuideDecl(isExplicit()), true, cxxDeductionGuideDecl(isExplicit()), langCxx20OrLater()));
"-std=c++2a")); EXPECT_TRUE(notMatches("template<typename T> struct S { S(int);};"
EXPECT_TRUE(matchesConditionally("template<typename T> struct S { S(int);};"
"explicit(false) S(int) -> S<int>;", "explicit(false) S(int) -> S<int>;",
cxxDeductionGuideDecl(isExplicit()), false, cxxDeductionGuideDecl(isExplicit()),
"-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(
"template<typename T> struct S { S(int);};" notMatches("template<typename T> struct S { S(int);};"
"template<bool b = true> explicit(b) S(int) -> S<int>;", "template<bool b = true> explicit(b) S(int) -> S<int>;",
cxxDeductionGuideDecl(isExplicit()), false, "-std=c++2a")); cxxDeductionGuideDecl(isExplicit()), langCxx20OrLater()));
} }
TEST(ConstructorDeclaration, Kinds) { TEST(ConstructorDeclaration, Kinds) {
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
"struct S { S(); };", "struct S { S(); };",
cxxConstructorDecl(isDefaultConstructor(), unless(isImplicit())))); cxxConstructorDecl(isDefaultConstructor(), unless(isImplicit()))));
EXPECT_TRUE(notMatches( EXPECT_TRUE(notMatches(
"struct S { S(); };", "struct S { S(); };",
▲ Show 20 Lines • Show All 1,626 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

Show First 20 Lines • Show All 196 Lines • ▼ Show 20 LinesTEST(Matcher, UnresolvedLookupExpr) {
EXPECT_TRUE(matchesConditionally("template<typename T>" EXPECT_TRUE(matchesConditionally("template<typename T>"
"T foo() { T a; return a; }" "T foo() { T a; return a; }"
"template<typename T>" "template<typename T>"
"void bar() {" "void bar() {"
" foo<T>();" " foo<T>();"
"}", "}",
unresolvedLookupExpr(), unresolvedLookupExpr(),
/*ExpectMatch=*/true, /*ExpectMatch=*/true,
"-fno-delayed-template-parsing")); {"-fno-delayed-template-parsing"}));
} }
TEST(Matcher, ADLCall) { TEST(Matcher, ADLCall) {
StatementMatcher ADLMatch = callExpr(usesADL()); StatementMatcher ADLMatch = callExpr(usesADL());
StatementMatcher ADLMatchOper = cxxOperatorCallExpr(usesADL()); StatementMatcher ADLMatchOper = cxxOperatorCallExpr(usesADL());
StringRef NS_Str = R"cpp( StringRef NS_Str = R"cpp(
namespace NS { namespace NS {
struct X {}; struct X {};
▲ Show 20 Lines • Show All 570 Lines • ▼ Show 20 Lines EXPECT_TRUE(matches("void foo() { int *ptr; __atomic_load_n(ptr, 1); }",
atomicExpr())); atomicExpr()));
} }
TEST(Matcher, Initializers) { TEST(Matcher, Initializers) {
const char *ToMatch = "void foo() { struct point { double x; double y; };" const char *ToMatch = "void foo() { struct point { double x; double y; };"
" struct point ptarray[10] = " " struct point ptarray[10] = "
" { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }"; " { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }";
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(matchesConditionally(
ToMatch, ToMatch,
initListExpr( initListExpr(
has( has(cxxConstructExpr(requiresZeroInitialization())),
cxxConstructExpr( has(initListExpr(
requiresZeroInitialization())), hasType(asString("struct point")), has(floatLiteral(equals(1.0))),
has( has(implicitValueInitExpr(hasType(asString("double")))))),
initListExpr( has(initListExpr(hasType(asString("struct point")),
hasType(asString("struct point")),
has(floatLiteral(equals(1.0))),
has(implicitValueInitExpr(
hasType(asString("double")))))),
has(
initListExpr(
hasType(asString("struct point")),
has(floatLiteral(equals(2.0))), has(floatLiteral(equals(2.0))),
has(floatLiteral(equals(1.0))))) has(floatLiteral(equals(1.0)))))),
), true, "-std=gnu++98")); true, {"-std=gnu++03"}));
EXPECT_TRUE(matchesC99(ToMatch, EXPECT_TRUE(matchesC99(
initListExpr( ToMatch,
hasSyntacticForm( initListExpr(hasSyntacticForm(initListExpr(
initListExpr( has(designatedInitExpr(designatorCountIs(2),
has( hasDescendant(floatLiteral(equals(1.0))),
designatedInitExpr( hasDescendant(integerLiteral(equals(2))))),
designatorCountIs(2), has(designatedInitExpr(designatorCountIs(2),
hasDescendant(floatLiteral( hasDescendant(floatLiteral(equals(2.0))),
equals(1.0))), hasDescendant(integerLiteral(equals(2))))),
hasDescendant(integerLiteral( has(designatedInitExpr(
equals(2))))), designatorCountIs(2), hasDescendant(floatLiteral(equals(1.0))),
has( hasDescendant(integerLiteral(equals(0))))))))));
designatedInitExpr(
designatorCountIs(2),
hasDescendant(floatLiteral(
equals(2.0))),
hasDescendant(integerLiteral(
equals(2))))),
has(
designatedInitExpr(
designatorCountIs(2),
hasDescendant(floatLiteral(
equals(1.0))),
hasDescendant(integerLiteral(
equals(0)))))
)))));
} }
TEST(Matcher, ParenListExpr) { TEST(Matcher, ParenListExpr) {
EXPECT_TRUE( EXPECT_TRUE(
matches("template<typename T> class foo { void bar() { foo X(*this); } };" matches("template<typename T> class foo { void bar() { foo X(*this); } };"
"template class foo<int>;", "template class foo<int>;",
varDecl(hasInitializer(parenListExpr(has(unaryOperator())))))); varDecl(hasInitializer(parenListExpr(has(unaryOperator()))))));
} }
▲ Show 20 Lines • Show All 626 Lines • ▼ Show 20 Lines
} }
TEST(TypeMatching, MatchesTemplateSpecializationType) { TEST(TypeMatching, MatchesTemplateSpecializationType) {
EXPECT_TRUE(matches("template <typename T> class A{}; A<int> a;", EXPECT_TRUE(matches("template <typename T> class A{}; A<int> a;",
templateSpecializationType())); templateSpecializationType()));
} }
TEST(TypeMatching, MatchesDeucedTemplateSpecializationType) { TEST(TypeMatching, MatchesDeucedTemplateSpecializationType) {
EXPECT_TRUE(matches("template <typename T> class A{ public: A(T) {} }; A a(1);", EXPECT_TRUE(
deducedTemplateSpecializationType(), matches("template <typename T> class A{ public: A(T) {} }; A a(1);",
LanguageMode::Cxx17OrLater)); deducedTemplateSpecializationType(), langCxx17OrLater()));
} }
TEST(TypeMatching, MatchesRecordType) { TEST(TypeMatching, MatchesRecordType) {
EXPECT_TRUE(matches("class C{}; C c;", recordType())); EXPECT_TRUE(matches("class C{}; C c;", recordType()));
EXPECT_TRUE(matches("struct S{}; S s;", EXPECT_TRUE(matches("struct S{}; S s;",
recordType(hasDeclaration(recordDecl(hasName("S")))))); recordType(hasDeclaration(recordDecl(hasName("S"))))));
EXPECT_TRUE(notMatches("int i;", EXPECT_TRUE(notMatches("int i;",
recordType(hasDeclaration(recordDecl(hasName("S")))))); recordType(hasDeclaration(recordDecl(hasName("S"))))));
▲ Show 20 Lines • Show All 401 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersTest.h

//===- unittest/Tooling/ASTMatchersTest.h - Matcher tests helpers ------===// //===- unittest/Tooling/ASTMatchersTest.h - Matcher tests helpers ------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_UNITTESTS_ASTMATCHERS_ASTMATCHERSTEST_H #ifndef LLVM_CLANG_UNITTESTS_ASTMATCHERS_ASTMATCHERSTEST_H
#define LLVM_CLANG_UNITTESTS_ASTMATCHERS_ASTMATCHERSTEST_H #define LLVM_CLANG_UNITTESTS_ASTMATCHERS_ASTMATCHERSTEST_H
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Frontend/ASTUnit.h" #include "clang/Frontend/ASTUnit.h"
#include "clang/Testing/CommandLineArgs.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
namespace clang { namespace clang {
namespace ast_matchers { namespace ast_matchers {
using clang::tooling::buildASTFromCodeWithArgs; using clang::tooling::buildASTFromCodeWithArgs;
using clang::tooling::newFrontendActionFactory; using clang::tooling::newFrontendActionFactory;
Show All 30 Lines if (FindResultReviewer)
FindResultReviewer->onEndOfTranslationUnit(); FindResultReviewer->onEndOfTranslationUnit();
} }
private: private:
bool *const Verified; bool *const Verified;
const std::unique_ptr<BoundNodesCallback> FindResultReviewer; const std::unique_ptr<BoundNodesCallback> FindResultReviewer;
}; };
enum class LanguageMode { inline ArrayRef<TestLanguage> langCxx11OrLater() {
Cxx11, static std::vector<TestLanguage> Result = {Lang_CXX11, Lang_CXX14, Lang_CXX17,
njames93Unsubmitted
Not Done
ReplyInline Actions

Bit late, but surely these should have been const arrays instead of vectors.

njames93: Bit late, but surely these should have been const arrays instead of vectors.
gribozavr2Unsubmitted
Done
ReplyInline Actions

Thanks! https://reviews.llvm.org/D81180

gribozavr2: Thanks! https://reviews.llvm.org/D81180
Cxx14, Lang_CXX20};
Cxx17, return Result;
Cxx2a, }
Cxx11OrLater,
Cxx14OrLater, inline ArrayRef<TestLanguage> langCxx14OrLater() {
Cxx17OrLater, static std::vector<TestLanguage> Result = {Lang_CXX14, Lang_CXX17,
Cxx2aOrLater Lang_CXX20};
}; return Result;
}
inline ArrayRef<TestLanguage> langCxx17OrLater() {
static std::vector<TestLanguage> Result = {Lang_CXX17, Lang_CXX20};
return Result;
}
inline ArrayRef<TestLanguage> langCxx20OrLater() {
static std::vector<TestLanguage> Result = {Lang_CXX20};
return Result;
}
template <typename T> template <typename T>
testing::AssertionResult matchesConditionally( testing::AssertionResult matchesConditionally(
const Twine &Code, const T &AMatcher, bool ExpectMatch, const Twine &Code, const T &AMatcher, bool ExpectMatch,
llvm::ArrayRef<llvm::StringRef> CompileArgs, ArrayRef<std::string> CompileArgs,
const FileContentMappings &VirtualMappedFiles = FileContentMappings(), const FileContentMappings &VirtualMappedFiles = FileContentMappings(),
StringRef Filename = "input.cc") { StringRef Filename = "input.cc") {
bool Found = false, DynamicFound = false; bool Found = false, DynamicFound = false;
MatchFinder Finder; MatchFinder Finder;
VerifyMatch VerifyFound(nullptr, &Found); VerifyMatch VerifyFound(nullptr, &Found);
Finder.addMatcher(AMatcher, &VerifyFound); Finder.addMatcher(AMatcher, &VerifyFound);
VerifyMatch VerifyDynamicFound(nullptr, &DynamicFound); VerifyMatch VerifyDynamicFound(nullptr, &DynamicFound);
if (!Finder.addDynamicMatcher(AMatcher, &VerifyDynamicFound)) if (!Finder.addDynamicMatcher(AMatcher, &VerifyDynamicFound))
Show All 28 Linestesting::AssertionResult matchesConditionally(
} else if (Found && !ExpectMatch) { } else if (Found && !ExpectMatch) {
return testing::AssertionFailure() return testing::AssertionFailure()
<< "Found unexpected match in \"" << Code << "\""; << "Found unexpected match in \"" << Code << "\"";
} }
return testing::AssertionSuccess(); return testing::AssertionSuccess();
} }
template <typename T> template <typename T>
testing::AssertionResult matchesConditionally(
const Twine &Code, const T &AMatcher, bool ExpectMatch,
llvm::StringRef CompileArg,
const FileContentMappings &VirtualMappedFiles = FileContentMappings(),
StringRef Filename = "input.cc") {
return matchesConditionally(Code, AMatcher, ExpectMatch,
llvm::makeArrayRef(CompileArg),
VirtualMappedFiles, Filename);
}
template <typename T>
testing::AssertionResult testing::AssertionResult
matchesConditionally(const Twine &Code, const T &AMatcher, bool ExpectMatch, matchesConditionally(const Twine &Code, const T &AMatcher, bool ExpectMatch,
const LanguageMode &Mode) { ArrayRef<TestLanguage> TestLanguages) {
std::vector<LanguageMode> LangModes; for (auto Lang : TestLanguages) {
switch (Mode) { std::vector<std::string> Args = getCommandLineArgsForTesting(Lang);
case LanguageMode::Cxx11: Args.insert(Args.end(),
case LanguageMode::Cxx14: {"-Werror=c++14-extensions", "-Werror=c++17-extensions",
case LanguageMode::Cxx17:
case LanguageMode::Cxx2a:
LangModes = {Mode};
break;
case LanguageMode::Cxx11OrLater:
LangModes = {LanguageMode::Cxx11, LanguageMode::Cxx14, LanguageMode::Cxx17,
LanguageMode::Cxx2a};
break;
case LanguageMode::Cxx14OrLater:
LangModes = {LanguageMode::Cxx14, LanguageMode::Cxx17, LanguageMode::Cxx2a};
break;
case LanguageMode::Cxx17OrLater:
LangModes = {LanguageMode::Cxx17, LanguageMode::Cxx2a};
break;
case LanguageMode::Cxx2aOrLater:
LangModes = {LanguageMode::Cxx2a};
}
for (auto Mode : LangModes) {
StringRef LangModeArg;
switch (Mode) {
case LanguageMode::Cxx11:
LangModeArg = "-std=c++11";
break;
case LanguageMode::Cxx14:
LangModeArg = "-std=c++14";
break;
case LanguageMode::Cxx17:
LangModeArg = "-std=c++17";
break;
case LanguageMode::Cxx2a:
LangModeArg = "-std=c++2a";
break;
default:
llvm_unreachable("Invalid language mode");
}
auto Result = matchesConditionally(Code, AMatcher, ExpectMatch,
{LangModeArg, "-Werror=c++14-extensions",
"-Werror=c++17-extensions",
"-Werror=c++20-extensions"}); "-Werror=c++20-extensions"});
auto Result = matchesConditionally(Code, AMatcher, ExpectMatch, Args,
FileContentMappings(),
getFilenameForTesting(Lang));
if (!Result) if (!Result)
return Result; return Result;
} }
return testing::AssertionSuccess(); return testing::AssertionSuccess();
} }
template <typename T> template <typename T>
testing::AssertionResult testing::AssertionResult
matches(const Twine &Code, const T &AMatcher, matches(const Twine &Code, const T &AMatcher,
const LanguageMode &Mode = LanguageMode::Cxx11) { ArrayRef<TestLanguage> TestLanguages = {Lang_CXX11}) {
return matchesConditionally(Code, AMatcher, true, Mode); return matchesConditionally(Code, AMatcher, true, TestLanguages);
} }
template <typename T> template <typename T>
testing::AssertionResult testing::AssertionResult
notMatches(const Twine &Code, const T &AMatcher, notMatches(const Twine &Code, const T &AMatcher,
const LanguageMode &Mode = LanguageMode::Cxx11) { ArrayRef<TestLanguage> TestLanguages = {Lang_CXX11}) {
return matchesConditionally(Code, AMatcher, false, Mode); return matchesConditionally(Code, AMatcher, false, TestLanguages);
} }
template <typename T> template <typename T>
testing::AssertionResult matchesObjC(const Twine &Code, const T &AMatcher, testing::AssertionResult matchesObjC(const Twine &Code, const T &AMatcher,
bool ExpectMatch = true) { bool ExpectMatch = true) {
return matchesConditionally(Code, AMatcher, ExpectMatch, return matchesConditionally(Code, AMatcher, ExpectMatch,
{"-fobjc-nonfragile-abi", "-Wno-objc-root-class", {"-fobjc-nonfragile-abi", "-Wno-objc-root-class",
"-fblocks", "-Wno-incomplete-implementation"}, "-fblocks", "-Wno-incomplete-implementation"},
FileContentMappings(), "input.m"); FileContentMappings(), "input.m");
} }
template <typename T> template <typename T>
testing::AssertionResult matchesC(const Twine &Code, const T &AMatcher) { testing::AssertionResult matchesC(const Twine &Code, const T &AMatcher) {
return matchesConditionally(Code, AMatcher, true, "", FileContentMappings(), return matchesConditionally(Code, AMatcher, true, {}, FileContentMappings(),
"input.c"); "input.c");
} }
template <typename T> template <typename T>
testing::AssertionResult matchesC99(const Twine &Code, const T &AMatcher) { testing::AssertionResult matchesC99(const Twine &Code, const T &AMatcher) {
return matchesConditionally(Code, AMatcher, true, "-std=c99", return matchesConditionally(Code, AMatcher, true, {Lang_C99});
FileContentMappings(), "input.c");
} }
template <typename T> template <typename T>
testing::AssertionResult notMatchesC(const Twine &Code, const T &AMatcher) { testing::AssertionResult notMatchesC(const Twine &Code, const T &AMatcher) {
return matchesConditionally(Code, AMatcher, false, "", FileContentMappings(), return matchesConditionally(Code, AMatcher, false, {Lang_C89});
"input.c");
} }
template <typename T> template <typename T>
testing::AssertionResult notMatchesObjC(const Twine &Code, const T &AMatcher) { testing::AssertionResult notMatchesObjC(const Twine &Code, const T &AMatcher) {
return matchesObjC(Code, AMatcher, false); return matchesObjC(Code, AMatcher, false);
} }
// Function based on matchesConditionally with "-x cuda" argument added and // Function based on matchesConditionally with "-x cuda" argument added and
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
testing::AssertionResult notMatchesWithCuda(const Twine &Code, testing::AssertionResult notMatchesWithCuda(const Twine &Code,
const T &AMatcher) { const T &AMatcher) {
return matchesConditionallyWithCuda(Code, AMatcher, false, "-std=c++11"); return matchesConditionallyWithCuda(Code, AMatcher, false, "-std=c++11");
} }
template <typename T> template <typename T>
testing::AssertionResult matchesWithOpenMP(const Twine &Code, testing::AssertionResult matchesWithOpenMP(const Twine &Code,
const T &AMatcher) { const T &AMatcher) {
return matchesConditionally(Code, AMatcher, true, "-fopenmp=libomp"); return matchesConditionally(Code, AMatcher, true, {"-fopenmp=libomp"});
} }
template <typename T> template <typename T>
testing::AssertionResult notMatchesWithOpenMP(const Twine &Code, testing::AssertionResult notMatchesWithOpenMP(const Twine &Code,
const T &AMatcher) { const T &AMatcher) {
return matchesConditionally(Code, AMatcher, false, "-fopenmp=libomp"); return matchesConditionally(Code, AMatcher, false, {"-fopenmp=libomp"});
} }
template <typename T> template <typename T>
testing::AssertionResult matchAndVerifyResultConditionally( testing::AssertionResult matchAndVerifyResultConditionally(
const Twine &Code, const T &AMatcher, const Twine &Code, const T &AMatcher,
std::unique_ptr<BoundNodesCallback> FindResultVerifier, bool ExpectResult) { std::unique_ptr<BoundNodesCallback> FindResultVerifier, bool ExpectResult) {
bool VerifiedResult = false; bool VerifiedResult = false;
MatchFinder Finder; MatchFinder Finder;
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

Show First 20 Lines • Show All 945 Lines • ▼ Show 20 Lines const char input[] =
"template<typename T>\n" "template<typename T>\n"
"struct Struct {\n" "struct Struct {\n"
" template<typename T2> static int field;\n" " template<typename T2> static int field;\n"
"};\n" "};\n"
"template<typename U>\n" "template<typename U>\n"
"template<typename U2>\n" "template<typename U2>\n"
"int Struct<U>::field<U2*> = 123;\n"; "int Struct<U>::field<U2*> = 123;\n";
EXPECT_TRUE( EXPECT_TRUE(
matches(input, templateTypeParmDecl(hasName("T")), LanguageMode::Cxx14)); matches(input, templateTypeParmDecl(hasName("T")), langCxx14OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(input, templateTypeParmDecl(hasName("T2")), LanguageMode::Cxx14)); matches(input, templateTypeParmDecl(hasName("T2")), langCxx14OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(input, templateTypeParmDecl(hasName("U")), LanguageMode::Cxx14)); matches(input, templateTypeParmDecl(hasName("U")), langCxx14OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(input, templateTypeParmDecl(hasName("U2")), LanguageMode::Cxx14)); matches(input, templateTypeParmDecl(hasName("U2")), langCxx14OrLater()));
} }
TEST(TemplateTypeParmDecl, ClassTemplatePartialSpecializationDecl) { TEST(TemplateTypeParmDecl, ClassTemplatePartialSpecializationDecl) {
const char input[] = const char input[] =
"template<typename T>\n" "template<typename T>\n"
"class Class {\n" "class Class {\n"
" template<typename T2> struct Struct;\n" " template<typename T2> struct Struct;\n"
"};\n" "};\n"
▲ Show 20 Lines • Show All 513 Lines • ▼ Show 20 Lines
TEST(HasAnySubstatement, FindsSubstatementBetweenOthers) { TEST(HasAnySubstatement, FindsSubstatementBetweenOthers) {
EXPECT_TRUE(matches("void f() { 1; 2; 3; for (;;); 4; 5; 6; }", EXPECT_TRUE(matches("void f() { 1; 2; 3; for (;;); 4; 5; 6; }",
compoundStmt(hasAnySubstatement(forStmt())))); compoundStmt(hasAnySubstatement(forStmt()))));
} }
TEST(Member, MatchesMemberAllocationFunction) { TEST(Member, MatchesMemberAllocationFunction) {
// Fails in C++11 mode // Fails in C++11 mode
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(matchesConditionally(
"namespace std { typedef typeof(sizeof(int)) size_t; }" "namespace std { typedef typeof(sizeof(int)) size_t; }"
"class X { void *operator new(std::size_t); };", "class X { void *operator new(std::size_t); };",
cxxMethodDecl(ofClass(hasName("X"))), true, "-std=gnu++98")); cxxMethodDecl(ofClass(hasName("X"))), true, {"-std=gnu++03"}));
EXPECT_TRUE(matches("class X { void operator delete(void*); };", EXPECT_TRUE(matches("class X { void operator delete(void*); };",
cxxMethodDecl(ofClass(hasName("X"))))); cxxMethodDecl(ofClass(hasName("X")))));
// Fails in C++11 mode // Fails in C++11 mode
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(matchesConditionally(
"namespace std { typedef typeof(sizeof(int)) size_t; }" "namespace std { typedef typeof(sizeof(int)) size_t; }"
"class X { void operator delete[](void*, std::size_t); };", "class X { void operator delete[](void*, std::size_t); };",
cxxMethodDecl(ofClass(hasName("X"))), true, "-std=gnu++98")); cxxMethodDecl(ofClass(hasName("X"))), true, {"-std=gnu++03"}));
} }
TEST(HasDestinationType, MatchesSimpleCase) { TEST(HasDestinationType, MatchesSimpleCase) {
EXPECT_TRUE(matches("char* p = static_cast<char*>(0);", EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
cxxStaticCastExpr(hasDestinationType( cxxStaticCastExpr(hasDestinationType(
pointsTo(TypeMatcher(anything())))))); pointsTo(TypeMatcher(anything()))))));
} }
Show All 27 Lines EXPECT_TRUE(
"template<typename T> H B(T A);" "template<typename T> H B(T A);"
"void f() {" "void f() {"
" H D1;" " H D1;"
" D1 = B(B(1));" " D1 = B(B(1));"
"}", "}",
cxxOperatorCallExpr(hasArgument( cxxOperatorCallExpr(hasArgument(
1, callExpr(hasArgument( 1, callExpr(hasArgument(
0, ignoringElidableConstructorCall(callExpr()))))), 0, ignoringElidableConstructorCall(callExpr()))))),
LanguageMode::Cxx11OrLater)); langCxx11OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches("struct H {};" matches("struct H {};"
"template<typename T> H B(T A);" "template<typename T> H B(T A);"
"void f() {" "void f() {"
" H D1;" " H D1;"
" D1 = B(1);" " D1 = B(1);"
"}", "}",
cxxOperatorCallExpr(hasArgument( cxxOperatorCallExpr(hasArgument(
1, callExpr(hasArgument(0, ignoringElidableConstructorCall( 1, callExpr(hasArgument(0, ignoringElidableConstructorCall(
integerLiteral()))))), integerLiteral()))))),
LanguageMode::Cxx11OrLater)); langCxx11OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
"struct H {};" "struct H {};"
"H G();" "H G();"
"void f() {" "void f() {"
" H D = G();" " H D = G();"
"}", "}",
varDecl(hasInitializer(anyOf( varDecl(hasInitializer(anyOf(
ignoringElidableConstructorCall(callExpr()), ignoringElidableConstructorCall(callExpr()),
exprWithCleanups(has(ignoringElidableConstructorCall(callExpr())))))), exprWithCleanups(has(ignoringElidableConstructorCall(callExpr())))))),
LanguageMode::Cxx11OrLater)); langCxx11OrLater()));
} }
TEST(Matcher, IgnoresElidableInReturn) { TEST(Matcher, IgnoresElidableInReturn) {
auto matcher = expr(ignoringElidableConstructorCall(declRefExpr())); auto matcher = expr(ignoringElidableConstructorCall(declRefExpr()));
EXPECT_TRUE(matches("struct H {};" EXPECT_TRUE(matches("struct H {};"
"H f() {" "H f() {"
" H g;" " H g;"
" return g;" " return g;"
"}", "}",
matcher, LanguageMode::Cxx11OrLater)); matcher, langCxx11OrLater()));
EXPECT_TRUE(notMatches("struct H {};" EXPECT_TRUE(notMatches("struct H {};"
"H f() {" "H f() {"
" return H();" " return H();"
"}", "}",
matcher, LanguageMode::Cxx11OrLater)); matcher, langCxx11OrLater()));
} }
TEST(Matcher, IgnoreElidableConstructorDoesNotMatchConstructors) { TEST(Matcher, IgnoreElidableConstructorDoesNotMatchConstructors) {
EXPECT_TRUE(matches("struct H {};" EXPECT_TRUE(matches("struct H {};"
"void f() {" "void f() {"
" H D;" " H D;"
"}", "}",
varDecl(hasInitializer( varDecl(hasInitializer(
ignoringElidableConstructorCall(cxxConstructExpr()))), ignoringElidableConstructorCall(cxxConstructExpr()))),
LanguageMode::Cxx11OrLater)); langCxx11OrLater()));
} }
TEST(Matcher, IgnoresElidableDoesNotPreventMatches) { TEST(Matcher, IgnoresElidableDoesNotPreventMatches) {
EXPECT_TRUE(matches("void f() {" EXPECT_TRUE(matches("void f() {"
" int D = 10;" " int D = 10;"
"}", "}",
expr(ignoringElidableConstructorCall(integerLiteral())), expr(ignoringElidableConstructorCall(integerLiteral())),
LanguageMode::Cxx11OrLater)); langCxx11OrLater()));
} }
TEST(Matcher, IgnoresElidableInVarInit) { TEST(Matcher, IgnoresElidableInVarInit) {
auto matcher = auto matcher =
varDecl(hasInitializer(ignoringElidableConstructorCall(callExpr()))); varDecl(hasInitializer(ignoringElidableConstructorCall(callExpr())));
EXPECT_TRUE(matches("struct H {};" EXPECT_TRUE(matches("struct H {};"
"H G();" "H G();"
"void f(H D = G()) {" "void f(H D = G()) {"
" return;" " return;"
"}", "}",
matcher, LanguageMode::Cxx11OrLater)); matcher, langCxx11OrLater()));
EXPECT_TRUE(matches("struct H {};" EXPECT_TRUE(matches("struct H {};"
"H G();" "H G();"
"void f() {" "void f() {"
" H D = G();" " H D = G();"
"}", "}",
matcher, LanguageMode::Cxx11OrLater)); matcher, langCxx11OrLater()));
} }
TEST(IgnoringImplicit, MatchesImplicit) { TEST(IgnoringImplicit, MatchesImplicit) {
EXPECT_TRUE(matches("class C {}; C a = C();", EXPECT_TRUE(matches("class C {}; C a = C();",
varDecl(has(ignoringImplicit(cxxConstructExpr()))))); varDecl(has(ignoringImplicit(cxxConstructExpr())))));
} }
TEST(IgnoringImplicit, MatchesNestedImplicit) { TEST(IgnoringImplicit, MatchesNestedImplicit) {
▲ Show 20 Lines • Show All 440 Lines • ▼ Show 20 Lines
)cpp"; )cpp";
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func1"))), returnStmt(forFunction(functionDecl(hasName("func1"))),
hasReturnValue(integerLiteral(equals(42))))), hasReturnValue(integerLiteral(equals(42))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
integerLiteral(equals(42), integerLiteral(equals(42),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func1"))))))), functionDecl(hasName("func1"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func2"))), returnStmt(forFunction(functionDecl(hasName("func2"))),
hasReturnValue(cxxTemporaryObjectExpr( hasReturnValue(cxxTemporaryObjectExpr(
hasArgument(0, integerLiteral(equals(42))))))), hasArgument(0, integerLiteral(equals(42))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
integerLiteral(equals(42), integerLiteral(equals(42),
hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt( hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt(
forFunction(functionDecl(hasName("func2"))))))))), forFunction(functionDecl(hasName("func2"))))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func3"))), returnStmt(forFunction(functionDecl(hasName("func3"))),
hasReturnValue(cxxFunctionalCastExpr( hasReturnValue(cxxFunctionalCastExpr(
hasSourceExpression(integerLiteral(equals(42))))))), hasSourceExpression(integerLiteral(equals(42))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
integerLiteral(equals(42), integerLiteral(equals(42),
hasParent(cxxFunctionalCastExpr(hasParent(returnStmt( hasParent(cxxFunctionalCastExpr(hasParent(returnStmt(
forFunction(functionDecl(hasName("func3"))))))))), forFunction(functionDecl(hasName("func3"))))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func4"))), returnStmt(forFunction(functionDecl(hasName("func4"))),
hasReturnValue(cxxTemporaryObjectExpr()))), hasReturnValue(cxxTemporaryObjectExpr()))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func5"))), returnStmt(forFunction(functionDecl(hasName("func5"))),
hasReturnValue(cxxTemporaryObjectExpr()))), hasReturnValue(cxxTemporaryObjectExpr()))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func6"))), returnStmt(forFunction(functionDecl(hasName("func6"))),
hasReturnValue(cxxTemporaryObjectExpr()))), hasReturnValue(cxxTemporaryObjectExpr()))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func7"))), returnStmt(forFunction(functionDecl(hasName("func7"))),
hasReturnValue(cxxTemporaryObjectExpr()))), hasReturnValue(cxxTemporaryObjectExpr()))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func8"))), returnStmt(forFunction(functionDecl(hasName("func8"))),
hasReturnValue(cxxFunctionalCastExpr( hasReturnValue(cxxFunctionalCastExpr(
hasSourceExpression(initListExpr()))))), hasSourceExpression(initListExpr()))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func9"))), returnStmt(forFunction(functionDecl(hasName("func9"))),
hasReturnValue(cxxFunctionalCastExpr( hasReturnValue(cxxFunctionalCastExpr(
hasSourceExpression(initListExpr()))))), hasSourceExpression(initListExpr()))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func10"))), returnStmt(forFunction(functionDecl(hasName("func10"))),
hasReturnValue(declRefExpr(to(varDecl(hasName("a"))))))), hasReturnValue(declRefExpr(to(varDecl(hasName("a"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
declRefExpr(to(varDecl(hasName("a"))), declRefExpr(to(varDecl(hasName("a"))),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func10"))))))), functionDecl(hasName("func10"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func11"))), returnStmt(forFunction(functionDecl(hasName("func11"))),
hasReturnValue(declRefExpr(to(varDecl(hasName("b"))))))), hasReturnValue(declRefExpr(to(varDecl(hasName("b"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
declRefExpr(to(varDecl(hasName("b"))), declRefExpr(to(varDecl(hasName("b"))),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func11"))))))), functionDecl(hasName("func11"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func12"))), returnStmt(forFunction(functionDecl(hasName("func12"))),
hasReturnValue(declRefExpr(to(varDecl(hasName("c"))))))), hasReturnValue(declRefExpr(to(varDecl(hasName("c"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
declRefExpr(to(varDecl(hasName("c"))), declRefExpr(to(varDecl(hasName("c"))),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func12"))))))), functionDecl(hasName("func12"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
lambdaExpr(forFunction(functionDecl(hasName("func13"))), lambdaExpr(forFunction(functionDecl(hasName("func13"))),
has(compoundStmt(hasDescendant(varDecl(hasName("e"))))), has(compoundStmt(hasDescendant(varDecl(hasName("e"))))),
has(declRefExpr(to(varDecl(hasName("a"))))), has(declRefExpr(to(varDecl(hasName("a"))))),
has(varDecl(hasName("b"), hasInitializer(declRefExpr(to( has(varDecl(hasName("b"), hasInitializer(declRefExpr(to(
varDecl(hasName("c"))))))), varDecl(hasName("c"))))))),
has(parmVarDecl(hasName("d"))))), has(parmVarDecl(hasName("d"))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
declRefExpr(to(varDecl(hasName("a"))), declRefExpr(to(varDecl(hasName("a"))),
hasParent(lambdaExpr(forFunction( hasParent(lambdaExpr(forFunction(
functionDecl(hasName("func13"))))))), functionDecl(hasName("func13"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("b"), varDecl(hasName("b"),
hasInitializer(declRefExpr(to(varDecl(hasName("c"))))), hasInitializer(declRefExpr(to(varDecl(hasName("c"))))),
hasParent(lambdaExpr( hasParent(lambdaExpr(
forFunction(functionDecl(hasName("func13"))))))), forFunction(functionDecl(hasName("func13"))))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
lambdaExpr(forFunction(functionDecl(hasName("func14"))), lambdaExpr(forFunction(functionDecl(hasName("func14"))),
has(templateTypeParmDecl(hasName("TemplateType"))))), has(templateTypeParmDecl(hasName("TemplateType"))))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
functionDecl(hasName("func14"), hasDescendant(floatLiteral()))), functionDecl(hasName("func14"), hasDescendant(floatLiteral()))),
LanguageMode::Cxx2a)); langCxx20OrLater()));
} }
TEST(IgnoringImpCasts, MatchesImpCasts) { TEST(IgnoringImpCasts, MatchesImpCasts) {
// This test checks that ignoringImpCasts matches when implicit casts are // This test checks that ignoringImpCasts matches when implicit casts are
// present and its inner matcher alone does not match. // present and its inner matcher alone does not match.
// Note that this test creates an implicit const cast. // Note that this test creates an implicit const cast.
EXPECT_TRUE(matches("int x = 0; const int y = x;", EXPECT_TRUE(matches("int x = 0; const int y = x;",
varDecl(hasInitializer(ignoringImpCasts( varDecl(hasInitializer(ignoringImpCasts(
▲ Show 20 Lines • Show All 218 Lines • ▼ Show 20 LinesTEST(SwitchCase, MatchesEachCase) {
EXPECT_TRUE(matchAndVerifyResultTrue( EXPECT_TRUE(matchAndVerifyResultTrue(
"void x() { switch (42) { case 1: case 2: case 3: default:; } }", "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
switchStmt(forEachSwitchCase(caseStmt().bind("x"))), switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
std::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3))); std::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3)));
} }
TEST(Declaration, HasExplicitSpecifier) { TEST(Declaration, HasExplicitSpecifier) {
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(notMatches("void f();",
"void f();", functionDecl(hasExplicitSpecifier(constantExpr())), false, functionDecl(hasExplicitSpecifier(constantExpr())),
"-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(
"template<bool b> struct S { explicit operator int(); };", notMatches("template<bool b> struct S { explicit operator int(); };",
cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))), cxxConversionDecl(
false, "-std=c++2a")); hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
EXPECT_TRUE(matchesConditionally( langCxx20OrLater()));
"template<bool b> struct S { explicit(b) operator int(); };", EXPECT_TRUE(
cxxConversionDecl(hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))), notMatches("template<bool b> struct S { explicit(b) operator int(); };",
false, "-std=c++2a")); cxxConversionDecl(
EXPECT_TRUE( hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
matchesConditionally("struct S { explicit(true) operator int(); };", langCxx20OrLater()));
EXPECT_TRUE(matches("struct S { explicit(true) operator int(); };",
traverse(ast_type_traits::TK_AsIs, traverse(ast_type_traits::TK_AsIs,
cxxConversionDecl(hasExplicitSpecifier( cxxConversionDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
true, "-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(matches("struct S { explicit(false) operator int(); };",
matchesConditionally("struct S { explicit(false) operator int(); };",
traverse(ast_type_traits::TK_AsIs, traverse(ast_type_traits::TK_AsIs,
cxxConversionDecl(hasExplicitSpecifier( cxxConversionDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
true, "-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(notMatches("template<bool b> struct S { explicit(b) S(int); };",
matchesConditionally("template<bool b> struct S { explicit(b) S(int); };",
traverse(ast_type_traits::TK_AsIs, traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl(hasExplicitSpecifier( cxxConstructorDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
false, "-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(matches("struct S { explicit(true) S(int); };",
matchesConditionally("struct S { explicit(true) S(int); };",
traverse(ast_type_traits::TK_AsIs, traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl(hasExplicitSpecifier( cxxConstructorDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
true, "-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(matches("struct S { explicit(false) S(int); };",
matchesConditionally("struct S { explicit(false) S(int); };",
traverse(ast_type_traits::TK_AsIs, traverse(ast_type_traits::TK_AsIs,
cxxConstructorDecl(hasExplicitSpecifier( cxxConstructorDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
true, "-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE(matchesConditionally( EXPECT_TRUE(
"template<typename T> struct S { S(int); };" notMatches("template<typename T> struct S { S(int); };"
"template<bool b = true> explicit(b) S(int) -> S<int>;", "template<bool b = true> explicit(b) S(int) -> S<int>;",
traverse(ast_type_traits::TK_AsIs, traverse(ast_type_traits::TK_AsIs,
cxxDeductionGuideDecl( cxxDeductionGuideDecl(hasExplicitSpecifier(
hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
false, "-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(matches("template<typename T> struct S { S(int); };"
matchesConditionally("template<typename T> struct S { S(int); };"
"explicit(true) S(int) -> S<int>;", "explicit(true) S(int) -> S<int>;",
traverse(ast_type_traits::TK_AsIs, traverse(ast_type_traits::TK_AsIs,
cxxDeductionGuideDecl(hasExplicitSpecifier( cxxDeductionGuideDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
true, "-std=c++2a")); langCxx20OrLater()));
EXPECT_TRUE( EXPECT_TRUE(matches("template<typename T> struct S { S(int); };"
matchesConditionally("template<typename T> struct S { S(int); };"
"explicit(false) S(int) -> S<int>;", "explicit(false) S(int) -> S<int>;",
traverse(ast_type_traits::TK_AsIs, traverse(ast_type_traits::TK_AsIs,
cxxDeductionGuideDecl(hasExplicitSpecifier( cxxDeductionGuideDecl(hasExplicitSpecifier(
constantExpr(has(cxxBoolLiteral()))))), constantExpr(has(cxxBoolLiteral()))))),
true, "-std=c++2a")); langCxx20OrLater()));
} }
TEST(ForEachConstructorInitializer, MatchesInitializers) { TEST(ForEachConstructorInitializer, MatchesInitializers) {
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
"struct X { X() : i(42), j(42) {} int i, j; };", "struct X { X() : i(42), j(42) {} int i, j; };",
cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer())))); cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer()))));
} }
▲ Show 20 Lines • Show All 808 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/CMakeLists.txt

Show All 21 Lines
clang_target_link_libraries(ASTMatchersTests clang_target_link_libraries(ASTMatchersTests
PRIVATE PRIVATE
clangAST clangAST
clangASTMatchers clangASTMatchers
clangBasic clangBasic
clangFrontend clangFrontend
clangSerialization clangSerialization
clangTesting
clangTooling clangTooling
) )
target_link_libraries(ASTMatchersTests target_link_libraries(ASTMatchersTests
PRIVATE PRIVATE
LLVMTestingSupport LLVMTestingSupport
) )
add_subdirectory(Dynamic) add_subdirectory(Dynamic)

clang/unittests/ASTMatchers/Dynamic/CMakeLists.txt

Show All 11 Lines
clang_target_link_libraries(DynamicASTMatchersTests clang_target_link_libraries(DynamicASTMatchersTests
PRIVATE PRIVATE
clangAST clangAST
clangASTMatchers clangASTMatchers
clangBasic clangBasic
clangDynamicASTMatchers clangDynamicASTMatchers
clangFrontend clangFrontend
clangSerialization clangSerialization
clangTesting
clangTooling clangTooling
) )

clang/unittests/Sema/CMakeLists.txt

Show All 12 Linesclang_target_link_libraries(SemaTests
PRIVATE PRIVATE
clangAST clangAST
clangASTMatchers clangASTMatchers
clangBasic clangBasic
clangFrontend clangFrontend
clangParse clangParse
clangSema clangSema
clangSerialization clangSerialization
clangTesting
clangTooling clangTooling
) )
target_link_libraries(SemaTests target_link_libraries(SemaTests
PRIVATE PRIVATE
LLVMTestingSupport LLVMTestingSupport
) )