MyDeveloperDay updated this revision to Diff 373802. MyDeveloperDay added a comment.
Allow the use of "TypenameMacros" to allow for Capitialized types (be aware they should be non pointer types and don't have to be macros, so may need its own future "NonPtrTypes" setting) CHANGES SINCE LAST ACTION https://reviews.llvm.org/D69764/new/ https://reviews.llvm.org/D69764 Files: clang/docs/ClangFormatStyleOptions.rst clang/docs/ReleaseNotes.rst clang/docs/tools/dump_format_style.py clang/include/clang/Format/Format.h clang/lib/Format/CMakeLists.txt clang/lib/Format/Format.cpp clang/lib/Format/QualifierAlignmentFixer.cpp clang/lib/Format/QualifierAlignmentFixer.h clang/tools/clang-format/ClangFormat.cpp clang/unittests/Format/CMakeLists.txt clang/unittests/Format/FormatTest.cpp clang/unittests/Format/QualifierFixerTest.cpp
Index: clang/unittests/Format/QualifierFixerTest.cpp =================================================================== --- /dev/null +++ clang/unittests/Format/QualifierFixerTest.cpp @@ -0,0 +1,846 @@ +//===- unittest/Format/QualifierFixerTest.cpp - Formatting unit tests -----===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "clang/Format/Format.h" + +#include "FormatTestUtils.h" +#include "TestLexer.h" +#include "gtest/gtest.h" + +#include "../../lib/Format/QualifierAlignmentFixer.h" + +#define DEBUG_TYPE "format-qualifier-fixer-test" + +using testing::ScopedTrace; + +namespace clang { +namespace format { +namespace { + +#define CHECK_PARSE(TEXT, FIELD, VALUE) \ + EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!"; \ + EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ + EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!" + +#define FAIL_PARSE(TEXT, FIELD, VALUE) \ + EXPECT_NE(0, parseConfiguration(TEXT, &Style).value()); \ + EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!" + +class QualifierFixerTest : public ::testing::Test { +protected: + enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; + + TokenList annotate(llvm::StringRef Code, + const FormatStyle &Style = getLLVMStyle()) { + return TestLexer(Allocator, Buffers, Style).annotate(Code); + } + llvm::SpecificBumpPtrAllocator<FormatToken> Allocator; + std::vector<std::unique_ptr<llvm::MemoryBuffer>> Buffers; + + std::string format(llvm::StringRef Code, + const FormatStyle &Style = getLLVMStyle(), + StatusCheck CheckComplete = SC_ExpectComplete) { + LLVM_DEBUG(llvm::errs() << "---\n"); + LLVM_DEBUG(llvm::errs() << Code << "\n\n"); + std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); + FormattingAttemptStatus Status; + tooling::Replacements Replaces = + reformat(Style, Code, Ranges, "<stdin>", &Status); + if (CheckComplete != SC_DoNotCheck) { + bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; + EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) + << Code << "\n\n"; + } + ReplacementCount = Replaces.size(); + auto Result = applyAllReplacements(Code, Replaces); + EXPECT_TRUE(static_cast<bool>(Result)); + LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); + return *Result; + } + + FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { + Style.ColumnLimit = ColumnLimit; + return Style; + } + + FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { + return getStyleWithColumns(getLLVMStyle(), ColumnLimit); + } + + void _verifyFormat(const char *File, int Line, llvm::StringRef Expected, + llvm::StringRef Code, + const FormatStyle &Style = getLLVMStyle()) { + ScopedTrace t(File, Line, ::testing::Message() << Code.str()); + EXPECT_EQ(Expected.str(), format(Expected, Style)) + << "Expected code is not stable"; + EXPECT_EQ(Expected.str(), format(Code, Style)); + if (Style.Language == FormatStyle::LK_Cpp) { + // Objective-C++ is a superset of C++, so everything checked for C++ + // needs to be checked for Objective-C++ as well. + FormatStyle ObjCStyle = Style; + ObjCStyle.Language = FormatStyle::LK_ObjC; + EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); + } + } + + void _verifyFormat(const char *File, int Line, llvm::StringRef Code, + const FormatStyle &Style = getLLVMStyle()) { + _verifyFormat(File, Line, Code, test::messUp(Code), Style); + } + + void _verifyIncompleteFormat(const char *File, int Line, llvm::StringRef Code, + const FormatStyle &Style = getLLVMStyle()) { + ScopedTrace t(File, Line, ::testing::Message() << Code.str()); + EXPECT_EQ(Code.str(), + format(test::messUp(Code), Style, SC_ExpectIncomplete)); + } + + void _verifyIndependentOfContext(const char *File, int Line, + llvm::StringRef Text, + const FormatStyle &Style = getLLVMStyle()) { + _verifyFormat(File, Line, Text, Style); + _verifyFormat(File, Line, llvm::Twine("void f() { " + Text + " }").str(), + Style); + } + + /// \brief Verify that clang-format does not crash on the given input. + void verifyNoCrash(llvm::StringRef Code, + const FormatStyle &Style = getLLVMStyle()) { + format(Code, Style, SC_DoNotCheck); + } + + int ReplacementCount; +}; + +#define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__) + +}; // namespace + +TEST_F(QualifierFixerTest, RotateTokens) { + // TODO add test + EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("const"), + tok::kw_const); + EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("volatile"), + tok::kw_volatile); + EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("inline"), + tok::kw_inline); + EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("static"), + tok::kw_static); + EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("restrict"), + tok::kw_restrict); +} + +TEST_F(QualifierFixerTest, FailQualifierInvalidConfiguration) { + FormatStyle Style = {}; + Style.Language = FormatStyle::LK_Cpp; + FAIL_PARSE("QualifierAlignment: Custom\n" + "QualifierOrder: [const, volatile, apples, type]", + QualifierOrder, + std::vector<std::string>({"const", "volatile", "apples", "type"})); +} + +TEST_F(QualifierFixerTest, FailQualifierDuplicateConfiguration) { + FormatStyle Style = {}; + Style.Language = FormatStyle::LK_Cpp; + FAIL_PARSE("QualifierAlignment: Custom\n" + "QualifierOrder: [const, volatile, const, type]", + QualifierOrder, + std::vector<std::string>({"const", "volatile", "const", "type"})); +} + +TEST_F(QualifierFixerTest, FailQualifierMissingType) { + FormatStyle Style = {}; + Style.Language = FormatStyle::LK_Cpp; + FAIL_PARSE("QualifierAlignment: Custom\n" + "QualifierOrder: [const, volatile ]", + QualifierOrder, + std::vector<std::string>({ + "const", + "volatile", + })); +} + +TEST_F(QualifierFixerTest, FailQualifierEmptyOrder) { + FormatStyle Style = {}; + Style.Language = FormatStyle::LK_Cpp; + FAIL_PARSE("QualifierAlignment: Custom\nQualifierOrder: []", QualifierOrder, + std::vector<std::string>({})); +} + +TEST_F(QualifierFixerTest, FailQualifierMissingOrder) { + FormatStyle Style = {}; + Style.Language = FormatStyle::LK_Cpp; + FAIL_PARSE("QualifierAlignment: Custom", QualifierOrder, + std::vector<std::string>()); +} + +TEST_F(QualifierFixerTest, QualifierLeft) { + FormatStyle Style = {}; + Style.Language = FormatStyle::LK_Cpp; + CHECK_PARSE("QualifierAlignment: Left", QualifierOrder, + std::vector<std::string>({"const", "volatile", "type"})); +} + +TEST_F(QualifierFixerTest, QualifierRight) { + FormatStyle Style = {}; + Style.Language = FormatStyle::LK_Cpp; + CHECK_PARSE("QualifierAlignment: Right", QualifierOrder, + std::vector<std::string>({"type", "const", "volatile"})); +} + +TEST_F(QualifierFixerTest, QualifiersCustomOrder) { + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Left; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("inline"); + Style.QualifierOrder.push_back("constexpr"); + Style.QualifierOrder.push_back("static"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + Style.QualifierOrder.push_back("type"); + + verifyFormat("const volatile int a;", "const volatile int a;", Style); + verifyFormat("const volatile int a;", "volatile const int a;", Style); + verifyFormat("const volatile int a;", "int const volatile a;", Style); + verifyFormat("const volatile int a;", "int volatile const a;", Style); + verifyFormat("const volatile int a;", "const int volatile a;", Style); + + verifyFormat("static const volatile int a;", "const static int volatile a;", + Style); + verifyFormat("inline static const volatile int a;", + "const static inline int volatile a;", Style); + + verifyFormat("constexpr static int a;", "static constexpr int a;", Style); + verifyFormat("constexpr static int A;", "static constexpr int A;", Style); + verifyFormat("constexpr static int Bar;", "static constexpr int Bar;", Style); + verifyFormat("constexpr static LPINT Bar;", "static constexpr LPINT Bar;", + Style); + verifyFormat("const const int a;", "const int const a;", Style); +} + +TEST_F(QualifierFixerTest, LeftRightQualifier) { + FormatStyle Style = getLLVMStyle(); + + // keep the const style unaltered + verifyFormat("const int a;", Style); + verifyFormat("const int *a;", Style); + verifyFormat("const int &a;", Style); + verifyFormat("const int &&a;", Style); + verifyFormat("int const b;", Style); + verifyFormat("int const *b;", Style); + verifyFormat("int const &b;", Style); + verifyFormat("int const &&b;", Style); + verifyFormat("int const *b const;", Style); + verifyFormat("int *const c;", Style); + + verifyFormat("const Foo a;", Style); + verifyFormat("const Foo *a;", Style); + verifyFormat("const Foo &a;", Style); + verifyFormat("const Foo &&a;", Style); + verifyFormat("Foo const b;", Style); + verifyFormat("Foo const *b;", Style); + verifyFormat("Foo const &b;", Style); + verifyFormat("Foo const &&b;", Style); + verifyFormat("Foo const *b const;", Style); + + verifyFormat("LLVM_NODISCARD const int &Foo();", Style); + verifyFormat("LLVM_NODISCARD int const &Foo();", Style); + + verifyFormat("volatile const int *restrict;", Style); + verifyFormat("const volatile int *restrict;", Style); + verifyFormat("const int volatile *restrict;", Style); +} + +TEST_F(QualifierFixerTest, RightQualifier) { + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Right; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + + verifyFormat("int const a;", Style); + verifyFormat("int const *a;", Style); + verifyFormat("int const &a;", Style); + verifyFormat("int const &&a;", Style); + verifyFormat("int const b;", Style); + verifyFormat("int const *b;", Style); + verifyFormat("int const &b;", Style); + verifyFormat("int const &&b;", Style); + verifyFormat("int const *b const;", Style); + verifyFormat("int *const c;", Style); + + verifyFormat("Foo const a;", Style); + verifyFormat("Foo const *a;", Style); + verifyFormat("Foo const &a;", Style); + verifyFormat("Foo const &&a;", Style); + verifyFormat("Foo const b;", Style); + verifyFormat("Foo const *b;", Style); + verifyFormat("Foo const &b;", Style); + verifyFormat("Foo const &&b;", Style); + verifyFormat("Foo const *b const;", Style); + verifyFormat("Foo *const b;", Style); + verifyFormat("Foo const *const b;", Style); + verifyFormat("auto const v = get_value();", Style); + verifyFormat("long long const &a;", Style); + verifyFormat("unsigned char const *a;", Style); + verifyFormat("int main(int const argc, char const *const *const argv)", + Style); + + verifyFormat("LLVM_NODISCARD int const &Foo();", Style); + verifyFormat("SourceRange getSourceRange() const override LLVM_READONLY", + Style); + verifyFormat("void foo() const override;", Style); + verifyFormat("void foo() const override LLVM_READONLY;", Style); + verifyFormat("void foo() const final;", Style); + verifyFormat("void foo() const final LLVM_READONLY;", Style); + verifyFormat("void foo() const LLVM_READONLY;", Style); + + verifyFormat( + "template <typename Func> explicit Action(Action<Func> const &action);", + Style); + verifyFormat( + "template <typename Func> explicit Action(Action<Func> const &action);", + "template <typename Func> explicit Action(const Action<Func>& action);", + Style); + verifyFormat( + "template <typename Func> explicit Action(Action<Func> const &action);", + "template <typename Func>\nexplicit Action(const Action<Func>& action);", + Style); + + verifyFormat("int const a;", "const int a;", Style); + verifyFormat("int const *a;", "const int *a;", Style); + verifyFormat("int const &a;", "const int &a;", Style); + verifyFormat("foo(int const &a)", "foo(const int &a)", Style); + verifyFormat("unsigned char *a;", "unsigned char *a;", Style); + verifyFormat("unsigned char const *a;", "const unsigned char *a;", Style); + verifyFormat("vector<int, int const, int &, int const &> args1", + "vector<int, const int, int &, const int &> args1", Style); + verifyFormat("unsigned int const &get_nu() const", + "const unsigned int &get_nu() const", Style); + verifyFormat("Foo<int> const &a", "const Foo<int> &a", Style); + verifyFormat("Foo<int>::iterator const &a", "const Foo<int>::iterator &a", + Style); + + verifyFormat("Foo(int a, " + "unsigned b, // c-style args\n" + " Bar const &c);", + "Foo(int a, " + "unsigned b, // c-style args\n" + " const Bar &c);", + Style); + + verifyFormat("int const volatile;", "volatile const int;", Style); + verifyFormat("int const volatile;", "const volatile int;", Style); + verifyFormat("int const volatile;", "const int volatile;", Style); + verifyFormat("int const volatile *restrict;", "volatile const int *restrict;", + Style); + verifyFormat("int const volatile *restrict;", "const volatile int *restrict;", + Style); + verifyFormat("int const volatile *restrict;", "const int volatile *restrict;", + Style); + + verifyFormat("static int const bat;", "static const int bat;", Style); + verifyFormat("static int const bat;", "static int const bat;", Style); + + verifyFormat("int const Foo<int>::bat = 0;", "const int Foo<int>::bat = 0;", + Style); + verifyFormat("int const Foo<int>::bat = 0;", "int const Foo<int>::bat = 0;", + Style); + verifyFormat("void fn(Foo<T> const &i);", "void fn(const Foo<T> &i);", Style); + verifyFormat("int const Foo<int>::fn() {", "int const Foo<int>::fn() {", + Style); + verifyFormat("Foo<Foo<int>> const *p;", "const Foo<Foo<int>> *p;", Style); + verifyFormat( + "Foo<Foo<int>> const *p = const_cast<Foo<Foo<int>> const *>(&ffi);", + "const Foo<Foo<int>> *p = const_cast<const Foo<Foo<int>> *>(&ffi);", + Style); + + verifyFormat("void fn(Foo<T> const &i);", "void fn(const Foo<T> &i);", Style); + verifyFormat("void fns(ns::S const &s);", "void fns(const ns::S &s);", Style); + verifyFormat("void fn(ns::Foo<T> const &i);", "void fn(const ns::Foo<T> &i);", + Style); + verifyFormat("void fns(ns::ns2::S const &s);", + "void fns(const ns::ns2::S &s);", Style); + verifyFormat("void fn(ns::Foo<Bar<T>> const &i);", + "void fn(const ns::Foo<Bar<T>> &i);", Style); + verifyFormat("void fn(ns::ns2::Foo<Bar<T>> const &i);", + "void fn(const ns::ns2::Foo<Bar<T>> &i);", Style); + verifyFormat("void fn(ns::ns2::Foo<Bar<T, U>> const &i);", + "void fn(const ns::ns2::Foo<Bar<T, U>> &i);", Style); + + verifyFormat("LocalScope const *Scope = nullptr;", + "const LocalScope* Scope = nullptr;", Style); + verifyFormat("struct DOTGraphTraits<Stmt const *>", + "struct DOTGraphTraits<const Stmt *>", Style); + + verifyFormat( + "bool tools::addXRayRuntime(ToolChain const &TC, ArgList const &Args) {", + "bool tools::addXRayRuntime(const ToolChain&TC, const ArgList &Args) {", + Style); + verifyFormat("Foo<Foo<int> const> P;", "Foo<const Foo<int>> P;", Style); + verifyFormat("Foo<Foo<int> const> P;\n", "Foo<const Foo<int>> P;\n", Style); + verifyFormat("Foo<Foo<int> const> P;\n#if 0\n#else\n#endif", + "Foo<const Foo<int>> P;\n#if 0\n#else\n#endif", Style); + + verifyFormat("auto const i = 0;", "const auto i = 0;", Style); + verifyFormat("auto const &ir = i;", "const auto &ir = i;", Style); + verifyFormat("auto const *ip = &i;", "const auto *ip = &i;", Style); + + verifyFormat("Foo<Foo<int> const> P;\n#if 0\n#else\n#endif", + "Foo<const Foo<int>> P;\n#if 0\n#else\n#endif", Style); + + verifyFormat("Bar<Bar<int const> const> P;\n#if 0\n#else\n#endif", + "Bar<Bar<const int> const> P;\n#if 0\n#else\n#endif", Style); + + verifyFormat("Baz<Baz<int const> const> P;\n#if 0\n#else\n#endif", + "Baz<const Baz<const int>> P;\n#if 0\n#else\n#endif", Style); + + // verifyFormat("#if 0\nBoo<Boo<int const> const> P;\n#else\n#endif", + // "#if 0\nBoo<const Boo<const int>> P;\n#else\n#endif", Style); + + verifyFormat("int const P;\n#if 0\n#else\n#endif", + "const int P;\n#if 0\n#else\n#endif", Style); + + verifyFormat("unsigned long const a;", "const unsigned long a;", Style); + verifyFormat("unsigned long long const a;", "const unsigned long long a;", + Style); + + // don't adjust macros + verifyFormat("const INTPTR a;", "const INTPTR a;", Style); +} + +TEST_F(QualifierFixerTest, LeftQualifier) { + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Left; + Style.QualifierOrder.push_back("inline"); + Style.QualifierOrder.push_back("static"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + Style.QualifierOrder.push_back("type"); + + verifyFormat("const int a;", Style); + verifyFormat("const int *a;", Style); + verifyFormat("const int &a;", Style); + verifyFormat("const int &&a;", Style); + verifyFormat("const int b;", Style); + verifyFormat("const int *b;", Style); + verifyFormat("const int &b;", Style); + verifyFormat("const int &&b;", Style); + verifyFormat("const int *b const;", Style); + verifyFormat("int *const c;", Style); + + verifyFormat("const Foo a;", Style); + verifyFormat("const Foo *a;", Style); + verifyFormat("const Foo &a;", Style); + verifyFormat("const Foo &&a;", Style); + verifyFormat("const Foo b;", Style); + verifyFormat("const Foo *b;", Style); + verifyFormat("const Foo &b;", Style); + verifyFormat("const Foo &&b;", Style); + verifyFormat("const Foo *b const;", Style); + verifyFormat("Foo *const b;", Style); + verifyFormat("const Foo *const b;", Style); + + verifyFormat("LLVM_NODISCARD const int &Foo();", Style); + + verifyFormat("const char a[];", Style); + verifyFormat("const auto v = get_value();", Style); + verifyFormat("const long long &a;", Style); + verifyFormat("const unsigned char *a;", Style); + verifyFormat("const unsigned char *a;", "unsigned char const *a;", Style); + verifyFormat("const Foo<int> &a", "Foo<int> const &a", Style); + verifyFormat("const Foo<int>::iterator &a", "Foo<int>::iterator const &a", + Style); + + verifyFormat("const int a;", "int const a;", Style); + verifyFormat("const int *a;", "int const *a;", Style); + verifyFormat("const int &a;", "int const &a;", Style); + verifyFormat("foo(const int &a)", "foo(int const &a)", Style); + verifyFormat("unsigned char *a;", "unsigned char *a;", Style); + verifyFormat("const unsigned int &get_nu() const", + "unsigned int const &get_nu() const", Style); + + verifyFormat("const volatile int;", "volatile const int;", Style); + verifyFormat("const volatile int;", "const volatile int;", Style); + verifyFormat("const volatile int;", "const int volatile;", Style); + + verifyFormat("const volatile int *restrict;", "volatile const int *restrict;", + Style); + verifyFormat("const volatile int *restrict;", "const volatile int *restrict;", + Style); + verifyFormat("const volatile int *restrict;", "const int volatile *restrict;", + Style); + + verifyFormat("SourceRange getSourceRange() const override LLVM_READONLY;", + Style); + + verifyFormat("void foo() const override;", Style); + verifyFormat("void foo() const override LLVM_READONLY;", Style); + verifyFormat("void foo() const final;", Style); + verifyFormat("void foo() const final LLVM_READONLY;", Style); + verifyFormat("void foo() const LLVM_READONLY;", Style); + + verifyFormat( + "template <typename Func> explicit Action(const Action<Func> &action);", + Style); + verifyFormat( + "template <typename Func> explicit Action(const Action<Func> &action);", + "template <typename Func> explicit Action(Action<Func> const &action);", + Style); + + verifyFormat("static const int bat;", "static const int bat;", Style); + verifyFormat("static const int bat;", "static int const bat;", Style); + + verifyFormat("static const int Foo<int>::bat = 0;", + "static const int Foo<int>::bat = 0;", Style); + verifyFormat("static const int Foo<int>::bat = 0;", + "static int const Foo<int>::bat = 0;", Style); + + verifyFormat("void fn(const Foo<T> &i);"); + + verifyFormat("const int Foo<int>::bat = 0;", "const int Foo<int>::bat = 0;", + Style); + verifyFormat("const int Foo<int>::bat = 0;", "int const Foo<int>::bat = 0;", + Style); + verifyFormat("void fn(const Foo<T> &i);", "void fn( Foo<T> const &i);", + Style); + verifyFormat("const int Foo<int>::fn() {", "int const Foo<int>::fn() {", + Style); + verifyFormat("const Foo<Foo<int>> *p;", "Foo<Foo<int>> const *p;", Style); + verifyFormat( + "const Foo<Foo<int>> *p = const_cast<const Foo<Foo<int>> *>(&ffi);", + "const Foo<Foo<int>> *p = const_cast<Foo<Foo<int>> const *>(&ffi);", + Style); + + verifyFormat("void fn(const Foo<T> &i);", "void fn(Foo<T> const &i);", Style); + verifyFormat("void fns(const ns::S &s);", "void fns(ns::S const &s);", Style); + verifyFormat("void fn(const ns::Foo<T> &i);", "void fn(ns::Foo<T> const &i);", + Style); + verifyFormat("void fns(const ns::ns2::S &s);", + "void fns(ns::ns2::S const &s);", Style); + verifyFormat("void fn(const ns::Foo<Bar<T>> &i);", + "void fn(ns::Foo<Bar<T>> const &i);", Style); + verifyFormat("void fn(const ns::ns2::Foo<Bar<T>> &i);", + "void fn(ns::ns2::Foo<Bar<T>> const &i);", Style); + verifyFormat("void fn(const ns::ns2::Foo<Bar<T, U>> &i);", + "void fn(ns::ns2::Foo<Bar<T, U>> const &i);", Style); + + verifyFormat("const auto i = 0;", "auto const i = 0;", Style); + verifyFormat("const auto &ir = i;", "auto const &ir = i;", Style); + verifyFormat("const auto *ip = &i;", "auto const *ip = &i;", Style); + + verifyFormat("Foo<const Foo<int>> P;\n#if 0\n#else\n#endif", + "Foo<Foo<int> const> P;\n#if 0\n#else\n#endif", Style); + + verifyFormat("Foo<Foo<const int>> P;\n#if 0\n#else\n#endif", + "Foo<Foo<int const>> P;\n#if 0\n#else\n#endif", Style); + + verifyFormat("const int P;\n#if 0\n#else\n#endif", + "int const P;\n#if 0\n#else\n#endif", Style); + + verifyFormat("const unsigned long a;", "unsigned long const a;", Style); + verifyFormat("const unsigned long long a;", "unsigned long long const a;", + Style); + + verifyFormat("const long long unsigned a;", "long const long unsigned a;", + Style); + + verifyFormat("const std::Foo", "const std::Foo", Style); + verifyFormat("const std::Foo<>", "const std::Foo<>", Style); + verifyFormat("const std::Foo < int", "const std::Foo<int", Style); + verifyFormat("const std::Foo<int>", "const std::Foo<int>", Style); + + // don't adjust macros + verifyFormat("INTPTR const a;", "INTPTR const a;", Style); +} + +TEST_F(QualifierFixerTest, ConstVolatileQualifiersOrder) { + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Left; + Style.QualifierOrder.push_back("inline"); + Style.QualifierOrder.push_back("static"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + Style.QualifierOrder.push_back("type"); + + // The Default + EXPECT_EQ(Style.QualifierOrder.size(), 5); + EXPECT_EQ(Style.QualifierOrder[0], "inline"); + EXPECT_EQ(Style.QualifierOrder[1], "static"); + EXPECT_EQ(Style.QualifierOrder[2], "const"); + EXPECT_EQ(Style.QualifierOrder[3], "volatile"); + EXPECT_EQ(Style.QualifierOrder[4], "type"); + + verifyFormat("const volatile int a;", "const volatile int a;", Style); + verifyFormat("const volatile int a;", "volatile const int a;", Style); + verifyFormat("const volatile int a;", "int const volatile a;", Style); + verifyFormat("const volatile int a;", "int volatile const a;", Style); + verifyFormat("const volatile int a;", "const int volatile a;", Style); + + Style.QualifierAlignment = FormatStyle::QAS_Right; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + + verifyFormat("int const volatile a;", "const volatile int a;", Style); + verifyFormat("int const volatile a;", "volatile const int a;", Style); + verifyFormat("int const volatile a;", "int const volatile a;", Style); + verifyFormat("int const volatile a;", "int volatile const a;", Style); + verifyFormat("int const volatile a;", "const int volatile a;", Style); + + Style.QualifierAlignment = FormatStyle::QAS_Left; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("volatile"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("type"); + + verifyFormat("volatile const int a;", "const volatile int a;", Style); + verifyFormat("volatile const int a;", "volatile const int a;", Style); + verifyFormat("volatile const int a;", "int const volatile a;", Style); + verifyFormat("volatile const int a;", "int volatile const a;", Style); + verifyFormat("volatile const int a;", "const int volatile a;", Style); + + Style.QualifierAlignment = FormatStyle::QAS_Right; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("volatile"); + Style.QualifierOrder.push_back("const"); + + verifyFormat("int volatile const a;", "const volatile int a;", Style); + verifyFormat("int volatile const a;", "volatile const int a;", Style); + verifyFormat("int volatile const a;", "int const volatile a;", Style); + verifyFormat("int volatile const a;", "int volatile const a;", Style); + verifyFormat("int volatile const a;", "const int volatile a;", Style); + + Style.QualifierAlignment = FormatStyle::QAS_Custom; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("volatile"); + Style.QualifierOrder.push_back("const"); + + verifyFormat("int volatile const a;", "const volatile int a;", Style); + verifyFormat("int volatile const a;", "volatile const int a;", Style); + verifyFormat("int volatile const a;", "int const volatile a;", Style); + verifyFormat("int volatile const a;", "int volatile const a;", Style); + verifyFormat("int volatile const a;", "const int volatile a;", Style); +} + +TEST_F(QualifierFixerTest, InlineStatics) { + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Left; + Style.QualifierOrder.push_back("inline"); + Style.QualifierOrder.push_back("static"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + Style.QualifierOrder.push_back("type"); + + // the Default + EXPECT_EQ(Style.QualifierOrder.size(), 5); + EXPECT_EQ(Style.QualifierOrder[0], "inline"); + EXPECT_EQ(Style.QualifierOrder[1], "static"); + EXPECT_EQ(Style.QualifierOrder[2], "const"); + EXPECT_EQ(Style.QualifierOrder[3], "volatile"); + EXPECT_EQ(Style.QualifierOrder[4], "type"); + + verifyFormat("inline static const volatile int a;", + "const inline static volatile int a;", Style); + verifyFormat("inline static const volatile int a;", + "volatile inline static const int a;", Style); + verifyFormat("inline static const volatile int a;", + "int const inline static volatile a;", Style); + verifyFormat("inline static const volatile int a;", + "int volatile inline static const a;", Style); + verifyFormat("inline static const volatile int a;", + "const int inline static volatile a;", Style); +} + +TEST_F(QualifierFixerTest, AmpEqual) { + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Custom; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("static"); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("const"); + EXPECT_EQ(Style.QualifierOrder.size(), 3); + + verifyFormat("foo(std::string const & = std::string()) const", + "foo(const std::string & = std::string()) const", Style); + verifyFormat("foo(std::string const & = std::string())", + "foo(const std::string & = std::string())", Style); +} + +TEST_F(QualifierFixerTest, MoveConstBeyondTypeSmall) { + + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Custom; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("const"); + EXPECT_EQ(Style.QualifierOrder.size(), 2); + + verifyFormat("int const a;", "const int a;", Style); + verifyFormat("int const *a;", "const int*a;", Style); + verifyFormat("int const *a;", "const int *a;", Style); + verifyFormat("int const &a;", "const int &a;", Style); + verifyFormat("int const &&a;", "const int &&a;", Style); +} + +TEST_F(QualifierFixerTest, MoveConstBeforeTypeSmall) { + + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Custom; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("type"); + EXPECT_EQ(Style.QualifierOrder.size(), 2); + + verifyFormat("const int a;", "int const a;", Style); + verifyFormat("const int *a;", "int const *a;", Style); + verifyFormat("const int *a const;", "int const *a const;", Style); + + verifyFormat("const int a = foo();", "int const a = foo();", Style); + verifyFormat("const int *a = foo();", "int const *a = foo();", Style); + verifyFormat("const int *a const = foo();", "int const *a const = foo();", + Style); + + verifyFormat("const auto a = foo();", "auto const a = foo();", Style); + verifyFormat("const auto *a = foo();", "auto const *a = foo();", Style); + verifyFormat("const auto *a const = foo();", "auto const *a const = foo();", + Style); +} + +TEST_F(QualifierFixerTest, MoveConstBeyondType) { + + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Custom; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("static"); + Style.QualifierOrder.push_back("inline"); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + EXPECT_EQ(Style.QualifierOrder.size(), 5); + + verifyFormat("static inline int const volatile a;", + "const inline static volatile int a;", Style); + verifyFormat("static inline int const volatile a;", + "volatile inline static const int a;", Style); + verifyFormat("static inline int const volatile a;", + "int const inline static volatile a;", Style); + verifyFormat("static inline int const volatile a;", + "int volatile inline static const a;", Style); + verifyFormat("static inline int const volatile a;", + "const int inline static volatile a;", Style); + + verifyFormat("static inline int const volatile *a const;", + "const int inline static volatile *a const;", Style); +} + +TEST_F(QualifierFixerTest, PrepareLeftRightOrdering) { + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Custom; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("static"); + Style.QualifierOrder.push_back("inline"); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + + std::vector<std::string> Left; + std::vector<std::string> Right; + QualifierAlignmentFixer::PrepareLeftRightOrdering(Style.QualifierOrder, Left, + Right); + + EXPECT_EQ(Left.size(), 2); + EXPECT_EQ(Right.size(), 2); + + std::vector<std::string> LeftResult; + std::vector<std::string> RightResult; + LeftResult.push_back("inline"); + LeftResult.push_back("static"); + + RightResult.push_back("const"); + RightResult.push_back("volatile"); + + EXPECT_EQ(Left, LeftResult); + EXPECT_EQ(Right, RightResult); +} + +TEST_F(QualifierFixerTest, IsQualifierType) { + + auto Tokens = + annotate("const static inline auto restrict int double long constexpr"); + + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[0])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[1])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[2])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[3])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[4])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[5])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[6])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[7])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(Tokens[8])); + + auto NotTokens = annotate("for while do Foo Bar "); + + EXPECT_FALSE( + LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[0])); + EXPECT_FALSE( + LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[1])); + EXPECT_FALSE( + LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[2])); + EXPECT_FALSE( + LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[3])); + EXPECT_FALSE( + LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[4])); + EXPECT_FALSE( + LeftRightQualifierAlignmentFixer::isQualifierOrType(NotTokens[5])); +} + +TEST_F(QualifierFixerTest, IsMacro) { + + auto Tokens = annotate("INT INTPR Foo int"); + + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[0])); + EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[1])); + EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[2])); + EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isPossibleMacro(Tokens[3])); +} + +TEST_F(QualifierFixerTest, OverlappingQualifier) { + + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Left; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("type"); + + verifyFormat("Foo(const Bar &name);", "Foo(Bar const &name);", Style); +} + +TEST_F(QualifierFixerTest, QualifierAlignUsingTypeNameMacros) { + + FormatStyle Style = getLLVMStyle(); + Style.QualifierAlignment = FormatStyle::QAS_Left; + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("type"); + + verifyFormat("HRESULT const OnChange(DWORD const wID);", Style); + + Style.TypenameMacros.push_back("HRESULT"); + Style.TypenameMacros.push_back("DWORD"); + + verifyFormat("const HRESULT OnChange(const DWORD wID);", + "HRESULT const OnChange(DWORD const wID);", Style); +} + +} // namespace format +} // namespace clang Index: clang/unittests/Format/FormatTest.cpp =================================================================== --- clang/unittests/Format/FormatTest.cpp +++ clang/unittests/Format/FormatTest.cpp @@ -18325,6 +18325,26 @@ CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); + Style.QualifierAlignment = FormatStyle::QAS_Right; + CHECK_PARSE("QualifierAlignment: Leave", QualifierAlignment, + FormatStyle::QAS_Leave); + CHECK_PARSE("QualifierAlignment: Right", QualifierAlignment, + FormatStyle::QAS_Right); + CHECK_PARSE("QualifierAlignment: Left", QualifierAlignment, + FormatStyle::QAS_Left); + CHECK_PARSE("QualifierAlignment: Custom", QualifierAlignment, + FormatStyle::QAS_Custom); + + Style.QualifierOrder.clear(); + CHECK_PARSE("QualifierOrder: [ const, volatile, type ]", QualifierOrder, + std::vector<std::string>({"const", "volatile", "type"})); + Style.QualifierOrder.clear(); + CHECK_PARSE("QualifierOrder: [const, type]", QualifierOrder, + std::vector<std::string>({"const", "type"})); + Style.QualifierOrder.clear(); + CHECK_PARSE("QualifierOrder: [volatile, type]", QualifierOrder, + std::vector<std::string>({"volatile", "type"})); + Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive; CHECK_PARSE("AlignConsecutiveAssignments: None", AlignConsecutiveAssignments, FormatStyle::ACS_None); @@ -18992,8 +19012,6 @@ EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); } -#undef CHECK_PARSE - TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { FormatStyle Style = {}; Style.Language = FormatStyle::LK_JavaScript; @@ -22294,6 +22312,7 @@ "}"; EXPECT_EQ(Code, format(Code, Style)); } + } // namespace } // namespace format } // namespace clang Index: clang/unittests/Format/CMakeLists.txt =================================================================== --- clang/unittests/Format/CMakeLists.txt +++ clang/unittests/Format/CMakeLists.txt @@ -18,6 +18,7 @@ FormatTestTextProto.cpp MacroExpanderTest.cpp NamespaceEndCommentsFixerTest.cpp + QualifierFixerTest.cpp SortImportsTestJS.cpp SortImportsTestJava.cpp SortIncludesTest.cpp Index: clang/tools/clang-format/ClangFormat.cpp =================================================================== --- clang/tools/clang-format/ClangFormat.cpp +++ clang/tools/clang-format/ClangFormat.cpp @@ -19,6 +19,7 @@ #include "clang/Basic/Version.h" #include "clang/Format/Format.h" #include "clang/Rewrite/Core/Rewriter.h" +#include "llvm/ADT/StringSwitch.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/InitLLVM.h" @@ -104,6 +105,13 @@ "SortIncludes style flag"), cl::cat(ClangFormatCategory)); +static cl::opt<std::string> QualifierAlignment( + "qualifier-aligment", + cl::desc( + "If set, overrides the cvqualifier style behavior determined by the " + "QualifierAlignment style flag"), + cl::init(""), cl::cat(ClangFormatCategory)); + static cl::opt<bool> Verbose("verbose", cl::desc("If set, shows the list of processed files"), cl::cat(ClangFormatCategory)); @@ -402,6 +410,14 @@ return true; } + StringRef ConstAlignment = QualifierAlignment; + + FormatStyle->QualifierAlignment = + StringSwitch<FormatStyle::QualifierAlignmentStyle>(ConstAlignment.lower()) + .Case("right", FormatStyle::QAS_Right) + .Case("left", FormatStyle::QAS_Left) + .Default(FormatStyle->QualifierAlignment); + if (SortIncludes.getNumOccurrences() != 0) { if (SortIncludes) FormatStyle->SortIncludes = FormatStyle::SI_CaseSensitive; Index: clang/lib/Format/QualifierAlignmentFixer.h =================================================================== --- /dev/null +++ clang/lib/Format/QualifierAlignmentFixer.h @@ -0,0 +1,97 @@ +//===--- LeftRightQualifierAlignmentFixer.h ------------------------------*- C++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file declares LeftRightQualifierAlignmentFixer, a TokenAnalyzer that +/// enforces either east or west const depending on the style. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_LIB_FORMAT_LeftRightQualifierAlignmentFixer_H +#define LLVM_CLANG_LIB_FORMAT_LeftRightQualifierAlignmentFixer_H + +#include "TokenAnalyzer.h" + +namespace clang { +namespace format { + +typedef std::function<std::pair<tooling::Replacements, unsigned>( + const Environment &)> + AnalyzerPass; + +class QualifierAlignmentFixer : public TokenAnalyzer { + // Left to Right ordering requires multiple passes + SmallVector<AnalyzerPass, 8> Passes; + StringRef &Code; + ArrayRef<tooling::Range> Ranges; + unsigned FirstStartColumn; + unsigned NextStartColumn; + unsigned LastStartColumn; + StringRef FileName; + +public: + QualifierAlignmentFixer(const Environment &Env, const FormatStyle &Style, + StringRef &Code, ArrayRef<tooling::Range> Ranges, + unsigned FirstStartColumn, unsigned NextStartColumn, + unsigned LastStartColumn, StringRef FileName); + + std::pair<tooling::Replacements, unsigned> + analyze(TokenAnnotator &Annotator, + SmallVectorImpl<AnnotatedLine *> &AnnotatedLines, + FormatTokenLexer &Tokens) override; + + static void QualifierAlignmentFixer::PrepareLeftRightOrdering( + const std::vector<std::string> &Order, + std::vector<std::string> &LeftOrder, + std::vector<std::string> &RightOrder); +}; + +class LeftRightQualifierAlignmentFixer : public TokenAnalyzer { + std::string Qualifier; + bool RightAlign; + SmallVector<tok::TokenKind, 8> QualifierTokens; + +public: + LeftRightQualifierAlignmentFixer(const Environment &Env, + const FormatStyle &Style, + const std::string &Qualifier, + bool RightAlign); + + std::pair<tooling::Replacements, unsigned> + analyze(TokenAnnotator &Annotator, + SmallVectorImpl<AnnotatedLine *> &AnnotatedLines, + FormatTokenLexer &Tokens) override; + + static tok::TokenKind getTokenFromQualifier(const std::string &Qualifier); + + static FormatToken *analyzeRight(const SourceManager &SourceMgr, + const AdditionalKeywords &Keywords, + tooling::Replacements &Fixes, + FormatToken *Tok, + const std::string &Qualifier, + tok::TokenKind QualifierType); + + static FormatToken *analyzeLeft(const SourceManager &SourceMgr, + const AdditionalKeywords &Keywords, + tooling::Replacements &Fixes, + FormatToken *Tok, + const std::string &Qualifier, + tok::TokenKind QualifierType); + + // is the Token a simple or qualifier type + static bool isQualifierOrType(const FormatToken *Tok); + + // is the Token likely a Macro + static bool isPossibleMacro(const FormatToken *Tok); +}; + +} // end namespace format +} // end namespace clang + +#endif Index: clang/lib/Format/QualifierAlignmentFixer.cpp =================================================================== --- /dev/null +++ clang/lib/Format/QualifierAlignmentFixer.cpp @@ -0,0 +1,457 @@ +//===--- LeftRightQualifierAlignmentFixer.cpp -------------------*- C++--*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// This file implements LeftRightQualifierAlignmentFixer, a TokenAnalyzer that +/// enforces either left or right const depending on the style. +/// +//===----------------------------------------------------------------------===// + +#include "QualifierAlignmentFixer.h" +#include "FormatToken.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/Regex.h" + +#include <algorithm> + +#define DEBUG_TYPE "format-qualifier-alignment-fixer" + +namespace clang { +namespace format { + +QualifierAlignmentFixer::QualifierAlignmentFixer( + const Environment &Env, const FormatStyle &Style, StringRef &Code, + ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn, + unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName) + : TokenAnalyzer(Env, Style), Code(Code), Ranges(Ranges), + FirstStartColumn(FirstStartColumn), NextStartColumn(NextStartColumn), + LastStartColumn(LastStartColumn), FileName(FileName) { + std::vector<std::string> LeftOrder; + std::vector<std::string> RightOrder; + PrepareLeftRightOrdering(Style.QualifierOrder, LeftOrder, RightOrder); + + // Handle the left and right Alignment Seperately + for (const auto &Qualifier : LeftOrder) { + Passes.emplace_back([&, Qualifier](const Environment &Env) { + return LeftRightQualifierAlignmentFixer(Env, Style, Qualifier, + /*RightAlign=*/false) + .process(); + }); + } + for (const auto &Qualifier : RightOrder) { + Passes.emplace_back([&, Qualifier](const Environment &Env) { + return LeftRightQualifierAlignmentFixer(Env, Style, Qualifier, + /*RightAlign=*/true) + .process(); + }); + } +} + +std::pair<tooling::Replacements, unsigned> QualifierAlignmentFixer::analyze( + TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines, + FormatTokenLexer &Tokens) { + + auto Env = + std::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn, + NextStartColumn, LastStartColumn); + llvm::Optional<std::string> CurrentCode = None; + tooling::Replacements Fixes; + unsigned Penalty = 0; + for (size_t I = 0, E = Passes.size(); I < E; ++I) { + std::pair<tooling::Replacements, unsigned> PassFixes = Passes[I](*Env); + auto NewCode = applyAllReplacements( + CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first); + if (NewCode) { + Fixes = Fixes.merge(PassFixes.first); + Penalty += PassFixes.second; + if (I + 1 < E) { + CurrentCode = std::move(*NewCode); + Env = std::make_unique<Environment>( + *CurrentCode, FileName, + tooling::calculateRangesAfterReplacements(Fixes, Ranges), + FirstStartColumn, NextStartColumn, LastStartColumn); + } + } + } + + // Don't make replacements that replace nothing. + tooling::Replacements NonNoOpFixes; + + for (auto I = Fixes.begin(), E = Fixes.end(); I != E; ++I) { + StringRef OriginalCode = Code.substr(I->getOffset(), I->getLength()); + + if (!OriginalCode.equals(I->getReplacementText())) { + auto Err = NonNoOpFixes.add(*I); + if (Err) + llvm::errs() << "Error removing no op replacements : " + << llvm::toString(std::move(Err)) << "\n"; + } + } + + return {NonNoOpFixes, 0}; +} + +static void replaceToken(const SourceManager &SourceMgr, + tooling::Replacements &Fixes, + const CharSourceRange &Range, std::string NewText) { + auto Replacement = tooling::Replacement(SourceMgr, Range, NewText); + auto Err = Fixes.add(Replacement); + + if (Err) + llvm::errs() << "Error while rearranging Qualifier : " + << llvm::toString(std::move(Err)) << "\n"; +} + +static void removeToken(const SourceManager &SourceMgr, + tooling::Replacements &Fixes, + const FormatToken *First) { + auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(), + First->Tok.getEndLoc()); + replaceToken(SourceMgr, Fixes, Range, ""); +} + +static void insertQualifierAfter(const SourceManager &SourceMgr, + tooling::Replacements &Fixes, + const FormatToken *First, + const std::string &Qualifier) { + FormatToken *Next = First->Next; + if (!Next) + return; + auto Range = CharSourceRange::getCharRange(Next->getStartOfNonWhitespace(), + Next->Tok.getEndLoc()); + + std::string NewText = " " + Qualifier + " "; + NewText += Next->TokenText; + replaceToken(SourceMgr, Fixes, Range, NewText); +} + +static void insertQualifierBefore(const SourceManager &SourceMgr, + tooling::Replacements &Fixes, + const FormatToken *First, + const std::string &Qualifier) { + auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(), + First->Tok.getEndLoc()); + + std::string NewText = " " + Qualifier + " "; + NewText += First->TokenText; + + replaceToken(SourceMgr, Fixes, Range, NewText); +} + +static bool endsWithSpace(const std::string &s) { + if (s.empty()) { + return false; + } + return isspace(s.back()); +} + +static bool startsWithSpace(const std::string &s) { + if (s.empty()) { + return false; + } + return isspace(s.front()); +} + +static void rotateTokens(const SourceManager &SourceMgr, + tooling::Replacements &Fixes, const FormatToken *First, + const FormatToken *Last, bool Left) { + auto *End = Last; + auto *Begin = First; + if (!Left) { + End = Last->Next; + Begin = First->Next; + } + + std::string NewText; + // If we are rotating to the left we move the Last token to the front. + if (Left) { + NewText += Last->TokenText; + NewText += " "; + } + + // Then move through the other tokens. + auto *Tok = Begin; + while (Tok != End) { + if (!NewText.empty() && !endsWithSpace(NewText)) { + NewText += " "; + } + + NewText += Tok->TokenText; + Tok = Tok->Next; + } + + // If we are rotating to the right we move the first token to the back. + if (!Left) { + if (!NewText.empty() && !startsWithSpace(NewText)) { + NewText += " "; + } + NewText += First->TokenText; + } + + auto Range = CharSourceRange::getCharRange(First->getStartOfNonWhitespace(), + Last->Tok.getEndLoc()); + + replaceToken(SourceMgr, Fixes, Range, NewText); +} + +FormatToken *LeftRightQualifierAlignmentFixer::analyzeRight( + const SourceManager &SourceMgr, const AdditionalKeywords &Keywords, + tooling::Replacements &Fixes, FormatToken *Tok, + const std::string &Qualifier, tok::TokenKind QualifierType) { + // We only need to think about streams that begin with a qualifier. + if (!Tok->is(QualifierType)) + return Tok; + // Don't concern yourself if nothing follows the qualifier. + if (!Tok->Next) + return Tok; + if (LeftRightQualifierAlignmentFixer::isPossibleMacro(Tok->Next)) + return Tok; + + FormatToken *Qual = Tok->Next; + FormatToken *LastQual = Qual; + while (Qual && isQualifierOrType(Qual)) { + LastQual = Qual; + Qual = Qual->Next; + } + if (LastQual && Qual != LastQual) { + rotateTokens(SourceMgr, Fixes, Tok, LastQual, /*Left=*/false); + Tok = LastQual; + } else if (Tok->startsSequence(QualifierType, tok::identifier, + TT_TemplateOpener)) { + // Read from the TemplateOpener to + // TemplateCloser as in const ArrayRef<int> a; const ArrayRef<int> &a; + FormatToken *EndTemplate = Tok->Next->Next->MatchingParen; + if (EndTemplate) { + // Move to the end of any template class members e.g. + // `Foo<int>::iterator`. + if (EndTemplate->startsSequence(TT_TemplateCloser, tok::coloncolon, + tok::identifier)) + EndTemplate = EndTemplate->Next->Next; + } + if (EndTemplate && EndTemplate->Next && + !EndTemplate->Next->isOneOf(tok::equal, tok::l_paren)) { + insertQualifierAfter(SourceMgr, Fixes, EndTemplate, Qualifier); + // Remove the qualifier. + removeToken(SourceMgr, Fixes, Tok); + return Tok; + } + } else if (Tok->startsSequence(QualifierType, tok::identifier)) { + FormatToken *Next = Tok->Next; + // The case `const Foo` -> `Foo const` + // The case `const Foo *` -> `Foo const *` + // The case `const Foo &` -> `Foo const &` + // The case `const Foo &&` -> `Foo const &&` + // The case `const std::Foo &&` -> `std::Foo const &&` + // The case `const std::Foo<T> &&` -> `std::Foo<T> const &&` + while (Next && Next->isOneOf(tok::identifier, tok::coloncolon)) { + Next = Next->Next; + } + if (Next && Next->is(TT_TemplateOpener)) { + Next = Next->MatchingParen; + // Move to the end of any template class members e.g. + // `Foo<int>::iterator`. + if (Next && Next->startsSequence(TT_TemplateCloser, tok::coloncolon, + tok::identifier)) { + Next = Next->Next->Next; + return Tok; + } + assert(Next && "Missing template opener"); + Next = Next->Next; + } + if (Next && Next->isOneOf(tok::star, tok::amp, tok::ampamp) && + !Tok->Next->isOneOf(Keywords.kw_override, Keywords.kw_final)) { + if (Next->Previous && !Next->Previous->is(QualifierType)) { + insertQualifierAfter(SourceMgr, Fixes, Next->Previous, Qualifier); + removeToken(SourceMgr, Fixes, Tok); + } + return Next; + } + } + + return Tok; +} + +FormatToken *LeftRightQualifierAlignmentFixer::analyzeLeft( + const SourceManager &SourceMgr, const AdditionalKeywords &Keywords, + tooling::Replacements &Fixes, FormatToken *Tok, + const std::string &Qualifier, tok::TokenKind QualifierType) { + // if Tok is an identifier and possibly a macro then don't convert. + if (LeftRightQualifierAlignmentFixer::isPossibleMacro(Tok)) + return Tok; + + FormatToken *Qual = Tok; + FormatToken *LastQual = Qual; + while (Qual && isQualifierOrType(Qual)) { + LastQual = Qual; + Qual = Qual->Next; + if (Qual && Qual->is(QualifierType)) + break; + } + + if (!Qual) { + return Tok; + } + + if (LastQual && Qual != LastQual && Qual->is(QualifierType)) { + rotateTokens(SourceMgr, Fixes, Tok, Qual, /*Left=*/true); + Tok = Qual->Next; + } else if (Tok->startsSequence(tok::identifier, QualifierType)) { + if (Tok->Next->Next && Tok->Next->Next->isOneOf(tok::identifier, tok::star, + tok::amp, tok::ampamp)) { + // Don't swap `::iterator const` to `::const iterator`. + if (!Tok->Previous || + (Tok->Previous && !Tok->Previous->is(tok::coloncolon))) { + rotateTokens(SourceMgr, Fixes, Tok, Tok->Next, /*Left=*/true); + Tok = Tok->Next; + } + } + } + if (Tok->is(TT_TemplateOpener) && Tok->Next && + (Tok->Next->is(tok::identifier) || Tok->Next->isSimpleTypeSpecifier()) && + Tok->Next->Next && Tok->Next->Next->is(QualifierType)) { + rotateTokens(SourceMgr, Fixes, Tok->Next, Tok->Next->Next, /*Left=*/true); + } + if (Tok->startsSequence(tok::identifier) && Tok->Next) { + if (Tok->Previous && + Tok->Previous->isOneOf(tok::star, tok::ampamp, tok::amp)) { + return Tok; + } + FormatToken *Next = Tok->Next; + // The case `std::Foo<T> const` -> `const std::Foo<T> &&` + while (Next && Next->isOneOf(tok::identifier, tok::coloncolon)) + Next = Next->Next; + if (Next && Next->Previous && + Next->Previous->startsSequence(tok::identifier, TT_TemplateOpener)) { + // Read from to the end of the TemplateOpener to + // TemplateCloser const ArrayRef<int> a; const ArrayRef<int> &a; + assert(Next->MatchingParen && "Missing template closer"); + Next = Next->MatchingParen->Next; + + // Move to the end of any template class members e.g. + // `Foo<int>::iterator`. + if (Next && Next->startsSequence(tok::coloncolon, tok::identifier)) + Next = Next->Next->Next; + if (Next && Next->is(QualifierType)) { + // Remove the const. + insertQualifierBefore(SourceMgr, Fixes, Tok, Qualifier); + removeToken(SourceMgr, Fixes, Next); + return Next; + } + } + if (Next && Next->Next && + Next->Next->isOneOf(tok::amp, tok::ampamp, tok::star)) { + if (Next->is(QualifierType)) { + // Remove the qualifier. + insertQualifierBefore(SourceMgr, Fixes, Tok, Qualifier); + removeToken(SourceMgr, Fixes, Next); + return Next; + } + } + } + return Tok; +} + +tok::TokenKind LeftRightQualifierAlignmentFixer::getTokenFromQualifier( + const std::string &Qualifier) { + // don't let 'type' be an indentifier steal typeof token + return llvm::StringSwitch<tok::TokenKind>(Qualifier) + .Case("type", tok::kw_typeof) + .Case("const", tok::kw_const) + .Case("volatile", tok::kw_volatile) + .Case("static", tok::kw_static) + .Case("inline", tok::kw_inline) + .Case("constexpr", tok::kw_constexpr) + .Case("restrict", tok::kw_restrict) + .Default(tok::identifier); +} + +LeftRightQualifierAlignmentFixer::LeftRightQualifierAlignmentFixer( + const Environment &Env, const FormatStyle &Style, + const std::string &Qualifier, bool RightAlign) + : TokenAnalyzer(Env, Style), Qualifier(Qualifier), RightAlign(RightAlign) {} + +std::pair<tooling::Replacements, unsigned> +LeftRightQualifierAlignmentFixer::analyze( + TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines, + FormatTokenLexer &Tokens) { + tooling::Replacements Fixes; + const AdditionalKeywords &Keywords = Tokens.getKeywords(); + const SourceManager &SourceMgr = Env.getSourceManager(); + AffectedRangeMgr.computeAffectedLines(AnnotatedLines); + + tok::TokenKind QualifierToken = getTokenFromQualifier(Qualifier); + assert(QualifierToken != tok::identifier && "Unrecognised Qualifier"); + + for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) { + FormatToken *First = AnnotatedLines[I]->First; + const auto *Last = AnnotatedLines[I]->Last; + + for (auto *Tok = First; Tok && Tok != Last && Tok->Next; Tok = Tok->Next) { + if (Tok->is(tok::comment)) + continue; + if (RightAlign) + Tok = analyzeRight(SourceMgr, Keywords, Fixes, Tok, Qualifier, + QualifierToken); + else + Tok = analyzeLeft(SourceMgr, Keywords, Fixes, Tok, Qualifier, + QualifierToken); + } + } + return {Fixes, 0}; +} + +void QualifierAlignmentFixer::PrepareLeftRightOrdering( + const std::vector<std::string> &Order, std::vector<std::string> &LeftOrder, + std::vector<std::string> &RightOrder) { + + // Depending on the position of type in the order you need + // To iterate forward or backward through the order list as qualifier + // can push through each other. + auto type = std::find(Order.begin(), Order.end(), "type"); + // The Order list must define the position of "type" to signify + assert(type != Order.end() && "QualifierOrder must contain type"); + // Split the Order list by type and reverse the left side. + + bool left = true; + for (const auto &s : Order) { + if (s == "type") { + left = false; + continue; + } + if (left) + // Reverse the order for left aligned items. + LeftOrder.insert(LeftOrder.begin(), s); + else + RightOrder.push_back(s); + } +} + +bool LeftRightQualifierAlignmentFixer::isQualifierOrType( + const FormatToken *Tok) { + return Tok && (Tok->isSimpleTypeSpecifier() || + Tok->isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_auto, + tok::kw_static, tok::kw_inline, tok::kw_constexpr, + tok::kw_restrict)); +} + +// If a token is an identifier and it's upper case, it could +// be a macro and hence we need to be able to ignore it. +bool LeftRightQualifierAlignmentFixer::isPossibleMacro(const FormatToken *Tok) { + if (!Tok) + return false; + if (!Tok->is(tok::identifier)) + return false; + if (Tok->is(TT_TypenameMacro)) + return false; + if (Tok->TokenText.upper() == Tok->TokenText.str()) + return true; + return false; +} + +} // namespace format +} // namespace clang Index: clang/lib/Format/Format.cpp =================================================================== --- clang/lib/Format/Format.cpp +++ clang/lib/Format/Format.cpp @@ -19,6 +19,7 @@ #include "FormatInternal.h" #include "FormatTokenLexer.h" #include "NamespaceEndCommentsFixer.h" +#include "QualifierAlignmentFixer.h" #include "SortJavaScriptImports.h" #include "TokenAnalyzer.h" #include "TokenAnnotator.h" @@ -126,6 +127,16 @@ } }; +template <> +struct ScalarEnumerationTraits<FormatStyle::QualifierAlignmentStyle> { + static void enumeration(IO &IO, FormatStyle::QualifierAlignmentStyle &Value) { + IO.enumCase(Value, "Leave", FormatStyle::QAS_Leave); + IO.enumCase(Value, "Left", FormatStyle::QAS_Left); + IO.enumCase(Value, "Right", FormatStyle::QAS_Right); + IO.enumCase(Value, "Custom", FormatStyle::QAS_Custom); + } +}; + template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> { static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) { IO.enumCase(Value, "None", FormatStyle::SFS_None); @@ -641,6 +652,23 @@ IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals); IO.mapOptional("ColumnLimit", Style.ColumnLimit); IO.mapOptional("CommentPragmas", Style.CommentPragmas); + IO.mapOptional("QualifierAlignment", Style.QualifierAlignment); + + // Default Order for Left/Right based Qualifier alignment. + if (Style.QualifierAlignment == FormatStyle::QAS_Right) { + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("type"); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + } else if (Style.QualifierAlignment == FormatStyle::QAS_Left) { + Style.QualifierOrder.clear(); + Style.QualifierOrder.push_back("const"); + Style.QualifierOrder.push_back("volatile"); + Style.QualifierOrder.push_back("type"); + } else if (Style.QualifierAlignment == FormatStyle::QAS_Custom) { + IO.mapOptional("QualifierOrder", Style.QualifierOrder); + } + IO.mapOptional("CompactNamespaces", Style.CompactNamespaces); IO.mapOptional("ConstructorInitializerIndentWidth", Style.ConstructorInitializerIndentWidth); @@ -905,6 +933,14 @@ return "Unsuitable"; case ParseError::BinPackTrailingCommaConflict: return "trailing comma insertion cannot be used with bin packing"; + case ParseError::InvalidQualifierSpecified: + return "Invalid qualifier specified in QualifierOrder"; + case ParseError::DuplicateQualifierSpecified: + return "Duplicate qualifier specified in QualfierOrder"; + case ParseError::MissingQualifierType: + return "Missing type in QualfierOrder"; + case ParseError::MissingQualifierOrder: + return "Missing QualfierOrder"; } llvm_unreachable("unexpected parse error"); } @@ -1078,6 +1114,10 @@ LLVMStyle.ConstructorInitializerIndentWidth = 4; LLVMStyle.ContinuationIndentWidth = 4; LLVMStyle.Cpp11BracedListStyle = true; + + // Off by default Qualifier ordering + LLVMStyle.QualifierAlignment = FormatStyle::QAS_Leave; + LLVMStyle.DeriveLineEnding = true; LLVMStyle.DerivePointerAlignment = false; LLVMStyle.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never; @@ -1512,6 +1552,37 @@ return true; } +ParseError validateQualifierOrder(FormatStyle *Style) { + // If its empty then it means don't do anything. + if (Style->QualifierOrder.empty()) + return ParseError::MissingQualifierOrder; + + // Ensure the list contains only currently valid qualifiers. + for (const auto &Qualifier : Style->QualifierOrder) { + if (Qualifier == "type") + continue; + auto token = + LeftRightQualifierAlignmentFixer::getTokenFromQualifier(Qualifier); + if (token == tok::identifier) + return ParseError::InvalidQualifierSpecified; + } + // Ensure the list is unqiue (no duplicates). + std::set<std::string> UniqueQualifiers(Style->QualifierOrder.begin(), + Style->QualifierOrder.end()); + if (Style->QualifierOrder.size() != UniqueQualifiers.size()) { + LLVM_DEBUG(llvm::dbgs() + << "Duplicate Qualifiers " << Style->QualifierOrder.size() + << " vs " << UniqueQualifiers.size() << "\n"); + return ParseError::DuplicateQualifierSpecified; + } + + auto type = std::find(Style->QualifierOrder.begin(), + Style->QualifierOrder.end(), "type"); + if (type == Style->QualifierOrder.end()) + return ParseError::MissingQualifierType; + return ParseError::Success; +} + std::error_code parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style, bool AllowUnknownOptions, llvm::SourceMgr::DiagHandlerTy DiagHandler, @@ -1573,6 +1644,8 @@ // See comment on FormatStyle::TSC_Wrapped. return make_error_code(ParseError::BinPackTrailingCommaConflict); } + if (Style->QualifierAlignment != FormatStyle::QAS_Leave) + return make_error_code(validateQualifierOrder(Style)); return make_error_code(ParseError::Success); } @@ -2894,6 +2967,15 @@ AnalyzerPass; SmallVector<AnalyzerPass, 4> Passes; + if (Style.isCpp() && Style.QualifierAlignment != FormatStyle::QAS_Leave) { + Passes.emplace_back([&](const Environment &Env) { + return QualifierAlignmentFixer(Env, Expanded, Code, Ranges, + FirstStartColumn, NextStartColumn, + LastStartColumn, FileName) + .process(); + }); + } + if (Style.Language == FormatStyle::LK_Cpp) { if (Style.FixNamespaceComments) Passes.emplace_back([&](const Environment &Env) { Index: clang/lib/Format/CMakeLists.txt =================================================================== --- clang/lib/Format/CMakeLists.txt +++ clang/lib/Format/CMakeLists.txt @@ -9,6 +9,7 @@ FormatTokenLexer.cpp MacroExpander.cpp NamespaceEndCommentsFixer.cpp + QualifierAlignmentFixer.cpp SortJavaScriptImports.cpp TokenAnalyzer.cpp TokenAnnotator.cpp Index: clang/include/clang/Format/Format.h =================================================================== --- clang/include/clang/Format/Format.h +++ clang/include/clang/Format/Format.h @@ -40,7 +40,11 @@ Success = 0, Error, Unsuitable, - BinPackTrailingCommaConflict + BinPackTrailingCommaConflict, + InvalidQualifierSpecified, + DuplicateQualifierSpecified, + MissingQualifierType, + MissingQualifierOrder }; class ParseErrorCategory final : public std::error_category { public: @@ -1819,6 +1823,67 @@ /// \endcode std::string CommentPragmas; + /// Different const/volatile qualifier alignment styles. + enum QualifierAlignmentStyle { + /// Don't change specifiers/qualifier to either Left or Right alignment + /// (default) + /// \code + /// int const a; + /// const int *a; + /// \endcode + QAS_Leave, + /// Change specifiers/qualifiers to be Left aligned. + /// \code + /// const int a; + /// const int *a; + /// \endcode + QAS_Left, + /// Change specifiers/qualifiers to be Right aligned. + /// \code + /// int const a; + /// int const *a; + /// \endcode + QAS_Right, + /// Change specifiers/qualifiers to be aligned based on QualfierOrder. + /// With: + /// \code{.yaml} + /// QualifierOrder: ['inline', 'static' , '<type>', 'const'] + /// \endcode + /// + /// \code + /// + /// int const a; + /// int const *a; + /// \endcode + QAS_Custom + }; + + /// Different ways to arrange const/volatile qualifiers. + /// \warning + /// ``QualifierAlignment`` COULD lead to incorrect code generation. + /// \endwarning + QualifierAlignmentStyle QualifierAlignment; + + /// The Order in which the qualifiers appear. + /// Order is a an array can contain any of the following + /// + /// * const + /// * inline + /// * static + /// * constexpr + /// * volatile + /// * restrict + /// * type + /// + /// Note: it MUST contain 'type'. + /// Items to the left of type will be aligned in the order supplied. + /// Items to the right of type will be aligned in the order supplied. + /// + /// \code{.yaml} + /// QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ] + /// \endcode + std::vector<std::string> QualifierOrder; + /// Different ways to break inheritance list. enum BreakInheritanceListStyle : unsigned char { /// Break inheritance list before the colon and after the commas. @@ -3496,6 +3561,8 @@ PenaltyBreakTemplateDeclaration == R.PenaltyBreakTemplateDeclaration && PointerAlignment == R.PointerAlignment && + QualifierAlignment == R.QualifierAlignment && + QualifierOrder == R.QualifierOrder && RawStringFormats == R.RawStringFormats && ReferenceAlignment == R.ReferenceAlignment && ShortNamespaceLines == R.ShortNamespaceLines && Index: clang/docs/tools/dump_format_style.py =================================================================== --- clang/docs/tools/dump_format_style.py +++ clang/docs/tools/dump_format_style.py @@ -117,6 +117,14 @@ endcode_match = re.match(r'^/// +\\endcode$', line) if endcode_match: return '' + + match = re.match(r'^/// \\warning$', line) + if match: + return '\n.. warning:: \n\n' + + endwarning_match = re.match(r'^/// +\\endwarning$', line) + if endwarning_match: + return '' return line[4:] + '\n' def read_options(header): Index: clang/docs/ReleaseNotes.rst =================================================================== --- clang/docs/ReleaseNotes.rst +++ clang/docs/ReleaseNotes.rst @@ -189,6 +189,16 @@ - Option ``AllowShortEnumsOnASingleLine: false`` has been improved, it now correctly places the opening brace according to ``BraceWrapping.AfterEnum``. +- Option ``QualifierAligment`` has been added in order to auto-arrange the + positioning of specifiers/qualifiers + `const` `volatile` `static` `inline` `constexpr` `restrict` + in variable and parameter declarations to be either ``Right`` aligned + or ``Left`` aligned or ``Custom`` using ``QualifierOrder``. + +- Option ``QualifierOrder`` has been added to allow the order + `const` `volatile` `static` `inline` `constexpr` `restrict` + to be controlled relative to the `type`. + libclang -------- Index: clang/docs/ClangFormatStyleOptions.rst =================================================================== --- clang/docs/ClangFormatStyleOptions.rst +++ clang/docs/ClangFormatStyleOptions.rst @@ -3225,6 +3225,78 @@ +**QualifierAlignment** (``QualifierAlignmentStyle``) + Different ways to arrange const/volatile qualifiers. + + .. warning:: + + ``QualifierAlignment`` COULD lead to incorrect code generation. + + Possible values: + + * ``QAS_Leave`` (in configuration: ``Leave``) + Don't change specifiers/qualifier to either Left or Right alignment + (default) + + .. code-block:: c++ + + int const a; + const int *a; + + * ``QAS_Left`` (in configuration: ``Left``) + Change specifiers/qualifiers to be Left aligned. + + .. code-block:: c++ + + const int a; + const int *a; + + * ``QAS_Right`` (in configuration: ``Right``) + Change specifiers/qualifiers to be Right aligned. + + .. code-block:: c++ + + int const a; + int const *a; + + * ``QAS_Custom`` (in configuration: ``Custom``) + Change specifiers/qualifiers to be aligned based on QualfierOrder. + With: + + .. code-block:: yaml + + QualifierOrder: ['inline', 'static' , '<type>', 'const'] + + + .. code-block:: c++ + + + int const a; + int const *a; + + + +**QualifierOrder** (``std::vector<std::string>``) + The Order in which the qualifiers appear. + Order is a an array can contain any of the following + + * const + * inline + * static + * constexpr + * volatile + * restrict + * type + + Note: it MUST contain 'type'. + Items to the left of type will be aligned in the order supplied. + Items to the right of type will be aligned in the order supplied. + + + .. code-block:: yaml + + QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ] + **RawStringFormats** (``std::vector<RawStringFormat>``) Defines hints for detecting supported languages code blocks in raw strings.
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
