clang/unittests/Format/FormatTestSelective.cpp

   1 //===- unittest/Format/FormatTestSelective.cpp - Formatting unit tests ----===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "FormatTestUtils.h"
  10 #include "clang/Format/Format.h"
  11 #include "llvm/Support/Debug.h"
  12 #include "gtest/gtest.h"
  13
  14 #define DEBUG_TYPE "format-test"
  15
  16 namespace clang {
  17 namespace format {
  18 namespace {
  19
  20 class FormatTestSelective : public testing::Test {
  21 protected:
  22   std::string format(StringRef Code, unsigned Offset, unsigned Length) {
  23     LLVM_DEBUG(llvm::errs() << "---\n");
  24     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
  25     std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
  26     FormattingAttemptStatus Status;
  27     tooling::Replacements Replaces =
  28         reformat(Style, Code, Ranges, "<stdin>", &Status);
  29     EXPECT_TRUE(Status.FormatComplete) << Code << "\n\n";
  30     auto Result = applyAllReplacements(Code, Replaces);
  31     EXPECT_TRUE(static_cast<bool>(Result));
  32     LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
  33     return *Result;
  34   }
  35
  36   FormatStyle Style = getLLVMStyle();
  37 };
  38
  39 TEST_F(FormatTestSelective, RemovesTrailingWhitespaceOfFormattedLine) {
  40   EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0));
  41   EXPECT_EQ("int a;", format("int a;         ", 0, 0));
  42   EXPECT_EQ("int a;\n", format("int a;  \n   \n   \n ", 0, 0));
  43   EXPECT_EQ("int a;\nint b;    ", format("int a;  \nint b;    ", 0, 0));
  44 }
  45
  46 TEST_F(FormatTestSelective, FormatsCorrectRegionForLeadingWhitespace) {
  47   EXPECT_EQ("{int b;\n"
  48             "  int a;\n"
  49             "}",
  50             format("{int b;\n  int  a;}", 8, 0));
  51   EXPECT_EQ("{\n"
  52             "  int b;\n"
  53             "  int  a;}",
  54             format("{int b;\n  int  a;}", 7, 0));
  55
  56   Style.ColumnLimit = 12;
  57   EXPECT_EQ("#define A  \\\n"
  58             "  int a;   \\\n"
  59             "  int b;",
  60             format("#define A  \\\n"
  61                    "  int a;   \\\n"
  62                    "    int b;",
  63                    26, 0));
  64   EXPECT_EQ("#define A  \\\n"
  65             "  int a;   \\\n"
  66             "  int b;",
  67             format("#define A  \\\n"
  68                    "  int a;   \\\n"
  69                    "  int b;",
  70                    25, 0));
  71 }
  72
  73 TEST_F(FormatTestSelective, FormatLineWhenInvokedOnTrailingNewline) {
  74   EXPECT_EQ("int  b;\n\nint a;", format("int  b;\n\nint a;", 8, 0));
  75   EXPECT_EQ("int b;\n\nint a;", format("int  b;\n\nint a;", 7, 0));
  76
  77   // This might not strictly be correct, but is likely good in all practical
  78   // cases.
  79   EXPECT_EQ("int b;\nint a;", format("int  b;int a;", 7, 0));
  80 }
  81
  82 TEST_F(FormatTestSelective, RemovesWhitespaceWhenTriggeredOnEmptyLine) {
  83   EXPECT_EQ("int  a;\n\n int b;", format("int  a;\n  \n\n int b;", 8, 0));
  84   EXPECT_EQ("int  a;\n\n int b;", format("int  a;\n  \n\n int b;", 9, 0));
  85 }
  86
  87 TEST_F(FormatTestSelective, ReformatsMovedLines) {
  88   EXPECT_EQ(
  89       "template <typename T> T *getFETokenInfo() const {\n"
  90       "  return static_cast<T *>(FETokenInfo);\n"
  91       "}\n"
  92       "int  a; // <- Should not be formatted",
  93       format(
  94           "template<typename T>\n"
  95           "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n"
  96           "int  a; // <- Should not be formatted",
  97           9, 5));
  98 }
  99
 100 TEST_F(FormatTestSelective, FormatsIfWithoutCompoundStatement) {
 101   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
 102   EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1));
 103   EXPECT_EQ("if (a) return; // comment",
 104             format("if(a)\nreturn; // comment", 20, 1));
 105 }
 106
 107 TEST_F(FormatTestSelective, FormatsCommentsLocally) {
 108   EXPECT_EQ("int a;    // comment\n"
 109             "int    b; // comment",
 110             format("int   a; // comment\n"
 111                    "int    b; // comment",
 112                    0, 0));
 113   EXPECT_EQ("int a; // comment\n"
 114             "       // line 2\n"
 115             "int b;",
 116             format("int   a; // comment\n"
 117                    "            // line 2\n"
 118                    "int b;",
 119                    28, 0));
 120   EXPECT_EQ("int   a; // comment\n"
 121             "// comment 2\n"
 122             "int b;",
 123             format("int   a; // comment\n"
 124                    "// comment 2\n"
 125                    "int b;",
 126                    28, 0));
 127   EXPECT_EQ("int aaaaaa; // comment\n"
 128             "int b;\n"
 129             "int c; // unrelated comment",
 130             format("int aaaaaa; // comment\n"
 131                    "int b;\n"
 132                    "int   c; // unrelated comment",
 133                    31, 0));
 134
 135   EXPECT_EQ("int a; // This\n"
 136             "       // is\n"
 137             "       // a",
 138             format("int a;      // This\n"
 139                    "            // is\n"
 140                    "            // a",
 141                    0, 0));
 142   EXPECT_EQ("int a; // This\n"
 143             "       // is\n"
 144             "       // a\n"
 145             "// This is b\n"
 146             "int b;",
 147             format("int a; // This\n"
 148                    "     // is\n"
 149                    "     // a\n"
 150                    "// This is b\n"
 151                    "int b;",
 152                    0, 0));
 153   EXPECT_EQ("int a; // This\n"
 154             "       // is\n"
 155             "       // a\n"
 156             "\n"
 157             "//This is unrelated",
 158             format("int a; // This\n"
 159                    "     // is\n"
 160                    "     // a\n"
 161                    "\n"
 162                    "//This is unrelated",
 163                    0, 0));
 164   EXPECT_EQ("int a;\n"
 165             "// This is\n"
 166             "// not formatted.   ",
 167             format("int a;\n"
 168                    "// This is\n"
 169                    "// not formatted.   ",
 170                    0, 0));
 171   EXPECT_EQ("int x;  // Format this line.\n"
 172             "int xx; //\n"
 173             "int xxxxx; //",
 174             format("int x; // Format this line.\n"
 175                    "int xx; //\n"
 176                    "int xxxxx; //",
 177                    0, 0));
 178 }
 179
 180 TEST_F(FormatTestSelective, ContinueReindenting) {
 181   // When we change an indent, we continue formatting as long as following
 182   // lines are not indented correctly.
 183   EXPECT_EQ("int   i;\n"
 184             "int b;\n"
 185             "int c;\n"
 186             "int d;\n"
 187             "int e;\n"
 188             "  int f;",
 189             format("int   i;\n"
 190                    "  int b;\n"
 191                    " int   c;\n"
 192                    "  int d;\n"
 193                    "int e;\n"
 194                    "  int f;",
 195                    11, 0));
 196 }
 197
 198 TEST_F(FormatTestSelective, ReindentClosingBrace) {
 199   EXPECT_EQ("int   i;\n"
 200             "int f() {\n"
 201             "  int a;\n"
 202             "  int b;\n"
 203             "}\n"
 204             " int c;",
 205             format("int   i;\n"
 206                    "  int f(){\n"
 207                    "int a;\n"
 208                    "int b;\n"
 209                    "  }\n"
 210                    " int c;",
 211                    11, 0));
 212   EXPECT_EQ("void f() {\n"
 213             "  if (foo) {\n"
 214             "    b();\n"
 215             "  } else {\n"
 216             "    c();\n"
 217             "  }\n"
 218             "int d;\n"
 219             "}",
 220             format("void f() {\n"
 221                    "  if (foo) {\n"
 222                    "b();\n"
 223                    "}else{\n"
 224                    "c();\n"
 225                    "}\n"
 226                    "int d;\n"
 227                    "}",
 228                    13, 0));
 229   EXPECT_EQ("int i = []() {\n"
 230             "  class C {\n"
 231             "    int a;\n"
 232             "    int b;\n"
 233             "  };\n"
 234             "  int c;\n"
 235             "};",
 236             format("int i = []() {\n"
 237                    "  class C{\n"
 238                    "int a;\n"
 239                    "int b;\n"
 240                    "};\n"
 241                    "int c;\n"
 242                    "  };",
 243                    17, 0));
 244 }
 245
 246 TEST_F(FormatTestSelective, IndividualStatementsOfNestedBlocks) {
 247   EXPECT_EQ("DEBUG({\n"
 248             "  int i;\n"
 249             "  int        j;\n"
 250             "});",
 251             format("DEBUG(   {\n"
 252                    "  int        i;\n"
 253                    "  int        j;\n"
 254                    "}   )  ;",
 255                    20, 1));
 256   EXPECT_EQ("DEBUG(   {\n"
 257             "  int        i;\n"
 258             "  int j;\n"
 259             "}   )  ;",
 260             format("DEBUG(   {\n"
 261                    "  int        i;\n"
 262                    "  int        j;\n"
 263                    "}   )  ;",
 264                    41, 1));
 265   EXPECT_EQ("DEBUG(   {\n"
 266             "    int        i;\n"
 267             "    int j;\n"
 268             "}   )  ;",
 269             format("DEBUG(   {\n"
 270                    "    int        i;\n"
 271                    "    int        j;\n"
 272                    "}   )  ;",
 273                    41, 1));
 274   EXPECT_EQ("DEBUG({\n"
 275             "  int i;\n"
 276             "  int j;\n"
 277             "});",
 278             format("DEBUG(   {\n"
 279                    "    int        i;\n"
 280                    "    int        j;\n"
 281                    "}   )  ;",
 282                    20, 1));
 283
 284   EXPECT_EQ("Debug({\n"
 285             "        if (aaaaaaaaaaaaaaaaaaaaaaaa)\n"
 286             "          return;\n"
 287             "      },\n"
 288             "      a);",
 289             format("Debug({\n"
 290                    "        if (aaaaaaaaaaaaaaaaaaaaaaaa)\n"
 291                    "             return;\n"
 292                    "      },\n"
 293                    "      a);",
 294                    50, 1));
 295   EXPECT_EQ("DEBUG({\n"
 296             "  DEBUG({\n"
 297             "    int a;\n"
 298             "    int b;\n"
 299             "  }) ;\n"
 300             "});",
 301             format("DEBUG({\n"
 302                    "  DEBUG({\n"
 303                    "    int a;\n"
 304                    "    int    b;\n" // Format this line only.
 305                    "  }) ;\n"        // Don't touch this line.
 306                    "});",
 307                    35, 0));
 308   EXPECT_EQ("DEBUG({\n"
 309             "  int a; //\n"
 310             "});",
 311             format("DEBUG({\n"
 312                    "    int a; //\n"
 313                    "});",
 314                    0, 0));
 315   EXPECT_EQ("someFunction(\n"
 316             "    [] {\n"
 317             "      // Only with this comment.\n"
 318             "      int i; // invoke formatting here.\n"
 319             "    }, // force line break\n"
 320             "    aaa);",
 321             format("someFunction(\n"
 322                    "    [] {\n"
 323                    "      // Only with this comment.\n"
 324                    "      int   i; // invoke formatting here.\n"
 325                    "    }, // force line break\n"
 326                    "    aaa);",
 327                    63, 1));
 328
 329   EXPECT_EQ("int longlongname; // comment\n"
 330             "int x = f({\n"
 331             "  int x; // comment\n"
 332             "  int y; // comment\n"
 333             "});",
 334             format("int longlongname; // comment\n"
 335                    "int x = f({\n"
 336                    "  int x; // comment\n"
 337                    "  int y; // comment\n"
 338                    "});",
 339                    65, 0));
 340   EXPECT_EQ("int s = f({\n"
 341             "  class X {\n"
 342             "  public:\n"
 343             "    void f();\n"
 344             "  };\n"
 345             "});",
 346             format("int s = f({\n"
 347                    "  class X {\n"
 348                    "    public:\n"
 349                    "    void f();\n"
 350                    "  };\n"
 351                    "});",
 352                    0, 0));
 353   EXPECT_EQ("SomeFunction(\n"
 354             "    [] {\n"
 355             "      int i;\n"
 356             "      return i;\n" // Format this line.
 357             "    },\n"
 358             "    [] {\n"
 359             "       return 2;\n" // Don't fix this.
 360             "    });",
 361             format("SomeFunction(\n"
 362                    "    [] {\n"
 363                    "      int i;\n"
 364                    "       return i;\n" // Format this line.
 365                    "    },\n"
 366                    "    [] {\n"
 367                    "       return 2;\n" // Don't fix this.
 368                    "    });",
 369                    40, 0));
 370 }
 371
 372 TEST_F(FormatTestSelective, WrongIndent) {
 373   EXPECT_EQ("namespace {\n"
 374             "int i;\n"
 375             "int j;\n"
 376             "}",
 377             format("namespace {\n"
 378                    "  int i;\n" // Format here.
 379                    "  int j;\n"
 380                    "}",
 381                    15, 0));
 382   EXPECT_EQ("namespace {\n"
 383             "  int i;\n"
 384             "  int j;\n"
 385             "}",
 386             format("namespace {\n"
 387                    "  int i;\n"
 388                    "  int j;\n" // Format here.
 389                    "}",
 390                    24, 0));
 391 }
 392
 393 TEST_F(FormatTestSelective, AlwaysFormatsEntireMacroDefinitions) {
 394   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
 395   EXPECT_EQ("int  i;\n"
 396             "#define A \\\n"
 397             "  int i;  \\\n"
 398             "  int j\n"
 399             "int  k;",
 400             format("int  i;\n"
 401                    "#define A  \\\n"
 402                    " int   i    ;  \\\n"
 403                    " int   j\n"
 404                    "int  k;",
 405                    8, 0)); // 8: position of "#define".
 406   EXPECT_EQ("int  i;\n"
 407             "#define A \\\n"
 408             "  int i;  \\\n"
 409             "  int j\n"
 410             "int  k;",
 411             format("int  i;\n"
 412                    "#define A  \\\n"
 413                    " int   i    ;  \\\n"
 414                    " int   j\n"
 415                    "int  k;",
 416                    45, 0)); // 45: position of "j".
 417 }
 418
 419 TEST_F(FormatTestSelective, ReformatRegionAdjustsIndent) {
 420   EXPECT_EQ("{\n"
 421             "{\n"
 422             "a;\n"
 423             "b;\n"
 424             "}\n"
 425             "}",
 426             format("{\n"
 427                    "{\n"
 428                    "a;\n"
 429                    "     b;\n"
 430                    "}\n"
 431                    "}",
 432                    13, 2));
 433   EXPECT_EQ("{\n"
 434             "{\n"
 435             "  a;\n"
 436             "  b;\n"
 437             "  c;\n"
 438             " d;\n"
 439             "}\n"
 440             "}",
 441             format("{\n"
 442                    "{\n"
 443                    "     a;\n"
 444                    "   b;\n"
 445                    "  c;\n"
 446                    " d;\n"
 447                    "}\n"
 448                    "}",
 449                    9, 2));
 450   EXPECT_EQ("{\n"
 451             "{\n"
 452             "public:\n"
 453             "  b;\n"
 454             "}\n"
 455             "}",
 456             format("{\n"
 457                    "{\n"
 458                    "public:\n"
 459                    "     b;\n"
 460                    "}\n"
 461                    "}",
 462                    17, 2));
 463   EXPECT_EQ("{\n"
 464             "{\n"
 465             "a;\n"
 466             "}\n"
 467             "{\n"
 468             "  b; //\n"
 469             "}\n"
 470             "}",
 471             format("{\n"
 472                    "{\n"
 473                    "a;\n"
 474                    "}\n"
 475                    "{\n"
 476                    "           b; //\n"
 477                    "}\n"
 478                    "}",
 479                    22, 2));
 480   EXPECT_EQ("  {\n"
 481             "    a; //\n"
 482             "  }",
 483             format("  {\n"
 484                    "a; //\n"
 485                    "  }",
 486                    4, 2));
 487   EXPECT_EQ("void f() {}\n"
 488             "void g() {}",
 489             format("void f() {}\n"
 490                    "void g() {}",
 491                    13, 0));
 492   EXPECT_EQ("int a; // comment\n"
 493             "       // line 2\n"
 494             "int b;",
 495             format("int a; // comment\n"
 496                    "       // line 2\n"
 497                    "  int b;",
 498                    35, 0));
 499
 500   EXPECT_EQ(" void f() {\n"
 501             "#define A 1\n"
 502             " }",
 503             format(" void f() {\n"
 504                    "     #define A 1\n" // Format this line.
 505                    " }",
 506                    20, 0));
 507   EXPECT_EQ(" void f() {\n"
 508             "    int i;\n"
 509             "#define A \\\n"
 510             "    int i;  \\\n"
 511             "   int j;\n"
 512             "    int k;\n"
 513             " }",
 514             format(" void f() {\n"
 515                    "    int i;\n"
 516                    "#define A \\\n"
 517                    "    int i;  \\\n"
 518                    "   int j;\n"
 519                    "      int k;\n" // Format this line.
 520                    " }",
 521                    67, 0));
 522
 523   Style.ColumnLimit = 11;
 524   EXPECT_EQ("  int a;\n"
 525             "  void\n"
 526             "  ffffff() {\n"
 527             "  }",
 528             format("  int a;\n"
 529                    "void ffffff() {}",
 530                    11, 0));
 531
 532   // https://github.com/llvm/llvm-project/issues/59178
 533   Style = getMozillaStyle();
 534   EXPECT_EQ("int a()\n"
 535             "{\n"
 536             "return 0;\n"
 537             "}\n"
 538             "int b()\n"
 539             "{\n"
 540             "  return 42;\n"
 541             "}",
 542             format("int a()\n"
 543                    "{\n"
 544                    "return 0;\n"
 545                    "}\n"
 546                    "int b()\n"
 547                    "{\n"
 548                    "return 42;\n" // Format this line only
 549                    "}",
 550                    32, 0));
 551 }
 552
 553 TEST_F(FormatTestSelective, UnderstandsTabs) {
 554   Style.IndentWidth = 8;
 555   Style.UseTab = FormatStyle::UT_Always;
 556   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
 557   EXPECT_EQ("void f() {\n"
 558             "\tf();\n"
 559             "\tg();\n"
 560             "}",
 561             format("void f() {\n"
 562                    "\tf();\n"
 563                    "\tg();\n"
 564                    "}",
 565                    0, 0));
 566   EXPECT_EQ("void f() {\n"
 567             "\tf();\n"
 568             "\tg();\n"
 569             "}",
 570             format("void f() {\n"
 571                    "\tf();\n"
 572                    "\tg();\n"
 573                    "}",
 574                    16, 0));
 575   EXPECT_EQ("void f() {\n"
 576             "  \tf();\n"
 577             "\tg();\n"
 578             "}",
 579             format("void f() {\n"
 580                    "  \tf();\n"
 581                    "  \tg();\n"
 582                    "}",
 583                    21, 0));
 584 }
 585
 586 TEST_F(FormatTestSelective, StopFormattingWhenLeavingScope) {
 587   EXPECT_EQ(
 588       "void f() {\n"
 589       "  if (a) {\n"
 590       "    g();\n"
 591       "    h();\n"
 592       "  }\n"
 593       "\n"
 594       "void g() {\n"
 595       "}",
 596       format("void f() {\n"
 597              "  if (a) {\n" // Assume this was added without the closing brace.
 598              "  g();\n"
 599              "  h();\n"
 600              "}\n"
 601              "\n"
 602              "void g() {\n" // Make sure not to format this.
 603              "}",
 604              15, 0));
 605 }
 606
 607 TEST_F(FormatTestSelective, SelectivelyRequoteJavaScript) {
 608   Style = getGoogleStyle(FormatStyle::LK_JavaScript);
 609   EXPECT_EQ("var x = \"a\";\n"
 610             "var x = 'a';\n"
 611             "var x = \"a\";",
 612             format("var x = \"a\";\n"
 613                    "var x = \"a\";\n"
 614                    "var x = \"a\";",
 615                    20, 0));
 616 }
 617
 618 TEST_F(FormatTestSelective, KeepsIndentAfterCommentSectionImport) {
 619   std::string Code = "#include <a> // line 1\n" // 23 chars long
 620                      "             // line 2\n" // 23 chars long
 621                      "\n"                       // this newline is char 47
 622                      "int i;";                  // this line is not indented
 623   EXPECT_EQ(Code, format(Code, 47, 1));
 624 }
 625
 626 TEST_F(FormatTestSelective, DontAssert) {
 627   // https://llvm.org/PR53880
 628   std::string Code = "void f() {\n"
 629                      "  return a == 8 ? 32 : 16;\n"
 630                      "}\n";
 631   EXPECT_EQ(Code, format(Code, 40, 0));
 632
 633   // https://llvm.org/PR56352
 634   Style.CompactNamespaces = true;
 635   Style.NamespaceIndentation = FormatStyle::NI_All;
 636   Code = "\n"
 637          "namespace ns1 { namespace ns2 {\n"
 638          "}}";
 639   EXPECT_EQ(Code, format(Code, 0, 0));
 640
 641   // https://reviews.llvm.org/D151047#4369742
 642   Style = getLLVMStyle();
 643   Style.FixNamespaceComments = false;
 644   Code = "namespace ns {\n"
 645          "#define REF(alias) alias alias_var;\n"
 646          "}"; // Format this line only
 647   EXPECT_EQ(Code, format(Code, 51, 0));
 648 }
 649
 650 TEST_F(FormatTestSelective, FormatMacroRegardlessOfPreviousIndent) {
 651   // clang-format currently does not (or should not) take into account the
 652   // indent of previous unformatted lines when formatting a PP directive.
 653   // Technically speaking, LevelIndentTracker::IndentForLevel is only for non-PP
 654   // lines. So these tests here check that the indent of previous non-PP lines
 655   // do not affect the formatting. If this requirement changes, the tests here
 656   // need to be adapted.
 657   Style = getLLVMStyle();
 658
 659   const StringRef Code{"      class Foo {\n"
 660                        "            void test() {\n"
 661                        "    #ifdef 1\n"
 662                        "                #define some\n" // format this line
 663                        "         #endif\n"
 664                        "    }};"};
 665
 666   EXPECT_EQ(Style.IndentPPDirectives,
 667             FormatStyle::PPDirectiveIndentStyle::PPDIS_None);
 668   EXPECT_EQ("      class Foo {\n"
 669             "            void test() {\n"
 670             "    #ifdef 1\n"
 671             "#define some\n" // Formatted line
 672             "#endif\n"       // That this line is also formatted might be a bug.
 673             "            }};", // Ditto: Bug?
 674             format(Code, 57, 0));
 675
 676   Style.IndentPPDirectives =
 677       FormatStyle::PPDirectiveIndentStyle::PPDIS_BeforeHash;
 678   EXPECT_EQ("      class Foo {\n"
 679             "            void test() {\n"
 680             "    #ifdef 1\n"
 681             "  #define some\n" // Formatted line
 682             "         #endif\n"
 683             "    }};",
 684             format(Code, 57, 0));
 685
 686   Style.IndentPPDirectives =
 687       FormatStyle::PPDirectiveIndentStyle::PPDIS_AfterHash;
 688   EXPECT_EQ("      class Foo {\n"
 689             "            void test() {\n"
 690             "    #ifdef 1\n"
 691             "#  define some\n" // Formatted line
 692             "#endif\n" // That this line is also formatted might be a bug.
 693             "    }};",
 694             format(Code, 57, 0));
 695 }
 696
 697 } // end namespace
 698 } // end namespace format
 699 } // end namespace clang