| 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 |