Debian Codegraph @

llvm-project/clang/unittests/Format/QualifierFixerTest.cpp

raw
1 //===- unittest/Format/QualifierFixerTest.cpp - Formatting unit tests -----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "clang/Format/Format.h"
10
11 #include "FormatTestUtils.h"
12 #include "TestLexer.h"
13 #include "gtest/gtest.h"
14
15 #include "../../lib/Format/QualifierAlignmentFixer.h"
16
17 #define DEBUG_TYPE "format-qualifier-fixer-test"
18
19 using testing::ScopedTrace;
20
21 namespace clang {
22 namespace format {
23 namespace {
24
25 #define CHECK_PARSE(TEXT, FIELD, VALUE) \
26 EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!"; \
27 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \
28 EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
29
30 #define FAIL_PARSE(TEXT, FIELD, VALUE) \
31 EXPECT_NE(0, parseConfiguration(TEXT, &Style).value()); \
32 EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
33
34 class QualifierFixerTest : public ::testing::Test {
35 protected:
36 enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
37
38 TokenList annotate(llvm::StringRef Code,
39 const FormatStyle &Style = getLLVMStyle()) {
40 return TestLexer(Allocator, Buffers, Style).annotate(Code);
41 }
42 llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
43 std::vector<std::unique_ptr<llvm::MemoryBuffer>> Buffers;
44
45 std::string format(llvm::StringRef Code,
46 const FormatStyle &Style = getLLVMStyle(),
47 StatusCheck CheckComplete = SC_ExpectComplete) {
48 LLVM_DEBUG(llvm::errs() << "---\n");
49 LLVM_DEBUG(llvm::errs() << Code << "\n\n");
50 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
51 FormattingAttemptStatus Status;
52 tooling::Replacements Replaces =
53 reformat(Style, Code, Ranges, "<stdin>", &Status);
54 if (CheckComplete != SC_DoNotCheck) {
55 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
56 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
57 << Code << "\n\n";
58 }
59 ReplacementCount = Replaces.size();
60 auto Result = applyAllReplacements(Code, Replaces);
61 EXPECT_TRUE(static_cast<bool>(Result));
62 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
63 return *Result;
64 }
65
66 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
67 Style.ColumnLimit = ColumnLimit;
68 return Style;
69 }
70
71 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
72 return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
73 }
74
75 void _verifyFormat(const char *File, int Line, llvm::StringRef Expected,
76 llvm::StringRef Code,
77 const FormatStyle &Style = getLLVMStyle()) {
78 ScopedTrace t(File, Line, ::testing::Message() << Code.str());
79 EXPECT_EQ(Expected.str(), format(Expected, Style))
80 << "Expected code is not stable";
81 EXPECT_EQ(Expected.str(), format(Code, Style));
82 if (Style.Language == FormatStyle::LK_Cpp) {
83 // Objective-C++ is a superset of C++, so everything checked for C++
84 // needs to be checked for Objective-C++ as well.
85 FormatStyle ObjCStyle = Style;
86 ObjCStyle.Language = FormatStyle::LK_ObjC;
87 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
88 }
89 }
90
91 void _verifyFormat(const char *File, int Line, llvm::StringRef Code,
92 const FormatStyle &Style = getLLVMStyle()) {
93 _verifyFormat(File, Line, Code, test::messUp(Code), Style);
94 }
95
96 void _verifyIncompleteFormat(const char *File, int Line, llvm::StringRef Code,
97 const FormatStyle &Style = getLLVMStyle()) {
98 ScopedTrace t(File, Line, ::testing::Message() << Code.str());
99 EXPECT_EQ(Code.str(),
100 format(test::messUp(Code), Style, SC_ExpectIncomplete));
101 }
102
103 void _verifyIndependentOfContext(const char *File, int Line,
104 llvm::StringRef Text,
105 const FormatStyle &Style = getLLVMStyle()) {
106 _verifyFormat(File, Line, Text, Style);
107 _verifyFormat(File, Line, llvm::Twine("void f() { " + Text + " }").str(),
108 Style);
109 }
110
111 /// \brief Verify that clang-format does not crash on the given input.
112 void verifyNoCrash(llvm::StringRef Code,
113 const FormatStyle &Style = getLLVMStyle()) {
114 format(Code, Style, SC_DoNotCheck);
115 }
116
117 int ReplacementCount;
118 };
119
120 #define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)
121
122 } // namespace
123
124 TEST_F(QualifierFixerTest, RotateTokens) {
125 // TODO add test
126 EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("const"),
127 tok::kw_const);
128 EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("volatile"),
129 tok::kw_volatile);
130 EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("inline"),
131 tok::kw_inline);
132 EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("static"),
133 tok::kw_static);
134 EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("restrict"),
135 tok::kw_restrict);
136 EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("friend"),
137 tok::kw_friend);
138 }
139
140 TEST_F(QualifierFixerTest, FailQualifierInvalidConfiguration) {
141 FormatStyle Style = {};
142 Style.Language = FormatStyle::LK_Cpp;
143 FAIL_PARSE("QualifierAlignment: Custom\n"
144 "QualifierOrder: [const, volatile, apples, type]",
145 QualifierOrder,
146 std::vector<std::string>({"const", "volatile", "apples", "type"}));
147 }
148
149 TEST_F(QualifierFixerTest, FailQualifierDuplicateConfiguration) {
150 FormatStyle Style = {};
151 Style.Language = FormatStyle::LK_Cpp;
152 FAIL_PARSE("QualifierAlignment: Custom\n"
153 "QualifierOrder: [const, volatile, const, type]",
154 QualifierOrder,
155 std::vector<std::string>({"const", "volatile", "const", "type"}));
156 }
157
158 TEST_F(QualifierFixerTest, FailQualifierMissingType) {
159 FormatStyle Style = {};
160 Style.Language = FormatStyle::LK_Cpp;
161 FAIL_PARSE("QualifierAlignment: Custom\n"
162 "QualifierOrder: [const, volatile ]",
163 QualifierOrder,
164 std::vector<std::string>({
165 "const",
166 "volatile",
167 }));
168 }
169
170 TEST_F(QualifierFixerTest, FailQualifierEmptyOrder) {
171 FormatStyle Style = {};
172 Style.Language = FormatStyle::LK_Cpp;
173 FAIL_PARSE("QualifierAlignment: Custom\nQualifierOrder: []", QualifierOrder,
174 std::vector<std::string>({}));
175 }
176
177 TEST_F(QualifierFixerTest, FailQualifierMissingOrder) {
178 FormatStyle Style = {};
179 Style.Language = FormatStyle::LK_Cpp;
180 FAIL_PARSE("QualifierAlignment: Custom", QualifierOrder,
181 std::vector<std::string>());
182 }
183
184 TEST_F(QualifierFixerTest, QualifierLeft) {
185 FormatStyle Style = {};
186 Style.Language = FormatStyle::LK_Cpp;
187 CHECK_PARSE("QualifierAlignment: Left", QualifierOrder,
188 std::vector<std::string>({"const", "volatile", "type"}));
189 }
190
191 TEST_F(QualifierFixerTest, QualifierRight) {
192 FormatStyle Style = {};
193 Style.Language = FormatStyle::LK_Cpp;
194 CHECK_PARSE("QualifierAlignment: Right", QualifierOrder,
195 std::vector<std::string>({"type", "const", "volatile"}));
196 }
197
198 TEST_F(QualifierFixerTest, QualifiersCustomOrder) {
199 FormatStyle Style = getLLVMStyle();
200 Style.QualifierAlignment = FormatStyle::QAS_Left;
201 Style.QualifierOrder = {"friend", "inline", "constexpr", "static",
202 "const", "volatile", "type"};
203
204 verifyFormat("const volatile int a;", "const volatile int a;", Style);
205 verifyFormat("const volatile int a;", "volatile const int a;", Style);
206 verifyFormat("const volatile int a;", "int const volatile a;", Style);
207 verifyFormat("const volatile int a;", "int volatile const a;", Style);
208 verifyFormat("const volatile int a;", "const int volatile a;", Style);
209
210 verifyFormat("static const volatile int a;", "const static int volatile a;",
211 Style);
212 verifyFormat("inline static const volatile int a;",
213 "const static inline int volatile a;", Style);
214
215 verifyFormat("constexpr static int a;", "static constexpr int a;", Style);
216 verifyFormat("constexpr static int A;", "static constexpr int A;", Style);
217 verifyFormat("constexpr static int Bar;", "static constexpr int Bar;", Style);
218 verifyFormat("constexpr static LPINT Bar;", "static constexpr LPINT Bar;",
219 Style);
220 verifyFormat("const const int a;", "const int const a;", Style);
221
222 verifyFormat(
223 "friend constexpr auto operator<=>(const foo &, const foo &) = default;",
224 "constexpr friend auto operator<=>(const foo &, const foo &) = default;",
225 Style);
226 verifyFormat(
227 "friend constexpr bool operator==(const foo &, const foo &) = default;",
228 "constexpr bool friend operator==(const foo &, const foo &) = default;",
229 Style);
230 }
231
232 TEST_F(QualifierFixerTest, LeftRightQualifier) {
233 FormatStyle Style = getLLVMStyle();
234
235 // keep the const style unaltered
236 verifyFormat("const int a;", Style);
237 verifyFormat("const int *a;", Style);
238 verifyFormat("const int &a;", Style);
239 verifyFormat("const int &&a;", Style);
240 verifyFormat("int const b;", Style);
241 verifyFormat("int const *b;", Style);
242 verifyFormat("int const &b;", Style);
243 verifyFormat("int const &&b;", Style);
244 verifyFormat("int const *b const;", Style);
245 verifyFormat("int *const c;", Style);
246
247 verifyFormat("const Foo a;", Style);
248 verifyFormat("const Foo *a;", Style);
249 verifyFormat("const Foo &a;", Style);
250 verifyFormat("const Foo &&a;", Style);
251 verifyFormat("Foo const b;", Style);
252 verifyFormat("Foo const *b;", Style);
253 verifyFormat("Foo const &b;", Style);
254 verifyFormat("Foo const &&b;", Style);
255 verifyFormat("Foo const *b const;", Style);
256
257 verifyFormat("LLVM_NODISCARD const int &Foo();", Style);
258 verifyFormat("LLVM_NODISCARD int const &Foo();", Style);
259
260 verifyFormat("volatile const int *restrict;", Style);
261 verifyFormat("const volatile int *restrict;", Style);
262 verifyFormat("const int volatile *restrict;", Style);
263 }
264
265 TEST_F(QualifierFixerTest, RightQualifier) {
266 FormatStyle Style = getLLVMStyle();
267 Style.QualifierAlignment = FormatStyle::QAS_Right;
268 Style.QualifierOrder = {"type", "const", "volatile"};
269
270 verifyFormat("int const a;", Style);
271 verifyFormat("int const *a;", Style);
272 verifyFormat("int const &a;", Style);
273 verifyFormat("int const &&a;", Style);
274 verifyFormat("int const b;", Style);
275 verifyFormat("int const *b;", Style);
276 verifyFormat("int const &b;", Style);
277 verifyFormat("int const &&b;", Style);
278 verifyFormat("int const *b const;", Style);
279 verifyFormat("int *const c;", Style);
280
281 verifyFormat("Foo const a;", Style);
282 verifyFormat("Foo const *a;", Style);
283 verifyFormat("Foo const &a;", Style);
284 verifyFormat("Foo const &&a;", Style);
285 verifyFormat("Foo const b;", Style);
286 verifyFormat("Foo const *b;", Style);
287 verifyFormat("Foo const &b;", Style);
288 verifyFormat("Foo const &&b;", Style);
289 verifyFormat("Foo const *b const;", Style);
290 verifyFormat("Foo *const b;", Style);
291 verifyFormat("Foo const *const b;", Style);
292 verifyFormat("auto const v = get_value();", Style);
293 verifyFormat("long long const &a;", Style);
294 verifyFormat("unsigned char const *a;", Style);
295 verifyFormat("int main(int const argc, char const *const *const argv)",
296 Style);
297
298 verifyFormat("LLVM_NODISCARD int const &Foo();", Style);
299 verifyFormat("SourceRange getSourceRange() const override LLVM_READONLY",
300 Style);
301 verifyFormat("void foo() const override;", Style);
302 verifyFormat("void foo() const override LLVM_READONLY;", Style);
303 verifyFormat("void foo() const final;", Style);
304 verifyFormat("void foo() const final LLVM_READONLY;", Style);
305 verifyFormat("void foo() const LLVM_READONLY;", Style);
306
307 verifyFormat(
308 "template <typename Func> explicit Action(Action<Func> const &action);",
309 Style);
310 verifyFormat(
311 "template <typename Func> explicit Action(Action<Func> const &action);",
312 "template <typename Func> explicit Action(const Action<Func>& action);",
313 Style);
314 verifyFormat(
315 "template <typename Func> explicit Action(Action<Func> const &action);",
316 "template <typename Func>\nexplicit Action(const Action<Func>& action);",
317 Style);
318
319 verifyFormat("int const a;", "const int a;", Style);
320 verifyFormat("int const *a;", "const int *a;", Style);
321 verifyFormat("int const &a;", "const int &a;", Style);
322 verifyFormat("foo(int const &a)", "foo(const int &a)", Style);
323 verifyFormat("unsigned char *a;", "unsigned char *a;", Style);
324 verifyFormat("unsigned char const *a;", "const unsigned char *a;", Style);
325 verifyFormat("vector<int, int const, int &, int const &> args1",
326 "vector<int, const int, int &, const int &> args1", Style);
327 verifyFormat("unsigned int const &get_nu() const",
328 "const unsigned int &get_nu() const", Style);
329 verifyFormat("Foo<int> const &a", "const Foo<int> &a", Style);
330 verifyFormat("Foo<int>::iterator const &a", "const Foo<int>::iterator &a",
331 Style);
332 verifyFormat("::Foo<int>::iterator const &a", "const ::Foo<int>::iterator &a",
333 Style);
334
335 verifyFormat("Foo(int a, "
336 "unsigned b, // c-style args\n"
337 " Bar const &c);",
338 "Foo(int a, "
339 "unsigned b, // c-style args\n"
340 " const Bar &c);",
341 Style);
342
343 verifyFormat("int const volatile;", "volatile const int;", Style);
344 verifyFormat("int const volatile;", "const volatile int;", Style);
345 verifyFormat("int const volatile;", "const int volatile;", Style);
346 verifyFormat("int const volatile *restrict;", "volatile const int *restrict;",
347 Style);
348 verifyFormat("int const volatile *restrict;", "const volatile int *restrict;",
349 Style);
350 verifyFormat("int const volatile *restrict;", "const int volatile *restrict;",
351 Style);
352
353 verifyFormat("static int const bat;", "static const int bat;", Style);
354 verifyFormat("static int const bat;", "static int const bat;", Style);
355
356 verifyFormat("int const Foo<int>::bat = 0;", "const int Foo<int>::bat = 0;",
357 Style);
358 verifyFormat("int const Foo<int>::bat = 0;", "int const Foo<int>::bat = 0;",
359 Style);
360 verifyFormat("void fn(Foo<T> const &i);", "void fn(const Foo<T> &i);", Style);
361 verifyFormat("int const Foo<int>::fn() {", "int const Foo<int>::fn() {",
362 Style);
363 verifyFormat("Foo<Foo<int>> const *p;", "const Foo<Foo<int>> *p;", Style);
364 verifyFormat(
365 "Foo<Foo<int>> const *p = const_cast<Foo<Foo<int>> const *>(&ffi);",
366 "const Foo<Foo<int>> *p = const_cast<const Foo<Foo<int>> *>(&ffi);",
367 Style);
368
369 verifyFormat("void fn(Foo<T> const &i);", "void fn(const Foo<T> &i);", Style);
370 verifyFormat("void fns(ns::S const &s);", "void fns(const ns::S &s);", Style);
371 verifyFormat("void fns(::ns::S const &s);", "void fns(const ::ns::S &s);",
372 Style);
373 verifyFormat("void fn(ns::Foo<T> const &i);", "void fn(const ns::Foo<T> &i);",
374 Style);
375 verifyFormat("void fns(ns::ns2::S const &s);",
376 "void fns(const ns::ns2::S &s);", Style);
377 verifyFormat("void fn(ns::Foo<Bar<T>> const &i);",
378 "void fn(const ns::Foo<Bar<T>> &i);", Style);
379 verifyFormat("void fn(ns::ns2::Foo<Bar<T>> const &i);",
380 "void fn(const ns::ns2::Foo<Bar<T>> &i);", Style);
381 verifyFormat("void fn(ns::ns2::Foo<Bar<T, U>> const &i);",
382 "void fn(const ns::ns2::Foo<Bar<T, U>> &i);", Style);
383
384 verifyFormat("LocalScope const *Scope = nullptr;",
385 "const LocalScope* Scope = nullptr;", Style);
386 verifyFormat("struct DOTGraphTraits<Stmt const *>",
387 "struct DOTGraphTraits<const Stmt *>", Style);
388
389 verifyFormat(
390 "bool tools::addXRayRuntime(ToolChain const &TC, ArgList const &Args) {",
391 "bool tools::addXRayRuntime(const ToolChain&TC, const ArgList &Args) {",
392 Style);
393 verifyFormat("Foo<Foo<int> const> P;", "Foo<const Foo<int>> P;", Style);
394 verifyFormat("Foo<Foo<int> const> P;\n", "Foo<const Foo<int>> P;\n", Style);
395 verifyFormat("Foo<Foo<int> const> P;\n#if 0\n#else\n#endif",
396 "Foo<const Foo<int>> P;\n#if 0\n#else\n#endif", Style);
397
398 verifyFormat("auto const i = 0;", "const auto i = 0;", Style);
399 verifyFormat("auto const &ir = i;", "const auto &ir = i;", Style);
400 verifyFormat("auto const *ip = &i;", "const auto *ip = &i;", Style);
401
402 verifyFormat("Foo<Foo<int> const> P;\n#if 0\n#else\n#endif",
403 "Foo<const Foo<int>> P;\n#if 0\n#else\n#endif", Style);
404
405 verifyFormat("Bar<Bar<int const> const> P;\n#if 0\n#else\n#endif",
406 "Bar<Bar<const int> const> P;\n#if 0\n#else\n#endif", Style);
407
408 verifyFormat("Baz<Baz<int const> const> P;\n#if 0\n#else\n#endif",
409 "Baz<const Baz<const int>> P;\n#if 0\n#else\n#endif", Style);
410
411 // verifyFormat("#if 0\nBoo<Boo<int const> const> P;\n#else\n#endif",
412 // "#if 0\nBoo<const Boo<const int>> P;\n#else\n#endif", Style);
413
414 verifyFormat("int const P;\n#if 0\n#else\n#endif",
415 "const int P;\n#if 0\n#else\n#endif", Style);
416
417 verifyFormat("unsigned long const a;", "const unsigned long a;", Style);
418 verifyFormat("unsigned long long const a;", "const unsigned long long a;",
419 Style);
420
421 // don't adjust macros
422 verifyFormat("const INTPTR a;", "const INTPTR a;", Style);
423
424 // Pointers to members
425 verifyFormat("int S::*a;", Style);
426 verifyFormat("int const S::*a;", "const int S:: *a;", Style);
427 verifyFormat("int const S::*const a;", "const int S::* const a;", Style);
428 verifyFormat("int A::*const A::*p1;", Style);
429 verifyFormat("float (C::*p)(int);", Style);
430 verifyFormat("float (C::*const p)(int);", Style);
431 verifyFormat("float (C::*p)(int) const;", Style);
432 verifyFormat("float const (C::*p)(int);", "const float (C::*p)(int);", Style);
433 }
434
435 TEST_F(QualifierFixerTest, LeftQualifier) {
436 FormatStyle Style = getLLVMStyle();
437 Style.QualifierAlignment = FormatStyle::QAS_Left;
438 Style.QualifierOrder = {"inline", "static", "const", "volatile", "type"};
439
440 verifyFormat("const int a;", Style);
441 verifyFormat("const int *a;", Style);
442 verifyFormat("const int &a;", Style);
443 verifyFormat("const int &&a;", Style);
444 verifyFormat("const int b;", Style);
445 verifyFormat("const int *b;", Style);
446 verifyFormat("const int &b;", Style);
447 verifyFormat("const int &&b;", Style);
448 verifyFormat("const int *b const;", Style);
449 verifyFormat("int *const c;", Style);
450
451 verifyFormat("const Foo a;", Style);
452 verifyFormat("const Foo *a;", Style);
453 verifyFormat("const Foo &a;", Style);
454 verifyFormat("const Foo &&a;", Style);
455 verifyFormat("const Foo b;", Style);
456 verifyFormat("const Foo *b;", Style);
457 verifyFormat("const Foo &b;", Style);
458 verifyFormat("const Foo &&b;", Style);
459 verifyFormat("const Foo *b const;", Style);
460 verifyFormat("Foo *const b;", Style);
461 verifyFormat("const Foo *const b;", Style);
462
463 verifyFormat("LLVM_NODISCARD const int &Foo();", Style);
464
465 verifyFormat("const char a[];", Style);
466 verifyFormat("const auto v = get_value();", Style);
467 verifyFormat("const long long &a;", Style);
468 verifyFormat("const unsigned char *a;", Style);
469 verifyFormat("const unsigned char *a;", "unsigned char const *a;", Style);
470 verifyFormat("const Foo<int> &a", "Foo<int> const &a", Style);
471 verifyFormat("const Foo<int>::iterator &a", "Foo<int>::iterator const &a",
472 Style);
473 verifyFormat("const ::Foo<int>::iterator &a", "::Foo<int>::iterator const &a",
474 Style);
475
476 verifyFormat("const int a;", "int const a;", Style);
477 verifyFormat("const int *a;", "int const *a;", Style);
478 verifyFormat("const int &a;", "int const &a;", Style);
479 verifyFormat("foo(const int &a)", "foo(int const &a)", Style);
480 verifyFormat("unsigned char *a;", "unsigned char *a;", Style);
481 verifyFormat("const unsigned int &get_nu() const",
482 "unsigned int const &get_nu() const", Style);
483
484 verifyFormat("const volatile int;", "volatile const int;", Style);
485 verifyFormat("const volatile int;", "const volatile int;", Style);
486 verifyFormat("const volatile int;", "const int volatile;", Style);
487
488 verifyFormat("const volatile int *restrict;", "volatile const int *restrict;",
489 Style);
490 verifyFormat("const volatile int *restrict;", "const volatile int *restrict;",
491 Style);
492 verifyFormat("const volatile int *restrict;", "const int volatile *restrict;",
493 Style);
494
495 verifyFormat("SourceRange getSourceRange() const override LLVM_READONLY;",
496 Style);
497
498 verifyFormat("void foo() const override;", Style);
499 verifyFormat("void foo() const override LLVM_READONLY;", Style);
500 verifyFormat("void foo() const final;", Style);
501 verifyFormat("void foo() const final LLVM_READONLY;", Style);
502 verifyFormat("void foo() const LLVM_READONLY;", Style);
503
504 verifyFormat(
505 "template <typename Func> explicit Action(const Action<Func> &action);",
506 Style);
507 verifyFormat(
508 "template <typename Func> explicit Action(const Action<Func> &action);",
509 "template <typename Func> explicit Action(Action<Func> const &action);",
510 Style);
511
512 verifyFormat("static const int bat;", "static const int bat;", Style);
513 verifyFormat("static const int bat;", "static int const bat;", Style);
514
515 verifyFormat("static const int Foo<int>::bat = 0;",
516 "static const int Foo<int>::bat = 0;", Style);
517 verifyFormat("static const int Foo<int>::bat = 0;",
518 "static int const Foo<int>::bat = 0;", Style);
519
520 verifyFormat("void fn(const Foo<T> &i);");
521
522 verifyFormat("const int Foo<int>::bat = 0;", "const int Foo<int>::bat = 0;",
523 Style);
524 verifyFormat("const int Foo<int>::bat = 0;", "int const Foo<int>::bat = 0;",
525 Style);
526 verifyFormat("void fn(const Foo<T> &i);", "void fn( Foo<T> const &i);",
527 Style);
528 verifyFormat("const int Foo<int>::fn() {", "int const Foo<int>::fn() {",
529 Style);
530 verifyFormat("const Foo<Foo<int>> *p;", "Foo<Foo<int>> const *p;", Style);
531 verifyFormat(
532 "const Foo<Foo<int>> *p = const_cast<const Foo<Foo<int>> *>(&ffi);",
533 "const Foo<Foo<int>> *p = const_cast<Foo<Foo<int>> const *>(&ffi);",
534 Style);
535
536 verifyFormat("void fn(const Foo<T> &i);", "void fn(Foo<T> const &i);", Style);
537 verifyFormat("void fns(const ns::S &s);", "void fns(ns::S const &s);", Style);
538 verifyFormat("void fns(const ::ns::S &s);", "void fns(::ns::S const &s);",
539 Style);
540 verifyFormat("void fn(const ns::Foo<T> &i);", "void fn(ns::Foo<T> const &i);",
541 Style);
542 verifyFormat("void fns(const ns::ns2::S &s);",
543 "void fns(ns::ns2::S const &s);", Style);
544 verifyFormat("void fn(const ns::Foo<Bar<T>> &i);",
545 "void fn(ns::Foo<Bar<T>> const &i);", Style);
546 verifyFormat("void fn(const ns::ns2::Foo<Bar<T>> &i);",
547 "void fn(ns::ns2::Foo<Bar<T>> const &i);", Style);
548 verifyFormat("void fn(const ns::ns2::Foo<Bar<T, U>> &i);",
549 "void fn(ns::ns2::Foo<Bar<T, U>> const &i);", Style);
550
551 verifyFormat("const auto i = 0;", "auto const i = 0;", Style);
552 verifyFormat("const auto &ir = i;", "auto const &ir = i;", Style);
553 verifyFormat("const auto *ip = &i;", "auto const *ip = &i;", Style);
554
555 verifyFormat("Foo<const Foo<int>> P;\n#if 0\n#else\n#endif",
556 "Foo<Foo<int> const> P;\n#if 0\n#else\n#endif", Style);
557
558 verifyFormat("Foo<Foo<const int>> P;\n#if 0\n#else\n#endif",
559 "Foo<Foo<int const>> P;\n#if 0\n#else\n#endif", Style);
560
561 verifyFormat("const int P;\n#if 0\n#else\n#endif",
562 "int const P;\n#if 0\n#else\n#endif", Style);
563
564 verifyFormat("const unsigned long a;", "unsigned long const a;", Style);
565 verifyFormat("const unsigned long long a;", "unsigned long long const a;",
566 Style);
567
568 verifyFormat("const long long unsigned a;", "long const long unsigned a;",
569 Style);
570
571 verifyFormat("const std::Foo", "const std::Foo", Style);
572 verifyFormat("const std::Foo<>", "const std::Foo<>", Style);
573 verifyFormat("const std::Foo < int", "const std::Foo<int", Style);
574 verifyFormat("const std::Foo<int>", "const std::Foo<int>", Style);
575
576 // don't adjust macros
577 verifyFormat("INTPTR const a;", "INTPTR const a;", Style);
578
579 // Pointers to members
580 verifyFormat("int S::*a;", Style);
581 verifyFormat("const int S::*a;", "int const S:: *a;", Style);
582 verifyFormat("const int S::*const a;", "int const S::* const a;", Style);
583 verifyFormat("int A::*const A::*p1;", Style);
584 verifyFormat("float (C::*p)(int);", Style);
585 verifyFormat("float (C::*const p)(int);", Style);
586 verifyFormat("float (C::*p)(int) const;", Style);
587 verifyFormat("const float (C::*p)(int);", "float const (C::*p)(int);", Style);
588 }
589
590 TEST_F(QualifierFixerTest, ConstVolatileQualifiersOrder) {
591 FormatStyle Style = getLLVMStyle();
592 Style.QualifierAlignment = FormatStyle::QAS_Left;
593 Style.QualifierOrder = {"inline", "static", "const", "volatile", "type"};
594
595 // The Default
596 EXPECT_EQ(Style.QualifierOrder.size(), (size_t)5);
597
598 verifyFormat("const volatile int a;", "const volatile int a;", Style);
599 verifyFormat("const volatile int a;", "volatile const int a;", Style);
600 verifyFormat("const volatile int a;", "int const volatile a;", Style);
601 verifyFormat("const volatile int a;", "int volatile const a;", Style);
602 verifyFormat("const volatile int a;", "const int volatile a;", Style);
603
604 Style.QualifierAlignment = FormatStyle::QAS_Right;
605 Style.QualifierOrder = {"type", "const", "volatile"};
606
607 verifyFormat("int const volatile a;", "const volatile int a;", Style);
608 verifyFormat("int const volatile a;", "volatile const int a;", Style);
609 verifyFormat("int const volatile a;", "int const volatile a;", Style);
610 verifyFormat("int const volatile a;", "int volatile const a;", Style);
611 verifyFormat("int const volatile a;", "const int volatile a;", Style);
612
613 Style.QualifierAlignment = FormatStyle::QAS_Left;
614 Style.QualifierOrder = {"volatile", "const", "type"};
615
616 verifyFormat("volatile const int a;", "const volatile int a;", Style);
617 verifyFormat("volatile const int a;", "volatile const int a;", Style);
618 verifyFormat("volatile const int a;", "int const volatile a;", Style);
619 verifyFormat("volatile const int a;", "int volatile const a;", Style);
620 verifyFormat("volatile const int a;", "const int volatile a;", Style);
621
622 Style.QualifierAlignment = FormatStyle::QAS_Right;
623 Style.QualifierOrder = {"type", "volatile", "const"};
624
625 verifyFormat("int volatile const a;", "const volatile int a;", Style);
626 verifyFormat("int volatile const a;", "volatile const int a;", Style);
627 verifyFormat("int volatile const a;", "int const volatile a;", Style);
628 verifyFormat("int volatile const a;", "int volatile const a;", Style);
629 verifyFormat("int volatile const a;", "const int volatile a;", Style);
630
631 Style.QualifierAlignment = FormatStyle::QAS_Custom;
632 Style.QualifierOrder = {"type", "volatile", "const"};
633
634 verifyFormat("int volatile const a;", "const volatile int a;", Style);
635 verifyFormat("int volatile const a;", "volatile const int a;", Style);
636 verifyFormat("int volatile const a;", "int const volatile a;", Style);
637 verifyFormat("int volatile const a;", "int volatile const a;", Style);
638 verifyFormat("int volatile const a;", "const int volatile a;", Style);
639 }
640
641 TEST_F(QualifierFixerTest, InlineStatics) {
642 FormatStyle Style = getLLVMStyle();
643 Style.QualifierAlignment = FormatStyle::QAS_Left;
644 Style.QualifierOrder = {"inline", "static", "const", "volatile", "type"};
645 EXPECT_EQ(Style.QualifierOrder.size(), (size_t)5);
646
647 verifyFormat("inline static const volatile int a;",
648 "const inline static volatile int a;", Style);
649 verifyFormat("inline static const volatile int a;",
650 "volatile inline static const int a;", Style);
651 verifyFormat("inline static const volatile int a;",
652 "int const inline static volatile a;", Style);
653 verifyFormat("inline static const volatile int a;",
654 "int volatile inline static const a;", Style);
655 verifyFormat("inline static const volatile int a;",
656 "const int inline static volatile a;", Style);
657 }
658
659 TEST_F(QualifierFixerTest, AmpEqual) {
660 FormatStyle Style = getLLVMStyle();
661 Style.QualifierAlignment = FormatStyle::QAS_Custom;
662 Style.QualifierOrder = {"static", "type", "const"};
663 EXPECT_EQ(Style.QualifierOrder.size(), (size_t)3);
664
665 verifyFormat("foo(std::string const & = std::string()) const",
666 "foo(const std::string & = std::string()) const", Style);
667 verifyFormat("foo(std::string const & = std::string())",
668 "foo(const std::string & = std::string())", Style);
669 }
670
671 TEST_F(QualifierFixerTest, MoveConstBeyondTypeSmall) {
672
673 FormatStyle Style = getLLVMStyle();
674 Style.QualifierAlignment = FormatStyle::QAS_Custom;
675 Style.QualifierOrder = {"type", "const"};
676 EXPECT_EQ(Style.QualifierOrder.size(), (size_t)2);
677
678 verifyFormat("int const a;", "const int a;", Style);
679 verifyFormat("int const *a;", "const int*a;", Style);
680 verifyFormat("int const *a;", "const int *a;", Style);
681 verifyFormat("int const &a;", "const int &a;", Style);
682 verifyFormat("int const &&a;", "const int &&a;", Style);
683 }
684
685 TEST_F(QualifierFixerTest, MoveConstBeforeTypeSmall) {
686
687 FormatStyle Style = getLLVMStyle();
688 Style.QualifierAlignment = FormatStyle::QAS_Custom;
689 Style.QualifierOrder = {"const", "type"};
690 EXPECT_EQ(Style.QualifierOrder.size(), (size_t)2);
691
692 verifyFormat("const int a;", "int const a;", Style);
693 verifyFormat("const int *a;", "int const *a;", Style);
694 verifyFormat("const int *a const;", "int const *a const;", Style);
695
696 verifyFormat("const int a = foo();", "int const a = foo();", Style);
697 verifyFormat("const int *a = foo();", "int const *a = foo();", Style);
698 verifyFormat("const int *a const = foo();", "int const *a const = foo();",
699 Style);
700
701 verifyFormat("const auto a = foo();", "auto const a = foo();", Style);
702 verifyFormat("const auto *a = foo();", "auto const *a = foo();", Style);
703 verifyFormat("const auto *a const = foo();", "auto const *a const = foo();",
704 Style);
705 }
706
707 TEST_F(QualifierFixerTest, MoveConstBeyondType) {
708
709 FormatStyle Style = getLLVMStyle();
710 Style.QualifierAlignment = FormatStyle::QAS_Custom;
711 Style.QualifierOrder = {"static", "inline", "type", "const", "volatile"};
712 EXPECT_EQ(Style.QualifierOrder.size(), (size_t)5);
713
714 verifyFormat("static inline int const volatile a;",
715 "const inline static volatile int a;", Style);
716 verifyFormat("static inline int const volatile a;",
717 "volatile inline static const int a;", Style);
718 verifyFormat("static inline int const volatile a;",
719 "int const inline static volatile a;", Style);
720 verifyFormat("static inline int const volatile a;",
721 "int volatile inline static const a;", Style);
722 verifyFormat("static inline int const volatile a;",
723 "const int inline static volatile a;", Style);
724
725 verifyFormat("static inline int const volatile *a const;",
726 "const int inline static volatile *a const;", Style);
727 }
728
729 TEST_F(QualifierFixerTest, PrepareLeftRightOrdering) {
730 FormatStyle Style = getLLVMStyle();
731 Style.QualifierAlignment = FormatStyle::QAS_Custom;
732 Style.QualifierOrder = {"static", "inline", "type", "const", "volatile"};
733
734 std::vector<std::string> Left;
735 std::vector<std::string> Right;
736 std::vector<tok::TokenKind> ConfiguredTokens;
737 QualifierAlignmentFixer::PrepareLeftRightOrdering(Style.QualifierOrder, Left,
738 Right, ConfiguredTokens);
739
740 EXPECT_EQ(Left.size(), (size_t)2);
741 EXPECT_EQ(Right.size(), (size_t)2);
742
743 std::vector<std::string> LeftResult = {"inline", "static"};
744 std::vector<std::string> RightResult = {"const", "volatile"};
745 EXPECT_EQ(Left, LeftResult);
746 EXPECT_EQ(Right, RightResult);
747 }
748
749 TEST_F(QualifierFixerTest, IsQualifierType) {
750
751 std::vector<tok::TokenKind> ConfiguredTokens;
752 ConfiguredTokens.push_back(tok::kw_const);
753 ConfiguredTokens.push_back(tok::kw_static);
754 ConfiguredTokens.push_back(tok::kw_inline);
755 ConfiguredTokens.push_back(tok::kw_restrict);
756 ConfiguredTokens.push_back(tok::kw_constexpr);
757 ConfiguredTokens.push_back(tok::kw_friend);
758
759 auto Tokens = annotate(
760 "const static inline auto restrict int double long constexpr friend");
761
762 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
763 Tokens[0], ConfiguredTokens));
764 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
765 Tokens[1], ConfiguredTokens));
766 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
767 Tokens[2], ConfiguredTokens));
768 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
769 Tokens[3], ConfiguredTokens));
770 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
771 Tokens[4], ConfiguredTokens));
772 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
773 Tokens[5], ConfiguredTokens));
774 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
775 Tokens[6], ConfiguredTokens));
776 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
777 Tokens[7], ConfiguredTokens));
778 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
779 Tokens[8], ConfiguredTokens));
780 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
781 Tokens[9], ConfiguredTokens));
782
783 auto NotTokens = annotate("for while do Foo Bar ");
784
785 EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
786 NotTokens[0], ConfiguredTokens));
787 EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
788 NotTokens[1], ConfiguredTokens));
789 EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
790 NotTokens[2], ConfiguredTokens));
791 EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
792 NotTokens[3], ConfiguredTokens));
793 EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
794 NotTokens[4], ConfiguredTokens));
795 EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
796 NotTokens[5], ConfiguredTokens));
797 }
798
799 TEST_F(QualifierFixerTest, IsMacro) {
800
801 auto Tokens = annotate("INT INTPR Foo int");
802
803 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[0]));
804 EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[1]));
805 EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[2]));
806 EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[3]));
807 }
808
809 TEST_F(QualifierFixerTest, OverlappingQualifier) {
810
811 FormatStyle Style = getLLVMStyle();
812 Style.QualifierAlignment = FormatStyle::QAS_Left;
813 Style.QualifierOrder = {"const", "type"};
814
815 verifyFormat("Foo(const Bar &name);", "Foo(Bar const &name);", Style);
816 }
817
818 TEST_F(QualifierFixerTest, DontPushQualifierThroughNonSpecifiedTypes) {
819
820 FormatStyle Style = getLLVMStyle();
821 Style.QualifierAlignment = FormatStyle::QAS_Left;
822 Style.QualifierOrder = {"const", "type"};
823
824 verifyFormat("inline static const int a;", Style);
825
826 Style.QualifierOrder = {"static", "const", "type"};
827
828 verifyFormat("inline static const int a;", Style);
829 verifyFormat("static inline const int a;", "static inline const int a;",
830 Style);
831
832 verifyFormat("static const int a;", "const static int a;", Style);
833 }
834
835 TEST_F(QualifierFixerTest, UnsignedQualifier) {
836
837 FormatStyle Style = getLLVMStyle();
838 Style.QualifierAlignment = FormatStyle::QAS_Left;
839 Style.QualifierOrder = {"const", "type"};
840
841 verifyFormat("Foo(const unsigned char *bytes)",
842 "Foo(unsigned const char *bytes)", Style);
843
844 Style.QualifierAlignment = FormatStyle::QAS_Right;
845 Style.QualifierOrder = {"type", "const"};
846
847 verifyFormat("Foo(unsigned char const *bytes)",
848 "Foo(unsigned const char *bytes)", Style);
849 }
850
851 TEST_F(QualifierFixerTest, NoOpQualifierReplacements) {
852
853 FormatStyle Style = getLLVMStyle();
854 Style.QualifierAlignment = FormatStyle::QAS_Custom;
855 Style.QualifierOrder = {"static", "const", "type"};
856
857 ReplacementCount = 0;
858 EXPECT_EQ(ReplacementCount, 0);
859 verifyFormat("static const uint32 foo[] = {0, 31};", Style);
860 verifyFormat("#define MACRO static const", Style);
861 verifyFormat("using sc = static const", Style);
862 EXPECT_EQ(ReplacementCount, 0);
863 }
864
865 TEST_F(QualifierFixerTest, QualifierTemplates) {
866 FormatStyle Style = getLLVMStyle();
867 Style.QualifierAlignment = FormatStyle::QAS_Custom;
868 Style.QualifierOrder = {"static", "const", "type"};
869
870 ReplacementCount = 0;
871 EXPECT_EQ(ReplacementCount, 0);
872 verifyFormat("using A = B<>;", Style);
873 verifyFormat("using A = B /**/<>;", Style);
874 verifyFormat("template <class C> using A = B<Foo<C>, 1>;", Style);
875 verifyFormat("template <class C> using A = B /**/<Foo<C>, 1>;", Style);
876 verifyFormat("template <class C> using A = B /* */<Foo<C>, 1>;", Style);
877 verifyFormat("template <class C> using A = B /*foo*/<Foo<C>, 1>;", Style);
878 verifyFormat("template <class C> using A = B /**/ /**/<Foo<C>, 1>;", Style);
879 verifyFormat("template <class C> using A = B<Foo</**/ C>, 1>;", Style);
880 verifyFormat("template <class C> using A = /**/ B<Foo<C>, 1>;", Style);
881 EXPECT_EQ(ReplacementCount, 0);
882 verifyFormat("template <class C>\n"
883 "using A = B // foo\n"
884 " <Foo<C>, 1>;",
885 Style);
886
887 ReplacementCount = 0;
888 Style.QualifierOrder = {"type", "static", "const"};
889 verifyFormat("using A = B<>;", Style);
890 verifyFormat("using A = B /**/<>;", Style);
891 verifyFormat("template <class C> using A = B<Foo<C>, 1>;", Style);
892 verifyFormat("template <class C> using A = B /**/<Foo<C>, 1>;", Style);
893 verifyFormat("template <class C> using A = B /* */<Foo<C>, 1>;", Style);
894 verifyFormat("template <class C> using A = B /*foo*/<Foo<C>, 1>;", Style);
895 verifyFormat("template <class C> using A = B /**/ /**/<Foo<C>, 1>;", Style);
896 verifyFormat("template <class C> using A = B<Foo</**/ C>, 1>;", Style);
897 verifyFormat("template <class C> using A = /**/ B<Foo<C>, 1>;", Style);
898 EXPECT_EQ(ReplacementCount, 0);
899 verifyFormat("template <class C>\n"
900 "using A = B // foo\n"
901 " <Foo<C>, 1>;",
902 Style);
903 }
904
905 TEST_F(QualifierFixerTest, WithConstraints) {
906 FormatStyle Style = getLLVMStyle();
907 Style.QualifierAlignment = FormatStyle::QAS_Custom;
908 Style.QualifierOrder = {"constexpr", "type"};
909
910 verifyFormat("template <typename T>\n"
911 " requires Concept<F>\n"
912 "constexpr constructor();",
913 Style);
914 verifyFormat("template <typename T>\n"
915 " requires Concept1<F> && Concept2<F>\n"
916 "constexpr constructor();",
917 Style);
918 }
919
920 TEST_F(QualifierFixerTest, DisableRegions) {
921 FormatStyle Style = getLLVMStyle();
922 Style.QualifierAlignment = FormatStyle::QAS_Custom;
923 Style.QualifierOrder = {"inline", "static", "const", "type"};
924
925 ReplacementCount = 0;
926 verifyFormat("// clang-format off\n"
927 "int const inline static a = 0;\n"
928 "// clang-format on\n",
929 Style);
930 EXPECT_EQ(ReplacementCount, 0);
931 verifyFormat("// clang-format off\n"
932 "int const inline static a = 0;\n"
933 "// clang-format on\n"
934 "inline static const int a = 0;\n",
935 "// clang-format off\n"
936 "int const inline static a = 0;\n"
937 "// clang-format on\n"
938 "int const inline static a = 0;\n",
939 Style);
940 }
941
942 TEST_F(QualifierFixerTest, TemplatesRight) {
943 FormatStyle Style = getLLVMStyle();
944 Style.QualifierAlignment = FormatStyle::QAS_Custom;
945 Style.QualifierOrder = {"type", "const"};
946
947 verifyFormat("template <typename T>\n"
948 " requires Concept<T const>\n"
949 "void f();",
950 "template <typename T>\n"
951 " requires Concept<const T>\n"
952 "void f();",
953 Style);
954 verifyFormat("TemplateType<T const> t;", "TemplateType<const T> t;", Style);
955 verifyFormat("TemplateType<Container const> t;",
956 "TemplateType<const Container> t;", Style);
957 }
958
959 TEST_F(QualifierFixerTest, TemplatesLeft) {
960 FormatStyle Style = getLLVMStyle();
961 Style.QualifierAlignment = FormatStyle::QAS_Custom;
962 Style.QualifierOrder = {"const", "type"};
963
964 verifyFormat("template <const T> t;", "template <T const> t;", Style);
965 verifyFormat("template <typename T>\n"
966 " requires Concept<const T>\n"
967 "void f();",
968 "template <typename T>\n"
969 " requires Concept<T const>\n"
970 "void f();",
971 Style);
972 verifyFormat("TemplateType<const T> t;", "TemplateType<T const> t;", Style);
973 verifyFormat("TemplateType<const Container> t;",
974 "TemplateType<Container const> t;", Style);
975 }
976
977 } // namespace format
978 } // namespace clang