[clang-format] Correctly indent closing brace of compound requires

[rymiel]

Summary

When a compound requirement is too long to fit onto a single line, the
braces are split apart onto separate lines, and the contained expression
is indented. However, this indentation would also apply to the closing
brace and the trailing return type requirement thereof.
This was because the indentation level was being restored after all
trailing things were already read

With this change, the initial level of the opening brace is set before
attempting to read any trailing return type requirements

Fixes https://github.com/llvm/llvm-project/issues/57108

[rymiel]

Note: I don't have the historical insight to know why the code order was as it was. I simply tried yoinking the place where the level was being set to occur earlier, and it surprisingly seemed to work, and also seemed to not break any other tests; I hope it doesn't break something in some subtle way

[MyDeveloperDay]

Hmm…it’s nice when it’s this simple, but I get an uneasy feeling about the knock on effects. I’d say go for it but perhaps we could run it over a larger code base to see the implications

[rymiel]

I built 2 versions of clang-format, before and after this patch, and made 2 separate clones of all of LLVM+clang and ran them through either, removing all .clang-formats, then ran a recursive diff.

I found 1 difference, in a test case at clang/test/CodeGen/constrained-math-builtins.c and reduced it to the following:

clang-format before the patch produced this:

int foo() { ; };

  // Comment

#preprocessor

clang-format after this patch produced this:

int foo() { ; };

// Comment

#preprocessor

Very specific requirements here, needing a comment which follows a function with a non-empty body and with a (redundant) trailing semicolon, followed by any preprocessor directive.

Nevertheless, the output seems to make more sense *with* the patch, so I think this counts as a bug fix rather than a regression?

My testing surely isn't perfect but this was the only difference I found (besides instances of the specific bug that this patch was intended to fix)

[MyDeveloperDay]

LGTM

clang/lib/Format/UnwrappedLineParser.cpp

FormatToken *UnwrappedLineParser::parseBlock(
 
   // Munch the closing brace.
   nextToken(/*LevelDifference=*/-AddLevels);
   HandleVerilogBlockLabel();
 
   if (MacroBlock && FormatTok->is(tok::l_paren))
     parseParens();
 
+  Line->Level = InitialLevel;
+
   if (FormatTok->is(tok::kw_noexcept)) {
     // A noexcept in a requires expression.
     nextToken();
   }
 
   if (FormatTok->is(tok::arrow)) {
     // Following the } or noexcept we can find a trailing return type arrow
     // as part of an implicit conversion constraint.
     nextToken();
     parseStructuralElement();
   }
 
   if (MunchSemi && FormatTok->is(tok::semi))
     nextToken();
 
-  Line->Level = InitialLevel;
-
   if (PPStartHash == PPEndHash) {
     Line->MatchingOpeningBlockLineIndex = OpeningLineIndex;
     if (OpeningLineIndex != UnwrappedLine::kInvalidIndex) {
       // Update the opening line to add the forward reference as well
       (*CurrentLines)[OpeningLineIndex].MatchingClosingBlockLineIndex =
           CurrentLines->size() - 1;
     }
   }

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, Concepts) {
   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>\n"
+               "concept C = requires(T x) {\n"
+               "              {\n"
+               "                long_long_long_function_call(1, 2, 3, 4, 5)\n"
+               "              } -> long_long_concept_name<T>;\n"
+               "              {\n"
+               "                long_long_long_function_call(1, 2, 3, 4, 5)\n"
+               "              } noexcept -> long_long_concept_name<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"