This is an archive of the discontinued LLVM Phabricator instance.

Differential D80884

[ASTMatchers] Force c++ unittests to specify correct language standard
ClosedPublic

Authored by njames93 on May 31 2020, 2:18 AM.

Details

Reviewers
klimek
hokein
gribozavr
jvikstrom
gribozavr2
Commits
rGb6d23f2efc64: [ASTMatchers] Force c++ unittests to specify correct language standard
Summary

Force the unittests on c++ code for matchers to specify the correct standard.

Diff Detail

Unit TestsFailed

TimeTest
420 mslibomp.ompt/tasks::Unknown Unit Message ("")

Event Timeline

njames93 created this revision.May 31 2020, 2:18 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 31 2020, 2:18 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
Harbormaster failed remote builds in B58560: Diff 267491!May 31 2020, 3:11 AM
gribozavr2 added a subscriber: gribozavr2.May 31 2020, 4:06 AM

This is an interesting question. Since Clang accepts certain constructs in older C++ standard versions as extensions, shouldn't we test AST matchers in those modes as well? I think it could be argued either way.

gribozavr2 added a comment.May 31 2020, 4:08 AM

Approving since I think that it is probably too costly for tooling to try to handle such language extensions. We also don't have a principled way to know what "future" C++ feature is supported in a given language mode, so I think we would always have implementation and testing gaps because people implementing tooling won't know what features to even expect in ASTs.

gribozavr2 accepted this revision.May 31 2020, 4:08 AM
This revision is now accepted and ready to land.May 31 2020, 4:08 AM
njames93 added a comment.May 31 2020, 4:26 AM
In D80884#2065270, @gribozavr2 wrote:

This is an interesting question. Since Clang accepts certain constructs in older C++ standard versions as extensions, shouldn't we test AST matchers in those modes as well? I think it could be argued either way.

Clang accepts a lot of stuff for better or worse, my fist try at this was using -pedantic-errors, but that was throwing errors with gnu and microsoft extensions which would be a much more invasive fix to sort out.

Closed by commit rGb6d23f2efc64: [ASTMatchers] Force c++ unittests to specify correct language standard (authored by njames93). · Explain WhyMay 31 2020, 11:57 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
clang/
unittests/
ASTMatchers/
8 lines
237 lines

Diff 267491

clang/unittests/ASTMatchers/ASTMatchersTest.h

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 LinesmatchesConditionally(const std::string &Code, const T &AMatcher,
case LanguageMode::Cxx17OrLater: case LanguageMode::Cxx17OrLater:
LangModes = {LanguageMode::Cxx17, LanguageMode::Cxx2a}; LangModes = {LanguageMode::Cxx17, LanguageMode::Cxx2a};
break; break;
case LanguageMode::Cxx2aOrLater: case LanguageMode::Cxx2aOrLater:
LangModes = {LanguageMode::Cxx2a}; LangModes = {LanguageMode::Cxx2a};
} }
for (auto Mode : LangModes) { for (auto Mode : LangModes) {
std::string LangModeArg; StringRef LangModeArg;
switch (Mode) { switch (Mode) {
case LanguageMode::Cxx11: case LanguageMode::Cxx11:
LangModeArg = "-std=c++11"; LangModeArg = "-std=c++11";
break; break;
case LanguageMode::Cxx14: case LanguageMode::Cxx14:
LangModeArg = "-std=c++14"; LangModeArg = "-std=c++14";
break; break;
case LanguageMode::Cxx17: case LanguageMode::Cxx17:
LangModeArg = "-std=c++17"; LangModeArg = "-std=c++17";
break; break;
case LanguageMode::Cxx2a: case LanguageMode::Cxx2a:
LangModeArg = "-std=c++2a"; LangModeArg = "-std=c++2a";
break; break;
default: default:
llvm_unreachable("Invalid language mode"); llvm_unreachable("Invalid language mode");
} }
auto Result = auto Result = matchesConditionally(Code, AMatcher, ExpectMatch,
matchesConditionally(Code, AMatcher, ExpectMatch, LangModeArg); {LangModeArg, "-Werror=c++14-extensions",
"-Werror=c++17-extensions",
"-Werror=c++20-extensions"});
if (!Result) if (!Result)
return Result; return Result;
} }
return testing::AssertionSuccess(); return testing::AssertionSuccess();
} }
template <typename T> template <typename T>
▲ Show 20 Lines • Show All 274 Lines • Show Last 20 Lines

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

Show First 20 Lines • Show All 944 Lines • ▼ Show 20 LinesTEST(TemplateTypeParmDecl, VarTemplatePartialSpecializationDecl) {
const char input[] = 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(matches(input, templateTypeParmDecl(hasName("T")))); EXPECT_TRUE(
EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T2")))); matches(input, templateTypeParmDecl(hasName("T")), LanguageMode::Cxx14));
EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U")))); EXPECT_TRUE(
EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U2")))); matches(input, templateTypeParmDecl(hasName("T2")), LanguageMode::Cxx14));
EXPECT_TRUE(
matches(input, templateTypeParmDecl(hasName("U")), LanguageMode::Cxx14));
EXPECT_TRUE(
matches(input, templateTypeParmDecl(hasName("U2")), LanguageMode::Cxx14));
} }
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 1,091 Lines • ▼ Show 20 Lines
void func14() { void func14() {
[] <typename TemplateType> (TemplateType t, TemplateType u) { int e = t + u; }; [] <typename TemplateType> (TemplateType t, TemplateType u) { int e = t + u; };
float i = 42.0; float i = 42.0;
} }
)cpp"; )cpp";
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func1"))), returnStmt(forFunction(functionDecl(hasName("func1"))),
hasReturnValue(integerLiteral(equals(42))))))); hasReturnValue(integerLiteral(equals(42))))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource,
integerLiteral(equals(42), integerLiteral(equals(42),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func1"))))))))); functionDecl(hasName("func1"))))))),
LanguageMode::Cxx2a));
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));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(
integerLiteral( TK_IgnoreUnlessSpelledInSource,
equals(42), integerLiteral(equals(42),
hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt( hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt(
forFunction(functionDecl(hasName("func2"))))))))))); forFunction(functionDecl(hasName("func2"))))))))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(TK_IgnoreUnlessSpelledInSource, Code,
traverse(
TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func3"))), returnStmt(forFunction(functionDecl(hasName("func3"))),
hasReturnValue( hasReturnValue(cxxFunctionalCastExpr(
cxxFunctionalCastExpr(hasSourceExpression( hasSourceExpression(integerLiteral(equals(42))))))),
integerLiteral(equals(42))))))))); LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(TK_IgnoreUnlessSpelledInSource, traverse(
integerLiteral( TK_IgnoreUnlessSpelledInSource,
equals(42), integerLiteral(equals(42),
hasParent(cxxFunctionalCastExpr(hasParent(returnStmt( hasParent(cxxFunctionalCastExpr(hasParent(returnStmt(
forFunction(functionDecl(hasName("func3"))))))))))); forFunction(functionDecl(hasName("func3"))))))))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func4"))), returnStmt(forFunction(functionDecl(hasName("func4"))),
hasReturnValue(cxxTemporaryObjectExpr()))))); hasReturnValue(cxxTemporaryObjectExpr()))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func5"))), returnStmt(forFunction(functionDecl(hasName("func5"))),
hasReturnValue(cxxTemporaryObjectExpr()))))); hasReturnValue(cxxTemporaryObjectExpr()))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func6"))), returnStmt(forFunction(functionDecl(hasName("func6"))),
hasReturnValue(cxxTemporaryObjectExpr()))))); hasReturnValue(cxxTemporaryObjectExpr()))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func7"))), returnStmt(forFunction(functionDecl(hasName("func7"))),
hasReturnValue(cxxTemporaryObjectExpr()))))); hasReturnValue(cxxTemporaryObjectExpr()))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func8"))), returnStmt(forFunction(functionDecl(hasName("func8"))),
hasReturnValue(cxxFunctionalCastExpr( hasReturnValue(cxxFunctionalCastExpr(
hasSourceExpression(initListExpr()))))))); hasSourceExpression(initListExpr()))))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func9"))), returnStmt(forFunction(functionDecl(hasName("func9"))),
hasReturnValue(cxxFunctionalCastExpr( hasReturnValue(cxxFunctionalCastExpr(
hasSourceExpression(initListExpr()))))))); hasSourceExpression(initListExpr()))))),
LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(TK_IgnoreUnlessSpelledInSource, Code,
traverse(
TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func10"))), returnStmt(forFunction(functionDecl(hasName("func10"))),
hasReturnValue( hasReturnValue(declRefExpr(to(varDecl(hasName("a"))))))),
declRefExpr(to(varDecl(hasName("a"))))))))); LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
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));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(TK_IgnoreUnlessSpelledInSource, Code,
traverse(
TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func11"))), returnStmt(forFunction(functionDecl(hasName("func11"))),
hasReturnValue( hasReturnValue(declRefExpr(to(varDecl(hasName("b"))))))),
declRefExpr(to(varDecl(hasName("b"))))))))); LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
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));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(TK_IgnoreUnlessSpelledInSource, Code,
traverse(
TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func12"))), returnStmt(forFunction(functionDecl(hasName("func12"))),
hasReturnValue( hasReturnValue(declRefExpr(to(varDecl(hasName("c"))))))),
declRefExpr(to(varDecl(hasName("c"))))))))); LanguageMode::Cxx2a));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
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));
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));
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, traverse(TK_IgnoreUnlessSpelledInSource, matches(Code,
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));
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));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(TK_IgnoreUnlessSpelledInSource, Code,
lambdaExpr( traverse(TK_IgnoreUnlessSpelledInSource,
forFunction(functionDecl(hasName("func14"))), lambdaExpr(forFunction(functionDecl(hasName("func14"))),
has(templateTypeParmDecl(hasName("TemplateType"))))))); has(templateTypeParmDecl(hasName("TemplateType"))))),
LanguageMode::Cxx2a));
EXPECT_TRUE( EXPECT_TRUE(matches(
matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, Code,
functionDecl(hasName("func14"), traverse(TK_IgnoreUnlessSpelledInSource,
hasDescendant(floatLiteral()))))); functionDecl(hasName("func14"), hasDescendant(floatLiteral()))),
LanguageMode::Cxx2a));
} }
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 1,106 Lines • Show Last 20 Lines