[clang-format] Mark pragma region lines as StringLiterals

[thieta]

Summary

In our code-base we auto-generate pragma regions the regions
look like method signatures like:

#pragma region MYREGION(Foo: bar)

The problem here was that the rest of the line after region
was not marked as stringliteral as in the case of pragma mark
so clang-format tried to change the formatting based on the
method signature.

Added test and mark it similar as pragma mark.

[owenpan]

Can you add a test to TokenAnnotatorTest.cpp?

clang/unittests/Format/FormatTest.cpp

19971–19972

Redundant?

[thieta]

Added TokenAnnotatorTest and removed reduntant FormatTests

[thieta]

In D136336#3877238, @owenpan wrote:

Can you add a test to TokenAnnotatorTest.cpp?

Thanks for the review. Fixed it.

[owenpan]

Can you run git-clang-format?

clang/lib/Format/TokenAnnotator.cpp

1340

Over 80 columns.

clang/unittests/Format/TokenAnnotatorTest.cpp

9

Extraneous.

[thieta]

git clang-format
removed accidental include

[owenpan]

LGTM

[HazardyKnusperkeks]

clang/lib/Format/TokenAnnotator.cpp

1344

This shouldn't be here. There is no closing brace for this, or am I missing something?

clang/unittests/Format/TokenAnnotatorTest.cpp

654

Maybe you can add that in a additional commit.

[thieta]

clang/lib/Format/TokenAnnotator.cpp

1344

No you are right it was a miss in the rebase. But it's fixed on main now.

[owenpan]

clang/lib/Format/TokenAnnotator.cpp

1344

Probably caused by https://github.com/llvm/llvm-project/issues/58161, which was fixed in 37e754e5801c.

clang/lib/Format/TokenAnnotator.cpp

void parseWarningOrError() {
     }
   }
 
   void parsePragma() {
     next(); // Consume "pragma".
     if (CurrentToken &&
         CurrentToken->isOneOf(Keywords.kw_mark, Keywords.kw_option,
                               Keywords.kw_region)) {
-      bool IsMark = CurrentToken->is(Keywords.kw_mark);
+      bool IsMarkOrRegion = CurrentToken->isOneOf(Keywords.kw_mark, Keywords.kw_region);
       next();
       next(); // Consume first token (so we fix leading whitespace).
       while (CurrentToken) {
-        if (IsMark || CurrentToken->Previous->is(TT_BinaryOperator))
+        if (IsMarkOrRegion || CurrentToken->Previous->is(TT_BinaryOperator))
           CurrentToken->setType(TT_ImplicitStringLiteral);
         next();
       }
     }
   }
 
   void parseHasInclude() {
     if (!CurrentToken || !CurrentToken->is(tok::l_paren))

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, UnderstandPragmaOption) {
   verifyFormat("#pragma option -C -A");
 
   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
 }
 
 TEST_F(FormatTest, UnderstandPragmaRegion) {
   auto Style = getLLVMStyleWithColumns(0);
   verifyFormat("#pragma region TEST(FOO : BAR)", Style);
-
-  EXPECT_EQ("#pragma region TEST(FOO : BAR)",
-            format("#pragma region TEST(FOO : BAR)", Style));
+  verifyFormat("#pragma region TEST(FOO: NOSPACE)", Style);
 }
 
 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
   FormatStyle Style = getLLVMStyleWithColumns(20);
 
   // See PR41213
   EXPECT_EQ("/*\n"
             " *\t9012345\n"
             " * /8901\n"
             " */",
             format("/*\n"
                    " *\t9012345 /8901\n"

clang/unittests/Format/TokenAnnotatorTest.cpp

 //===- unittest/Format/TokenAnnotatorTest.cpp - Formatting unit tests -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Format/Format.h"
 
 #include "FormatTestUtils.h"
 #include "TestLexer.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace format {
TEST_F(TokenAnnotatorTest, UnderstandsRequiresExpressions) {
   Tokens = annotate("bool r10 = requires (struct new_struct { int x; } s) { "
                     "requires true; };");
   ASSERT_EQ(Tokens.size(), 21u) << Tokens;
   EXPECT_TOKEN(Tokens[3], tok::kw_requires, TT_RequiresExpression);
   EXPECT_TOKEN(Tokens[4], tok::l_paren, TT_RequiresExpressionLParen);
   EXPECT_TOKEN(Tokens[14], tok::l_brace, TT_RequiresExpressionLBrace);
 }
 
+TEST_F(TokenAnnotatorTest, UnderstandsPragmaRegion) {
+  // Everything after #pragma region should be ImplicitStringLiteral
+  auto Tokens = annotate("#pragma region Foo(Bar: Hello)");
+  ASSERT_EQ(Tokens.size(), 10u) << Tokens;
+  EXPECT_TOKEN(Tokens[5], tok::identifier, TT_ImplicitStringLiteral);
+  EXPECT_TOKEN(Tokens[6], tok::colon, TT_ImplicitStringLiteral);
+  EXPECT_TOKEN(Tokens[7], tok::identifier, TT_ImplicitStringLiteral);
+
+  // Make sure it's annotated correctly inside a function as well
+  Tokens = annotate("void test(){\n#pragma region Foo(Bar: Hello)\n}");
+  ASSERT_EQ(Tokens.size(), 16u) << Tokens;
+  EXPECT_TOKEN(Tokens[10], tok::identifier, TT_ImplicitStringLiteral);
+  EXPECT_TOKEN(Tokens[11], tok::colon, TT_ImplicitStringLiteral);
+  EXPECT_TOKEN(Tokens[12], tok::identifier, TT_ImplicitStringLiteral);
+
+}
+
 TEST_F(TokenAnnotatorTest, RequiresDoesNotChangeParsingOfTheRest) {
   const char *BaseCode = nullptr;
   const char *ConstrainedCode = nullptr;
   auto BaseTokenCount = 0u;
   auto RequiresTokenCount = 0u;
   auto PrefixTokenCount = 0u;
 
   auto TestRequires = [&](int Line) {