Skip to content

Commit 7dfdca1

Browse files
5chmidtiSirraide
5chmidti
and
Sirraide
authoredSep 27, 2024
[clang][test] add TestLanguage.def to specify all tested language versions (#94243)
Adds a def file to have a single location where tested language versions are specified. Removes the need to update multiple locations in the testing infrastructure to add a new language version to be tested. Test instatiation can now include all languages without needing to specify them. This patch also adds pretty printing for instantiated test names. That means, that a test instantiated with C++23 will have the name `...TestSuite/TestName/CXX23` instead ending with some number (index of the argument for instantiation of the test), which provides a better experience when encountering a test failure with a specific language version. The suffix will also contain an `_win` if the target contains `win`. --------- Co-authored-by: Sirraide <[email protected]>
1 parent 3fee3e8 commit 7dfdca1

12 files changed

+256
-149
lines changed
 

‎clang/include/clang/Testing/CommandLineArgs.h

+8-9
Original file line numberDiff line numberDiff line change
@@ -21,19 +21,18 @@
2121
namespace clang {
2222

2323
enum TestLanguage {
24-
Lang_C89,
25-
Lang_C99,
26-
Lang_CXX03,
27-
Lang_CXX11,
28-
Lang_CXX14,
29-
Lang_CXX17,
30-
Lang_CXX20,
31-
Lang_CXX23,
24+
#define TESTLANGUAGE(lang, version, std_flag, version_index) \
25+
Lang_##lang##version,
26+
#include "clang/Testing/TestLanguage.def"
27+
3228
Lang_OpenCL,
3329
Lang_OBJC,
34-
Lang_OBJCXX
30+
Lang_OBJCXX,
3531
};
3632

33+
std::vector<TestLanguage> getCOrLater(int MinimumStd);
34+
std::vector<TestLanguage> getCXXOrLater(int MinimumStd);
35+
3736
std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang);
3837
std::vector<std::string> getCC1ArgsForTesting(TestLanguage Lang);
3938

‎clang/include/clang/Testing/TestClangConfig.h

+96-19
Original file line numberDiff line numberDiff line change
@@ -27,37 +27,90 @@ struct TestClangConfig {
2727
/// The argument of the `-target` command line flag.
2828
std::string Target;
2929

30-
bool isC() const { return Language == Lang_C89 || Language == Lang_C99; }
30+
bool isC() const {
31+
return false
32+
#define TESTLANGUAGE_C(lang, version, std_flag, version_index) \
33+
|| Language == Lang_##lang##version
34+
#include "clang/Testing/TestLanguage.def"
35+
;
36+
}
3137

32-
bool isC99OrLater() const { return Language == Lang_C99; }
38+
bool isC(int Version) const {
39+
return false
40+
#define TESTLANGUAGE_C(lang, version, std_flag, version_index) \
41+
|| (Version == version && Language == Lang_##lang##version)
42+
#include "clang/Testing/TestLanguage.def"
43+
;
44+
}
3345

34-
bool isCXX() const {
35-
return Language == Lang_CXX03 || Language == Lang_CXX11 ||
36-
Language == Lang_CXX14 || Language == Lang_CXX17 ||
37-
Language == Lang_CXX20 || Language == Lang_CXX23;
46+
bool isCOrLater(int MinimumStdVersion) const {
47+
const auto MinimumStdVersionIndex = 0
48+
#define TESTLANGUAGE_C(lang, version, std_flag, version_index) \
49+
+(MinimumStdVersion == version ? version_index : 0)
50+
#include "clang/Testing/TestLanguage.def"
51+
;
52+
switch (Language) {
53+
#define TESTLANGUAGE_C(lang, version, std_flag, version_index) \
54+
case Lang_##lang##version: \
55+
return MinimumStdVersionIndex <= version_index;
56+
#include "clang/Testing/TestLanguage.def"
57+
default:
58+
return false;
59+
}
3860
}
3961

40-
bool isCXX11OrLater() const {
41-
return Language == Lang_CXX11 || Language == Lang_CXX14 ||
42-
Language == Lang_CXX17 || Language == Lang_CXX20 ||
43-
Language == Lang_CXX23;
62+
bool isC99OrLater() const { return isCOrLater(99); }
63+
64+
bool isCOrEarlier(int MaximumStdVersion) const {
65+
return isC() && (isC(MaximumStdVersion) || !isCOrLater(MaximumStdVersion));
4466
}
4567

46-
bool isCXX14OrLater() const {
47-
return Language == Lang_CXX14 || Language == Lang_CXX17 ||
48-
Language == Lang_CXX20 || Language == Lang_CXX23;
68+
bool isCXX() const {
69+
return false
70+
#define TESTLANGUAGE_CXX(lang, version, std_flag, version_index) \
71+
|| Language == Lang_##lang##version
72+
#include "clang/Testing/TestLanguage.def"
73+
;
4974
}
5075

51-
bool isCXX17OrLater() const {
52-
return Language == Lang_CXX17 || Language == Lang_CXX20 ||
53-
Language == Lang_CXX23;
76+
bool isCXX(int Version) const {
77+
return false
78+
#define TESTLANGUAGE_CXX(lang, version, std_flag, version_index) \
79+
|| (Version == version && Language == Lang_##lang##version)
80+
#include "clang/Testing/TestLanguage.def"
81+
;
5482
}
5583

56-
bool isCXX20OrLater() const {
57-
return Language == Lang_CXX20 || Language == Lang_CXX23;
84+
bool isCXXOrLater(int MinimumStdVersion) const {
85+
const auto MinimumStdVersionIndex = 0
86+
#define TESTLANGUAGE_CXX(lang, version, std_flag, version_index) \
87+
+(MinimumStdVersion == version ? version_index : 0)
88+
#include "clang/Testing/TestLanguage.def"
89+
;
90+
switch (Language) {
91+
#define TESTLANGUAGE_CXX(lang, version, std_flag, version_index) \
92+
case Lang_##lang##version: \
93+
return MinimumStdVersionIndex <= version_index;
94+
#include "clang/Testing/TestLanguage.def"
95+
default:
96+
return false;
97+
}
5898
}
5999

60-
bool isCXX23OrLater() const { return Language == Lang_CXX23; }
100+
bool isCXX11OrLater() const { return isCXXOrLater(11); }
101+
102+
bool isCXX14OrLater() const { return isCXXOrLater(14); }
103+
104+
bool isCXX17OrLater() const { return isCXXOrLater(17); }
105+
106+
bool isCXX20OrLater() const { return isCXXOrLater(20); }
107+
108+
bool isCXX23OrLater() const { return isCXXOrLater(23); }
109+
110+
bool isCXXOrEarlier(int MaximumStdVersion) const {
111+
return isCXX() &&
112+
(isCXX(MaximumStdVersion) || !isCXXOrLater(MaximumStdVersion));
113+
}
61114

62115
bool supportsCXXDynamicExceptionSpecification() const {
63116
return Language == Lang_CXX03 || Language == Lang_CXX11 ||
@@ -75,6 +128,30 @@ struct TestClangConfig {
75128
return Result;
76129
}
77130

131+
std::string toShortString() const {
132+
std::string Result;
133+
llvm::raw_string_ostream OS(Result);
134+
switch (Language) {
135+
#define TESTLANGUAGE(lang, version, std_flag, version_index) \
136+
case Lang_##lang##version: \
137+
OS << (#lang #version); \
138+
break;
139+
#include "clang/Testing/TestLanguage.def"
140+
case Lang_OpenCL:
141+
OS << "OpenCL";
142+
break;
143+
case Lang_OBJC:
144+
OS << "OBJC";
145+
break;
146+
case Lang_OBJCXX:
147+
OS << "OBJCXX";
148+
break;
149+
}
150+
151+
OS << (Target.find("win") != std::string::npos ? "_win" : "");
152+
return Result;
153+
}
154+
78155
std::string toString() const {
79156
std::string Result;
80157
llvm::raw_string_ostream OS(Result);

‎clang/include/clang/Testing/TestLanguage.def

+47
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
2+
//===-- TestLanguage.def - Language Versions for Testing --------*- C++ -*-===//
3+
//
4+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5+
// See https://llvm.org/LICENSE.txt for license information.
6+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7+
//
8+
//===----------------------------------------------------------------------===//
9+
10+
// The TESTLANGUAGE(-C/-CXX) macros have four parameters:
11+
// the language, the standard version, the corresponding compile-flag,
12+
// and an index of the language version for each language.
13+
// The standard version is used to compare a standard version numerically,
14+
// and the index is used to impose ordering for the language versions
15+
// with respect to each language.
16+
17+
#ifndef TESTLANGUAGE
18+
# define TESTLANGUAGE(...)
19+
#endif
20+
21+
#ifndef TESTLANGUAGE_C
22+
# define TESTLANGUAGE_C(...) TESTLANGUAGE(__VA_ARGS__)
23+
#endif
24+
25+
#ifndef TESTLANGUAGE_CXX
26+
# define TESTLANGUAGE_CXX(...) TESTLANGUAGE(__VA_ARGS__)
27+
#endif
28+
29+
TESTLANGUAGE_C(C, 89, c89, 0)
30+
TESTLANGUAGE_C(C, 99, c99, 1)
31+
TESTLANGUAGE_C(C, 11, c11, 2)
32+
TESTLANGUAGE_C(C, 17, c17, 3)
33+
TESTLANGUAGE_C(C, 23, c23, 4)
34+
TESTLANGUAGE_C(C, 26, c2y, 5)
35+
36+
// TESTLANGUAGE_CXX(CXX, 98, c++98, 0)
37+
TESTLANGUAGE_CXX(CXX, 03, c++03, 1)
38+
TESTLANGUAGE_CXX(CXX, 11, c++11, 2)
39+
TESTLANGUAGE_CXX(CXX, 14, c++14, 3)
40+
TESTLANGUAGE_CXX(CXX, 17, c++17, 4)
41+
TESTLANGUAGE_CXX(CXX, 20, c++20, 5)
42+
TESTLANGUAGE_CXX(CXX, 23, c++23, 6)
43+
TESTLANGUAGE_CXX(CXX, 26, c++26, 7)
44+
45+
#undef TESTLANGUAGE_CXX
46+
#undef TESTLANGUAGE_C
47+
#undef TESTLANGUAGE

‎clang/lib/Testing/CommandLineArgs.cpp

+49-69
Original file line numberDiff line numberDiff line change
@@ -11,99 +11,79 @@
1111
#include "llvm/Support/ErrorHandling.h"
1212

1313
namespace clang {
14+
std::vector<TestLanguage> getCOrLater(const int MinimumStd) {
15+
std::vector<TestLanguage> Result{};
16+
17+
#define TESTLANGUAGE_C(lang, version, std_flag, version_index) \
18+
if (version >= MinimumStd) \
19+
Result.push_back(Lang_##lang##version);
20+
#include "clang/Testing/TestLanguage.def"
21+
22+
return Result;
23+
}
24+
std::vector<TestLanguage> getCXXOrLater(const int MinimumStd) {
25+
std::vector<TestLanguage> Result{};
26+
27+
#define TESTLANGUAGE_CXX(lang, version, std_flag, version_index) \
28+
if (version >= MinimumStd) \
29+
Result.push_back(Lang_##lang##version);
30+
#include "clang/Testing/TestLanguage.def"
31+
32+
return Result;
33+
}
1434

1535
std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang) {
16-
std::vector<std::string> Args;
1736
// Test with basic arguments.
1837
switch (Lang) {
19-
case Lang_C89:
20-
Args = {"-x", "c", "-std=c89"};
21-
break;
22-
case Lang_C99:
23-
Args = {"-x", "c", "-std=c99"};
24-
break;
25-
case Lang_CXX03:
26-
Args = {"-std=c++03", "-frtti"};
27-
break;
28-
case Lang_CXX11:
29-
Args = {"-std=c++11", "-frtti"};
30-
break;
31-
case Lang_CXX14:
32-
Args = {"-std=c++14", "-frtti"};
33-
break;
34-
case Lang_CXX17:
35-
Args = {"-std=c++17", "-frtti"};
36-
break;
37-
case Lang_CXX20:
38-
Args = {"-std=c++20", "-frtti"};
39-
break;
40-
case Lang_CXX23:
41-
Args = {"-std=c++23", "-frtti"};
42-
break;
38+
#define TESTLANGUAGE_C(lang, version, std_flag, version_index) \
39+
case Lang_##lang##version: \
40+
return { "-x", "c", "-std=" #std_flag };
41+
#define TESTLANGUAGE_CXX(lang, version, std_flag, version_index) \
42+
case Lang_##lang##version: \
43+
return { "-std=" #std_flag, "-frtti" };
44+
#include "clang/Testing/TestLanguage.def"
45+
4346
case Lang_OBJC:
44-
Args = {"-x", "objective-c", "-frtti", "-fobjc-nonfragile-abi"};
45-
break;
47+
return {"-x", "objective-c", "-frtti", "-fobjc-nonfragile-abi"};
4648
case Lang_OBJCXX:
47-
Args = {"-x", "objective-c++", "-frtti"};
48-
break;
49+
return {"-x", "objective-c++", "-frtti"};
4950
case Lang_OpenCL:
50-
llvm_unreachable("Not implemented yet!");
51+
llvm_unreachable("Unhandled TestLanguage enum");
5152
}
52-
return Args;
53+
llvm_unreachable("Unhandled TestLanguage enum");
5354
}
5455

5556
std::vector<std::string> getCC1ArgsForTesting(TestLanguage Lang) {
56-
std::vector<std::string> Args;
5757
switch (Lang) {
58-
case Lang_C89:
59-
Args = {"-xc", "-std=c89"};
60-
break;
61-
case Lang_C99:
62-
Args = {"-xc", "-std=c99"};
63-
break;
64-
case Lang_CXX03:
65-
Args = {"-std=c++03"};
66-
break;
67-
case Lang_CXX11:
68-
Args = {"-std=c++11"};
69-
break;
70-
case Lang_CXX14:
71-
Args = {"-std=c++14"};
72-
break;
73-
case Lang_CXX17:
74-
Args = {"-std=c++17"};
75-
break;
76-
case Lang_CXX20:
77-
Args = {"-std=c++20"};
78-
break;
79-
case Lang_CXX23:
80-
Args = {"-std=c++23"};
81-
break;
58+
#define TESTLANGUAGE_C(lang, version, std_flag, version_index) \
59+
case Lang_##lang##version: \
60+
return { "-xc", "-std=" #std_flag };
61+
#define TESTLANGUAGE_CXX(lang, version, std_flag, version_index) \
62+
case Lang_##lang##version: \
63+
return { "-std=" #std_flag };
64+
#include "clang/Testing/TestLanguage.def"
65+
8266
case Lang_OBJC:
83-
Args = {"-xobjective-c"};
67+
return {"-xobjective-c"};
8468
break;
8569
case Lang_OBJCXX:
86-
Args = {"-xobjective-c++"};
70+
return {"-xobjective-c++"};
8771
break;
8872
case Lang_OpenCL:
89-
llvm_unreachable("Not implemented yet!");
73+
llvm_unreachable("Unhandled TestLanguage enum");
9074
}
91-
return Args;
75+
llvm_unreachable("Unhandled TestLanguage enum");
9276
}
9377

9478
StringRef getFilenameForTesting(TestLanguage Lang) {
9579
switch (Lang) {
96-
case Lang_C89:
97-
case Lang_C99:
80+
#define TESTLANGUAGE_C(lang, version, std_flag, version_index) \
81+
case Lang_##lang##version: \
9882
return "input.c";
99-
100-
case Lang_CXX03:
101-
case Lang_CXX11:
102-
case Lang_CXX14:
103-
case Lang_CXX17:
104-
case Lang_CXX20:
105-
case Lang_CXX23:
83+
#define TESTLANGUAGE_CXX(lang, version, std_flag, version_index) \
84+
case Lang_##lang##version: \
10685
return "input.cc";
86+
#include "clang/Testing/TestLanguage.def"
10787

10888
case Lang_OpenCL:
10989
return "input.cl";

0 commit comments

Comments
 (0)
Please sign in to comment.