[clang] 44f989e - Run syntax tree tests in many language modes
Dmitri Gribenko via cfe-commits
cfe-commits at lists.llvm.org
Tue Jun 2 01:43:38 PDT 2020
Author: Dmitri Gribenko
Date: 2020-06-02T10:30:01+02:00
New Revision: 44f989e7809633f13bd0420cc1d79660ad982173
URL: https://github.com/llvm/llvm-project/commit/44f989e7809633f13bd0420cc1d79660ad982173
DIFF: https://github.com/llvm/llvm-project/commit/44f989e7809633f13bd0420cc1d79660ad982173.diff
LOG: Run syntax tree tests in many language modes
Reviewers: hlopko, eduucaldas
Reviewed By: hlopko, eduucaldas
Subscribers: gribozavr2, mgorny, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D80822
Added:
Modified:
clang/unittests/Tooling/Syntax/CMakeLists.txt
clang/unittests/Tooling/Syntax/TreeTest.cpp
Removed:
################################################################################
diff --git a/clang/unittests/Tooling/Syntax/CMakeLists.txt b/clang/unittests/Tooling/Syntax/CMakeLists.txt
index 5de7d24e2675..62d1ecc81cad 100644
--- a/clang/unittests/Tooling/Syntax/CMakeLists.txt
+++ b/clang/unittests/Tooling/Syntax/CMakeLists.txt
@@ -14,6 +14,7 @@ clang_target_link_libraries(SyntaxTests
clangFrontend
clangLex
clangSerialization
+ clangTesting
clangTooling
clangToolingCore
clangToolingSyntax
diff --git a/clang/unittests/Tooling/Syntax/TreeTest.cpp b/clang/unittests/Tooling/Syntax/TreeTest.cpp
index 04786257c434..705cb872c6a4 100644
--- a/clang/unittests/Tooling/Syntax/TreeTest.cpp
+++ b/clang/unittests/Tooling/Syntax/TreeTest.cpp
@@ -17,6 +17,7 @@
#include "clang/Frontend/FrontendAction.h"
#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "clang/Lex/PreprocessorOptions.h"
+#include "clang/Testing/CommandLineArgs.h"
#include "clang/Tooling/Core/Replacement.h"
#include "clang/Tooling/Syntax/BuildTree.h"
#include "clang/Tooling/Syntax/Mutations.h"
@@ -25,6 +26,7 @@
#include "clang/Tooling/Tooling.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Error.h"
@@ -45,12 +47,71 @@ static llvm::ArrayRef<syntax::Token> tokens(syntax::Node *N) {
T->lastLeaf()->token() + 1);
}
-class SyntaxTreeTest : public ::testing::Test {
+struct TestClangConfig {
+ TestLanguage Language;
+ std::string Target;
+
+ bool isCXX() const {
+ return Language == Lang_CXX || Language == Lang_CXX11 ||
+ Language == Lang_CXX14 || Language == Lang_CXX17 ||
+ Language == Lang_CXX2a;
+ }
+
+ bool isCXX11OrLater() const {
+ return Language == Lang_CXX11 || Language == Lang_CXX14 ||
+ Language == Lang_CXX17 || Language == Lang_CXX2a;
+ }
+
+ bool hasDelayedTemplateParsing() const {
+ return Target == "x86_64-pc-win32-msvc";
+ }
+
+ std::vector<std::string> getCommandLineArgs() const {
+ std::vector<std::string> Result = getCommandLineArgsForTesting(Language);
+ Result.push_back("-target");
+ Result.push_back(Target);
+ return Result;
+ }
+
+ std::string toString() const {
+ std::string Result;
+ llvm::raw_string_ostream OS(Result);
+ OS << "{ Language=" << Language << ", Target=" << Target << " }";
+ return OS.str();
+ }
+
+ friend std::ostream &operator<<(std::ostream &OS,
+ const TestClangConfig &ClangConfig) {
+ return OS << ClangConfig.toString();
+ }
+
+ static std::vector<TestClangConfig> &allConfigs() {
+ static std::vector<TestClangConfig> all_configs = []() {
+ std::vector<TestClangConfig> all_configs;
+ for (TestLanguage lang : {Lang_C, Lang_C89, Lang_CXX, Lang_CXX11,
+ Lang_CXX14, Lang_CXX17, Lang_CXX2a}) {
+ TestClangConfig config;
+ config.Language = lang;
+ config.Target = "x86_64-pc-linux-gnu";
+ all_configs.push_back(config);
+
+ // Windows target is interesting to test because it enables
+ // `-fdelayed-template-parsing`.
+ config.Target = "x86_64-pc-win32-msvc";
+ all_configs.push_back(config);
+ }
+ return all_configs;
+ }();
+ return all_configs;
+ }
+};
+
+class SyntaxTreeTest : public ::testing::Test,
+ public ::testing::WithParamInterface<TestClangConfig> {
protected:
// Build a syntax tree for the code.
- syntax::TranslationUnit *
- buildTree(llvm::StringRef Code,
- const std::string &Target = "x86_64-pc-linux-gnu") {
+ syntax::TranslationUnit *buildTree(llvm::StringRef Code,
+ const TestClangConfig &ClangConfig) {
// FIXME: this code is almost the identical to the one in TokensTest. Share
// it.
class BuildSyntaxTree : public ASTConsumer {
@@ -105,11 +166,19 @@ class SyntaxTreeTest : public ::testing::Test {
diag::Severity::Ignored, SourceLocation());
// Prepare to run a compiler.
- std::vector<const char *> Args = {
- "syntax-test", "-target", Target.c_str(),
- FileName, "-fsyntax-only", "-std=c++17",
+ std::vector<std::string> Args = {
+ "syntax-test",
+ "-fsyntax-only",
};
- Invocation = createInvocationFromCommandLine(Args, Diags, FS);
+ llvm::copy(ClangConfig.getCommandLineArgs(), std::back_inserter(Args));
+ Args.push_back(FileName);
+
+ std::vector<const char *> ArgsCStr;
+ for (const std::string &arg : Args) {
+ ArgsCStr.push_back(arg.c_str());
+ }
+
+ Invocation = createInvocationFromCommandLine(ArgsCStr, Diags, FS);
assert(Invocation);
Invocation->getFrontendOpts().DisableFree = false;
Invocation->getPreprocessorOpts().addRemappedFile(
@@ -133,32 +202,15 @@ class SyntaxTreeTest : public ::testing::Test {
return Root;
}
- void expectTreeDumpEqual(StringRef Code, StringRef Tree,
- bool RunWithDelayedTemplateParsing = true) {
+ void expectTreeDumpEqual(StringRef Code, StringRef Tree) {
+ SCOPED_TRACE(llvm::join(GetParam().getCommandLineArgs(), " "));
SCOPED_TRACE(Code);
- std::string Expected = Tree.trim().str();
-
- // We want to run the test with -fdelayed-template-parsing enabled and
- // disabled, therefore we use these representative targets that
diff er in
- // the default value.
- // We are not passing -fdelayed-template-parsing directly but we are using
- // the `-target` to improve coverage and discover
diff erences in behavior
- // early.
- for (const std::string Target :
- {"x86_64-pc-linux-gnu", "x86_64-pc-win32-msvc"}) {
- if (!RunWithDelayedTemplateParsing &&
- Target == "x86_64-pc-win32-msvc") {
- continue;
- }
- auto *Root = buildTree(Code, Target);
- EXPECT_EQ(Diags->getClient()->getNumErrors(), 0u)
- << "Source file has syntax errors, they were printed to the test log";
- std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim());
- EXPECT_EQ(Expected, Actual)
- << "for target " << Target << " the resulting dump is:\n"
- << Actual;
- }
+ auto *Root = buildTree(Code, GetParam());
+ EXPECT_EQ(Diags->getClient()->getNumErrors(), 0u)
+ << "Source file has syntax errors, they were printed to the test log";
+ std::string Actual = std::string(StringRef(Root->dump(*Arena)).trim());
+ EXPECT_EQ(Tree.trim().str(), Actual);
}
// Adds a file to the test VFS.
@@ -206,7 +258,7 @@ class SyntaxTreeTest : public ::testing::Test {
std::unique_ptr<syntax::Arena> Arena;
};
-TEST_F(SyntaxTreeTest, Simple) {
+TEST_P(SyntaxTreeTest, Simple) {
expectTreeDumpEqual(
R"cpp(
int main() {}
@@ -237,7 +289,7 @@ void foo() {}
)txt");
}
-TEST_F(SyntaxTreeTest, SimpleVariable) {
+TEST_P(SyntaxTreeTest, SimpleVariable) {
expectTreeDumpEqual(
R"cpp(
int a;
@@ -261,7 +313,7 @@ int b = 42;
)txt");
}
-TEST_F(SyntaxTreeTest, SimpleFunction) {
+TEST_P(SyntaxTreeTest, SimpleFunction) {
expectTreeDumpEqual(
R"cpp(
void foo(int a, int b) {}
@@ -290,12 +342,12 @@ void foo(int a, int b) {}
)txt");
}
-TEST_F(SyntaxTreeTest, If) {
+TEST_P(SyntaxTreeTest, If) {
expectTreeDumpEqual(
R"cpp(
int main() {
- if (true) {}
- if (true) {} else if (false) {}
+ if (1) {}
+ if (1) {} else if (0) {}
}
)cpp",
R"txt(
@@ -313,7 +365,7 @@ int main() {
| |-if
| |-(
| |-UnknownExpression
- | | `-true
+ | | `-1
| |-)
| `-CompoundStatement
| |-{
@@ -322,7 +374,7 @@ int main() {
| |-if
| |-(
| |-UnknownExpression
- | | `-true
+ | | `-1
| |-)
| |-CompoundStatement
| | |-{
@@ -332,7 +384,7 @@ int main() {
| |-if
| |-(
| |-UnknownExpression
- | | `-false
+ | | `-0
| |-)
| `-CompoundStatement
| |-{
@@ -341,7 +393,7 @@ int main() {
)txt");
}
-TEST_F(SyntaxTreeTest, For) {
+TEST_P(SyntaxTreeTest, For) {
expectTreeDumpEqual(
R"cpp(
void test() {
@@ -372,12 +424,16 @@ void test() {
)txt");
}
-TEST_F(SyntaxTreeTest, RangeBasedFor) {
+TEST_P(SyntaxTreeTest, RangeBasedFor) {
+ if (!GetParam().isCXX11OrLater()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
void test() {
int a[3];
- for (int x : a) ;
+ for (int x : a)
+ ;
}
)cpp",
R"txt(
@@ -419,7 +475,7 @@ void test() {
)txt");
}
-TEST_F(SyntaxTreeTest, DeclarationStatement) {
+TEST_P(SyntaxTreeTest, DeclarationStatement) {
expectTreeDumpEqual("void test() { int a = 10; }",
R"txt(
*: TranslationUnit
@@ -445,11 +501,11 @@ TEST_F(SyntaxTreeTest, DeclarationStatement) {
)txt");
}
-TEST_F(SyntaxTreeTest, Switch) {
+TEST_P(SyntaxTreeTest, Switch) {
expectTreeDumpEqual(
R"cpp(
void test() {
- switch (true) {
+ switch (1) {
case 0:
default:;
}
@@ -470,7 +526,7 @@ void test() {
| |-switch
| |-(
| |-UnknownExpression
- | | `-true
+ | | `-1
| |-)
| `-CompoundStatement
| |-{
@@ -489,11 +545,11 @@ void test() {
)txt");
}
-TEST_F(SyntaxTreeTest, While) {
+TEST_P(SyntaxTreeTest, While) {
expectTreeDumpEqual(
R"cpp(
void test() {
- while (true) { continue; break; }
+ while (1) { continue; break; }
}
)cpp",
R"txt(
@@ -511,7 +567,7 @@ void test() {
| |-while
| |-(
| |-UnknownExpression
- | | `-true
+ | | `-1
| |-)
| `-CompoundStatement
| |-{
@@ -526,7 +582,7 @@ void test() {
)txt");
}
-TEST_F(SyntaxTreeTest, UnhandledStatement) {
+TEST_P(SyntaxTreeTest, UnhandledStatement) {
// Unhandled statements should end up as 'unknown statement'.
// This example uses a 'label statement', which does not yet have a syntax
// counterpart.
@@ -554,14 +610,14 @@ TEST_F(SyntaxTreeTest, UnhandledStatement) {
)txt");
}
-TEST_F(SyntaxTreeTest, Expressions) {
+TEST_P(SyntaxTreeTest, Expressions) {
// expressions should be wrapped in 'ExpressionStatement' when they appear
// in a statement position.
expectTreeDumpEqual(
R"cpp(
void test() {
test();
- if (true) test(); else test();
+ if (1) test(); else test();
}
)cpp",
R"txt(
@@ -586,7 +642,7 @@ void test() {
| |-if
| |-(
| |-UnknownExpression
- | | `-true
+ | | `-1
| |-)
| |-ExpressionStatement
| | |-UnknownExpression
@@ -607,7 +663,7 @@ void test() {
)txt");
}
-TEST_F(SyntaxTreeTest, PostfixUnaryOperator) {
+TEST_P(SyntaxTreeTest, PostfixUnaryOperator) {
expectTreeDumpEqual(
R"cpp(
void test(int a) {
@@ -646,7 +702,11 @@ void test(int a) {
)txt");
}
-TEST_F(SyntaxTreeTest, PrefixUnaryOperator) {
+TEST_P(SyntaxTreeTest, PrefixUnaryOperator) {
+ if (!GetParam().isCXX()) {
+ // TODO: Split parts that depend on C++ into a separate test.
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
void test(int a, int *ap, bool b) {
@@ -762,7 +822,11 @@ void test(int a, int *ap, bool b) {
)txt");
}
-TEST_F(SyntaxTreeTest, BinaryOperator) {
+TEST_P(SyntaxTreeTest, BinaryOperator) {
+ if (!GetParam().isCXX()) {
+ // TODO: Split parts that depend on C++ into a separate test.
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
void test(int a) {
@@ -880,7 +944,7 @@ void test(int a) {
)txt");
}
-TEST_F(SyntaxTreeTest, NestedBinaryOperator) {
+TEST_P(SyntaxTreeTest, NestedBinaryOperator) {
expectTreeDumpEqual(
R"cpp(
void test(int a, int b) {
@@ -993,7 +1057,10 @@ void test(int a, int b) {
)txt");
}
-TEST_F(SyntaxTreeTest, UserDefinedBinaryOperator) {
+TEST_P(SyntaxTreeTest, UserDefinedBinaryOperator) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
struct X {
@@ -1121,7 +1188,7 @@ void test(X x, X y) {
)txt");
}
-TEST_F(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
+TEST_P(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
expectTreeDumpEqual(
R"cpp(
int *a, b; int *c, d;
@@ -1149,7 +1216,7 @@ TEST_F(SyntaxTreeTest, MultipleDeclaratorsGrouping) {
)txt");
}
-TEST_F(SyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
+TEST_P(SyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
expectTreeDumpEqual(
R"cpp(
typedef int *a, b;
@@ -1169,7 +1236,7 @@ TEST_F(SyntaxTreeTest, MultipleDeclaratorsGroupingTypedef) {
)txt");
}
-TEST_F(SyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
+TEST_P(SyntaxTreeTest, MultipleDeclaratorsInsideStatement) {
expectTreeDumpEqual(
R"cpp(
void foo() {
@@ -1213,7 +1280,10 @@ void foo() {
)txt");
}
-TEST_F(SyntaxTreeTest, Namespaces) {
+TEST_P(SyntaxTreeTest, Namespaces) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
namespace a { namespace b {} }
@@ -1254,7 +1324,10 @@ namespace foo = a;
)txt");
}
-TEST_F(SyntaxTreeTest, UsingDirective) {
+TEST_P(SyntaxTreeTest, UsingDirective) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
namespace ns {}
@@ -1276,7 +1349,10 @@ using namespace ::ns;
)txt");
}
-TEST_F(SyntaxTreeTest, UsingDeclaration) {
+TEST_P(SyntaxTreeTest, UsingDeclaration) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
namespace ns { int a; }
@@ -1303,7 +1379,7 @@ using ns::a;
)txt");
}
-TEST_F(SyntaxTreeTest, FreeStandingClasses) {
+TEST_P(SyntaxTreeTest, FreeStandingClasses) {
// Free-standing classes, must live inside a SimpleDeclaration.
expectTreeDumpEqual(
R"cpp(
@@ -1354,7 +1430,15 @@ struct {} *a1;
)txt");
}
-TEST_F(SyntaxTreeTest, Templates) {
+TEST_P(SyntaxTreeTest, Templates) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
+ if (GetParam().hasDelayedTemplateParsing()) {
+ // FIXME: Make this test work on Windows by generating the expected syntax
+ // tree when `-fdelayed-template-parsing` is active.
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
template <class T> struct cls {};
@@ -1408,13 +1492,13 @@ template <class T> int fun() {}
`-CompoundStatement
|-{
`-}
-)txt",
- // FIXME: Make this test work on windows by generating the expected Syntax
- // tree when -fdelayed-template-parsing is active.
- /*RunWithDelayedTemplateParsing=*/false);
+)txt");
}
-TEST_F(SyntaxTreeTest, NestedTemplates) {
+TEST_P(SyntaxTreeTest, NestedTemplates) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
template <class T>
@@ -1456,7 +1540,10 @@ struct X {
)txt");
}
-TEST_F(SyntaxTreeTest, Templates2) {
+TEST_P(SyntaxTreeTest, Templates2) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
template <class T> struct X { struct Y; };
@@ -1502,7 +1589,10 @@ template <class T> struct X<T>::Y {};
)txt");
}
-TEST_F(SyntaxTreeTest, TemplatesUsingUsing) {
+TEST_P(SyntaxTreeTest, TemplatesUsingUsing) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
template <class T> struct X {
@@ -1541,7 +1631,10 @@ template <class T> struct X {
)txt");
}
-TEST_F(SyntaxTreeTest, ExplicitTemplateInstantations) {
+TEST_P(SyntaxTreeTest, ExplicitTemplateInstantations) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
template <class T> struct X {};
@@ -1618,7 +1711,10 @@ extern template struct X<float>;
)txt");
}
-TEST_F(SyntaxTreeTest, UsingType) {
+TEST_P(SyntaxTreeTest, UsingType) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
using type = int;
@@ -1634,7 +1730,7 @@ using type = int;
)txt");
}
-TEST_F(SyntaxTreeTest, EmptyDeclaration) {
+TEST_P(SyntaxTreeTest, EmptyDeclaration) {
expectTreeDumpEqual(
R"cpp(
;
@@ -1646,7 +1742,10 @@ TEST_F(SyntaxTreeTest, EmptyDeclaration) {
)txt");
}
-TEST_F(SyntaxTreeTest, StaticAssert) {
+TEST_P(SyntaxTreeTest, StaticAssert) {
+ if (!GetParam().isCXX11OrLater()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
static_assert(true, "message");
@@ -1674,7 +1773,10 @@ static_assert(true);
)txt");
}
-TEST_F(SyntaxTreeTest, ExternC) {
+TEST_P(SyntaxTreeTest, ExternC) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
extern "C" int a;
@@ -1708,7 +1810,7 @@ extern "C" { int b; int c; }
)txt");
}
-TEST_F(SyntaxTreeTest, NonModifiableNodes) {
+TEST_P(SyntaxTreeTest, NonModifiableNodes) {
// Some nodes are non-modifiable, they are marked with 'I:'.
expectTreeDumpEqual(
R"cpp(
@@ -1749,7 +1851,7 @@ void test() {
)txt");
}
-TEST_F(SyntaxTreeTest, ModifiableNodes) {
+TEST_P(SyntaxTreeTest, ModifiableNodes) {
// All nodes can be mutated.
expectTreeDumpEqual(
R"cpp(
@@ -1795,7 +1897,7 @@ void test() {
)txt");
}
-TEST_F(SyntaxTreeTest, ArraySubscriptsInDeclarators) {
+TEST_P(SyntaxTreeTest, ArraySubscriptsInDeclarators) {
expectTreeDumpEqual(
R"cpp(
int a[10];
@@ -1858,7 +1960,11 @@ int c[] = {1,2,3};
`-; )txt");
}
-TEST_F(SyntaxTreeTest, ParameterListsInDeclarators) {
+TEST_P(SyntaxTreeTest, ParameterListsInDeclarators) {
+ if (!GetParam().isCXX()) {
+ // TODO: Split parts that depend on C++ into a separate test.
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
struct Test {
@@ -1979,7 +2085,11 @@ struct Test {
)txt");
}
-TEST_F(SyntaxTreeTest, TrailingConst) {
+TEST_P(SyntaxTreeTest, TrailingConst) {
+ if (!GetParam().isCXX()) {
+ // TODO: Split parts that depend on C++ into a separate test.
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
struct X {
@@ -2006,7 +2116,10 @@ struct X {
)txt");
}
-TEST_F(SyntaxTreeTest, TrailingReturn) {
+TEST_P(SyntaxTreeTest, TrailingReturn) {
+ if (!GetParam().isCXX11OrLater()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
auto foo() -> int;
@@ -2027,7 +2140,11 @@ auto foo() -> int;
)txt");
}
-TEST_F(SyntaxTreeTest, ExceptionSpecification) {
+TEST_P(SyntaxTreeTest, ExceptionSpecification) {
+ if (!GetParam().isCXX11OrLater()) {
+ // TODO: Split parts that depend on C++11 into a separate test.
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
int a() noexcept;
@@ -2072,7 +2189,7 @@ int c() throw();
)txt");
}
-TEST_F(SyntaxTreeTest, DeclaratorsInParentheses) {
+TEST_P(SyntaxTreeTest, DeclaratorsInParentheses) {
expectTreeDumpEqual(
R"cpp(
int (a);
@@ -2130,7 +2247,7 @@ int *(d)(int);
)txt");
}
-TEST_F(SyntaxTreeTest, ConstVolatileQualifiers) {
+TEST_P(SyntaxTreeTest, ConstVolatileQualifiers) {
expectTreeDumpEqual(
R"cpp(
const int west = -1;
@@ -2184,7 +2301,10 @@ const int const *const *volatile b;
)txt");
}
-TEST_F(SyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
+TEST_P(SyntaxTreeTest, RangesOfDeclaratorsWithTrailingReturnTypes) {
+ if (!GetParam().isCXX11OrLater()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
auto foo() -> auto(*)(int) -> double*;
@@ -2220,7 +2340,10 @@ auto foo() -> auto(*)(int) -> double*;
)txt");
}
-TEST_F(SyntaxTreeTest, MemberPointers) {
+TEST_P(SyntaxTreeTest, MemberPointers) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
expectTreeDumpEqual(
R"cpp(
struct X {};
@@ -2257,7 +2380,7 @@ const int X::* b;
)txt");
}
-TEST_F(SyntaxTreeTest, ComplexDeclarator) {
+TEST_P(SyntaxTreeTest, ComplexDeclarator) {
expectTreeDumpEqual(
R"cpp(
void x(char a, short (*b)(int));
@@ -2293,7 +2416,7 @@ void x(char a, short (*b)(int));
)txt");
}
-TEST_F(SyntaxTreeTest, ComplexDeclarator2) {
+TEST_P(SyntaxTreeTest, ComplexDeclarator2) {
expectTreeDumpEqual(
R"cpp(
void x(char a, short (*b)(int), long (**c)(long long));
@@ -2345,13 +2468,17 @@ void x(char a, short (*b)(int), long (**c)(long long));
)txt");
}
-TEST_F(SyntaxTreeTest, Mutations) {
+TEST_P(SyntaxTreeTest, Mutations) {
+ if (!GetParam().isCXX11OrLater()) {
+ return;
+ }
+
using Transformation = std::function<void(
const llvm::Annotations & /*Input*/, syntax::TranslationUnit * /*Root*/)>;
auto CheckTransformation = [this](std::string Input, std::string Expected,
Transformation Transform) -> void {
llvm::Annotations Source(Input);
- auto *Root = buildTree(Source.code());
+ auto *Root = buildTree(Source.code(), GetParam());
Transform(Source, Root);
@@ -2388,8 +2515,8 @@ TEST_F(SyntaxTreeTest, Mutations) {
CheckTransformation(C.first, C.second, RemoveStatement);
}
-TEST_F(SyntaxTreeTest, SynthesizedNodes) {
- buildTree("");
+TEST_P(SyntaxTreeTest, SynthesizedNodes) {
+ buildTree("", GetParam());
auto *C = syntax::createPunctuation(*Arena, tok::comma);
ASSERT_NE(C, nullptr);
@@ -2405,4 +2532,7 @@ TEST_F(SyntaxTreeTest, SynthesizedNodes) {
EXPECT_TRUE(S->isDetached());
}
+INSTANTIATE_TEST_CASE_P(SyntaxTreeTests, SyntaxTreeTest,
+ testing::ValuesIn(TestClangConfig::allConfigs()));
+
} // namespace
More information about the cfe-commits
mailing list