[clang-format] AllowShortRequiresExpressionOnASingleLine

[Backl1ght]

Summary

clang-format brace wrapping did not take requires into consideration, compound requirements will be affected by BraceWrapping.AfterFunction.

I plan to add 3 options AllowShortRequiresExpressionOnASingleLine, AllowShortCompoundRequirementOnASingleLine and BraceWrapping.AfterRequiresExpression.

This patch is for AllowShortRequiresExpressionOnASingleLine.

[rymiel]

Please re-upload with full context. See https://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface

clang/lib/Format/Format.cpp

811

I'm pretty sure these options should be in alphabetical order (and below too)

[HazardyKnusperkeks]

I don't know if adding two options at once (and I think you want to add a third), splitting that up might be a better idea.

Anyway you need to tun clang/docs/tools/dump_format_style.py and add an entry in the changelog.

clang/include/clang/Format/Format.h

542

We have both, but I like the variant with true and false next to each other, not below.

clang/lib/Format/UnwrappedLineParser.cpp

1105

Unrelated.

clang/unittests/Format/FormatTest.cpp

2911

You need to add the Style.

[Backl1ght]

I just find out I miss one case like below

template<typename T>
concept c = requires(T x) { { x + 1 } -> std::same_as<int>; };

Since I split AllowShortRequiresExpressionOnASingleLine and AllowShortCompoundRequirementOnASingleLine into two pathes, I can not fix this until AllowShortCompoundRequirementOnASingleLine got merged.

[HazardyKnusperkeks]

Please mark comments as done.

clang/lib/Format/Format.cpp

1270

Please initialize to false, because that is what we are doing right now.

clang/unittests/Format/FormatTest.cpp

2904

Please add a test where the clause is too long and will still be wrapped. Reduce the column limit and use some longer identifiers.

[MyDeveloperDay]

ditto my concerns with D139834: [clang-format] AllowShortCompoundRequirementOnASingleLine as to if we should have a Leave option

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
       auto lambda2 = [](int a) { return a; };
 
 
 
 **AllowShortLoopsOnASingleLine** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, ``while (true) continue;`` can be put on a single
   line.
 
+**AllowShortRequiresExpressionOnASingleLine** (``Boolean``) :versionbadge:`clang-format 16`
+  Allow short requires expression on a single line.
+
+  .. code-block:: c++
+
+    true:
+    template <typename T>
+    concept c = requires(T a, T b) { a + b; };
+
+    false:
+    template <typename T>
+    concept c = requires(T a, T b) {
+      a + b;
+    };
+
 **AlwaysBreakAfterDefinitionReturnType** (``DefinitionReturnTypeBreakingStyle``) :versionbadge:`clang-format 3.7`
   The function definition return type breaking style to use.  This
   option is **deprecated** and is retained for backwards compatibility.
 
   Possible values:
 
   * ``DRTBS_None`` (in configuration: ``None``)
     Break after return type automatically.

clang/include/clang/Format/Format.h

struct FormatStyle {
   ///                                             return;
   ///                                           }
   /// \endcode
   /// \version 3.6
   bool AllowShortCaseLabelsOnASingleLine;
 
   /// Allow short enums on a single line.
   /// \code
   ///   true:
   ///   enum { A, B } myEnum;
   ///
   ///   false:
   ///   enum {
   ///     A,
   ///     B
   ///   } myEnum;
   /// \endcode
struct FormatStyle {
   /// \version 9
   ShortLambdaStyle AllowShortLambdasOnASingleLine;
 
   /// If ``true``, ``while (true) continue;`` can be put on a single
   /// line.
   /// \version 3.7
   bool AllowShortLoopsOnASingleLine;
 
+  /// Allow short requires expression on a single line.
+  /// \code
+  ///   true:
+  ///   template <typename T>
+  ///   concept c = requires(T a, T b) { a + b; };
+  ///
+  ///   false:
+  ///   template <typename T>
+  ///   concept c = requires(T a, T b) {
+  ///     a + b;
+  ///   };
+  /// \endcode
+  /// \version 16
+  bool AllowShortRequiresExpressionOnASingleLine;
+
   /// Different ways to break after the function definition return type.
   /// This option is **deprecated** and is retained for backwards compatibility.
   enum DefinitionReturnTypeBreakingStyle : int8_t {
     /// Break after return type automatically.
     /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
     DRTBS_None,
     /// Always break after the return type.
     DRTBS_All,
return AccessModifierOffset == R.AccessModifierOffset &&
                R.AllowShortCaseLabelsOnASingleLine &&
            AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine &&
            AllowShortFunctionsOnASingleLine ==
                R.AllowShortFunctionsOnASingleLine &&
            AllowShortIfStatementsOnASingleLine ==
                R.AllowShortIfStatementsOnASingleLine &&
            AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine &&
            AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
+           AllowShortRequiresExpressionOnASingleLine ==
+               R.AllowShortRequiresExpressionOnASingleLine &&
            AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType &&
            AlwaysBreakBeforeMultilineStrings ==
                R.AlwaysBreakBeforeMultilineStrings &&
            AlwaysBreakTemplateDeclarations ==
                R.AlwaysBreakTemplateDeclarations &&
            AttributeMacros == R.AttributeMacros &&
            BinPackArguments == R.BinPackArguments &&
            BinPackParameters == R.BinPackParameters &&

clang/lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
                    Style.AllowAllParametersOfDeclarationOnNextLine);
     IO.mapOptional("AllowShortBlocksOnASingleLine",
                    Style.AllowShortBlocksOnASingleLine);
     IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
                    Style.AllowShortCaseLabelsOnASingleLine);
     IO.mapOptional("AllowShortEnumsOnASingleLine",
                    Style.AllowShortEnumsOnASingleLine);
     IO.mapOptional("AllowShortFunctionsOnASingleLine",
                    Style.AllowShortFunctionsOnASingleLine);
     IO.mapOptional("AllowShortIfStatementsOnASingleLine",
                    Style.AllowShortIfStatementsOnASingleLine);
     IO.mapOptional("AllowShortLambdasOnASingleLine",
                    Style.AllowShortLambdasOnASingleLine);
     IO.mapOptional("AllowShortLoopsOnASingleLine",
                    Style.AllowShortLoopsOnASingleLine);
+    IO.mapOptional("AllowShortRequiresExpressionOnASingleLine",
+                   Style.AllowShortRequiresExpressionOnASingleLine);
     IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
                    Style.AlwaysBreakAfterDefinitionReturnType);
     IO.mapOptional("AlwaysBreakAfterReturnType",
                    Style.AlwaysBreakAfterReturnType);
     IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
                    Style.AlwaysBreakBeforeMultilineStrings);
     IO.mapOptional("AlwaysBreakTemplateDeclarations",
                    Style.AlwaysBreakTemplateDeclarations);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
   LLVMStyle.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
   LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
   LLVMStyle.AllowShortEnumsOnASingleLine = true;
   LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
   LLVMStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
   LLVMStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
   LLVMStyle.AllowShortLoopsOnASingleLine = false;
+  LLVMStyle.AllowShortRequiresExpressionOnASingleLine = true;
   LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
   LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
   LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
   LLVMStyle.AttributeMacros.push_back("__capability");
   LLVMStyle.BitFieldColonSpacing = FormatStyle::BFCS_Both;
   LLVMStyle.BinPackArguments = true;
   LLVMStyle.BinPackParameters = true;

clang/lib/Format/UnwrappedLineFormatter.cpp

if (PreviousLine && Style.BraceWrapping.SplitEmptyRecord &&
       }
     }
 
     if (TheLine->Last->is(tok::l_brace)) {
       bool ShouldMerge = false;
       // Try to merge records.
       if (TheLine->Last->is(TT_EnumLBrace)) {
         ShouldMerge = Style.AllowShortEnumsOnASingleLine;
+      } else if (TheLine->Last->is(TT_RequiresExpressionLBrace)) {
+        ShouldMerge = Style.AllowShortRequiresExpressionOnASingleLine;
       } else if (TheLine->Last->isOneOf(TT_ClassLBrace, TT_StructLBrace)) {
         // NOTE: We use AfterClass (whereas AfterStruct exists) for both classes
         // and structs, but it seems that wrapping is still handled correctly
         // elsewhere.
         ShouldMerge = !Style.BraceWrapping.AfterClass ||
                       (NextLine.First->is(tok::r_brace) &&
                        !Style.BraceWrapping.SplitEmptyRecord);
       } else {

clang/lib/Format/UnwrappedLineParser.cpp

 }
 
 void UnwrappedLineParser::parseChildBlock(
     bool CanContainBracedList, clang::format::TokenType NextLBracesType) {
   assert(FormatTok->is(tok::l_brace));
   FormatTok->setBlockKind(BK_Block);
   const FormatToken *OpeningBrace = FormatTok;
   nextToken();
+
+  if (NextLBracesType == TT_CompoundRequirementLBrace &&
+      !Style.AllowShortRequiresExpressionOnASingleLine) {
+    addUnwrappedLine();
+  }
+
   {
     bool SkipIndent = (Style.isJavaScript() &&
                        (isGoogScope(*Line) || isIIFE(*Line, Keywords)));
     ScopedLineState LineState(*this);
     ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
                                             /*MustBeDeclaration=*/false);
     Line->Level += SkipIndent ? 0 : 1;
     parseLevel(OpeningBrace, CanContainBracedList, NextLBracesType);
     flushComments(isOnNewLine(*FormatTok));
     Line->Level -= SkipIndent ? 0 : 1;
   }
   nextToken();
 }
 
 void UnwrappedLineParser::parsePPDirective() {
   assert(FormatTok->is(tok::hash) && "'#' expected");
   ScopedMacroState MacroState(*Line, Tokens, FormatTok);
 
   nextToken();
 

clang/unittests/Format/ConfigParseTest.cpp

 TEST(ConfigParseTest, ParsesConfigurationBools) {
   FormatStyle Style = {};
   Style.Language = FormatStyle::LK_Cpp;
   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
+  CHECK_PARSE_BOOL(AllowShortRequiresExpressionOnASingleLine);
   CHECK_PARSE_BOOL(BinPackArguments);
   CHECK_PARSE_BOOL(BinPackParameters);
   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
   CHECK_PARSE_BOOL(BreakStringLiterals);
   CHECK_PARSE_BOOL(CompactNamespaces);
   CHECK_PARSE_BOOL(DeriveLineEnding);
   CHECK_PARSE_BOOL(DerivePointerAlignment);

clang/unittests/Format/FormatTest.cpp

verifyFormat("typedef enum\n"
                "{\n"
                "  A,\n"
                "  B,\n"
                "  C\n"
                "} ShortEnum1, ShortEnum2;",
                Style);
 }
 
+TEST_F(FormatTest, ShortRequiresExpression) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_TRUE(Style.AllowShortRequiresExpressionOnASingleLine);
+  verifyFormat("template <typename T>\n"
+               "concept c = requires(T a, T b) { a + b; };",
+               Style);
+  Style.AllowShortRequiresExpressionOnASingleLine = false;
+  verifyFormat("template <typename T>\n"
+               "concept c = requires(T a, T b) {\n"
+               "  a + b;\n"
+               "};",
+               Style);
+}
+
 TEST_F(FormatTest, ShortCaseLabels) {
   FormatStyle Style = getLLVMStyle();
   Style.AllowShortCaseLabelsOnASingleLine = true;
   verifyFormat("switch (a) {\n"
                "case 1: x = 1; break;\n"
                "case 2: return;\n"
                "case 3:\n"
                "case 4:\n"