[clang-format] Don't put `noexcept` on empty line following constructor

[rymiel]

Summary

With the AlwaysBreakTemplateDeclarations option, having a constructor
template for a type consisting of all-uppercase letters with a
noexcept specifier would put said noexcept specifier on its own blank
line.

This is because the all-uppercase type is understood as a macro-like
attribute (such as DEPRECATED()), and noexcept is seen as the
declaration. However, noexcept is a keyword and cannot be an
identifier on its own.

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

[rymiel]

Note for reviewing:
The criteria for reaching this misformat are extremely specific, requiring a single-character type or a type of a type consisting of all-uppercase letter, which are poor style on their own.
I am also unsure how often this all-uppercase macro-like attribute syntax is relied upon

I chose to simply add the keyword noexcept to the negative check for symbols, since, as far as I am aware, noexcept is the only legal specifier which can follow a constructor
However, I am unsure what the usual course of action is for version/language specific things, since I only use clang-format for modern C++, but it appears to be capable of a whole lot more than that.
I ask this because directly after my added line, there's mention of Objective-C, and technically noexcept itself wasn't always in C++. Should there be extra checks for these.

There could also possibly be a TokenAnnotatorTest checking for TT_FunctionAnnotationRParen, but there wasn't an existing one similar to it, so I was unsure if I should add one

[HazardyKnusperkeks]

In D132189#3733747, @rymiel wrote:

There could also possibly be a TokenAnnotatorTest checking for TT_FunctionAnnotationRParen, but there wasn't an existing one similar to it, so I was unsure if I should add one

Always. :) In my opinion there are way too few annotator tests and one relies only on the formatting.

clang/unittests/Format/FormatTest.cpp

9619

Could you add a class with more than one character all upper case?

[rymiel]

Extra tests, including token annotator tests

[MyDeveloperDay]

This looks pretty good to me, but wait for @HazardyKnusperkeks

[curdeius]

@rymiel, please provide your name and email address for the commit message, so that we can land it for you.

[rymiel]

Emilia Dreamer <[e-mail]>

Thank you!!

clang/lib/Format/TokenAnnotator.cpp

if (Current.is(Keywords.kw_instanceof)) {
         Current.setType(TT_CppCastLParen);
     } else if (Current.is(tok::r_paren)) {
       if (rParenEndsCast(Current))
         Current.setType(TT_CastRParen);
       if (Current.MatchingParen && Current.Next &&
           !Current.Next->isBinaryOperator() &&
           !Current.Next->isOneOf(tok::semi, tok::colon, tok::l_brace,
                                  tok::comma, tok::period, tok::arrow,
-                                 tok::coloncolon)) {
+                                 tok::coloncolon, tok::kw_noexcept)) {
         if (FormatToken *AfterParen = Current.MatchingParen->Next) {
           // Make sure this isn't the return type of an Obj-C block declaration
           if (AfterParen->isNot(tok::caret)) {
             if (FormatToken *BeforeParen = Current.MatchingParen->Previous) {
               if (BeforeParen->is(tok::identifier) &&
                   !BeforeParen->is(TT_TypenameMacro) &&
                   BeforeParen->TokenText == BeforeParen->TokenText.upper() &&
                   (!BeforeParen->Previous ||

clang/unittests/Format/FormatTest.cpp

verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
   verifyFormat("template <template <typename> class Fooooooo,\n"
                "          template <typename> class Baaaaaaar>\n"
                "struct C {};",
                AlwaysBreak);
   verifyFormat("template <typename T> // T can be A, B or C.\n"
                "struct C {};",
                AlwaysBreak);
+  verifyFormat("template <typename T>\n"
+               "C(T) noexcept;",
+               AlwaysBreak);
+  verifyFormat("template <typename T>\n"
+               "ClassName(T) noexcept;",
+               AlwaysBreak);
+  verifyFormat("template <typename T>\n"
+               "POOR_NAME(T) noexcept;",
+               AlwaysBreak);
   verifyFormat("template <enum E> class A {\n"
                "public:\n"
                "  E *f();\n"
                "};");
 
   FormatStyle NeverBreak = getLLVMStyle();
   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
   verifyFormat("template <typename T> class C {};", NeverBreak);
   verifyFormat("template <typename T> void f();", NeverBreak);
   verifyFormat("template <typename T> void f() {}", NeverBreak);
+  verifyFormat("template <typename T> C(T) noexcept;", NeverBreak);
+  verifyFormat("template <typename T> ClassName(T) noexcept;", NeverBreak);
+  verifyFormat("template <typename T> POOR_NAME(T) noexcept;", NeverBreak);
   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
                "bbbbbbbbbbbbbbbbbbbb) {}",
                NeverBreak);
   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
                NeverBreak);
   verifyFormat("template <template <typename> class Fooooooo,\n"

clang/unittests/Format/TokenAnnotatorTest.cpp

TEST_F(TokenAnnotatorTest, UnderstandsLambdas) {
   EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_LambdaLBrace);
 
   Tokens = annotate("[]() -> auto * {}");
   ASSERT_EQ(Tokens.size(), 10u) << Tokens;
   EXPECT_TOKEN(Tokens[4], tok::arrow, TT_LambdaArrow);
   EXPECT_TOKEN(Tokens[7], tok::l_brace, TT_LambdaLBrace);
 }
 
+TEST_F(TokenAnnotatorTest, UnderstandsFunctionAnnotations) {
+  auto Tokens = annotate("template <typename T>\n"
+                         "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
+                         "string OldFunction(const string &parameter) {}");
+  ASSERT_EQ(Tokens.size(), 20u) << Tokens;
+  EXPECT_TOKEN(Tokens[8], tok::r_paren, TT_FunctionAnnotationRParen);
+
+  Tokens = annotate("template <typename T>\n"
+                    "A(T) noexcept;");
+  ASSERT_EQ(Tokens.size(), 12u) << Tokens;
+  EXPECT_TOKEN(Tokens[8], tok::r_paren, TT_Unknown);
+}
+
 TEST_F(TokenAnnotatorTest, UnderstandsVerilogOperators) {
   auto Annotate = [this](llvm::StringRef Code) {
     return annotate(Code, getLLVMStyle(FormatStyle::LK_Verilog));
   };
   // Test that unary operators get labeled as such and that operators like '++'
   // don't get split.
   tok::TokenKind Unary[] = {tok::plus,  tok::minus,    tok::exclaim,
                             tok::tilde, tok::amp,      tok::pipe,