HazardyKnusperkeks updated this revision to Diff 406048.
HazardyKnusperkeks marked an inline comment as done.
HazardyKnusperkeks edited the summary of this revision.
HazardyKnusperkeks added a comment.
This took a lot of work and debugging.
I tried to minimize the refactoring on related code (I've prepared quite a few
other commits and stashes...).
I'm confident that we can now format every sane use of requires clauses,
expressions, and concept declarations. And even some I wouldn't call sane.
Decided to drop https://llvm.org/PR32166 since in this approach the book
keeping to bring the indention back on track after the clause would be too much
burden on everyone not using it.
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D113319/new/
https://reviews.llvm.org/D113319
Files:
clang/docs/ClangFormatStyleOptions.rst
clang/docs/ReleaseNotes.rst
clang/include/clang/Format/Format.h
clang/lib/Format/ContinuationIndenter.cpp
clang/lib/Format/Format.cpp
clang/lib/Format/FormatToken.h
clang/lib/Format/TokenAnnotator.cpp
clang/lib/Format/UnwrappedLineParser.cpp
clang/lib/Format/UnwrappedLineParser.h
clang/unittests/Format/FormatTest.cpp
clang/unittests/Format/TokenAnnotatorTest.cpp
Index: clang/unittests/Format/TokenAnnotatorTest.cpp
===================================================================
--- clang/unittests/Format/TokenAnnotatorTest.cpp
+++ clang/unittests/Format/TokenAnnotatorTest.cpp
@@ -14,6 +14,14 @@
namespace clang {
namespace format {
+
+// Not really the equality, but everything we need.
+static bool operator==(const FormatToken &LHS,
+ const FormatToken &RHS) noexcept {
+ return LHS.Tok.getKind() == RHS.Tok.getKind() &&
+ LHS.getType() == RHS.getType();
+}
+
namespace {
class TokenAnnotatorTest : public ::testing::Test {
@@ -91,6 +99,261 @@
EXPECT_TOKEN(Tokens[2], tok::l_brace, TT_RecordLBrace);
}
+TEST_F(TokenAnnotatorTest, UnderstandsRequiresClausesAndConcepts) {
+ auto Tokens = annotate("template <typename T>\n"
+ "concept C = (Foo && Bar) && (Bar && Baz);");
+
+ ASSERT_EQ(Tokens.size(), 21u) << Tokens;
+ EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[13], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[16], tok::ampamp, TT_BinaryOperator);
+
+ Tokens = annotate("template <typename T>\n"
+ "concept C = requires(T t) {\n"
+ " { t.foo() };\n"
+ "} && Bar<T> && Baz<T>;");
+ ASSERT_EQ(Tokens.size(), 35u) << Tokens;
+ EXPECT_TOKEN(Tokens[23], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator);
+
+ Tokens = annotate("template<typename T>\n"
+ "requires C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>\n"
+ "struct Foo;");
+ ASSERT_EQ(Tokens.size(), 36u) << Tokens;
+ EXPECT_TOKEN(Tokens[6], tok::identifier, TT_Unknown);
+ EXPECT_EQ(Tokens[6]->FakeLParens.size(), 1u);
+ EXPECT_TOKEN(Tokens[10], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[16], tok::pipepipe, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[21], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[27], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[31], tok::greater, TT_TemplateCloser);
+ EXPECT_EQ(Tokens[31]->FakeRParens, 1u);
+ EXPECT_TRUE(Tokens[31]->ClosesRequiresClause);
+
+ Tokens =
+ annotate("template<typename T>\n"
+ "requires (C1<T> && (C21<T> || C22<T> && C2e<T>) && C3<T>)\n"
+ "struct Foo;");
+ ASSERT_EQ(Tokens.size(), 38u) << Tokens;
+ EXPECT_TOKEN(Tokens[7], tok::identifier, TT_Unknown);
+ EXPECT_EQ(Tokens[7]->FakeLParens.size(), 1u);
+ EXPECT_TOKEN(Tokens[11], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[17], tok::pipepipe, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[22], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[28], tok::ampamp, TT_BinaryOperator);
+ EXPECT_TOKEN(Tokens[32], tok::greater, TT_TemplateCloser);
+ EXPECT_EQ(Tokens[32]->FakeRParens, 1u);
+ EXPECT_TOKEN(Tokens[33], tok::r_paren, TT_Unknown);
+ EXPECT_TRUE(Tokens[33]->ClosesRequiresClause);
+}
+
+TEST_F(TokenAnnotatorTest, RequiresDoesNotChangeParsingOfTheRest) {
+ auto NumberOfAdditionalRequiresClauseTokens = 5u;
+ auto NumberOfTokensBeforeRequires = 5u;
+
+ auto BaseTokens = annotate("template<typename T>\n"
+ "T Pi = 3.14;");
+ auto ConstrainedTokens = annotate("template<typename T>\n"
+ " requires Foo<T>\n"
+ "T Pi = 3.14;");
+
+ auto NumberOfBaseTokens = 11u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+
+ BaseTokens = annotate("template<typename T>\n"
+ "struct Bar;");
+ ConstrainedTokens = annotate("template<typename T>\n"
+ " requires Foo<T>\n"
+ "struct Bar;");
+ NumberOfBaseTokens = 9u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+
+ BaseTokens = annotate("template<typename T>\n"
+ "struct Bar {"
+ " T foo();\n"
+ " T bar();\n"
+ "};");
+ ConstrainedTokens = annotate("template<typename T>\n"
+ " requires Foo<T>\n"
+ "struct Bar {"
+ " T foo();\n"
+ " T bar();\n"
+ "};");
+ NumberOfBaseTokens = 21u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+
+ BaseTokens = annotate("template<typename T>\n"
+ "Bar(T) -> Bar<T>;");
+ ConstrainedTokens = annotate("template<typename T>\n"
+ " requires Foo<T>\n"
+ "Bar(T) -> Bar<T>;");
+ NumberOfBaseTokens = 16u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+
+ BaseTokens = annotate("template<typename T>\n"
+ "T foo();");
+ ConstrainedTokens = annotate("template<typename T>\n"
+ " requires Foo<T>\n"
+ "T foo();");
+ NumberOfBaseTokens = 11u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+
+ BaseTokens = annotate("template<typename T>\n"
+ "T foo() {\n"
+ " auto bar = baz();\n"
+ " return bar + T{};\n"
+ "}");
+ ConstrainedTokens = annotate("template<typename T>\n"
+ " requires Foo<T>\n"
+ "T foo() {\n"
+ " auto bar = baz();\n"
+ " return bar + T{};\n"
+ "}");
+ NumberOfBaseTokens = 26u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+
+ BaseTokens = annotate("template<typename T>\n"
+ "T foo();");
+ ConstrainedTokens = annotate("template<typename T>\n"
+ "T foo() requires Foo<T>;");
+ NumberOfBaseTokens = 11u;
+ NumberOfTokensBeforeRequires = 9u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+
+ BaseTokens = annotate("template<typename T>\n"
+ "T foo() {\n"
+ " auto bar = baz();\n"
+ " return bar + T{};\n"
+ "}");
+ ConstrainedTokens = annotate("template<typename T>\n"
+ "T foo() requires Foo<T> {\n"
+ " auto bar = baz();\n"
+ " return bar + T{};\n"
+ "}");
+ NumberOfBaseTokens = 26u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+
+ BaseTokens = annotate("template<typename T>\n"
+ "Bar(T) -> Bar<typename T::I>;");
+ ConstrainedTokens = annotate("template<typename T>\n"
+ " requires requires(T &&t) {\n"
+ " typename T::I;\n"
+ " }\n"
+ "Bar(T) -> Bar<typename T::I>;");
+ NumberOfBaseTokens = 19u;
+ NumberOfAdditionalRequiresClauseTokens = 14u;
+ NumberOfTokensBeforeRequires = 5u;
+
+ ASSERT_EQ(BaseTokens.size(), NumberOfBaseTokens) << BaseTokens;
+ ASSERT_EQ(ConstrainedTokens.size(),
+ NumberOfBaseTokens + NumberOfAdditionalRequiresClauseTokens)
+ << ConstrainedTokens;
+
+ for (auto I = 0u; I < NumberOfBaseTokens; ++I)
+ if (I < NumberOfTokensBeforeRequires)
+ EXPECT_EQ(*BaseTokens[I], *ConstrainedTokens[I]) << I;
+ else
+ EXPECT_EQ(*BaseTokens[I],
+ *ConstrainedTokens[I + NumberOfAdditionalRequiresClauseTokens])
+ << I;
+}
+
} // namespace
} // namespace format
} // namespace clang
Index: clang/unittests/Format/FormatTest.cpp
===================================================================
--- clang/unittests/Format/FormatTest.cpp
+++ clang/unittests/Format/FormatTest.cpp
@@ -3816,7 +3816,10 @@
"struct b_struct {};\n"
"} // namespace B\n",
Style);
- verifyFormat("template <int I> constexpr void foo requires(I == 42) {}\n"
+ verifyFormat("template <int I>\n"
+ "constexpr void foo\n"
+ " requires(I == 42)\n"
+ "{}\n"
"namespace ns {\n"
"void foo() {}\n"
"} // namespace ns\n",
@@ -19187,7 +19190,6 @@
CHECK_PARSE_BOOL(BinPackArguments);
CHECK_PARSE_BOOL(BinPackParameters);
CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
- CHECK_PARSE_BOOL(BreakBeforeConceptDeclarations);
CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
CHECK_PARSE_BOOL(BreakStringLiterals);
CHECK_PARSE_BOOL(CompactNamespaces);
@@ -19199,7 +19201,8 @@
CHECK_PARSE_BOOL(IndentCaseLabels);
CHECK_PARSE_BOOL(IndentCaseBlocks);
CHECK_PARSE_BOOL(IndentGotoLabels);
- CHECK_PARSE_BOOL(IndentRequires);
+ CHECK_PARSE_BOOL_FIELD(IndentRequiresClause, "IndentRequires");
+ CHECK_PARSE_BOOL(IndentRequiresClause);
CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
@@ -19865,6 +19868,26 @@
// For backward compatibility:
CHECK_PARSE("SpacesInAngles: false", SpacesInAngles, FormatStyle::SIAS_Never);
CHECK_PARSE("SpacesInAngles: true", SpacesInAngles, FormatStyle::SIAS_Always);
+
+ CHECK_PARSE("RequiresClausePosition: ToPreceding",
+ RequiresClausePosition, FormatStyle::RCPS_ToPreceding);
+ CHECK_PARSE("RequiresClausePosition: ToFollowing",
+ RequiresClausePosition, FormatStyle::RCPS_ToFollowing);
+ CHECK_PARSE("RequiresClausePosition: SingleLine",
+ RequiresClausePosition, FormatStyle::RCPS_SingleLine);
+ CHECK_PARSE("RequiresClausePosition: OwnLine",
+ RequiresClausePosition, FormatStyle::RCPS_OwnLine);
+
+ CHECK_PARSE("BreakBeforeConceptDeclarations: Never",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Never);
+ CHECK_PARSE("BreakBeforeConceptDeclarations: Always",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
+ CHECK_PARSE("BreakBeforeConceptDeclarations: Allowed",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
+ CHECK_PARSE("BreakBeforeConceptDeclarations: true",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Always);
+ CHECK_PARSE("BreakBeforeConceptDeclarations: false",
+ BreakBeforeConceptDeclarations, FormatStyle::BBCDS_Allowed);
}
TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
@@ -23133,275 +23156,585 @@
Style);
}
-TEST_F(FormatTest, ConceptsAndRequires) {
- FormatStyle Style = getLLVMStyle();
- Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
+TEST_F(FormatTest, Concepts) {
+ EXPECT_EQ(getLLVMStyle().BreakBeforeConceptDeclarations,
+ FormatStyle::BBCDS_Always);
+ verifyFormat("template <typename T>\n"
+ "concept True = true;");
verifyFormat("template <typename T>\n"
- "concept Hashable = requires(T a) {\n"
- " { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
- "};",
- Style);
+ "concept C = ((false || foo()) && C2<T>) ||\n"
+ " (std::trait<T>::value && Baz) || sizeof(T) >= 6;",
+ getLLVMStyleWithColumns(60));
+
verifyFormat("template <typename T>\n"
- "concept EqualityComparable = requires(T a, T b) {\n"
- " { a == b } -> bool;\n"
- "};",
- Style);
+ "concept DelayedCheck = true && requires(T t) { t.bar(); } && "
+ "sizeof(T) <= 8;");
+
verifyFormat("template <typename T>\n"
- "concept EqualityComparable = requires(T a, T b) {\n"
- " { a == b } -> bool;\n"
- " { a != b } -> bool;\n"
- "};",
- Style);
+ "concept DelayedCheck = true && requires(T t) {\n"
+ " t.bar();\n"
+ " t.baz();\n"
+ " } && sizeof(T) <= 8;");
+
verifyFormat("template <typename T>\n"
- "concept EqualityComparable = requires(T a, T b) {\n"
- " { a == b } -> bool;\n"
- " { a != b } -> bool;\n"
- "};",
- Style);
+ "concept DelayedCheck = true && requires(T t) { // Comment\n"
+ " t.bar();\n"
+ " t.baz();\n"
+ " } && sizeof(T) <= 8;");
- verifyFormat("template <typename It>\n"
- "requires Iterator<It>\n"
- "void sort(It begin, It end) {\n"
- " //....\n"
- "}",
- Style);
+ verifyFormat("template <typename T>\n"
+ "concept DelayedCheck = false || requires(T t) { t.bar(); } && "
+ "sizeof(T) <= 8;");
verifyFormat("template <typename T>\n"
- "concept Large = sizeof(T) > 10;",
- Style);
+ "concept DelayedCheck = !!false || requires(T t) { t.bar(); } "
+ "&& sizeof(T) <= 8;");
+
+ verifyFormat(
+ "template <typename T>\n"
+ "concept DelayedCheck = static_cast<bool>(0) ||\n"
+ " requires(T t) { t.bar(); } && sizeof(T) <= 8;");
- verifyFormat("template <typename T, typename U>\n"
- "concept FooableWith = requires(T t, U u) {\n"
- " typename T::foo_type;\n"
- " { t.foo(u) } -> typename T::foo_type;\n"
- " t++;\n"
- "};\n"
- "void doFoo(FooableWith<int> auto t) {\n"
- " t.foo(3);\n"
- "}",
- Style);
verifyFormat("template <typename T>\n"
- "concept Context = sizeof(T) == 1;",
- Style);
+ "concept DelayedCheck = bool(0) || requires(T t) { t.bar(); } "
+ "&& sizeof(T) <= 8;");
+
+ verifyFormat(
+ "template <typename T>\n"
+ "concept DelayedCheck = (bool)(0) ||\n"
+ " requires(T t) { t.bar(); } && sizeof(T) <= 8;");
+
verifyFormat("template <typename T>\n"
- "concept Context = is_specialization_of_v<context, T>;",
- Style);
+ "concept DelayedCheck = (bool)0 || requires(T t) { t.bar(); } "
+ "&& sizeof(T) <= 8;");
+
verifyFormat("template <typename T>\n"
- "concept Node = std::is_object_v<T>;",
- Style);
+ "concept Size = sizeof(T) >= 5 && requires(T t) { t.bar(); } && "
+ "sizeof(T) <= 8;");
+
verifyFormat("template <typename T>\n"
- "concept Tree = true;",
- Style);
+ "concept Size = 2 < 5 && 2 <= 5 && 8 >= 5 && 8 > 5 &&\n"
+ " requires(T t) {\n"
+ " t.bar();\n"
+ " t.baz();\n"
+ " } && sizeof(T) <= 8 && !(4 < 3);",
+ getLLVMStyleWithColumns(60));
- verifyFormat("template <typename T> int g(T i) requires Concept1<I> {\n"
- " //...\n"
- "}",
- Style);
+ verifyFormat("template <typename T>\n"
+ "concept TrueOrNot = IsAlwaysTrue || IsNeverTrue;");
+
+ verifyFormat("template <typename T>\n"
+ "concept C = foo();");
+
+ verifyFormat("template <typename T>\n"
+ "concept C = foo(T());");
+
+ verifyFormat("template <typename T>\n"
+ "concept C = foo(T{});");
+
+ verifyFormat("template <typename T>\n"
+ "concept Size = V<sizeof(T)>::Value > 5;");
+
+ verifyFormat("template <typename T>\n"
+ "concept True = S<T>::Value;");
verifyFormat(
- "template <typename T> int g(T i) requires Concept1<I> && Concept2<I> {\n"
- " //...\n"
- "}",
- Style);
+ "template <typename T>\n"
+ "concept C = []() { return true; }() && requires(T t) { t.bar(); } &&\n"
+ " sizeof(T) <= 8;");
+
+ // FIXME This is misformatted because the fake l paren starts at bool, not at
+ // the lambda l square.
+ verifyFormat("template <typename T>\n"
+ "concept C = [] -> bool { return true; }() && requires(T t) { "
+ "t.bar(); } &&\n"
+ " sizeof(T) <= 8;");
verifyFormat(
- "template <typename T> int g(T i) requires Concept1<I> || Concept2<I> {\n"
- " //...\n"
- "}",
- Style);
+ "template <typename T>\n"
+ "concept C = decltype([]() { return std::true_type{}; }())::value &&\n"
+ " requires(T t) { t.bar(); } && sizeof(T) <= 8;");
verifyFormat("template <typename T>\n"
- "veryveryvery_long_return_type g(T i) requires Concept1<I> || "
- "Concept2<I> {\n"
- " //...\n"
- "}",
- Style);
+ "concept C = decltype([]() { return std::true_type{}; "
+ "}())::value && requires(T t) { t.bar(); } && sizeof(T) <= 8;",
+ getLLVMStyleWithColumns(120));
verifyFormat("template <typename T>\n"
- "veryveryvery_long_return_type g(T i) requires Concept1<I> && "
- "Concept2<I> {\n"
- " //...\n"
- "}",
- Style);
+ "concept C = decltype([]() -> std::true_type { return {}; "
+ "}())::value &&\n"
+ " requires(T t) { t.bar(); } && sizeof(T) <= 8;");
+
+ verifyFormat("template <typename T>\n"
+ "concept C = true;\n"
+ "Foo Bar;");
+
+ verifyFormat("template <typename T>\n"
+ "concept Hashable = requires(T a) {\n"
+ " { std::hash<T>{}(a) } -> "
+ "std::convertible_to<std::size_t>;\n"
+ " };");
verifyFormat(
"template <typename T>\n"
- "veryveryvery_long_return_type g(T i) requires Concept1 && Concept2 {\n"
- " //...\n"
- "}",
- Style);
+ "concept EqualityComparable = requires(T a, T b) {\n"
+ " { a == b } -> std::same_as<bool>;\n"
+ " };");
verifyFormat(
"template <typename T>\n"
- "veryveryvery_long_return_type g(T i) requires Concept1 || Concept2 {\n"
- " //...\n"
- "}",
+ "concept EqualityComparable = requires(T a, T b) {\n"
+ " { a == b } -> std::same_as<bool>;\n"
+ " { a != b } -> std::same_as<bool>;\n"
+ " };");
+
+ verifyFormat("template <typename T>\n"
+ "concept WeakEqualityComparable = requires(T a, T b) {\n"
+ " { a == b };\n"
+ " { a != b };\n"
+ " };");
+
+ verifyFormat("template <typename T>\n"
+ "concept HasSizeT = requires { typename T::size_t; };");
+
+ verifyFormat("template <typename T>\n"
+ "concept Semiregular =\n"
+ " DefaultConstructible<T> && CopyConstructible<T> && "
+ "CopyAssignable<T> &&\n"
+ " requires(T a, std::size_t n) {\n"
+ " requires Same<T *, decltype(&a)>;\n"
+ " { a.~T() } noexcept;\n"
+ " requires Same<T *, decltype(new T)>;\n"
+ " requires Same<T *, decltype(new T[n])>;\n"
+ " { delete new T; };\n"
+ " { delete new T[n]; };\n"
+ " };");
+
+ verifyFormat("template <typename T>\n"
+ "concept Semiregular =\n"
+ " requires(T a, std::size_t n) {\n"
+ " requires Same<T *, decltype(&a)>;\n"
+ " { a.~T() } noexcept;\n"
+ " requires Same<T *, decltype(new T)>;\n"
+ " requires Same<T *, decltype(new T[n])>;\n"
+ " { delete new T; };\n"
+ " { delete new T[n]; };\n"
+ " { new T } -> std::same_as<T *>;\n"
+ " } && DefaultConstructible<T> && CopyConstructible<T> && "
+ "CopyAssignable<T>;");
+
+ verifyFormat(
+ "template <typename T>\n"
+ "concept Semiregular =\n"
+ " DefaultConstructible<T> && requires(T a, std::size_t n) {\n"
+ " requires Same<T *, decltype(&a)>;\n"
+ " { a.~T() } noexcept;\n"
+ " requires Same<T *, decltype(new T)>;\n"
+ " requires Same<T *, decltype(new "
+ "T[n])>;\n"
+ " { delete new T; };\n"
+ " { delete new T[n]; };\n"
+ " } && CopyConstructible<T> && "
+ "CopyAssignable<T>;");
+
+ verifyFormat("template <typename T>\n"
+ "concept Two = requires(T t) {\n"
+ " { t.foo() } -> std::same_as<Bar>;\n"
+ " } && requires(T &&t) {\n"
+ " { t.foo() } -> std::same_as<Bar &&>;\n"
+ " };");
+
+ verifyFormat(
+ "template <typename T>\n"
+ "concept C = requires(T x) {\n"
+ " { *x } -> std::convertible_to<typename T::inner>;\n"
+ " { x + 1 } noexcept -> std::same_as<int>;\n"
+ " { x * 1 } -> std::convertible_to<T>;\n"
+ " };");
+
+ verifyFormat(
+ "template <typename T, typename U = T>\n"
+ "concept Swappable = requires(T &&t, U &&u) {\n"
+ " swap(std::forward<T>(t), std::forward<U>(u));\n"
+ " swap(std::forward<U>(u), std::forward<T>(t));\n"
+ " };");
+
+ verifyFormat("template <typename T, typename U>\n"
+ "concept Common = requires(T &&t, U &&u) {\n"
+ " typename CommonType<T, U>;\n"
+ " { CommonType<T, U>(std::forward<T>(t)) };\n"
+ " };");
+
+ verifyFormat("template <typename T, typename U>\n"
+ "concept Common = requires(T &&t, U &&u) {\n"
+ " typename CommonType<T, U>;\n"
+ " { CommonType<T, U>{std::forward<T>(t)} };\n"
+ " };");
+
+ verifyFormat(
+ "template <typename T>\n"
+ "concept C = requires(T t) {\n"
+ " requires Bar<T> && Foo<T>;\n"
+ " requires((trait<T> && Baz) || (T2<T> && Foo<T>));\n"
+ " };");
+
+ verifyFormat("template <typename T>\n"
+ "concept HasFoo = requires(T t) {\n"
+ " { t.foo() };\n"
+ " t.foo();\n"
+ " };\n"
+ "template <typename T>\n"
+ "concept HasBar = requires(T t) {\n"
+ " { t.bar() };\n"
+ " t.bar();\n"
+ " };");
+
+ verifyFormat("template <typename T>\n"
+ "concept Large = sizeof(T) > 10;");
+
+ verifyFormat("template <typename T, typename U>\n"
+ "concept FooableWith = requires(T t, U u) {\n"
+ " typename T::foo_type;\n"
+ " { t.foo(u) } -> typename T::foo_type;\n"
+ " t++;\n"
+ " };\n"
+ "void doFoo(FooableWith<int> auto t) { t.foo(3); }");
+
+ verifyFormat("template <typename T>\n"
+ "concept Context = is_specialization_of_v<context, T>;");
+
+ verifyFormat("template <typename T>\n"
+ "concept Node = std::is_object_v<T>;");
+
+ auto Style = getLLVMStyle();
+ Style.BreakBeforeConceptDeclarations = FormatStyle::BBCDS_Allowed;
+
+ verifyFormat(
+ "template <typename T>\n"
+ "concept C = requires(T t) {\n"
+ " requires Bar<T> && Foo<T>;\n"
+ " requires((trait<T> && Baz) || (T2<T> && Foo<T>));\n"
+ " };",
Style);
- verifyFormat("template <typename It>\n"
- "requires Foo<It>() && Bar<It> {\n"
- " //....\n"
- "}",
+ verifyFormat("template <typename T>\n"
+ "concept HasFoo = requires(T t) {\n"
+ " { t.foo() };\n"
+ " t.foo();\n"
+ " };\n"
+ "template <typename T>\n"
+ "concept HasBar = requires(T t) {\n"
+ " { t.bar() };\n"
+ " t.bar();\n"
+ " };",
Style);
- verifyFormat("template <typename It>\n"
- "requires Foo<Bar<It>>() && Bar<Foo<It, It>> {\n"
- " //....\n"
- "}",
+ verifyFormat("template <typename T> concept True = true;", Style);
+
+ verifyFormat("template <typename T>\n"
+ "concept C = decltype([]() -> std::true_type { return {}; "
+ "}())::value &&\n"
+ " requires(T t) { t.bar(); } && sizeof(T) <= 8;",
Style);
- verifyFormat("template <typename It>\n"
- "requires Foo<Bar<It, It>>() && Bar<Foo<It, It>> {\n"
- " //....\n"
- "}",
+ verifyFormat("template <typename T>\n"
+ "concept Semiregular =\n"
+ " DefaultConstructible<T> && CopyConstructible<T> && "
+ "CopyAssignable<T> &&\n"
+ " requires(T a, std::size_t n) {\n"
+ " requires Same<T *, decltype(&a)>;\n"
+ " { a.~T() } noexcept;\n"
+ " requires Same<T *, decltype(new T)>;\n"
+ " requires Same<T *, decltype(new T[n])>;\n"
+ " { delete new T; };\n"
+ " { delete new T[n]; };\n"
+ " };",
Style);
+ Style.BreakBeforeConceptDeclarations = FormatStyle::BBCDS_Never;
+
verifyFormat(
- "template <typename It>\n"
- "requires Foo<Bar<It>, Baz<It>>() && Bar<Foo<It>, Baz<It, It>> {\n"
- " //....\n"
- "}",
+ "template <typename T> concept C =\n"
+ " requires(T t) {\n"
+ " requires Bar<T> && Foo<T>;\n"
+ " requires((trait<T> && Baz) || (T2<T> && Foo<T>));\n"
+ " };",
Style);
- Style.IndentRequires = true;
- verifyFormat("template <typename It>\n"
- " requires Iterator<It>\n"
- "void sort(It begin, It end) {\n"
- " //....\n"
- "}",
+ verifyFormat("template <typename T> concept HasFoo = requires(T t) {\n"
+ " { t.foo() };\n"
+ " t.foo();\n"
+ " };\n"
+ "template <typename T> concept HasBar = requires(T t) {\n"
+ " { t.bar() };\n"
+ " t.bar();\n"
+ " };",
Style);
- verifyFormat("template <std::size index_>\n"
- " requires(index_ < sizeof...(Children_))\n"
- "Tree auto &child() {\n"
- " // ...\n"
- "}",
+
+ verifyFormat("template <typename T> concept True = true;", Style);
+
+ verifyFormat(
+ "template <typename T> concept C = decltype([]() -> std::true_type {\n"
+ " return {};\n"
+ " }())::value\n"
+ " && requires(T t) { t.bar(); } &&\n"
+ " sizeof(T) <= 8;",
+ Style);
+
+ verifyFormat("template <typename T> concept Semiregular =\n"
+ " DefaultConstructible<T> && CopyConstructible<T> && "
+ "CopyAssignable<T> &&\n"
+ " requires(T a, std::size_t n) {\n"
+ " requires Same<T *, decltype(&a)>;\n"
+ " { a.~T() } noexcept;\n"
+ " requires Same<T *, decltype(new T)>;\n"
+ " requires Same<T *, decltype(new T[n])>;\n"
+ " { delete new T; };\n"
+ " { delete new T[n]; };\n"
+ " };",
+ Style);
+
+ // The following tests are invalid C++, we just want to make sure we don't
+ // assert.
+ verifyFormat("template <typename T>\n"
+ "concept C = requires C2<T>;");
+
+ verifyFormat("template <typename T>\n"
+ "concept C = 5 + 4;");
+
+ verifyFormat("template <typename T>\n"
+ "concept C =\n"
+ "class X;");
+
+ verifyFormat("template <typename T>\n"
+ "concept C = [] && true;");
+
+ verifyFormat("template <typename T>\n"
+ "concept C = [] && requires(T t) { typename T::size_type; };");
+}
+
+TEST_F(FormatTest, RequiresClauses) {
+ auto Style = getLLVMStyle();
+ EXPECT_EQ(Style.RequiresClausePosition, FormatStyle::RCPS_OwnLine);
+ EXPECT_EQ(Style.IndentRequiresClause, true);
+
+ verifyFormat("template <typename T>\n"
+ " requires(Foo<T> && std::trait<T>)\n"
+ "struct Bar;",
Style);
- Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
verifyFormat("template <typename T>\n"
- "concept Hashable = requires (T a) {\n"
- " { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
+ " requires(Foo<T> && std::trait<T>)\n"
+ "class Bar {\n"
+ "public:\n"
+ " Bar(T t);\n"
+ " bool baz();\n"
"};",
Style);
- verifyFormat("template <class T = void>\n"
- " requires EqualityComparable<T> || Same<T, void>\n"
- "struct equal_to;",
- Style);
+ verifyFormat(
+ "template <typename T>\n"
+ " requires requires(T &&t) {\n"
+ " typename T::I;\n"
+ " requires(F<typename T::I> && std::trait<typename T::I>);\n"
+ " }\n"
+ "Bar(T) -> Bar<typename T::I>;",
+ Style);
- verifyFormat("template <class T>\n"
- " requires requires {\n"
- " T{};\n"
- " T (int);\n"
- " }\n",
+ verifyFormat("template <typename T>\n"
+ " requires(Foo<T> && std::trait<T>)\n"
+ "constexpr T MyGlobal;",
Style);
- Style.ColumnLimit = 78;
verifyFormat("template <typename T>\n"
- "concept Context = Traits<typename T::traits_type> and\n"
- " Interface<typename T::interface_type> and\n"
- " Request<typename T::request_type> and\n"
- " Response<typename T::response_type> and\n"
- " ContextExtension<typename T::extension_type> and\n"
- " ::std::is_copy_constructable<T> and "
- "::std::is_move_constructable<T> and\n"
- " requires (T c) {\n"
- " { c.response; } -> Response;\n"
- "} and requires (T c) {\n"
- " { c.request; } -> Request;\n"
- "}\n",
+ " requires Foo<T> && requires(T t) {\n"
+ " { t.baz() } -> std::same_as<bool>;\n"
+ " requires std::same_as<T::Factor, int>;\n"
+ " }\n"
+ "inline int bar(T t) {\n"
+ " return t.baz() ? T::Factor : 5;\n"
+ "}",
Style);
verifyFormat("template <typename T>\n"
- "concept Context = Traits<typename T::traits_type> or\n"
- " Interface<typename T::interface_type> or\n"
- " Request<typename T::request_type> or\n"
- " Response<typename T::response_type> or\n"
- " ContextExtension<typename T::extension_type> or\n"
- " ::std::is_copy_constructable<T> or "
- "::std::is_move_constructable<T> or\n"
- " requires (T c) {\n"
- " { c.response; } -> Response;\n"
- "} or requires (T c) {\n"
- " { c.request; } -> Request;\n"
- "}\n",
+ "inline int bar(T t)\n"
+ " requires Foo<T> && requires(T t) {\n"
+ " { t.baz() } -> std::same_as<bool>;\n"
+ " requires std::same_as<T::Factor, int>;\n"
+ " }\n"
+ "{\n"
+ " return t.baz() ? T::Factor : 5;\n"
+ "}",
Style);
verifyFormat("template <typename T>\n"
- "concept Context = Traits<typename T::traits_type> &&\n"
- " Interface<typename T::interface_type> &&\n"
- " Request<typename T::request_type> &&\n"
- " Response<typename T::response_type> &&\n"
- " ContextExtension<typename T::extension_type> &&\n"
- " ::std::is_copy_constructable<T> && "
- "::std::is_move_constructable<T> &&\n"
- " requires (T c) {\n"
- " { c.response; } -> Response;\n"
- "} && requires (T c) {\n"
- " { c.request; } -> Request;\n"
- "}\n",
+ " requires F<T>\n"
+ "int bar(T t) {\n"
+ " return 5;\n"
+ "}",
Style);
- verifyFormat("template <typename T>\nconcept someConcept = Constraint1<T> && "
- "Constraint2<T>;");
-
- Style.BreakBeforeBraces = FormatStyle::BS_Custom;
- Style.BraceWrapping.AfterFunction = true;
- Style.BraceWrapping.AfterClass = true;
- Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
- Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
- verifyFormat("void Foo () requires (std::copyable<T>)\n"
+ verifyFormat("template <typename T>\n"
+ "int bar(T t)\n"
+ " requires F<T>\n"
"{\n"
- " return\n"
- "}\n",
+ " return 5;\n"
+ "}",
Style);
- verifyFormat("void Foo () requires std::copyable<T>\n"
- "{\n"
- " return\n"
- "}\n",
+ Style.IndentRequiresClause = false;
+ verifyFormat("template <typename T>\n"
+ "requires F<T>\n"
+ "int bar(T t) {\n"
+ " return 5;\n"
+ "}",
Style);
- verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
- " requires (std::invocable<F, std::invoke_result_t<Args>...>)\n"
- "struct constant;",
+ verifyFormat("template <typename T>\n"
+ "int bar(T t)\n"
+ "requires F<T>\n"
+ "{\n"
+ " return 5;\n"
+ "}",
Style);
- verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
- " requires std::invocable<F, std::invoke_result_t<Args>...>\n"
- "struct constant;",
+ Style.RequiresClausePosition = FormatStyle::RCPS_SingleLine;
+ verifyFormat("template <typename T> requires Foo<T> struct Bar {};\n"
+ "template <typename T> requires Foo<T> void bar() {}\n"
+ "template <typename T> void bar() requires Foo<T> {}\n"
+ "template <typename T> requires Foo<T> Bar(T) -> Bar<T>;",
Style);
- verifyFormat("template <class T>\n"
- "class plane_with_very_very_very_long_name\n"
- "{\n"
- " constexpr plane_with_very_very_very_long_name () requires "
- "std::copyable<T>\n"
- " : plane_with_very_very_very_long_name (1)\n"
- " {\n"
- " }\n"
- "}\n",
- Style);
+ auto ColumnStyle = Style;
+ ColumnStyle.ColumnLimit = 40;
+ verifyFormat("template <typename AAAAAAA>\n"
+ "requires Foo<T> struct Bar {};\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<T> void bar() {}\n"
+ "template <typename AAAAAAA>\n"
+ "void bar() requires Foo<T> {}\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<T> Baz(T) -> Baz<T>;",
+ ColumnStyle);
- verifyFormat("template <class T>\n"
- "class plane_with_long_name\n"
- "{\n"
- " constexpr plane_with_long_name () requires std::copyable<T>\n"
- " : plane_with_long_name (1)\n"
- " {\n"
- " }\n"
- "}\n",
+ verifyFormat("template <typename T>\n"
+ "requires Foo<AAAAAAA> struct Bar {};\n"
+ "template <typename T>\n"
+ "requires Foo<AAAAAAA> void bar() {}\n"
+ "template <typename T>\n"
+ "void bar() requires Foo<AAAAAAA> {}\n"
+ "template <typename T>\n"
+ "requires Foo<AAAAAAA> Bar(T) -> Bar<T>;",
+ ColumnStyle);
+
+ verifyFormat("template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "struct Bar {};\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "void bar() {}\n"
+ "template <typename AAAAAAA>\n"
+ "void bar()\n"
+ " requires Foo<AAAAAAAAAAAAAAAA> {}\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAA> Bar(T) -> Bar<T>;\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "Bar(T) -> Bar<T>;",
+ ColumnStyle);
+
+ Style.RequiresClausePosition = FormatStyle::RCPS_ToFollowing;
+ ColumnStyle.RequiresClausePosition = FormatStyle::RCPS_ToFollowing;
+
+ verifyFormat("template <typename T>\n"
+ "requires Foo<T> struct Bar {};\n"
+ "template <typename T>\n"
+ "requires Foo<T> void bar() {}\n"
+ "template <typename T>\n"
+ "void bar()\n"
+ "requires Foo<T> {}\n"
+ "template <typename T>\n"
+ "requires Foo<T> Bar(T) -> Bar<T>;",
Style);
- Style.BreakBeforeConceptDeclarations = false;
- verifyFormat("template <typename T> concept Tree = true;", Style);
+ verifyFormat("template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "struct Bar {};\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "void bar() {}\n"
+ "template <typename AAAAAAA>\n"
+ "void bar()\n"
+ "requires Foo<AAAAAAAAAAAAAAAA> {}\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAA> Bar(T) -> Bar<T>;\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "Bar(T) -> Bar<T>;",
+ ColumnStyle);
- Style.IndentRequires = false;
- verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
- "requires (std::invocable<F, std::invoke_result_t<Args>...>) "
- "struct constant;",
+ Style.IndentRequiresClause = true;
+ ColumnStyle.IndentRequiresClause = true;
+
+ verifyFormat("template <typename T>\n"
+ " requires Foo<T> struct Bar {};\n"
+ "template <typename T>\n"
+ " requires Foo<T> void bar() {}\n"
+ "template <typename T>\n"
+ "void bar()\n"
+ " requires Foo<T> {}\n"
+ "template <typename T>\n"
+ " requires Foo<T> Bar(T) -> Bar<T>;",
Style);
+
+ verifyFormat("template <typename AAAAAAA>\n"
+ " requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "struct Bar {};\n"
+ "template <typename AAAAAAA>\n"
+ " requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "void bar() {}\n"
+ "template <typename AAAAAAA>\n"
+ "void bar()\n"
+ " requires Foo<AAAAAAAAAAAAAAAA> {}\n"
+ "template <typename AAAAAAA>\n"
+ " requires Foo<AAAAAA> Bar(T) -> Bar<T>;\n"
+ "template <typename AAAAAAA>\n"
+ " requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "Bar(T) -> Bar<T>;",
+ ColumnStyle);
+
+ Style.RequiresClausePosition = FormatStyle::RCPS_ToPreceding;
+ ColumnStyle.RequiresClausePosition = FormatStyle::RCPS_ToPreceding;
+
+ verifyFormat("template <typename T> requires Foo<T>\n"
+ "struct Bar {};\n"
+ "template <typename T> requires Foo<T>\n"
+ "void bar() {}\n"
+ "template <typename T>\n"
+ "void bar() requires Foo<T>\n"
+ "{}\n"
+ "template <typename T> requires Foo<T>\n"
+ "Bar(T) -> Bar<T>;",
+ Style);
+
+ verifyFormat("template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "struct Bar {};\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "void bar() {}\n"
+ "template <typename AAAAAAA>\n"
+ "void bar()\n"
+ " requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "{}\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAA>\n"
+ "Bar(T) -> Bar<T>;\n"
+ "template <typename AAAAAAA>\n"
+ "requires Foo<AAAAAAAAAAAAAAAA>\n"
+ "Bar(T) -> Bar<T>;",
+ ColumnStyle);
}
TEST_F(FormatTest, StatementAttributeLikeMacros) {
Index: clang/lib/Format/UnwrappedLineParser.h
===================================================================
--- clang/lib/Format/UnwrappedLineParser.h
+++ clang/lib/Format/UnwrappedLineParser.h
@@ -92,11 +92,16 @@
void reset();
void parseFile();
bool precededByCommentOrPPDirective() const;
- bool parseLevel(bool HasOpeningBrace, IfStmtKind *IfKind = nullptr);
+ bool parseLevel(bool HasOpeningBrace, bool CanContainBracedList,
+ IfStmtKind *IfKind = nullptr,
+ TokenType NextLBracesType = TT_Unknown);
IfStmtKind parseBlock(bool MustBeDeclaration = false, unsigned AddLevels = 1u,
bool MunchSemi = true,
- bool UnindentWhitesmithsBraces = false);
- void parseChildBlock();
+ bool UnindentWhitesmithsBraces = false,
+ bool CanContainBracedList = true,
+ TokenType NextLBracesType = TT_Unknown);
+ void parseChildBlock(bool CanContainBracedList = true,
+ TokenType NextLBracesType = TT_Unknown);
void parsePPDirective();
void parsePPDefine();
void parsePPIf(bool IfDef);
@@ -106,11 +111,12 @@
void parsePPUnknown();
void readTokenWithJavaScriptASI();
void parseStructuralElement(IfStmtKind *IfKind = nullptr,
- bool IsTopLevel = false);
+ bool IsTopLevel = false,
+ TokenType NextLBracesType = TT_Unknown);
bool tryToParseBracedList();
bool parseBracedList(bool ContinueOnSemicolons = false, bool IsEnum = false,
tok::TokenKind ClosingBraceKind = tok::r_brace);
- void parseParens();
+ void parseParens(TokenType AmpAmpTokenType = TT_Unknown);
void parseSquare(bool LambdaIntroducer = false);
void keepAncestorBraces();
FormatToken *parseIfThenElse(IfStmtKind *IfKind, bool KeepBraces = false);
@@ -127,9 +133,9 @@
bool parseEnum();
bool parseStructLike();
void parseConcept();
- void parseRequires();
- void parseRequiresExpression(unsigned int OriginalLevel);
- void parseConstraintExpression(unsigned int OriginalLevel);
+ void parseRequiresClause();
+ void parseRequiresExpression();
+ void parseConstraintExpression();
void parseJavaEnumBody();
// Parses a record (aka class) as a top level element. If ParseAsExpr is true,
// parses the record as a child block, i.e. if the class declaration is an
Index: clang/lib/Format/UnwrappedLineParser.cpp
===================================================================
--- clang/lib/Format/UnwrappedLineParser.cpp
+++ clang/lib/Format/UnwrappedLineParser.cpp
@@ -369,7 +369,7 @@
if (Style.Language == FormatStyle::LK_TextProto)
parseBracedList();
else
- parseLevel(/*HasOpeningBrace=*/false);
+ parseLevel(/*HasOpeningBrace=*/false, /*CanContainBracedList=*/true);
// Make sure to format the remaining tokens.
//
// LK_TextProto is special since its top-level is parsed as the body of a
@@ -436,10 +436,20 @@
return Previous && Previous->is(tok::comment) &&
(Previous->IsMultiline || Previous->NewlinesBefore > 0);
}
-
-// Returns true if a simple block, or false otherwise. (A simple block has a
-// single statement.)
-bool UnwrappedLineParser::parseLevel(bool HasOpeningBrace, IfStmtKind *IfKind) {
+/// \brief Parses a level, that is ???.
+/// \param HasOpeningBrace If that level is started by an opening brace.
+/// \param CanContainBracedList If the content can contain (at any level) a
+/// braced list.
+/// \param NextLBracesType The type for left brace found in this level.
+/// \returns true if a simple block, or false otherwise. (A simple block has a
+/// single statement.)
+bool UnwrappedLineParser::parseLevel(bool HasOpeningBrace,
+ bool CanContainBracedList,
+ IfStmtKind *IfKind,
+ TokenType NextLBracesType) {
+ auto NextLevelLBracesType = NextLBracesType == TT_CompoundRequirementLBrace
+ ? TT_BracedListLBrace
+ : TT_Unknown;
const bool IsPrecededByCommentOrPPDirective =
!Style.RemoveBracesLLVM || precededByCommentOrPPDirective();
unsigned StatementCount = 0;
@@ -451,17 +461,36 @@
else if (FormatTok->getType() == TT_MacroBlockEnd)
kind = tok::r_brace;
+ auto ParseDefault = [this, HasOpeningBrace, IfKind, NextLevelLBracesType,
+ &StatementCount] {
+ parseStructuralElement(IfKind, /*IsTopLevel=*/!HasOpeningBrace,
+ /*NextLBracesType=*/NextLevelLBracesType);
+ ++StatementCount;
+ assert(StatementCount > 0 && "StatementCount overflow!");
+ };
+
switch (kind) {
case tok::comment:
nextToken();
addUnwrappedLine();
break;
case tok::l_brace:
- // FIXME: Add parameter whether this can happen - if this happens, we must
- // be in a non-declaration context.
- if (!FormatTok->is(TT_MacroBlockBegin) && tryToParseBracedList())
+ if (NextLBracesType != TT_Unknown)
+ FormatTok->setType(NextLBracesType);
+ else if (FormatTok->Previous &&
+ FormatTok->Previous->ClosesRequiresClause) {
+ // We need the 'default' case here to correctly parse a function
+ // l_brace.
+ ParseDefault();
continue;
- parseBlock();
+ }
+ if (CanContainBracedList && !FormatTok->is(TT_MacroBlockBegin) &&
+ tryToParseBracedList())
+ continue;
+ parseBlock(/*MustBeDeclaration=*/false, /*AddLevels=*/1u,
+ /*MunchSemi=*/true, /*UnindentWhitesmithBraces=*/false,
+ CanContainBracedList,
+ /*NextLBracesType=*/NextLBracesType);
++StatementCount;
assert(StatementCount > 0 && "StatementCount overflow!");
addUnwrappedLine();
@@ -517,9 +546,7 @@
}
LLVM_FALLTHROUGH;
default:
- parseStructuralElement(IfKind, !HasOpeningBrace);
- ++StatementCount;
- assert(StatementCount > 0 && "StatementCount overflow!");
+ ParseDefault();
break;
}
} while (!eof());
@@ -594,27 +621,46 @@
bool NextIsObjCMethod = NextTok->isOneOf(tok::plus, tok::minus) &&
NextTok->OriginalColumn == 0;
+ // Try to detect a braced list. Note that regardless how we mark inner
+ // braces here, we will overwrite the BlockKind later if we parse a
+ // braced list (where all blocks inside are by default braced lists),
+ // or when we explicitly detect blocks (for example while parsing
+ // lambdas).
+
+ // If we already marked the opening brace as braced list, the closing
+ // must also be part of it.
+ ProbablyBracedList = LBraceStack.back()->is(TT_BracedListLBrace);
+
+ ProbablyBracedList = ProbablyBracedList ||
+ (Style.isJavaScript() &&
+ NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in,
+ Keywords.kw_as));
+ ProbablyBracedList = ProbablyBracedList ||
+ (Style.isCpp() && NextTok->is(tok::l_paren));
+
// If there is a comma, semicolon or right paren after the closing
- // brace, we assume this is a braced initializer list. Note that
- // regardless how we mark inner braces here, we will overwrite the
- // BlockKind later if we parse a braced list (where all blocks
- // inside are by default braced lists), or when we explicitly detect
- // blocks (for example while parsing lambdas).
+ // brace, we assume this is a braced initializer list.
// FIXME: Some of these do not apply to JS, e.g. "} {" can never be a
// braced list in JS.
ProbablyBracedList =
- (Style.isJavaScript() &&
- NextTok->isOneOf(Keywords.kw_of, Keywords.kw_in,
- Keywords.kw_as)) ||
- (Style.isCpp() && NextTok->is(tok::l_paren)) ||
+ ProbablyBracedList ||
NextTok->isOneOf(tok::comma, tok::period, tok::colon,
tok::r_paren, tok::r_square, tok::l_brace,
- tok::ellipsis) ||
+ tok::ellipsis);
+
+ ProbablyBracedList =
+ ProbablyBracedList ||
(NextTok->is(tok::identifier) &&
- !PrevTok->isOneOf(tok::semi, tok::r_brace, tok::l_brace)) ||
- (NextTok->is(tok::semi) &&
- (!ExpectClassBody || LBraceStack.size() != 1)) ||
+ !PrevTok->isOneOf(tok::semi, tok::r_brace, tok::l_brace));
+
+ ProbablyBracedList = ProbablyBracedList ||
+ (NextTok->is(tok::semi) &&
+ (!ExpectClassBody || LBraceStack.size() != 1));
+
+ ProbablyBracedList =
+ ProbablyBracedList ||
(NextTok->isBinaryOperator() && !NextIsObjCMethod);
+
if (!Style.isCSharp() && NextTok->is(tok::l_square)) {
// We can have an array subscript after a braced init
// list, but C++11 attributes are expected after blocks.
@@ -680,8 +726,9 @@
UnwrappedLineParser::IfStmtKind
UnwrappedLineParser::parseBlock(bool MustBeDeclaration, unsigned AddLevels,
- bool MunchSemi,
- bool UnindentWhitesmithsBraces) {
+ bool MunchSemi, bool UnindentWhitesmithsBraces,
+ bool CanContainBracedList,
+ TokenType NextLBracesType) {
assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
"'{' or macro block token expected");
FormatToken *Tok = FormatTok;
@@ -721,7 +768,8 @@
Line->Level += AddLevels;
IfStmtKind IfKind = IfStmtKind::NotIf;
- const bool SimpleBlock = parseLevel(/*HasOpeningBrace=*/true, &IfKind);
+ const bool SimpleBlock = parseLevel(
+ /*HasOpeningBrace=*/true, CanContainBracedList, &IfKind, NextLBracesType);
if (eof())
return IfKind;
@@ -751,8 +799,12 @@
if (MacroBlock && FormatTok->is(tok::l_paren))
parseParens();
+ if (FormatTok->is(tok::kw_noexcept))
+ // A noexcept in a requires expression.
+ nextToken();
+
if (FormatTok->is(tok::arrow)) {
- // Following the } we can find a trailing return type arrow
+ // Following the } or noexcept we can find a trailing return type arrow
// as part of an implicit conversion constraint.
nextToken();
parseStructuralElement();
@@ -826,7 +878,8 @@
return false;
}
-void UnwrappedLineParser::parseChildBlock() {
+void UnwrappedLineParser::parseChildBlock(
+ bool CanContainBracedList, clang::format::TokenType NextLBracesType) {
FormatTok->setBlockKind(BK_Block);
nextToken();
{
@@ -836,7 +889,8 @@
ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
/*MustBeDeclaration=*/false);
Line->Level += SkipIndent ? 0 : 1;
- parseLevel(/*HasOpeningBrace=*/true);
+ parseLevel(/*HasOpeningBrace=*/true, CanContainBracedList,
+ /*IfKind=*/nullptr, NextLBracesType);
flushComments(isOnNewLine(*FormatTok));
Line->Level -= SkipIndent ? 0 : 1;
}
@@ -1231,7 +1285,8 @@
}
void UnwrappedLineParser::parseStructuralElement(IfStmtKind *IfKind,
- bool IsTopLevel) {
+ bool IsTopLevel,
+ TokenType NextLBracesType) {
if (Style.Language == FormatStyle::LK_TableGen &&
FormatTok->is(tok::pp_include)) {
nextToken();
@@ -1482,7 +1537,7 @@
parseConcept();
return;
case tok::kw_requires:
- parseRequires();
+ parseRequiresClause();
return;
case tok::kw_enum:
// Ignore if this is part of "template <enum ...".
@@ -1562,6 +1617,8 @@
parseChildBlock();
break;
case tok::l_brace:
+ if (NextLBracesType != TT_Unknown)
+ FormatTok->setType(NextLBracesType);
if (!tryToParsePropertyAccessor() && !tryToParseBracedList()) {
// A block outside of parentheses must be the last part of a
// structural element.
@@ -2094,7 +2151,10 @@
return false;
}
-void UnwrappedLineParser::parseParens() {
+/// \brief Parses a parens pair.
+/// \param AmpAmpTokenType If different than TT_Unknown sets this type for all
+/// double ampersands. This only counts for the current parens scope.
+void UnwrappedLineParser::parseParens(TokenType AmpAmpTokenType) {
assert(FormatTok->Tok.is(tok::l_paren) && "'(' expected.");
nextToken();
do {
@@ -2144,6 +2204,13 @@
else
nextToken();
break;
+ case tok::kw_requires:
+ parseRequiresExpression();
+ break;
+ case tok::ampamp:
+ if (AmpAmpTokenType != TT_Unknown)
+ FormatTok->setType(AmpAmpTokenType);
+ LLVM_FALLTHROUGH;
default:
nextToken();
break;
@@ -2694,6 +2761,11 @@
}
}
+/// \brief Parses a concept definition.
+/// \pre The current token has to be the concept keyword.
+///
+/// Returns if it either has finished parsing the concept, or it detects, that
+/// the concept definition is incorrect.
void UnwrappedLineParser::parseConcept() {
assert(FormatTok->Tok.is(tok::kw_concept) && "'concept' expected");
nextToken();
@@ -2703,100 +2775,179 @@
if (!FormatTok->Tok.is(tok::equal))
return;
nextToken();
- if (FormatTok->Tok.is(tok::kw_requires)) {
+ parseConstraintExpression();
+ if (FormatTok->Tok.is(tok::semi))
nextToken();
- parseRequiresExpression(Line->Level);
- } else {
- parseConstraintExpression(Line->Level);
- }
+ addUnwrappedLine();
+}
+
+/// \brief Parses a requires clause.
+/// \pre The current token needs to be the requires keyword.
+/// \sa parseRequiresExpression
+///
+/// Returns if it either has finished parsing the clause, or it detects, that
+/// the clause is incorrect.
+void UnwrappedLineParser::parseRequiresClause() {
+ assert(FormatTok->Tok.is(tok::kw_requires) && "'requires' expected");
+ assert(FormatTok->getType() == TT_Unknown);
+
+ // If there is no previous token, we are within a requires expression,
+ // otherwise we will always have the template or function declaration in front
+ // of it.
+ bool NotInRequiresExpression =
+ FormatTok->Previous &&
+ FormatTok->Previous->isNot(TT_RequiresExpressionLBrace);
+
+ FormatTok->setType(NotInRequiresExpression
+ ? TT_RequiresClause
+ : TT_RequiresClauseInARequiresExpression);
+
+ nextToken();
+ parseConstraintExpression();
+
+ if (NotInRequiresExpression)
+ FormatTok->Previous->ClosesRequiresClause = true;
}
-void UnwrappedLineParser::parseRequiresExpression(unsigned int OriginalLevel) {
- // requires (R range)
- if (FormatTok->Tok.is(tok::l_paren)) {
+/// \brief Parses a requires expression.
+/// \pre The current token needs to be the requires keyword.
+/// \sa parseRequiresClause
+///
+/// Returns if it either has finished parsing the expression, or it detects,
+/// that the expression is incorrect.
+void UnwrappedLineParser::parseRequiresExpression() {
+ assert(FormatTok->Tok.is(tok::kw_requires) && "'requires' expected");
+ assert(FormatTok->getType() == TT_Unknown);
+
+ FormatTok->setType(TT_RequiresExpression);
+ nextToken();
+
+ if (FormatTok->is(tok::l_paren)) {
+ FormatTok->setType(TT_RequiresExpressionLParen);
parseParens();
- if (Style.IndentRequires && OriginalLevel != Line->Level) {
- addUnwrappedLine();
- --Line->Level;
- }
}
- if (FormatTok->Tok.is(tok::l_brace)) {
- if (Style.BraceWrapping.AfterFunction)
- addUnwrappedLine();
- FormatTok->setType(TT_FunctionLBrace);
- parseBlock();
- addUnwrappedLine();
- } else {
- parseConstraintExpression(OriginalLevel);
+ if (FormatTok->is(tok::l_brace)) {
+ FormatTok->setType(TT_RequiresExpressionLBrace);
+ parseChildBlock(/*CanContainBracedList=*/false,
+ /*NextLBracesType=*/TT_CompoundRequirementLBrace);
}
}
-void UnwrappedLineParser::parseConstraintExpression(
- unsigned int OriginalLevel) {
- // requires Id<T> && Id<T> || Id<T>
- while (
- FormatTok->isOneOf(tok::identifier, tok::kw_requires, tok::coloncolon)) {
- nextToken();
- while (FormatTok->isOneOf(tok::identifier, tok::coloncolon, tok::less,
- tok::greater, tok::comma, tok::ellipsis)) {
- if (FormatTok->Tok.is(tok::less)) {
+/// \brief Parses a constraint expression.
+///
+/// This is either the definition of a concept, or the body of a requires
+/// clause. It returns, when the parsing is complete, or the expression is
+/// incorrect.
+void UnwrappedLineParser::parseConstraintExpression() {
+ do {
+ switch (FormatTok->Tok.getKind()) {
+ case tok::kw_requires:
+ parseRequiresExpression();
+ break;
+
+ case tok::l_paren:
+ parseParens(/*AmpAmpTokenType=*/TT_BinaryOperator);
+ break;
+
+ case tok::l_square:
+ if (!tryToParseLambda())
+ return;
+ break;
+
+ case tok::identifier:
+ // We need to differentiate identifiers for a template deduction guide,
+ // variables, or function return types (the constraint expression has
+ // ended before that), and basically all other cases. But it's easier to
+ // check the other way around.
+ assert(FormatTok->Previous);
+ switch (FormatTok->Previous->Tok.getKind()) {
+ case tok::coloncolon: // Nested identifier.
+ case tok::ampamp: // Start of a function or variable for the
+ case tok::pipepipe: // constraint expression.
+ case tok::kw_requires: // Initial identifier of a requires clause.
+ case tok::equal: // Initial identifier of a concept declaration.
+ break;
+ default:
+ return;
+ }
+
+ // Read identifier with optional template declaration.
+ nextToken();
+ if (FormatTok->Tok.is(tok::less))
parseBracedList(/*ContinueOnSemicolons=*/false, /*IsEnum=*/false,
/*ClosingBraceKind=*/tok::greater);
- continue;
- }
+ break;
+
+ case tok::kw_const:
+ case tok::semi:
+ case tok::kw_class:
+ case tok::kw_struct:
+ case tok::kw_union:
+ return;
+
+ case tok::l_brace:
+ // Potential function body.
+ return;
+
+ case tok::ampamp:
+ case tok::pipepipe:
+ FormatTok->setType(TT_BinaryOperator);
nextToken();
- }
- if (FormatTok->Tok.is(tok::kw_requires))
- parseRequiresExpression(OriginalLevel);
- if (FormatTok->Tok.is(tok::less)) {
- parseBracedList(/*ContinueOnSemicolons=*/false, /*IsEnum=*/false,
- /*ClosingBraceKind=*/tok::greater);
- }
+ break;
- if (FormatTok->Tok.is(tok::l_paren))
- parseParens();
- if (FormatTok->Tok.is(tok::l_brace)) {
- if (Style.BraceWrapping.AfterFunction)
- addUnwrappedLine();
- FormatTok->setType(TT_FunctionLBrace);
- parseBlock();
- }
- if (FormatTok->Tok.is(tok::semi)) {
- // Eat any trailing semi.
+ case tok::kw_true:
+ case tok::kw_false:
+ case tok::kw_sizeof:
+ case tok::greater:
+ case tok::greaterequal:
+ case tok::greatergreater:
+ case tok::less:
+ case tok::lessequal:
+ case tok::lessless:
+ case tok::equalequal:
+ case tok::exclaim:
+ case tok::exclaimequal:
+ case tok::plus:
+ case tok::minus:
+ case tok::star:
+ case tok::slash:
+ case tok::numeric_constant:
+ case tok::kw_decltype:
+ case tok::comment:
+ case tok::comma:
+ case tok::coloncolon:
+ // Just eat them.
nextToken();
- addUnwrappedLine();
- }
- if (FormatTok->Tok.is(tok::colon))
- return;
- if (!FormatTok->Tok.isOneOf(tok::ampamp, tok::pipepipe)) {
- if (FormatTok->Previous &&
- !FormatTok->Previous->isOneOf(tok::identifier, tok::kw_requires,
- tok::coloncolon))
- addUnwrappedLine();
- if (Style.IndentRequires && OriginalLevel != Line->Level)
- --Line->Level;
break;
- } else {
- FormatTok->setType(TT_ConstraintJunctions);
- }
- nextToken();
- }
-}
+ case tok::kw_static_cast:
+ case tok::kw_const_cast:
+ case tok::kw_reinterpret_cast:
+ case tok::kw_dynamic_cast:
+ nextToken();
+ if (!FormatTok->is(tok::less))
+ return;
-void UnwrappedLineParser::parseRequires() {
- assert(FormatTok->Tok.is(tok::kw_requires) && "'requires' expected");
+ parseBracedList(/*ContinueOnSemicolons=*/false, /*IsEnum=*/false,
+ /*ClosingBraceKind=*/tok::greater);
+ break;
- unsigned OriginalLevel = Line->Level;
- if (FormatTok->Previous && FormatTok->Previous->is(tok::greater)) {
- addUnwrappedLine();
- if (Style.IndentRequires)
- ++Line->Level;
- }
- nextToken();
+ case tok::kw_bool:
+ // bool is only allowed if it is directly followed by a paren for a cast:
+ // concept C = bool(...);
+ // and bool is the only type, all other types as cast must be inside a
+ // cast to bool an thus are handled by the other cases.
+ nextToken();
+ if (FormatTok->isNot(tok::l_paren))
+ return;
+ parseParens();
+ break;
- parseRequiresExpression(OriginalLevel);
+ default:
+ return;
+ }
+ } while (!eof());
}
bool UnwrappedLineParser::parseEnum() {
@@ -2992,7 +3143,7 @@
}
// Parse the class body after the enum's ";" if any.
- parseLevel(/*HasOpeningBrace=*/true);
+ parseLevel(/*HasOpeningBrace=*/true, /*CanContainBracedList=*/true);
nextToken();
--Line->Level;
addUnwrappedLine();
Index: clang/lib/Format/TokenAnnotator.cpp
===================================================================
--- clang/lib/Format/TokenAnnotator.cpp
+++ clang/lib/Format/TokenAnnotator.cpp
@@ -1019,7 +1019,7 @@
return false;
if (Line.MustBeDeclaration && Contexts.size() == 1 &&
!Contexts.back().IsExpression && !Line.startsWith(TT_ObjCProperty) &&
- !Tok->is(TT_TypeDeclarationParen) &&
+ !Tok->isOneOf(TT_TypeDeclarationParen, TT_RequiresExpressionLParen) &&
(!Tok->Previous || !Tok->Previous->isOneOf(tok::kw___attribute,
TT_LeadingJavaAnnotation)))
Line.MightBeFunctionDecl = true;
@@ -1152,6 +1152,10 @@
parseCSharpGenericTypeConstraint();
}
break;
+ case tok::arrow:
+ if (Tok->Previous && Tok->Previous->is(tok::kw_noexcept))
+ Tok->setType(TT_TrailingReturnArrow);
+ break;
default:
break;
}
@@ -1412,9 +1416,12 @@
TT_ImplicitStringLiteral, TT_InlineASMBrace, TT_FatArrow,
TT_LambdaArrow, TT_NamespaceMacro, TT_OverloadedOperator,
TT_RegexLiteral, TT_TemplateString, TT_ObjCStringLiteral,
- TT_UntouchableMacroFunc, TT_ConstraintJunctions,
- TT_StatementAttributeLikeMacro, TT_FunctionLikeOrFreestandingMacro,
- TT_RecordLBrace))
+ TT_UntouchableMacroFunc, TT_StatementAttributeLikeMacro,
+ TT_FunctionLikeOrFreestandingMacro, TT_RecordLBrace,
+ TT_RequiresClause, TT_RequiresClauseInARequiresExpression,
+ TT_RequiresExpression, TT_RequiresExpressionLParen,
+ TT_RequiresExpressionLBrace, TT_BinaryOperator,
+ TT_CompoundRequirementLBrace, TT_BracedListLBrace))
CurrentToken->setType(TT_Unknown);
CurrentToken->Role.reset();
CurrentToken->MatchingParen = nullptr;
@@ -1609,7 +1616,8 @@
PriorLeadingIdentifier = PriorLeadingIdentifier->Previous;
return (PriorLeadingIdentifier &&
- PriorLeadingIdentifier->is(TT_TemplateCloser) &&
+ (PriorLeadingIdentifier->is(TT_TemplateCloser) ||
+ PriorLeadingIdentifier->ClosesRequiresClause) &&
LeadingIdentifier->TokenText == Current.Next->TokenText);
}
}
@@ -1826,6 +1834,9 @@
if (!PreviousNotConst)
return false;
+ if (PreviousNotConst->ClosesRequiresClause)
+ return false;
+
bool IsPPKeyword = PreviousNotConst->is(tok::identifier) &&
PreviousNotConst->Previous &&
PreviousNotConst->Previous->is(tok::hash);
@@ -2145,7 +2156,7 @@
public:
ExpressionParser(const FormatStyle &Style, const AdditionalKeywords &Keywords,
AnnotatedLine &Line)
- : Style(Style), Keywords(Keywords), Current(Line.First) {}
+ : Style(Style), Keywords(Keywords), Line(Line), Current(Line.First) {}
/// Parse expressions with the given operator precedence.
void parse(int Precedence = 0) {
@@ -2200,7 +2211,11 @@
break;
// Consume scopes: (), [], <> and {}
- if (Current->opensScope()) {
+ // In addition to that we handle require clauses as scope, so that the
+ // constraints in that are correctly indented.
+ if (Current->opensScope() ||
+ Current->isOneOf(TT_RequiresClause,
+ TT_RequiresClauseInARequiresExpression)) {
// In fragment of a JavaScript template string can look like '}..${' and
// thus close a scope and open a new one at the same time.
while (Current && (!Current->closesScope() || Current->opensScope())) {
@@ -2222,12 +2237,26 @@
}
if (LatestOperator && (Current || Precedence > 0)) {
- // LatestOperator->LastOperator = true;
+ // The requires clauses do not neccessarily end in a semicolon or a brace,
+ // but just go over to struct/class or a function declaration, we need to
+ // intervene so that the fake right paren is inserted correctly.
+ auto End =
+ (Start->Previous &&
+ Start->Previous->isOneOf(TT_RequiresClause,
+ TT_RequiresClauseInARequiresExpression))
+ ? [this](){
+ auto Ret = Current ? Current : Line.Last;
+ while (!Ret->ClosesRequiresClause && Ret->Previous)
+ Ret = Ret->Previous;
+ return Ret;
+ }()
+ : nullptr;
+
if (Precedence == PrecedenceArrowAndPeriod) {
// Call expressions don't have a binary operator precedence.
- addFakeParenthesis(Start, prec::Unknown);
+ addFakeParenthesis(Start, prec::Unknown, End);
} else {
- addFakeParenthesis(Start, prec::Level(Precedence));
+ addFakeParenthesis(Start, prec::Level(Precedence), End);
}
}
}
@@ -2276,17 +2305,17 @@
return -1;
}
- void addFakeParenthesis(FormatToken *Start, prec::Level Precedence) {
+ void addFakeParenthesis(FormatToken *Start, prec::Level Precedence,
+ FormatToken *End = nullptr) {
Start->FakeLParens.push_back(Precedence);
if (Precedence > prec::Unknown)
Start->StartsBinaryExpression = true;
- if (Current) {
- FormatToken *Previous = Current->Previous;
- while (Previous->is(tok::comment) && Previous->Previous)
- Previous = Previous->Previous;
- ++Previous->FakeRParens;
+ if (!End && Current)
+ End = Current->getPreviousNonComment();
+ if (End) {
+ ++End->FakeRParens;
if (Precedence > prec::Unknown)
- Previous->EndsBinaryExpression = true;
+ End->EndsBinaryExpression = true;
}
}
@@ -2331,6 +2360,7 @@
const FormatStyle &Style;
const AdditionalKeywords &Keywords;
+ const AnnotatedLine &Line;
FormatToken *Current;
};
@@ -2901,6 +2931,8 @@
}
if (Left.ClosesTemplateDeclaration)
return Style.PenaltyBreakTemplateDeclaration;
+ if (Left.ClosesRequiresClause)
+ return 0;
if (Left.is(TT_ConditionalExpr))
return prec::Conditional;
prec::Level Level = Left.getPrecedence();
@@ -2968,9 +3000,6 @@
if (Left.isOneOf(tok::kw_co_await, tok::kw_co_yield, tok::kw_co_return) &&
Right.isNot(tok::semi))
return true;
- // requires clause Concept1<T> && Concept2<T>
- if (Left.is(TT_ConstraintJunctions) && Right.is(tok::identifier))
- return true;
if (Left.is(tok::l_paren) || Right.is(tok::r_paren))
return (Right.is(TT_CastRParen) ||
@@ -3868,6 +3897,15 @@
if (Right.is(tok::lessless) && Right.Next && Left.is(tok::string_literal) &&
Right.Next->is(tok::string_literal))
return true;
+ if (Right.is(TT_RequiresClause)) {
+ switch (Style.RequiresClausePosition) {
+ case FormatStyle::RCPS_OwnLine:
+ case FormatStyle::RCPS_ToFollowing:
+ return true;
+ default:
+ break;
+ }
+ }
// Can break after template<> declaration
if (Left.ClosesTemplateDeclaration && Left.MatchingParen &&
Left.MatchingParen->NestingLevel == 0) {
@@ -3875,9 +3913,18 @@
// template<typename T>
// concept ...
if (Right.is(tok::kw_concept))
- return Style.BreakBeforeConceptDeclarations;
+ return Style.BreakBeforeConceptDeclarations == FormatStyle::BBCDS_Always;
return (Style.AlwaysBreakTemplateDeclarations == FormatStyle::BTDS_Yes);
}
+ if (Left.ClosesRequiresClause) {
+ switch (Style.RequiresClausePosition) {
+ case FormatStyle::RCPS_OwnLine:
+ case FormatStyle::RCPS_ToPreceding:
+ return true;
+ default:
+ break;
+ }
+ }
if (Style.PackConstructorInitializers == FormatStyle::PCIS_Never) {
if (Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeColon &&
(Left.is(TT_CtorInitializerComma) || Right.is(TT_CtorInitializerColon)))
@@ -4272,8 +4319,14 @@
return Left.isNot(tok::period); // FIXME: Properly parse ObjC calls.
if (Left.is(tok::r_paren) && Line.Type == LT_ObjCProperty)
return true;
+ if (Right.is(tok::kw_concept))
+ return Style.BreakBeforeConceptDeclarations != FormatStyle::BBCDS_Never;
+ if (Right.is(TT_RequiresClause))
+ return true;
if (Left.ClosesTemplateDeclaration || Left.is(TT_FunctionAnnotationRParen))
return true;
+ if (Left.ClosesRequiresClause)
+ return true;
if (Right.isOneOf(TT_RangeBasedForLoopColon, TT_OverloadedOperatorLParen,
TT_OverloadedOperator))
return false;
Index: clang/lib/Format/FormatToken.h
===================================================================
--- clang/lib/Format/FormatToken.h
+++ clang/lib/Format/FormatToken.h
@@ -35,12 +35,13 @@
TYPE(BinaryOperator) \
TYPE(BitFieldColon) \
TYPE(BlockComment) \
+ TYPE(BracedListLBrace) \
TYPE(CastRParen) \
+ TYPE(CompoundRequirementLBrace) \
TYPE(ConditionalExpr) \
TYPE(ConflictAlternative) \
TYPE(ConflictEnd) \
TYPE(ConflictStart) \
- TYPE(ConstraintJunctions) \
TYPE(CtorInitializerColon) \
TYPE(CtorInitializerComma) \
TYPE(DesignatedInitializerLSquare) \
@@ -98,6 +99,11 @@
TYPE(RangeBasedForLoopColon) \
TYPE(RecordLBrace) \
TYPE(RegexLiteral) \
+ TYPE(RequiresClause) \
+ TYPE(RequiresClauseInARequiresExpression) \
+ TYPE(RequiresExpression) \
+ TYPE(RequiresExpressionLBrace) \
+ TYPE(RequiresExpressionLParen) \
TYPE(SelectorName) \
TYPE(StartOfName) \
TYPE(StatementAttributeLikeMacro) \
@@ -245,7 +251,8 @@
CanBreakBefore(false), ClosesTemplateDeclaration(false),
StartsBinaryExpression(false), EndsBinaryExpression(false),
PartOfMultiVariableDeclStmt(false), ContinuesLineCommentSection(false),
- Finalized(false), BlockKind(BK_Unknown), Decision(FD_Unformatted),
+ Finalized(false), ClosesRequiresClause(false),
+ BlockKind(BK_Unknown), Decision(FD_Unformatted),
PackingKind(PPK_Inconclusive), Type(TT_Unknown) {}
/// The \c Token.
@@ -312,6 +319,9 @@
/// changes.
unsigned Finalized : 1;
+ /// \c true if this is the last token within requires clause.
+ unsigned ClosesRequiresClause : 1;
+
private:
/// Contains the kind of block if this token is a brace.
unsigned BlockKind : 2;
Index: clang/lib/Format/Format.cpp
===================================================================
--- clang/lib/Format/Format.cpp
+++ clang/lib/Format/Format.cpp
@@ -257,6 +257,21 @@
}
};
+template <>
+struct ScalarEnumerationTraits<
+ FormatStyle::BreakBeforeConceptDeclarationsStyle> {
+ static void
+ enumeration(IO &IO, FormatStyle::BreakBeforeConceptDeclarationsStyle &Value) {
+ IO.enumCase(Value, "Never", FormatStyle::BBCDS_Never);
+ IO.enumCase(Value, "Allowed", FormatStyle::BBCDS_Allowed);
+ IO.enumCase(Value, "Always", FormatStyle::BBCDS_Always);
+
+ // For backward compatibility.
+ IO.enumCase(Value, "true", FormatStyle::BBCDS_Always);
+ IO.enumCase(Value, "false", FormatStyle::BBCDS_Allowed);
+ }
+};
+
template <>
struct ScalarEnumerationTraits<FormatStyle::BreakConstructorInitializersStyle> {
static void
@@ -463,6 +478,17 @@
}
};
+template <>
+struct ScalarEnumerationTraits<FormatStyle::RequiresClausePositionStyle> {
+ static void enumeration(IO &IO,
+ FormatStyle::RequiresClausePositionStyle &Value) {
+ IO.enumCase(Value, "OwnLine", FormatStyle::RCPS_OwnLine);
+ IO.enumCase(Value, "ToPreceding", FormatStyle::RCPS_ToPreceding);
+ IO.enumCase(Value, "ToFollowing", FormatStyle::RCPS_ToFollowing);
+ IO.enumCase(Value, "SingleLine", FormatStyle::RCPS_SingleLine);
+ }
+};
+
template <>
struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensStyle> {
static void enumeration(IO &IO, FormatStyle::SpaceBeforeParensStyle &Value) {
@@ -565,6 +591,7 @@
IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
IO.mapOptional("IndentFunctionDeclarationAfterType",
Style.IndentWrappedFunctionNames);
+ IO.mapOptional("IndentRequires", Style.IndentRequiresClause);
IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
IO.mapOptional("SpaceAfterControlStatementKeyword",
Style.SpaceBeforeParens);
@@ -737,7 +764,7 @@
IO.mapOptional("IndentGotoLabels", Style.IndentGotoLabels);
IO.mapOptional("IndentPPDirectives", Style.IndentPPDirectives);
IO.mapOptional("IndentExternBlock", Style.IndentExternBlock);
- IO.mapOptional("IndentRequires", Style.IndentRequires);
+ IO.mapOptional("IndentRequiresClause", Style.IndentRequiresClause);
IO.mapOptional("IndentWidth", Style.IndentWidth);
IO.mapOptional("IndentWrappedFunctionNames",
Style.IndentWrappedFunctionNames);
@@ -782,6 +809,8 @@
IO.mapOptional("ReferenceAlignment", Style.ReferenceAlignment);
IO.mapOptional("ReflowComments", Style.ReflowComments);
IO.mapOptional("RemoveBracesLLVM", Style.RemoveBracesLLVM);
+ IO.mapOptional("RequiresClausePosition",
+ Style.RequiresClausePosition);
IO.mapOptional("SeparateDefinitionBlocks", Style.SeparateDefinitionBlocks);
IO.mapOptional("ShortNamespaceLines", Style.ShortNamespaceLines);
IO.mapOptional("SortIncludes", Style.SortIncludes);
@@ -1130,7 +1159,7 @@
LLVMStyle.BinPackArguments = true;
LLVMStyle.BinPackParameters = true;
LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
- LLVMStyle.BreakBeforeConceptDeclarations = true;
+ LLVMStyle.BreakBeforeConceptDeclarations = FormatStyle::BBCDS_Always;
LLVMStyle.BreakBeforeTernaryOperators = true;
LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
LLVMStyle.BraceWrapping = {/*AfterCaseLabel=*/false,
@@ -1188,7 +1217,7 @@
LLVMStyle.IndentCaseBlocks = false;
LLVMStyle.IndentGotoLabels = true;
LLVMStyle.IndentPPDirectives = FormatStyle::PPDIS_None;
- LLVMStyle.IndentRequires = false;
+ LLVMStyle.IndentRequiresClause = true;
LLVMStyle.IndentWrappedFunctionNames = false;
LLVMStyle.IndentWidth = 2;
LLVMStyle.PPIndentWidth = -1;
@@ -1207,6 +1236,7 @@
LLVMStyle.ObjCSpaceBeforeProtocolList = true;
LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
LLVMStyle.ReferenceAlignment = FormatStyle::RAS_Pointer;
+ LLVMStyle.RequiresClausePosition = FormatStyle::RCPS_OwnLine;
LLVMStyle.SeparateDefinitionBlocks = FormatStyle::SDS_Leave;
LLVMStyle.ShortNamespaceLines = 1;
LLVMStyle.SpacesBeforeTrailingComments = 1;
@@ -3048,6 +3078,15 @@
FormatStyle Expanded = Style;
expandPresetsBraceWrapping(Expanded);
expandPresetsSpaceBeforeParens(Expanded);
+ switch (Expanded.RequiresClausePosition) {
+ case FormatStyle::RCPS_SingleLine:
+ case FormatStyle::RCPS_ToPreceding:
+ Expanded.IndentRequiresClause = false;
+ break;
+ default:
+ break;
+ }
+
if (Expanded.DisableFormat)
return {tooling::Replacements(), 0};
if (isLikelyXml(Code))
Index: clang/lib/Format/ContinuationIndenter.cpp
===================================================================
--- clang/lib/Format/ContinuationIndenter.cpp
+++ clang/lib/Format/ContinuationIndenter.cpp
@@ -478,11 +478,32 @@
return true;
if (Current.NestingLevel == 0 && !Current.isTrailingComment()) {
- // Always break after "template <...>" and leading annotations. This is only
- // for cases where the entire line does not fit on a single line as a
+ // Always break after "template <...>"(*) and leading annotations. This is
+ // only for cases where the entire line does not fit on a single line as a
// different LineFormatter would be used otherwise.
- if (Previous.ClosesTemplateDeclaration)
+ // *: Except when antoher option does interfere with that, like concepts.
+ if (Previous.ClosesTemplateDeclaration) {
+ if (Current.is(tok::kw_concept)) {
+ switch (Style.BreakBeforeConceptDeclarations) {
+ case FormatStyle::BBCDS_Allowed:
+ break;
+ case FormatStyle::BBCDS_Always:
+ return true;
+ case FormatStyle::BBCDS_Never:
+ return false;
+ }
+ }
+ if (Current.is(TT_RequiresClause)) {
+ switch (Style.RequiresClausePosition) {
+ case FormatStyle::RCPS_SingleLine:
+ case FormatStyle::RCPS_ToPreceding:
+ return false;
+ default:
+ return true;
+ }
+ }
return Style.AlwaysBreakTemplateDeclarations != FormatStyle::BTDS_No;
+ }
if (Previous.is(TT_FunctionAnnotationRParen) &&
State.Line->Type != LT_PreprocessorDirective)
return true;
@@ -669,6 +690,7 @@
if (Style.AlignAfterOpenBracket != FormatStyle::BAS_DontAlign &&
!State.Stack.back().IsCSharpGenericTypeConstraint &&
Previous.opensScope() && Previous.isNot(TT_ObjCMethodExpr) &&
+ Previous.isNot(TT_RequiresClause) &&
(Current.isNot(TT_LineComment) || Previous.is(BK_BracedInit))) {
State.Stack.back().Indent = State.Column + Spaces;
State.Stack.back().IsAligned = true;
@@ -880,7 +902,8 @@
Previous.is(TT_BinaryOperator))
State.Stack.back().BreakBeforeParameter = false;
if (PreviousNonComment &&
- PreviousNonComment->isOneOf(TT_TemplateCloser, TT_JavaAnnotation) &&
+ (PreviousNonComment->isOneOf(TT_TemplateCloser, TT_JavaAnnotation) ||
+ PreviousNonComment->ClosesRequiresClause) &&
Current.NestingLevel == 0)
State.Stack.back().BreakBeforeParameter = false;
if (NextNonComment->is(tok::question) ||
@@ -927,13 +950,19 @@
State.Stack[State.Stack.size() - 2].NestedBlockInlined) ||
(Style.Language == FormatStyle::LK_ObjC && Current.is(tok::r_brace) &&
State.Stack.size() > 1 && !Style.ObjCBreakBeforeNestedBlockParam);
+ // Do not force parameter break for statements with requires expressions.
+ NestedBlockSpecialCase =
+ NestedBlockSpecialCase ||
+ (Current.MatchingParen &&
+ Current.MatchingParen->is(TT_RequiresExpressionLBrace));
if (!NestedBlockSpecialCase)
for (unsigned i = 0, e = State.Stack.size() - 1; i != e; ++i)
State.Stack[i].BreakBeforeParameter = true;
if (PreviousNonComment &&
!PreviousNonComment->isOneOf(tok::comma, tok::colon, tok::semi) &&
- (PreviousNonComment->isNot(TT_TemplateCloser) ||
+ ((PreviousNonComment->isNot(TT_TemplateCloser) &&
+ !PreviousNonComment->ClosesRequiresClause) ||
Current.NestingLevel != 0) &&
!PreviousNonComment->isOneOf(
TT_BinaryOperator, TT_FunctionAnnotationRParen, TT_JavaAnnotation,
@@ -1094,10 +1123,22 @@
}
return State.Stack.back().QuestionColumn;
}
- if (Previous.is(tok::comma) && State.Stack.back().VariablePos != 0)
+ if (Previous.is(tok::comma) && CurrentState.VariablePos != 0)
return State.Stack.back().VariablePos;
+ if (Current.is(TT_RequiresClause)) {
+ if (Style.IndentRequiresClause)
+ return State.Stack.back().Indent + Style.IndentWidth;
+ switch (Style.RequiresClausePosition) {
+ case FormatStyle::RCPS_OwnLine:
+ case FormatStyle::RCPS_ToFollowing:
+ return State.Stack.back().Indent;
+ default:
+ break;
+ }
+ }
if ((PreviousNonComment &&
(PreviousNonComment->ClosesTemplateDeclaration ||
+ PreviousNonComment->ClosesRequiresClause ||
PreviousNonComment->isOneOf(
TT_AttributeParen, TT_AttributeSquare, TT_FunctionAnnotationRParen,
TT_JavaAnnotation, TT_LeadingJavaAnnotation))) ||
@@ -1281,6 +1322,8 @@
State.Column + Current.ColumnWidth + 1;
if (Current.isOneOf(TT_LambdaLSquare, TT_LambdaArrow))
State.Stack.back().LastSpace = State.Column;
+ if (Current.is(TT_RequiresExpression))
+ State.Stack.back().NestedBlockIndent = State.Column;
// Insert scopes created by fake parenthesis.
const FormatToken *Previous = Current.getPreviousNonComment();
@@ -1291,8 +1334,8 @@
// foo();
// bar();
// }, a, b, c);
- if (Current.isNot(tok::comment) && Previous &&
- Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
+ if (Current.isNot(tok::comment) && !Current.ClosesRequiresClause &&
+ Previous && Previous->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) &&
!Previous->is(TT_DictLiteral) && State.Stack.size() > 1 &&
!State.Stack.back().HasMultipleNestedBlocks) {
if (State.Stack[State.Stack.size() - 2].NestedBlockInlined && Newline)
@@ -1352,14 +1395,15 @@
const FormatToken *Previous = Current.getPreviousNonComment();
// Don't add extra indentation for the first fake parenthesis after
- // 'return', assignments or opening <({[. The indentation for these cases
- // is special cased.
+ // 'return', assignments, opening <({[, or requires clauses. The indentation
+ // for these cases is special cased.
bool SkipFirstExtraIndent =
- (Previous && (Previous->opensScope() ||
- Previous->isOneOf(tok::semi, tok::kw_return) ||
- (Previous->getPrecedence() == prec::Assignment &&
- Style.AlignOperands != FormatStyle::OAS_DontAlign) ||
- Previous->is(TT_ObjCMethodExpr)));
+ Previous &&
+ (Previous->opensScope() ||
+ Previous->isOneOf(tok::semi, tok::kw_return, TT_RequiresClause) ||
+ (Previous->getPrecedence() == prec::Assignment &&
+ Style.AlignOperands != FormatStyle::OAS_DontAlign) ||
+ Previous->is(TT_ObjCMethodExpr));
for (const auto &PrecedenceLevel : llvm::reverse(Current.FakeLParens)) {
ParenState NewParenState = State.Stack.back();
NewParenState.Tok = nullptr;
@@ -1392,7 +1436,7 @@
if (Previous &&
(Previous->getPrecedence() == prec::Assignment ||
- Previous->is(tok::kw_return) ||
+ Previous->isOneOf(tok::kw_return, TT_RequiresClause) ||
(PrecedenceLevel == prec::Conditional && Previous->is(tok::question) &&
Previous->is(TT_ConditionalExpr))) &&
!Newline) {
@@ -1450,6 +1494,12 @@
State.Stack.pop_back();
State.Stack.back().VariablePos = VariablePos;
}
+
+ if (State.NextToken->ClosesRequiresClause && Style.IndentRequiresClause) {
+ // Remove the indentation of the requires clauses (which is not in Indent,
+ // but in LastSpace).
+ State.Stack.back().LastSpace -= Style.IndentWidth;
+ }
}
void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
Index: clang/include/clang/Format/Format.h
===================================================================
--- clang/include/clang/Format/Format.h
+++ clang/include/clang/Format/Format.h
@@ -1770,17 +1770,27 @@
/// \version 3.8
BraceWrappingFlags BraceWrapping;
- /// If ``true``, concept will be placed on a new line.
- /// \code
- /// true:
- /// template<typename T>
- /// concept ...
- ///
- /// false:
- /// template<typename T> concept ...
- /// \endcode
+ /// Different ways to break before concept declarations.
+ enum BreakBeforeConceptDeclarationsStyle {
+ /// Never break, put them in the template declaration line.
+ /// \code
+ /// template <typename T> concept C = ...;
+ /// \endcode
+ BBCDS_Never,
+ /// It can be broken, but doesn't have to. The actual behavior depends on
+ /// the content and line breaking rules and penalities.
+ BBCDS_Allowed,
+ /// Always break, put them in the line after the template declaration.
+ /// \code
+ /// template <typename T>
+ /// concept C = ...;
+ /// \endcode
+ BBCDS_Always,
+ };
+
+ /// The style wether before ``concept`` declarations should be broken.
/// \version 13
- bool BreakBeforeConceptDeclarations;
+ BreakBeforeConceptDeclarationsStyle BreakBeforeConceptDeclarations;
/// If ``true``, ternary operators will be placed after line breaks.
/// \code
@@ -2509,7 +2519,8 @@
/// \version 12
IndentExternBlockStyle IndentExternBlock;
- /// Indent the requires clause in a template
+ /// Indent the requires clause in a template. This only applies
+ /// ``RequiresClausePosition`` is ``OwnLine``, or ``ToFollowing``.
/// \code
/// true:
/// template <typename It>
@@ -2526,7 +2537,7 @@
/// }
/// \endcode
/// \version 13
- bool IndentRequires;
+ bool IndentRequiresClause;
/// The number of columns to use for indentation.
/// \code
@@ -3116,6 +3127,71 @@
/// \version 14
bool RemoveBracesLLVM;
+ /// \brief The possible positions for the requires clause. The
+ /// ``IndentRequires`` option is only used if the ``requires`` is put on the
+ /// start of a line.
+ enum RequiresClausePositionStyle {
+ /// The clause always gets its own line.
+ /// \code
+ /// template<typename T>
+ /// requires C<T>
+ /// struct Foo {...
+ ///
+ /// template<typename T>
+ /// requires C<T>
+ /// void bar(T t) {...
+ ///
+ /// template<typename T>
+ /// void baz(T t)
+ /// requires C<T>
+ /// {...
+ /// \endcode
+ RCPS_OwnLine,
+ /// The clause tries to stick to the template declaration in case of class
+ /// templates or between template and function declarations. In case of
+ /// after the function declaration it tries to stick to this.
+ /// \code
+ /// template<typename T> requires C<T>
+ /// struct Foo {...
+ ///
+ /// template<typename T> requires C<T>
+ /// void bar(T t) {...
+ ///
+ /// template<typename T>
+ /// void baz(T t) requires C<T>
+ /// {...
+ /// \endcode
+ RCPS_ToPreceding,
+ /// The clause tries to stick to the class respectively function
+ /// declaration.
+ /// \code
+ /// template<typename T>
+ /// requires C<T> struct Foo {...
+ ///
+ /// template<typename T>
+ /// requires C<T> void bar(T t) {...
+ ///
+ /// template<typename T>
+ /// void baz(T t)
+ /// requires C<T> {...
+ /// \endcode
+ RCPS_ToFollowing,
+ /// The clause tries to get everything in the same line, if it doesn't fit
+ /// normal line breaking rules decide to which part it sticks.
+ /// \code
+ /// template<typename T> requires C<T> struct Foo {...
+ ///
+ /// template<typename T> requires C<T> void bar(T t) {...
+ ///
+ /// template<typename T> void bar(T t) requires C<T> {...
+ /// \endcode
+ RCPS_SingleLine,
+ };
+
+ /// \brief The position of the ``requires`` clause.
+ /// \version 15
+ RequiresClausePositionStyle RequiresClausePosition;
+
/// \brief The style if definition blocks should be separated.
enum SeparateDefinitionStyle {
/// Leave definition blocks as they are.
@@ -3889,8 +3965,8 @@
IndentGotoLabels == R.IndentGotoLabels &&
IndentPPDirectives == R.IndentPPDirectives &&
IndentExternBlock == R.IndentExternBlock &&
- IndentRequires == R.IndentRequires && IndentWidth == R.IndentWidth &&
- Language == R.Language &&
+ IndentRequiresClause == R.IndentRequiresClause &&
+ IndentWidth == R.IndentWidth && Language == R.Language &&
IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
JavaImportGroups == R.JavaImportGroups &&
JavaScriptQuotes == R.JavaScriptQuotes &&
@@ -3926,6 +4002,7 @@
RawStringFormats == R.RawStringFormats &&
ReferenceAlignment == R.ReferenceAlignment &&
RemoveBracesLLVM == R.RemoveBracesLLVM &&
+ RequiresClausePosition == R.RequiresClausePosition &&
SeparateDefinitionBlocks == R.SeparateDefinitionBlocks &&
ShortNamespaceLines == R.ShortNamespaceLines &&
SortIncludes == R.SortIncludes &&
Index: clang/docs/ReleaseNotes.rst
===================================================================
--- clang/docs/ReleaseNotes.rst
+++ clang/docs/ReleaseNotes.rst
@@ -154,6 +154,14 @@
clang-format
------------
+- **Important Change** Renamed ``IndentRequires`` to ``IndentRequiresClause``
+ and changed the default for all styles from ``false`` to ``true``.
+
+- Reworked and improved handling of concepts and requires. Added the
+ ``RequiresClausePosition`` option as part of that.
+
+- Changed ``BreakBeforeConceptDeclarations`` from ``Boolean`` to an enum.
+
libclang
--------
Index: clang/docs/ClangFormatStyleOptions.rst
===================================================================
--- clang/docs/ClangFormatStyleOptions.rst
+++ clang/docs/ClangFormatStyleOptions.rst
@@ -1988,17 +1988,31 @@
-**BreakBeforeConceptDeclarations** (``Boolean``) :versionbadge:`clang-format 13`
- If ``true``, concept will be placed on a new line.
+**BreakBeforeConceptDeclarations** (``BreakBeforeConceptDeclarationsStyle``) :versionbadge:`clang-format 13`
+ The style wether before ``concept`` declarations should be broken.
- .. code-block:: c++
+ Possible values:
+
+ * ``BBCDS_Never`` (in configuration: ``Never``)
+ Never break, put them in the template declaration line.
+
+ .. code-block:: c++
+
+ template <typename T> concept C = ...;
+
+ * ``BBCDS_Allowed`` (in configuration: ``Allowed``)
+ It can be broken, but doesn't have to. The actual behavior depends on
+ the content and line breaking rules and penalities.
+
+ * ``BBCDS_Always`` (in configuration: ``Always``)
+ Always break, put them in the line after the template declaration.
+
+ .. code-block:: c++
+
+ template <typename T>
+ concept C = ...;
- true:
- template<typename T>
- concept ...
- false:
- template<typename T> concept ...
**BreakBeforeTernaryOperators** (``Boolean``) :versionbadge:`clang-format 3.7`
If ``true``, ternary operators will be placed after line breaks.
@@ -2690,8 +2704,9 @@
-**IndentRequires** (``Boolean``) :versionbadge:`clang-format 13`
- Indent the requires clause in a template
+**IndentRequiresClause** (``Boolean``) :versionbadge:`clang-format 13`
+ Indent the requires clause in a template. This only applies
+ ``RequiresClausePosition`` is ``OwnLine``, or ``ToFollowing``.
.. code-block:: c++
@@ -3474,6 +3489,76 @@
}
}
+**RequiresClausePosition** (``RequiresClausePositionStyle``) :versionbadge:`clang-format 15`
+ The position of the ``requires`` clause.
+
+ Possible values:
+
+ * ``RCPS_OwnLine`` (in configuration: ``OwnLine``)
+ The clause always gets its own line.
+
+ .. code-block:: c++
+
+ template<typename T>
+ requires C<T>
+ struct Foo {...
+
+ template<typename T>
+ requires C<T>
+ void bar(T t) {...
+
+ template<typename T>
+ void baz(T t)
+ requires C<T>
+ {...
+
+ * ``RCPS_ToPreceding`` (in configuration: ``ToPreceding``)
+ The clause tries to stick to the template declaration in case of class
+ templates or between template and function declarations. In case of
+ after the function declaration it tries to stick to this.
+
+ .. code-block:: c++
+
+ template<typename T> requires C<T>
+ struct Foo {...
+
+ template<typename T> requires C<T>
+ void bar(T t) {...
+
+ template<typename T>
+ void baz(T t) requires C<T>
+ {...
+
+ * ``RCPS_ToFollowing`` (in configuration: ``ToFollowing``)
+ The clause tries to stick to the class respectively function
+ declaration.
+
+ .. code-block:: c++
+
+ template<typename T>
+ requires C<T> struct Foo {...
+
+ template<typename T>
+ requires C<T> void bar(T t) {...
+
+ template<typename T>
+ void baz(T t)
+ requires C<T> {...
+
+ * ``RCPS_SingleLine`` (in configuration: ``SingleLine``)
+ The clause tries to get everything in the same line, if it doesn't fit
+ normal line breaking rules decide to which part it sticks.
+
+ .. code-block:: c++
+
+ template<typename T> requires C<T> struct Foo {...
+
+ template<typename T> requires C<T> void bar(T t) {...
+
+ template<typename T> void bar(T t) requires C<T> {...
+
+
+
**SeparateDefinitionBlocks** (``SeparateDefinitionStyle``) :versionbadge:`clang-format 14`
Specifies the use of empty lines to separate definition blocks, including
classes, structs, enums, and functions.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
