1 //===--- Format.h - Format C++ code -----------------------------*- C++ -*-===// 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 /// \file 10 /// Various functions to configurably format source code. 11 /// 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_FORMAT_FORMAT_H 15 #define LLVM_CLANG_FORMAT_FORMAT_H 16 17 #include "clang/Basic/LangOptions.h" 18 #include "clang/Tooling/Core/Replacement.h" 19 #include "clang/Tooling/Inclusions/IncludeStyle.h" 20 #include "llvm/ADT/ArrayRef.h" 21 #include "llvm/Support/Regex.h" 22 #include "llvm/Support/SourceMgr.h" 23 #include <optional> 24 #include <system_error> 25 26 namespace llvm { 27 namespace vfs { 28 class FileSystem; 29 } 30 } // namespace llvm 31 32 namespace clang { 33 namespace format { 34 35 enum class ParseError { 36 Success = 0, 37 Error, 38 Unsuitable, 39 BinPackTrailingCommaConflict, 40 InvalidQualifierSpecified, 41 DuplicateQualifierSpecified, 42 MissingQualifierType, 43 MissingQualifierOrder 44 }; 45 class ParseErrorCategory final : public std::error_category { 46 public: 47 const char *name() const noexcept override; 48 std::string message(int EV) const override; 49 }; 50 const std::error_category &getParseCategory(); 51 std::error_code make_error_code(ParseError e); 52 53 /// The ``FormatStyle`` is used to configure the formatting to follow 54 /// specific guidelines. 55 struct FormatStyle { 56 // If the BasedOn: was InheritParentConfig and this style needs the file from 57 // the parent directories. It is not part of the actual style for formatting. 58 // Thus the // instead of ///. 59 bool InheritsParentConfig; 60 61 /// The extra indent or outdent of access modifiers, e.g. ``public:``. 62 /// \version 3.3 63 int AccessModifierOffset; 64 65 /// Different styles for aligning after open brackets. 66 enum BracketAlignmentStyle : int8_t { 67 /// Align parameters on the open bracket, e.g.: 68 /// \code 69 /// someLongFunction(argument1, 70 /// argument2); 71 /// \endcode 72 BAS_Align, 73 /// Don't align, instead use ``ContinuationIndentWidth``, e.g.: 74 /// \code 75 /// someLongFunction(argument1, 76 /// argument2); 77 /// \endcode 78 BAS_DontAlign, 79 /// Always break after an open bracket, if the parameters don't fit 80 /// on a single line, e.g.: 81 /// \code 82 /// someLongFunction( 83 /// argument1, argument2); 84 /// \endcode 85 BAS_AlwaysBreak, 86 /// Always break after an open bracket, if the parameters don't fit 87 /// on a single line. Closing brackets will be placed on a new line. 88 /// E.g.: 89 /// \code 90 /// someLongFunction( 91 /// argument1, argument2 92 /// ) 93 /// \endcode 94 /// 95 /// \note 96 /// This currently only applies to braced initializer lists (when 97 /// ``Cpp11BracedListStyle`` is ``true``) and parentheses. 98 /// \endnote 99 BAS_BlockIndent, 100 }; 101 102 /// If ``true``, horizontally aligns arguments after an open bracket. 103 /// 104 /// This applies to round brackets (parentheses), angle brackets and square 105 /// brackets. 106 /// \version 3.8 107 BracketAlignmentStyle AlignAfterOpenBracket; 108 109 /// Different style for aligning array initializers. 110 enum ArrayInitializerAlignmentStyle : int8_t { 111 /// Align array column and left justify the columns e.g.: 112 /// \code 113 /// struct test demo[] = 114 /// { 115 /// {56, 23, "hello"}, 116 /// {-1, 93463, "world"}, 117 /// {7, 5, "!!" } 118 /// }; 119 /// \endcode 120 AIAS_Left, 121 /// Align array column and right justify the columns e.g.: 122 /// \code 123 /// struct test demo[] = 124 /// { 125 /// {56, 23, "hello"}, 126 /// {-1, 93463, "world"}, 127 /// { 7, 5, "!!"} 128 /// }; 129 /// \endcode 130 AIAS_Right, 131 /// Don't align array initializer columns. 132 AIAS_None 133 }; 134 /// If not ``None``, when using initialization for an array of structs 135 /// aligns the fields into columns. 136 /// 137 /// \note 138 /// As of clang-format 15 this option only applied to arrays with equal 139 /// number of columns per row. 140 /// \endnote 141 /// 142 /// \version 13 143 ArrayInitializerAlignmentStyle AlignArrayOfStructures; 144 145 /// Alignment options. 146 /// 147 /// They can also be read as a whole for compatibility. The choices are: 148 /// 149 /// * ``None`` 150 /// * ``Consecutive`` 151 /// * ``AcrossEmptyLines`` 152 /// * ``AcrossComments`` 153 /// * ``AcrossEmptyLinesAndComments`` 154 /// 155 /// For example, to align across empty lines and not across comments, either 156 /// of these work. 157 /// \code 158 /// <option-name>: AcrossEmptyLines 159 /// 160 /// <option-name>: 161 /// Enabled: true 162 /// AcrossEmptyLines: true 163 /// AcrossComments: false 164 /// \endcode 165 struct AlignConsecutiveStyle { 166 /// Whether aligning is enabled. 167 /// \code 168 /// #define SHORT_NAME 42 169 /// #define LONGER_NAME 0x007f 170 /// #define EVEN_LONGER_NAME (2) 171 /// #define foo(x) (x * x) 172 /// #define bar(y, z) (y + z) 173 /// 174 /// int a = 1; 175 /// int somelongname = 2; 176 /// double c = 3; 177 /// 178 /// int aaaa : 1; 179 /// int b : 12; 180 /// int ccc : 8; 181 /// 182 /// int aaaa = 12; 183 /// float b = 23; 184 /// std::string ccc; 185 /// \endcode 186 bool Enabled; 187 /// Whether to align across empty lines. 188 /// \code 189 /// true: 190 /// int a = 1; 191 /// int somelongname = 2; 192 /// double c = 3; 193 /// 194 /// int d = 3; 195 /// 196 /// false: 197 /// int a = 1; 198 /// int somelongname = 2; 199 /// double c = 3; 200 /// 201 /// int d = 3; 202 /// \endcode 203 bool AcrossEmptyLines; 204 /// Whether to align across comments. 205 /// \code 206 /// true: 207 /// int d = 3; 208 /// /* A comment. */ 209 /// double e = 4; 210 /// 211 /// false: 212 /// int d = 3; 213 /// /* A comment. */ 214 /// double e = 4; 215 /// \endcode 216 bool AcrossComments; 217 /// Only for ``AlignConsecutiveAssignments``. Whether compound assignments 218 /// like ``+=`` are aligned along with ``=``. 219 /// \code 220 /// true: 221 /// a &= 2; 222 /// bbb = 2; 223 /// 224 /// false: 225 /// a &= 2; 226 /// bbb = 2; 227 /// \endcode 228 bool AlignCompound; 229 /// Only for ``AlignConsecutiveDeclarations``. Whether function declarations 230 /// are aligned. 231 /// \code 232 /// true: 233 /// unsigned int f1(void); 234 /// void f2(void); 235 /// size_t f3(void); 236 /// 237 /// false: 238 /// unsigned int f1(void); 239 /// void f2(void); 240 /// size_t f3(void); 241 /// \endcode 242 bool AlignFunctionDeclarations; 243 /// Only for ``AlignConsecutiveDeclarations``. Whether function pointers are 244 /// aligned. 245 /// \code 246 /// true: 247 /// unsigned i; 248 /// int &r; 249 /// int *p; 250 /// int (*f)(); 251 /// 252 /// false: 253 /// unsigned i; 254 /// int &r; 255 /// int *p; 256 /// int (*f)(); 257 /// \endcode 258 bool AlignFunctionPointers; 259 /// Only for ``AlignConsecutiveAssignments``. Whether short assignment 260 /// operators are left-padded to the same length as long ones in order to 261 /// put all assignment operators to the right of the left hand side. 262 /// \code 263 /// true: 264 /// a >>= 2; 265 /// bbb = 2; 266 /// 267 /// a = 2; 268 /// bbb >>= 2; 269 /// 270 /// false: 271 /// a >>= 2; 272 /// bbb = 2; 273 /// 274 /// a = 2; 275 /// bbb >>= 2; 276 /// \endcode 277 bool PadOperators; 278 bool operator==(const AlignConsecutiveStyle &R) const { 279 return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines && 280 AcrossComments == R.AcrossComments && 281 AlignCompound == R.AlignCompound && 282 AlignFunctionDeclarations == R.AlignFunctionDeclarations && 283 AlignFunctionPointers == R.AlignFunctionPointers && 284 PadOperators == R.PadOperators; 285 } 286 bool operator!=(const AlignConsecutiveStyle &R) const { 287 return !(*this == R); 288 } 289 }; 290 291 /// Style of aligning consecutive macro definitions. 292 /// 293 /// ``Consecutive`` will result in formattings like: 294 /// \code 295 /// #define SHORT_NAME 42 296 /// #define LONGER_NAME 0x007f 297 /// #define EVEN_LONGER_NAME (2) 298 /// #define foo(x) (x * x) 299 /// #define bar(y, z) (y + z) 300 /// \endcode 301 /// \version 9 302 AlignConsecutiveStyle AlignConsecutiveMacros; 303 /// Style of aligning consecutive assignments. 304 /// 305 /// ``Consecutive`` will result in formattings like: 306 /// \code 307 /// int a = 1; 308 /// int somelongname = 2; 309 /// double c = 3; 310 /// \endcode 311 /// \version 3.8 312 AlignConsecutiveStyle AlignConsecutiveAssignments; 313 /// Style of aligning consecutive bit fields. 314 /// 315 /// ``Consecutive`` will align the bitfield separators of consecutive lines. 316 /// This will result in formattings like: 317 /// \code 318 /// int aaaa : 1; 319 /// int b : 12; 320 /// int ccc : 8; 321 /// \endcode 322 /// \version 11 323 AlignConsecutiveStyle AlignConsecutiveBitFields; 324 /// Style of aligning consecutive declarations. 325 /// 326 /// ``Consecutive`` will align the declaration names of consecutive lines. 327 /// This will result in formattings like: 328 /// \code 329 /// int aaaa = 12; 330 /// float b = 23; 331 /// std::string ccc; 332 /// \endcode 333 /// \version 3.8 334 AlignConsecutiveStyle AlignConsecutiveDeclarations; 335 336 /// Alignment options. 337 /// 338 struct ShortCaseStatementsAlignmentStyle { 339 /// Whether aligning is enabled. 340 /// \code 341 /// true: 342 /// switch (level) { 343 /// case log::info: return "info:"; 344 /// case log::warning: return "warning:"; 345 /// default: return ""; 346 /// } 347 /// 348 /// false: 349 /// switch (level) { 350 /// case log::info: return "info:"; 351 /// case log::warning: return "warning:"; 352 /// default: return ""; 353 /// } 354 /// \endcode 355 bool Enabled; 356 /// Whether to align across empty lines. 357 /// \code 358 /// true: 359 /// switch (level) { 360 /// case log::info: return "info:"; 361 /// case log::warning: return "warning:"; 362 /// 363 /// default: return ""; 364 /// } 365 /// 366 /// false: 367 /// switch (level) { 368 /// case log::info: return "info:"; 369 /// case log::warning: return "warning:"; 370 /// 371 /// default: return ""; 372 /// } 373 /// \endcode 374 bool AcrossEmptyLines; 375 /// Whether to align across comments. 376 /// \code 377 /// true: 378 /// switch (level) { 379 /// case log::info: return "info:"; 380 /// case log::warning: return "warning:"; 381 /// /* A comment. */ 382 /// default: return ""; 383 /// } 384 /// 385 /// false: 386 /// switch (level) { 387 /// case log::info: return "info:"; 388 /// case log::warning: return "warning:"; 389 /// /* A comment. */ 390 /// default: return ""; 391 /// } 392 /// \endcode 393 bool AcrossComments; 394 /// Whether to align the case arrows when aligning short case expressions. 395 /// \code{.java} 396 /// true: 397 /// i = switch (day) { 398 /// case THURSDAY, SATURDAY -> 8; 399 /// case WEDNESDAY -> 9; 400 /// default -> 0; 401 /// }; 402 /// 403 /// false: 404 /// i = switch (day) { 405 /// case THURSDAY, SATURDAY -> 8; 406 /// case WEDNESDAY -> 9; 407 /// default -> 0; 408 /// }; 409 /// \endcode 410 bool AlignCaseArrows; 411 /// Whether aligned case labels are aligned on the colon, or on the tokens 412 /// after the colon. 413 /// \code 414 /// true: 415 /// switch (level) { 416 /// case log::info : return "info:"; 417 /// case log::warning: return "warning:"; 418 /// default : return ""; 419 /// } 420 /// 421 /// false: 422 /// switch (level) { 423 /// case log::info: return "info:"; 424 /// case log::warning: return "warning:"; 425 /// default: return ""; 426 /// } 427 /// \endcode 428 bool AlignCaseColons; 429 bool operator==(const ShortCaseStatementsAlignmentStyle &R) const { 430 return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines && 431 AcrossComments == R.AcrossComments && 432 AlignCaseArrows == R.AlignCaseArrows && 433 AlignCaseColons == R.AlignCaseColons; 434 } 435 }; 436 437 /// Style of aligning consecutive short case labels. 438 /// Only applies if ``AllowShortCaseExpressionOnASingleLine`` or 439 /// ``AllowShortCaseLabelsOnASingleLine`` is ``true``. 440 /// 441 /// \code{.yaml} 442 /// # Example of usage: 443 /// AlignConsecutiveShortCaseStatements: 444 /// Enabled: true 445 /// AcrossEmptyLines: true 446 /// AcrossComments: true 447 /// AlignCaseColons: false 448 /// \endcode 449 /// \version 17 450 ShortCaseStatementsAlignmentStyle AlignConsecutiveShortCaseStatements; 451 452 /// Style of aligning consecutive TableGen DAGArg operator colons. 453 /// If enabled, align the colon inside DAGArg which have line break inside. 454 /// This works only when TableGenBreakInsideDAGArg is BreakElements or 455 /// BreakAll and the DAGArg is not excepted by 456 /// TableGenBreakingDAGArgOperators's effect. 457 /// \code 458 /// let dagarg = (ins 459 /// a :$src1, 460 /// aa :$src2, 461 /// aaa:$src3 462 /// ) 463 /// \endcode 464 /// \version 19 465 AlignConsecutiveStyle AlignConsecutiveTableGenBreakingDAGArgColons; 466 467 /// Style of aligning consecutive TableGen cond operator colons. 468 /// Align the colons of cases inside !cond operators. 469 /// \code 470 /// !cond(!eq(size, 1) : 1, 471 /// !eq(size, 16): 1, 472 /// true : 0) 473 /// \endcode 474 /// \version 19 475 AlignConsecutiveStyle AlignConsecutiveTableGenCondOperatorColons; 476 477 /// Style of aligning consecutive TableGen definition colons. 478 /// This aligns the inheritance colons of consecutive definitions. 479 /// \code 480 /// def Def : Parent {} 481 /// def DefDef : Parent {} 482 /// def DefDefDef : Parent {} 483 /// \endcode 484 /// \version 19 485 AlignConsecutiveStyle AlignConsecutiveTableGenDefinitionColons; 486 487 /// Different styles for aligning escaped newlines. 488 enum EscapedNewlineAlignmentStyle : int8_t { 489 /// Don't align escaped newlines. 490 /// \code 491 /// #define A \ 492 /// int aaaa; \ 493 /// int b; \ 494 /// int dddddddddd; 495 /// \endcode 496 ENAS_DontAlign, 497 /// Align escaped newlines as far left as possible. 498 /// \code 499 /// #define A \ 500 /// int aaaa; \ 501 /// int b; \ 502 /// int dddddddddd; 503 /// \endcode 504 ENAS_Left, 505 /// Align escaped newlines as far left as possible, using the last line of 506 /// the preprocessor directive as the reference if it's the longest. 507 /// \code 508 /// #define A \ 509 /// int aaaa; \ 510 /// int b; \ 511 /// int dddddddddd; 512 /// \endcode 513 ENAS_LeftWithLastLine, 514 /// Align escaped newlines in the right-most column. 515 /// \code 516 /// #define A \ 517 /// int aaaa; \ 518 /// int b; \ 519 /// int dddddddddd; 520 /// \endcode 521 ENAS_Right, 522 }; 523 524 /// Options for aligning backslashes in escaped newlines. 525 /// \version 5 526 EscapedNewlineAlignmentStyle AlignEscapedNewlines; 527 528 /// Different styles for aligning operands. 529 enum OperandAlignmentStyle : int8_t { 530 /// Do not align operands of binary and ternary expressions. 531 /// The wrapped lines are indented ``ContinuationIndentWidth`` spaces from 532 /// the start of the line. 533 OAS_DontAlign, 534 /// Horizontally align operands of binary and ternary expressions. 535 /// 536 /// Specifically, this aligns operands of a single expression that needs 537 /// to be split over multiple lines, e.g.: 538 /// \code 539 /// int aaa = bbbbbbbbbbbbbbb + 540 /// ccccccccccccccc; 541 /// \endcode 542 /// 543 /// When ``BreakBeforeBinaryOperators`` is set, the wrapped operator is 544 /// aligned with the operand on the first line. 545 /// \code 546 /// int aaa = bbbbbbbbbbbbbbb 547 /// + ccccccccccccccc; 548 /// \endcode 549 OAS_Align, 550 /// Horizontally align operands of binary and ternary expressions. 551 /// 552 /// This is similar to ``OAS_Align``, except when 553 /// ``BreakBeforeBinaryOperators`` is set, the operator is un-indented so 554 /// that the wrapped operand is aligned with the operand on the first line. 555 /// \code 556 /// int aaa = bbbbbbbbbbbbbbb 557 /// + ccccccccccccccc; 558 /// \endcode 559 OAS_AlignAfterOperator, 560 }; 561 562 /// If ``true``, horizontally align operands of binary and ternary 563 /// expressions. 564 /// \version 3.5 565 OperandAlignmentStyle AlignOperands; 566 567 /// Enums for AlignTrailingComments 568 enum TrailingCommentsAlignmentKinds : int8_t { 569 /// Leave trailing comments as they are. 570 /// \code 571 /// int a; // comment 572 /// int ab; // comment 573 /// 574 /// int abc; // comment 575 /// int abcd; // comment 576 /// \endcode 577 TCAS_Leave, 578 /// Align trailing comments. 579 /// \code 580 /// int a; // comment 581 /// int ab; // comment 582 /// 583 /// int abc; // comment 584 /// int abcd; // comment 585 /// \endcode 586 TCAS_Always, 587 /// Don't align trailing comments but other formatter applies. 588 /// \code 589 /// int a; // comment 590 /// int ab; // comment 591 /// 592 /// int abc; // comment 593 /// int abcd; // comment 594 /// \endcode 595 TCAS_Never, 596 }; 597 598 /// Alignment options 599 struct TrailingCommentsAlignmentStyle { 600 /// Specifies the way to align trailing comments. 601 TrailingCommentsAlignmentKinds Kind; 602 /// How many empty lines to apply alignment. 603 /// When both ``MaxEmptyLinesToKeep`` and ``OverEmptyLines`` are set to 2, 604 /// it formats like below. 605 /// \code 606 /// int a; // all these 607 /// 608 /// int ab; // comments are 609 /// 610 /// 611 /// int abcdef; // aligned 612 /// \endcode 613 /// 614 /// When ``MaxEmptyLinesToKeep`` is set to 2 and ``OverEmptyLines`` is set 615 /// to 1, it formats like below. 616 /// \code 617 /// int a; // these are 618 /// 619 /// int ab; // aligned 620 /// 621 /// 622 /// int abcdef; // but this isn't 623 /// \endcode 624 unsigned OverEmptyLines; 625 626 bool operator==(const TrailingCommentsAlignmentStyle &R) const { 627 return Kind == R.Kind && OverEmptyLines == R.OverEmptyLines; 628 } 629 bool operator!=(const TrailingCommentsAlignmentStyle &R) const { 630 return !(*this == R); 631 } 632 }; 633 634 /// Control of trailing comments. 635 /// 636 /// The alignment stops at closing braces after a line break, and only 637 /// followed by other closing braces, a (``do-``) ``while``, a lambda call, or 638 /// a semicolon. 639 /// 640 /// \note 641 /// As of clang-format 16 this option is not a bool but can be set 642 /// to the options. Conventional bool options still can be parsed as before. 643 /// \endnote 644 /// 645 /// \code{.yaml} 646 /// # Example of usage: 647 /// AlignTrailingComments: 648 /// Kind: Always 649 /// OverEmptyLines: 2 650 /// \endcode 651 /// \version 3.7 652 TrailingCommentsAlignmentStyle AlignTrailingComments; 653 654 /// \brief If a function call or braced initializer list doesn't fit on a 655 /// line, allow putting all arguments onto the next line, even if 656 /// ``BinPackArguments`` is ``false``. 657 /// \code 658 /// true: 659 /// callFunction( 660 /// a, b, c, d); 661 /// 662 /// false: 663 /// callFunction(a, 664 /// b, 665 /// c, 666 /// d); 667 /// \endcode 668 /// \version 9 669 bool AllowAllArgumentsOnNextLine; 670 671 /// This option is **deprecated**. See ``NextLine`` of 672 /// ``PackConstructorInitializers``. 673 /// \version 9 674 // bool AllowAllConstructorInitializersOnNextLine; 675 676 /// If the function declaration doesn't fit on a line, 677 /// allow putting all parameters of a function declaration onto 678 /// the next line even if ``BinPackParameters`` is ``OnePerLine``. 679 /// \code 680 /// true: 681 /// void myFunction( 682 /// int a, int b, int c, int d, int e); 683 /// 684 /// false: 685 /// void myFunction(int a, 686 /// int b, 687 /// int c, 688 /// int d, 689 /// int e); 690 /// \endcode 691 /// \version 3.3 692 bool AllowAllParametersOfDeclarationOnNextLine; 693 694 /// Different ways to break before a noexcept specifier. 695 enum BreakBeforeNoexceptSpecifierStyle : int8_t { 696 /// No line break allowed. 697 /// \code 698 /// void foo(int arg1, 699 /// double arg2) noexcept; 700 /// 701 /// void bar(int arg1, double arg2) noexcept( 702 /// noexcept(baz(arg1)) && 703 /// noexcept(baz(arg2))); 704 /// \endcode 705 BBNSS_Never, 706 /// For a simple ``noexcept`` there is no line break allowed, but when we 707 /// have a condition it is. 708 /// \code 709 /// void foo(int arg1, 710 /// double arg2) noexcept; 711 /// 712 /// void bar(int arg1, double arg2) 713 /// noexcept(noexcept(baz(arg1)) && 714 /// noexcept(baz(arg2))); 715 /// \endcode 716 BBNSS_OnlyWithParen, 717 /// Line breaks are allowed. But note that because of the associated 718 /// penalties ``clang-format`` often prefers not to break before the 719 /// ``noexcept``. 720 /// \code 721 /// void foo(int arg1, 722 /// double arg2) noexcept; 723 /// 724 /// void bar(int arg1, double arg2) 725 /// noexcept(noexcept(baz(arg1)) && 726 /// noexcept(baz(arg2))); 727 /// \endcode 728 BBNSS_Always, 729 }; 730 731 /// Controls if there could be a line break before a ``noexcept`` specifier. 732 /// \version 18 733 BreakBeforeNoexceptSpecifierStyle AllowBreakBeforeNoexceptSpecifier; 734 735 /// Different styles for merging short blocks containing at most one 736 /// statement. 737 enum ShortBlockStyle : int8_t { 738 /// Never merge blocks into a single line. 739 /// \code 740 /// while (true) { 741 /// } 742 /// while (true) { 743 /// continue; 744 /// } 745 /// \endcode 746 SBS_Never, 747 /// Only merge empty blocks. 748 /// \code 749 /// while (true) {} 750 /// while (true) { 751 /// continue; 752 /// } 753 /// \endcode 754 SBS_Empty, 755 /// Always merge short blocks into a single line. 756 /// \code 757 /// while (true) {} 758 /// while (true) { continue; } 759 /// \endcode 760 SBS_Always, 761 }; 762 763 /// Dependent on the value, ``while (true) { continue; }`` can be put on a 764 /// single line. 765 /// \version 3.5 766 ShortBlockStyle AllowShortBlocksOnASingleLine; 767 768 /// Whether to merge a short switch labeled rule into a single line. 769 /// \code{.java} 770 /// true: false: 771 /// switch (a) { vs. switch (a) { 772 /// case 1 -> 1; case 1 -> 773 /// default -> 0; 1; 774 /// }; default -> 775 /// 0; 776 /// }; 777 /// \endcode 778 /// \version 19 779 bool AllowShortCaseExpressionOnASingleLine; 780 781 /// If ``true``, short case labels will be contracted to a single line. 782 /// \code 783 /// true: false: 784 /// switch (a) { vs. switch (a) { 785 /// case 1: x = 1; break; case 1: 786 /// case 2: return; x = 1; 787 /// } break; 788 /// case 2: 789 /// return; 790 /// } 791 /// \endcode 792 /// \version 3.6 793 bool AllowShortCaseLabelsOnASingleLine; 794 795 /// Allow short compound requirement on a single line. 796 /// \code 797 /// true: 798 /// template <typename T> 799 /// concept c = requires(T x) { 800 /// { x + 1 } -> std::same_as<int>; 801 /// }; 802 /// 803 /// false: 804 /// template <typename T> 805 /// concept c = requires(T x) { 806 /// { 807 /// x + 1 808 /// } -> std::same_as<int>; 809 /// }; 810 /// \endcode 811 /// \version 18 812 bool AllowShortCompoundRequirementOnASingleLine; 813 814 /// Allow short enums on a single line. 815 /// \code 816 /// true: 817 /// enum { A, B } myEnum; 818 /// 819 /// false: 820 /// enum { 821 /// A, 822 /// B 823 /// } myEnum; 824 /// \endcode 825 /// \version 11 826 bool AllowShortEnumsOnASingleLine; 827 828 /// Different styles for merging short functions containing at most one 829 /// statement. 830 enum ShortFunctionStyle : int8_t { 831 /// Never merge functions into a single line. 832 SFS_None, 833 /// Only merge functions defined inside a class. Same as ``inline``, 834 /// except it does not implies ``empty``: i.e. top level empty functions 835 /// are not merged either. 836 /// \code 837 /// class Foo { 838 /// void f() { foo(); } 839 /// }; 840 /// void f() { 841 /// foo(); 842 /// } 843 /// void f() { 844 /// } 845 /// \endcode 846 SFS_InlineOnly, 847 /// Only merge empty functions. 848 /// \code 849 /// void f() {} 850 /// void f2() { 851 /// bar2(); 852 /// } 853 /// \endcode 854 SFS_Empty, 855 /// Only merge functions defined inside a class. Implies ``empty``. 856 /// \code 857 /// class Foo { 858 /// void f() { foo(); } 859 /// }; 860 /// void f() { 861 /// foo(); 862 /// } 863 /// void f() {} 864 /// \endcode 865 SFS_Inline, 866 /// Merge all functions fitting on a single line. 867 /// \code 868 /// class Foo { 869 /// void f() { foo(); } 870 /// }; 871 /// void f() { bar(); } 872 /// \endcode 873 SFS_All, 874 }; 875 876 /// Dependent on the value, ``int f() { return 0; }`` can be put on a 877 /// single line. 878 /// \version 3.5 879 ShortFunctionStyle AllowShortFunctionsOnASingleLine; 880 881 /// Different styles for handling short if statements. 882 enum ShortIfStyle : int8_t { 883 /// Never put short ifs on the same line. 884 /// \code 885 /// if (a) 886 /// return; 887 /// 888 /// if (b) 889 /// return; 890 /// else 891 /// return; 892 /// 893 /// if (c) 894 /// return; 895 /// else { 896 /// return; 897 /// } 898 /// \endcode 899 SIS_Never, 900 /// Put short ifs on the same line only if there is no else statement. 901 /// \code 902 /// if (a) return; 903 /// 904 /// if (b) 905 /// return; 906 /// else 907 /// return; 908 /// 909 /// if (c) 910 /// return; 911 /// else { 912 /// return; 913 /// } 914 /// \endcode 915 SIS_WithoutElse, 916 /// Put short ifs, but not else ifs nor else statements, on the same line. 917 /// \code 918 /// if (a) return; 919 /// 920 /// if (b) return; 921 /// else if (b) 922 /// return; 923 /// else 924 /// return; 925 /// 926 /// if (c) return; 927 /// else { 928 /// return; 929 /// } 930 /// \endcode 931 SIS_OnlyFirstIf, 932 /// Always put short ifs, else ifs and else statements on the same 933 /// line. 934 /// \code 935 /// if (a) return; 936 /// 937 /// if (b) return; 938 /// else return; 939 /// 940 /// if (c) return; 941 /// else { 942 /// return; 943 /// } 944 /// \endcode 945 SIS_AllIfsAndElse, 946 }; 947 948 /// Dependent on the value, ``if (a) return;`` can be put on a single line. 949 /// \version 3.3 950 ShortIfStyle AllowShortIfStatementsOnASingleLine; 951 952 /// Different styles for merging short lambdas containing at most one 953 /// statement. 954 enum ShortLambdaStyle : int8_t { 955 /// Never merge lambdas into a single line. 956 SLS_None, 957 /// Only merge empty lambdas. 958 /// \code 959 /// auto lambda = [](int a) {}; 960 /// auto lambda2 = [](int a) { 961 /// return a; 962 /// }; 963 /// \endcode 964 SLS_Empty, 965 /// Merge lambda into a single line if the lambda is argument of a function. 966 /// \code 967 /// auto lambda = [](int x, int y) { 968 /// return x < y; 969 /// }; 970 /// sort(a.begin(), a.end(), [](int x, int y) { return x < y; }); 971 /// \endcode 972 SLS_Inline, 973 /// Merge all lambdas fitting on a single line. 974 /// \code 975 /// auto lambda = [](int a) {}; 976 /// auto lambda2 = [](int a) { return a; }; 977 /// \endcode 978 SLS_All, 979 }; 980 981 /// Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a 982 /// single line. 983 /// \version 9 984 ShortLambdaStyle AllowShortLambdasOnASingleLine; 985 986 /// If ``true``, ``while (true) continue;`` can be put on a single 987 /// line. 988 /// \version 3.7 989 bool AllowShortLoopsOnASingleLine; 990 991 /// If ``true``, ``namespace a { class b; }`` can be put on a single line. 992 /// \version 20 993 bool AllowShortNamespacesOnASingleLine; 994 995 /// Different ways to break after the function definition return type. 996 /// This option is **deprecated** and is retained for backwards compatibility. 997 enum DefinitionReturnTypeBreakingStyle : int8_t { 998 /// Break after return type automatically. 999 /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account. 1000 DRTBS_None, 1001 /// Always break after the return type. 1002 DRTBS_All, 1003 /// Always break after the return types of top-level functions. 1004 DRTBS_TopLevel, 1005 }; 1006 1007 /// Different ways to break after the function definition or 1008 /// declaration return type. 1009 enum ReturnTypeBreakingStyle : int8_t { 1010 /// This is **deprecated**. See ``Automatic`` below. 1011 RTBS_None, 1012 /// Break after return type based on ``PenaltyReturnTypeOnItsOwnLine``. 1013 /// \code 1014 /// class A { 1015 /// int f() { return 0; }; 1016 /// }; 1017 /// int f(); 1018 /// int f() { return 1; } 1019 /// int 1020 /// LongName::AnotherLongName(); 1021 /// \endcode 1022 RTBS_Automatic, 1023 /// Same as ``Automatic`` above, except that there is no break after short 1024 /// return types. 1025 /// \code 1026 /// class A { 1027 /// int f() { return 0; }; 1028 /// }; 1029 /// int f(); 1030 /// int f() { return 1; } 1031 /// int LongName:: 1032 /// AnotherLongName(); 1033 /// \endcode 1034 RTBS_ExceptShortType, 1035 /// Always break after the return type. 1036 /// \code 1037 /// class A { 1038 /// int 1039 /// f() { 1040 /// return 0; 1041 /// }; 1042 /// }; 1043 /// int 1044 /// f(); 1045 /// int 1046 /// f() { 1047 /// return 1; 1048 /// } 1049 /// int 1050 /// LongName::AnotherLongName(); 1051 /// \endcode 1052 RTBS_All, 1053 /// Always break after the return types of top-level functions. 1054 /// \code 1055 /// class A { 1056 /// int f() { return 0; }; 1057 /// }; 1058 /// int 1059 /// f(); 1060 /// int 1061 /// f() { 1062 /// return 1; 1063 /// } 1064 /// int 1065 /// LongName::AnotherLongName(); 1066 /// \endcode 1067 RTBS_TopLevel, 1068 /// Always break after the return type of function definitions. 1069 /// \code 1070 /// class A { 1071 /// int 1072 /// f() { 1073 /// return 0; 1074 /// }; 1075 /// }; 1076 /// int f(); 1077 /// int 1078 /// f() { 1079 /// return 1; 1080 /// } 1081 /// int 1082 /// LongName::AnotherLongName(); 1083 /// \endcode 1084 RTBS_AllDefinitions, 1085 /// Always break after the return type of top-level definitions. 1086 /// \code 1087 /// class A { 1088 /// int f() { return 0; }; 1089 /// }; 1090 /// int f(); 1091 /// int 1092 /// f() { 1093 /// return 1; 1094 /// } 1095 /// int 1096 /// LongName::AnotherLongName(); 1097 /// \endcode 1098 RTBS_TopLevelDefinitions, 1099 }; 1100 1101 /// The function definition return type breaking style to use. This 1102 /// option is **deprecated** and is retained for backwards compatibility. 1103 /// \version 3.7 1104 DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType; 1105 1106 /// This option is renamed to ``BreakAfterReturnType``. 1107 /// \version 3.8 1108 /// @deprecated 1109 // ReturnTypeBreakingStyle AlwaysBreakAfterReturnType; 1110 1111 /// If ``true``, always break before multiline string literals. 1112 /// 1113 /// This flag is mean to make cases where there are multiple multiline strings 1114 /// in a file look more consistent. Thus, it will only take effect if wrapping 1115 /// the string at that point leads to it being indented 1116 /// ``ContinuationIndentWidth`` spaces from the start of the line. 1117 /// \code 1118 /// true: false: 1119 /// aaaa = vs. aaaa = "bbbb" 1120 /// "bbbb" "cccc"; 1121 /// "cccc"; 1122 /// \endcode 1123 /// \version 3.4 1124 bool AlwaysBreakBeforeMultilineStrings; 1125 1126 /// Different ways to break after the template declaration. 1127 enum BreakTemplateDeclarationsStyle : int8_t { 1128 /// Do not change the line breaking before the declaration. 1129 /// \code 1130 /// template <typename T> 1131 /// T foo() { 1132 /// } 1133 /// template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa, 1134 /// int bbbbbbbbbbbbbbbbbbbbb) { 1135 /// } 1136 /// \endcode 1137 BTDS_Leave, 1138 /// Do not force break before declaration. 1139 /// ``PenaltyBreakTemplateDeclaration`` is taken into account. 1140 /// \code 1141 /// template <typename T> T foo() { 1142 /// } 1143 /// template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa, 1144 /// int bbbbbbbbbbbbbbbbbbbbb) { 1145 /// } 1146 /// \endcode 1147 BTDS_No, 1148 /// Force break after template declaration only when the following 1149 /// declaration spans multiple lines. 1150 /// \code 1151 /// template <typename T> T foo() { 1152 /// } 1153 /// template <typename T> 1154 /// T foo(int aaaaaaaaaaaaaaaaaaaaa, 1155 /// int bbbbbbbbbbbbbbbbbbbbb) { 1156 /// } 1157 /// \endcode 1158 BTDS_MultiLine, 1159 /// Always break after template declaration. 1160 /// \code 1161 /// template <typename T> 1162 /// T foo() { 1163 /// } 1164 /// template <typename T> 1165 /// T foo(int aaaaaaaaaaaaaaaaaaaaa, 1166 /// int bbbbbbbbbbbbbbbbbbbbb) { 1167 /// } 1168 /// \endcode 1169 BTDS_Yes 1170 }; 1171 1172 /// This option is renamed to ``BreakTemplateDeclarations``. 1173 /// \version 3.4 1174 /// @deprecated 1175 // BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations; 1176 1177 /// A vector of strings that should be interpreted as attributes/qualifiers 1178 /// instead of identifiers. This can be useful for language extensions or 1179 /// static analyzer annotations. 1180 /// 1181 /// For example: 1182 /// \code 1183 /// x = (char *__capability)&y; 1184 /// int function(void) __unused; 1185 /// void only_writes_to_buffer(char *__output buffer); 1186 /// \endcode 1187 /// 1188 /// In the .clang-format configuration file, this can be configured like: 1189 /// \code{.yaml} 1190 /// AttributeMacros: [__capability, __output, __unused] 1191 /// \endcode 1192 /// 1193 /// \version 12 1194 std::vector<std::string> AttributeMacros; 1195 1196 /// If ``false``, a function call's arguments will either be all on the 1197 /// same line or will have one line each. 1198 /// \code 1199 /// true: 1200 /// void f() { 1201 /// f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa, 1202 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); 1203 /// } 1204 /// 1205 /// false: 1206 /// void f() { 1207 /// f(aaaaaaaaaaaaaaaaaaaa, 1208 /// aaaaaaaaaaaaaaaaaaaa, 1209 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa); 1210 /// } 1211 /// \endcode 1212 /// \version 3.7 1213 bool BinPackArguments; 1214 1215 /// Different way to try to fit all parameters on a line. 1216 enum BinPackParametersStyle : int8_t { 1217 /// Bin-pack parameters. 1218 /// \code 1219 /// void f(int a, int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, 1220 /// int ccccccccccccccccccccccccccccccccccccccccccc); 1221 /// \endcode 1222 BPPS_BinPack, 1223 /// Put all parameters on the current line if they fit. 1224 /// Otherwise, put each one on its own line. 1225 /// \code 1226 /// void f(int a, int b, int c); 1227 /// 1228 /// void f(int a, 1229 /// int b, 1230 /// int ccccccccccccccccccccccccccccccccccccc); 1231 /// \endcode 1232 BPPS_OnePerLine, 1233 /// Always put each parameter on its own line. 1234 /// \code 1235 /// void f(int a, 1236 /// int b, 1237 /// int c); 1238 /// \endcode 1239 BPPS_AlwaysOnePerLine, 1240 }; 1241 1242 /// The bin pack parameters style to use. 1243 /// \version 3.7 1244 BinPackParametersStyle BinPackParameters; 1245 1246 /// Styles for adding spacing around ``:`` in bitfield definitions. 1247 enum BitFieldColonSpacingStyle : int8_t { 1248 /// Add one space on each side of the ``:`` 1249 /// \code 1250 /// unsigned bf : 2; 1251 /// \endcode 1252 BFCS_Both, 1253 /// Add no space around the ``:`` (except when needed for 1254 /// ``AlignConsecutiveBitFields``). 1255 /// \code 1256 /// unsigned bf:2; 1257 /// \endcode 1258 BFCS_None, 1259 /// Add space before the ``:`` only 1260 /// \code 1261 /// unsigned bf :2; 1262 /// \endcode 1263 BFCS_Before, 1264 /// Add space after the ``:`` only (space may be added before if 1265 /// needed for ``AlignConsecutiveBitFields``). 1266 /// \code 1267 /// unsigned bf: 2; 1268 /// \endcode 1269 BFCS_After 1270 }; 1271 /// The BitFieldColonSpacingStyle to use for bitfields. 1272 /// \version 12 1273 BitFieldColonSpacingStyle BitFieldColonSpacing; 1274 1275 /// The number of columns to use to indent the contents of braced init lists. 1276 /// If unset, ``ContinuationIndentWidth`` is used. 1277 /// \code 1278 /// AlignAfterOpenBracket: AlwaysBreak 1279 /// BracedInitializerIndentWidth: 2 1280 /// 1281 /// void f() { 1282 /// SomeClass c{ 1283 /// "foo", 1284 /// "bar", 1285 /// "baz", 1286 /// }; 1287 /// auto s = SomeStruct{ 1288 /// .foo = "foo", 1289 /// .bar = "bar", 1290 /// .baz = "baz", 1291 /// }; 1292 /// SomeArrayT a[3] = { 1293 /// { 1294 /// foo, 1295 /// bar, 1296 /// }, 1297 /// { 1298 /// foo, 1299 /// bar, 1300 /// }, 1301 /// SomeArrayT{}, 1302 /// }; 1303 /// } 1304 /// \endcode 1305 /// \version 17 1306 std::optional<unsigned> BracedInitializerIndentWidth; 1307 1308 /// Different ways to wrap braces after control statements. 1309 enum BraceWrappingAfterControlStatementStyle : int8_t { 1310 /// Never wrap braces after a control statement. 1311 /// \code 1312 /// if (foo()) { 1313 /// } else { 1314 /// } 1315 /// for (int i = 0; i < 10; ++i) { 1316 /// } 1317 /// \endcode 1318 BWACS_Never, 1319 /// Only wrap braces after a multi-line control statement. 1320 /// \code 1321 /// if (foo && bar && 1322 /// baz) 1323 /// { 1324 /// quux(); 1325 /// } 1326 /// while (foo || bar) { 1327 /// } 1328 /// \endcode 1329 BWACS_MultiLine, 1330 /// Always wrap braces after a control statement. 1331 /// \code 1332 /// if (foo()) 1333 /// { 1334 /// } else 1335 /// {} 1336 /// for (int i = 0; i < 10; ++i) 1337 /// {} 1338 /// \endcode 1339 BWACS_Always 1340 }; 1341 1342 /// Precise control over the wrapping of braces. 1343 /// \code 1344 /// # Should be declared this way: 1345 /// BreakBeforeBraces: Custom 1346 /// BraceWrapping: 1347 /// AfterClass: true 1348 /// \endcode 1349 struct BraceWrappingFlags { 1350 /// Wrap case labels. 1351 /// \code 1352 /// false: true: 1353 /// switch (foo) { vs. switch (foo) { 1354 /// case 1: { case 1: 1355 /// bar(); { 1356 /// break; bar(); 1357 /// } break; 1358 /// default: { } 1359 /// plop(); default: 1360 /// } { 1361 /// } plop(); 1362 /// } 1363 /// } 1364 /// \endcode 1365 bool AfterCaseLabel; 1366 /// Wrap class definitions. 1367 /// \code 1368 /// true: 1369 /// class foo 1370 /// {}; 1371 /// 1372 /// false: 1373 /// class foo {}; 1374 /// \endcode 1375 bool AfterClass; 1376 1377 /// Wrap control statements (``if``/``for``/``while``/``switch``/..). 1378 BraceWrappingAfterControlStatementStyle AfterControlStatement; 1379 /// Wrap enum definitions. 1380 /// \code 1381 /// true: 1382 /// enum X : int 1383 /// { 1384 /// B 1385 /// }; 1386 /// 1387 /// false: 1388 /// enum X : int { B }; 1389 /// \endcode 1390 bool AfterEnum; 1391 /// Wrap function definitions. 1392 /// \code 1393 /// true: 1394 /// void foo() 1395 /// { 1396 /// bar(); 1397 /// bar2(); 1398 /// } 1399 /// 1400 /// false: 1401 /// void foo() { 1402 /// bar(); 1403 /// bar2(); 1404 /// } 1405 /// \endcode 1406 bool AfterFunction; 1407 /// Wrap namespace definitions. 1408 /// \code 1409 /// true: 1410 /// namespace 1411 /// { 1412 /// int foo(); 1413 /// int bar(); 1414 /// } 1415 /// 1416 /// false: 1417 /// namespace { 1418 /// int foo(); 1419 /// int bar(); 1420 /// } 1421 /// \endcode 1422 bool AfterNamespace; 1423 /// Wrap ObjC definitions (interfaces, implementations...). 1424 /// \note 1425 /// @autoreleasepool and @synchronized blocks are wrapped 1426 /// according to ``AfterControlStatement`` flag. 1427 /// \endnote 1428 bool AfterObjCDeclaration; 1429 /// Wrap struct definitions. 1430 /// \code 1431 /// true: 1432 /// struct foo 1433 /// { 1434 /// int x; 1435 /// }; 1436 /// 1437 /// false: 1438 /// struct foo { 1439 /// int x; 1440 /// }; 1441 /// \endcode 1442 bool AfterStruct; 1443 /// Wrap union definitions. 1444 /// \code 1445 /// true: 1446 /// union foo 1447 /// { 1448 /// int x; 1449 /// } 1450 /// 1451 /// false: 1452 /// union foo { 1453 /// int x; 1454 /// } 1455 /// \endcode 1456 bool AfterUnion; 1457 /// Wrap extern blocks. 1458 /// \code 1459 /// true: 1460 /// extern "C" 1461 /// { 1462 /// int foo(); 1463 /// } 1464 /// 1465 /// false: 1466 /// extern "C" { 1467 /// int foo(); 1468 /// } 1469 /// \endcode 1470 bool AfterExternBlock; // Partially superseded by IndentExternBlock 1471 /// Wrap before ``catch``. 1472 /// \code 1473 /// true: 1474 /// try { 1475 /// foo(); 1476 /// } 1477 /// catch () { 1478 /// } 1479 /// 1480 /// false: 1481 /// try { 1482 /// foo(); 1483 /// } catch () { 1484 /// } 1485 /// \endcode 1486 bool BeforeCatch; 1487 /// Wrap before ``else``. 1488 /// \code 1489 /// true: 1490 /// if (foo()) { 1491 /// } 1492 /// else { 1493 /// } 1494 /// 1495 /// false: 1496 /// if (foo()) { 1497 /// } else { 1498 /// } 1499 /// \endcode 1500 bool BeforeElse; 1501 /// Wrap lambda block. 1502 /// \code 1503 /// true: 1504 /// connect( 1505 /// []() 1506 /// { 1507 /// foo(); 1508 /// bar(); 1509 /// }); 1510 /// 1511 /// false: 1512 /// connect([]() { 1513 /// foo(); 1514 /// bar(); 1515 /// }); 1516 /// \endcode 1517 bool BeforeLambdaBody; 1518 /// Wrap before ``while``. 1519 /// \code 1520 /// true: 1521 /// do { 1522 /// foo(); 1523 /// } 1524 /// while (1); 1525 /// 1526 /// false: 1527 /// do { 1528 /// foo(); 1529 /// } while (1); 1530 /// \endcode 1531 bool BeforeWhile; 1532 /// Indent the wrapped braces themselves. 1533 bool IndentBraces; 1534 /// If ``false``, empty function body can be put on a single line. 1535 /// This option is used only if the opening brace of the function has 1536 /// already been wrapped, i.e. the ``AfterFunction`` brace wrapping mode is 1537 /// set, and the function could/should not be put on a single line (as per 1538 /// ``AllowShortFunctionsOnASingleLine`` and constructor formatting 1539 /// options). 1540 /// \code 1541 /// false: true: 1542 /// int f() vs. int f() 1543 /// {} { 1544 /// } 1545 /// \endcode 1546 /// 1547 bool SplitEmptyFunction; 1548 /// If ``false``, empty record (e.g. class, struct or union) body 1549 /// can be put on a single line. This option is used only if the opening 1550 /// brace of the record has already been wrapped, i.e. the ``AfterClass`` 1551 /// (for classes) brace wrapping mode is set. 1552 /// \code 1553 /// false: true: 1554 /// class Foo vs. class Foo 1555 /// {} { 1556 /// } 1557 /// \endcode 1558 /// 1559 bool SplitEmptyRecord; 1560 /// If ``false``, empty namespace body can be put on a single line. 1561 /// This option is used only if the opening brace of the namespace has 1562 /// already been wrapped, i.e. the ``AfterNamespace`` brace wrapping mode is 1563 /// set. 1564 /// \code 1565 /// false: true: 1566 /// namespace Foo vs. namespace Foo 1567 /// {} { 1568 /// } 1569 /// \endcode 1570 /// 1571 bool SplitEmptyNamespace; 1572 }; 1573 1574 /// Control of individual brace wrapping cases. 1575 /// 1576 /// If ``BreakBeforeBraces`` is set to ``Custom``, use this to specify how 1577 /// each individual brace case should be handled. Otherwise, this is ignored. 1578 /// \code{.yaml} 1579 /// # Example of usage: 1580 /// BreakBeforeBraces: Custom 1581 /// BraceWrapping: 1582 /// AfterEnum: true 1583 /// AfterStruct: false 1584 /// SplitEmptyFunction: false 1585 /// \endcode 1586 /// \version 3.8 1587 BraceWrappingFlags BraceWrapping; 1588 1589 /// Break between adjacent string literals. 1590 /// \code 1591 /// true: 1592 /// return "Code" 1593 /// "\0\52\26\55\55\0" 1594 /// "x013" 1595 /// "\02\xBA"; 1596 /// false: 1597 /// return "Code" "\0\52\26\55\55\0" "x013" "\02\xBA"; 1598 /// \endcode 1599 /// \version 18 1600 bool BreakAdjacentStringLiterals; 1601 1602 /// Different ways to break after attributes. 1603 enum AttributeBreakingStyle : int8_t { 1604 /// Always break after attributes. 1605 /// \code 1606 /// [[maybe_unused]] 1607 /// const int i; 1608 /// [[gnu::const]] [[maybe_unused]] 1609 /// int j; 1610 /// 1611 /// [[nodiscard]] 1612 /// inline int f(); 1613 /// [[gnu::const]] [[nodiscard]] 1614 /// int g(); 1615 /// 1616 /// [[likely]] 1617 /// if (a) 1618 /// f(); 1619 /// else 1620 /// g(); 1621 /// 1622 /// switch (b) { 1623 /// [[unlikely]] 1624 /// case 1: 1625 /// ++b; 1626 /// break; 1627 /// [[likely]] 1628 /// default: 1629 /// return; 1630 /// } 1631 /// \endcode 1632 ABS_Always, 1633 /// Leave the line breaking after attributes as is. 1634 /// \code 1635 /// [[maybe_unused]] const int i; 1636 /// [[gnu::const]] [[maybe_unused]] 1637 /// int j; 1638 /// 1639 /// [[nodiscard]] inline int f(); 1640 /// [[gnu::const]] [[nodiscard]] 1641 /// int g(); 1642 /// 1643 /// [[likely]] if (a) 1644 /// f(); 1645 /// else 1646 /// g(); 1647 /// 1648 /// switch (b) { 1649 /// [[unlikely]] case 1: 1650 /// ++b; 1651 /// break; 1652 /// [[likely]] 1653 /// default: 1654 /// return; 1655 /// } 1656 /// \endcode 1657 ABS_Leave, 1658 /// Never break after attributes. 1659 /// \code 1660 /// [[maybe_unused]] const int i; 1661 /// [[gnu::const]] [[maybe_unused]] int j; 1662 /// 1663 /// [[nodiscard]] inline int f(); 1664 /// [[gnu::const]] [[nodiscard]] int g(); 1665 /// 1666 /// [[likely]] if (a) 1667 /// f(); 1668 /// else 1669 /// g(); 1670 /// 1671 /// switch (b) { 1672 /// [[unlikely]] case 1: 1673 /// ++b; 1674 /// break; 1675 /// [[likely]] default: 1676 /// return; 1677 /// } 1678 /// \endcode 1679 ABS_Never, 1680 }; 1681 1682 /// Break after a group of C++11 attributes before variable or function 1683 /// (including constructor/destructor) declaration/definition names or before 1684 /// control statements, i.e. ``if``, ``switch`` (including ``case`` and 1685 /// ``default`` labels), ``for``, and ``while`` statements. 1686 /// \version 16 1687 AttributeBreakingStyle BreakAfterAttributes; 1688 1689 /// The function declaration return type breaking style to use. 1690 /// \version 19 1691 ReturnTypeBreakingStyle BreakAfterReturnType; 1692 1693 /// If ``true``, clang-format will always break after a Json array ``[`` 1694 /// otherwise it will scan until the closing ``]`` to determine if it should 1695 /// add newlines between elements (prettier compatible). 1696 /// 1697 /// \note 1698 /// This is currently only for formatting JSON. 1699 /// \endnote 1700 /// \code 1701 /// true: false: 1702 /// [ vs. [1, 2, 3, 4] 1703 /// 1, 1704 /// 2, 1705 /// 3, 1706 /// 4 1707 /// ] 1708 /// \endcode 1709 /// \version 16 1710 bool BreakArrays; 1711 1712 /// The style of wrapping parameters on the same line (bin-packed) or 1713 /// on one line each. 1714 enum BinPackStyle : int8_t { 1715 /// Automatically determine parameter bin-packing behavior. 1716 BPS_Auto, 1717 /// Always bin-pack parameters. 1718 BPS_Always, 1719 /// Never bin-pack parameters. 1720 BPS_Never, 1721 }; 1722 1723 /// The style of breaking before or after binary operators. 1724 enum BinaryOperatorStyle : int8_t { 1725 /// Break after operators. 1726 /// \code 1727 /// LooooooooooongType loooooooooooooooooooooongVariable = 1728 /// someLooooooooooooooooongFunction(); 1729 /// 1730 /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + 1731 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == 1732 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && 1733 /// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa > 1734 /// ccccccccccccccccccccccccccccccccccccccccc; 1735 /// \endcode 1736 BOS_None, 1737 /// Break before operators that aren't assignments. 1738 /// \code 1739 /// LooooooooooongType loooooooooooooooooooooongVariable = 1740 /// someLooooooooooooooooongFunction(); 1741 /// 1742 /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1743 /// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1744 /// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1745 /// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1746 /// > ccccccccccccccccccccccccccccccccccccccccc; 1747 /// \endcode 1748 BOS_NonAssignment, 1749 /// Break before operators. 1750 /// \code 1751 /// LooooooooooongType loooooooooooooooooooooongVariable 1752 /// = someLooooooooooooooooongFunction(); 1753 /// 1754 /// bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1755 /// + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1756 /// == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1757 /// && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa 1758 /// > ccccccccccccccccccccccccccccccccccccccccc; 1759 /// \endcode 1760 BOS_All, 1761 }; 1762 1763 /// The way to wrap binary operators. 1764 /// \version 3.6 1765 BinaryOperatorStyle BreakBeforeBinaryOperators; 1766 1767 /// Different ways to attach braces to their surrounding context. 1768 enum BraceBreakingStyle : int8_t { 1769 /// Always attach braces to surrounding context. 1770 /// \code 1771 /// namespace N { 1772 /// enum E { 1773 /// E1, 1774 /// E2, 1775 /// }; 1776 /// 1777 /// class C { 1778 /// public: 1779 /// C(); 1780 /// }; 1781 /// 1782 /// bool baz(int i) { 1783 /// try { 1784 /// do { 1785 /// switch (i) { 1786 /// case 1: { 1787 /// foobar(); 1788 /// break; 1789 /// } 1790 /// default: { 1791 /// break; 1792 /// } 1793 /// } 1794 /// } while (--i); 1795 /// return true; 1796 /// } catch (...) { 1797 /// handleError(); 1798 /// return false; 1799 /// } 1800 /// } 1801 /// 1802 /// void foo(bool b) { 1803 /// if (b) { 1804 /// baz(2); 1805 /// } else { 1806 /// baz(5); 1807 /// } 1808 /// } 1809 /// 1810 /// void bar() { foo(true); } 1811 /// } // namespace N 1812 /// \endcode 1813 BS_Attach, 1814 /// Like ``Attach``, but break before braces on function, namespace and 1815 /// class definitions. 1816 /// \code 1817 /// namespace N 1818 /// { 1819 /// enum E { 1820 /// E1, 1821 /// E2, 1822 /// }; 1823 /// 1824 /// class C 1825 /// { 1826 /// public: 1827 /// C(); 1828 /// }; 1829 /// 1830 /// bool baz(int i) 1831 /// { 1832 /// try { 1833 /// do { 1834 /// switch (i) { 1835 /// case 1: { 1836 /// foobar(); 1837 /// break; 1838 /// } 1839 /// default: { 1840 /// break; 1841 /// } 1842 /// } 1843 /// } while (--i); 1844 /// return true; 1845 /// } catch (...) { 1846 /// handleError(); 1847 /// return false; 1848 /// } 1849 /// } 1850 /// 1851 /// void foo(bool b) 1852 /// { 1853 /// if (b) { 1854 /// baz(2); 1855 /// } else { 1856 /// baz(5); 1857 /// } 1858 /// } 1859 /// 1860 /// void bar() { foo(true); } 1861 /// } // namespace N 1862 /// \endcode 1863 BS_Linux, 1864 /// Like ``Attach``, but break before braces on enum, function, and record 1865 /// definitions. 1866 /// \code 1867 /// namespace N { 1868 /// enum E 1869 /// { 1870 /// E1, 1871 /// E2, 1872 /// }; 1873 /// 1874 /// class C 1875 /// { 1876 /// public: 1877 /// C(); 1878 /// }; 1879 /// 1880 /// bool baz(int i) 1881 /// { 1882 /// try { 1883 /// do { 1884 /// switch (i) { 1885 /// case 1: { 1886 /// foobar(); 1887 /// break; 1888 /// } 1889 /// default: { 1890 /// break; 1891 /// } 1892 /// } 1893 /// } while (--i); 1894 /// return true; 1895 /// } catch (...) { 1896 /// handleError(); 1897 /// return false; 1898 /// } 1899 /// } 1900 /// 1901 /// void foo(bool b) 1902 /// { 1903 /// if (b) { 1904 /// baz(2); 1905 /// } else { 1906 /// baz(5); 1907 /// } 1908 /// } 1909 /// 1910 /// void bar() { foo(true); } 1911 /// } // namespace N 1912 /// \endcode 1913 BS_Mozilla, 1914 /// Like ``Attach``, but break before function definitions, ``catch``, and 1915 /// ``else``. 1916 /// \code 1917 /// namespace N { 1918 /// enum E { 1919 /// E1, 1920 /// E2, 1921 /// }; 1922 /// 1923 /// class C { 1924 /// public: 1925 /// C(); 1926 /// }; 1927 /// 1928 /// bool baz(int i) 1929 /// { 1930 /// try { 1931 /// do { 1932 /// switch (i) { 1933 /// case 1: { 1934 /// foobar(); 1935 /// break; 1936 /// } 1937 /// default: { 1938 /// break; 1939 /// } 1940 /// } 1941 /// } while (--i); 1942 /// return true; 1943 /// } 1944 /// catch (...) { 1945 /// handleError(); 1946 /// return false; 1947 /// } 1948 /// } 1949 /// 1950 /// void foo(bool b) 1951 /// { 1952 /// if (b) { 1953 /// baz(2); 1954 /// } 1955 /// else { 1956 /// baz(5); 1957 /// } 1958 /// } 1959 /// 1960 /// void bar() { foo(true); } 1961 /// } // namespace N 1962 /// \endcode 1963 BS_Stroustrup, 1964 /// Always break before braces. 1965 /// \code 1966 /// namespace N 1967 /// { 1968 /// enum E 1969 /// { 1970 /// E1, 1971 /// E2, 1972 /// }; 1973 /// 1974 /// class C 1975 /// { 1976 /// public: 1977 /// C(); 1978 /// }; 1979 /// 1980 /// bool baz(int i) 1981 /// { 1982 /// try 1983 /// { 1984 /// do 1985 /// { 1986 /// switch (i) 1987 /// { 1988 /// case 1: 1989 /// { 1990 /// foobar(); 1991 /// break; 1992 /// } 1993 /// default: 1994 /// { 1995 /// break; 1996 /// } 1997 /// } 1998 /// } while (--i); 1999 /// return true; 2000 /// } 2001 /// catch (...) 2002 /// { 2003 /// handleError(); 2004 /// return false; 2005 /// } 2006 /// } 2007 /// 2008 /// void foo(bool b) 2009 /// { 2010 /// if (b) 2011 /// { 2012 /// baz(2); 2013 /// } 2014 /// else 2015 /// { 2016 /// baz(5); 2017 /// } 2018 /// } 2019 /// 2020 /// void bar() { foo(true); } 2021 /// } // namespace N 2022 /// \endcode 2023 BS_Allman, 2024 /// Like ``Allman`` but always indent braces and line up code with braces. 2025 /// \code 2026 /// namespace N 2027 /// { 2028 /// enum E 2029 /// { 2030 /// E1, 2031 /// E2, 2032 /// }; 2033 /// 2034 /// class C 2035 /// { 2036 /// public: 2037 /// C(); 2038 /// }; 2039 /// 2040 /// bool baz(int i) 2041 /// { 2042 /// try 2043 /// { 2044 /// do 2045 /// { 2046 /// switch (i) 2047 /// { 2048 /// case 1: 2049 /// { 2050 /// foobar(); 2051 /// break; 2052 /// } 2053 /// default: 2054 /// { 2055 /// break; 2056 /// } 2057 /// } 2058 /// } while (--i); 2059 /// return true; 2060 /// } 2061 /// catch (...) 2062 /// { 2063 /// handleError(); 2064 /// return false; 2065 /// } 2066 /// } 2067 /// 2068 /// void foo(bool b) 2069 /// { 2070 /// if (b) 2071 /// { 2072 /// baz(2); 2073 /// } 2074 /// else 2075 /// { 2076 /// baz(5); 2077 /// } 2078 /// } 2079 /// 2080 /// void bar() { foo(true); } 2081 /// } // namespace N 2082 /// \endcode 2083 BS_Whitesmiths, 2084 /// Always break before braces and add an extra level of indentation to 2085 /// braces of control statements, not to those of class, function 2086 /// or other definitions. 2087 /// \code 2088 /// namespace N 2089 /// { 2090 /// enum E 2091 /// { 2092 /// E1, 2093 /// E2, 2094 /// }; 2095 /// 2096 /// class C 2097 /// { 2098 /// public: 2099 /// C(); 2100 /// }; 2101 /// 2102 /// bool baz(int i) 2103 /// { 2104 /// try 2105 /// { 2106 /// do 2107 /// { 2108 /// switch (i) 2109 /// { 2110 /// case 1: 2111 /// { 2112 /// foobar(); 2113 /// break; 2114 /// } 2115 /// default: 2116 /// { 2117 /// break; 2118 /// } 2119 /// } 2120 /// } 2121 /// while (--i); 2122 /// return true; 2123 /// } 2124 /// catch (...) 2125 /// { 2126 /// handleError(); 2127 /// return false; 2128 /// } 2129 /// } 2130 /// 2131 /// void foo(bool b) 2132 /// { 2133 /// if (b) 2134 /// { 2135 /// baz(2); 2136 /// } 2137 /// else 2138 /// { 2139 /// baz(5); 2140 /// } 2141 /// } 2142 /// 2143 /// void bar() { foo(true); } 2144 /// } // namespace N 2145 /// \endcode 2146 BS_GNU, 2147 /// Like ``Attach``, but break before functions. 2148 /// \code 2149 /// namespace N { 2150 /// enum E { 2151 /// E1, 2152 /// E2, 2153 /// }; 2154 /// 2155 /// class C { 2156 /// public: 2157 /// C(); 2158 /// }; 2159 /// 2160 /// bool baz(int i) 2161 /// { 2162 /// try { 2163 /// do { 2164 /// switch (i) { 2165 /// case 1: { 2166 /// foobar(); 2167 /// break; 2168 /// } 2169 /// default: { 2170 /// break; 2171 /// } 2172 /// } 2173 /// } while (--i); 2174 /// return true; 2175 /// } catch (...) { 2176 /// handleError(); 2177 /// return false; 2178 /// } 2179 /// } 2180 /// 2181 /// void foo(bool b) 2182 /// { 2183 /// if (b) { 2184 /// baz(2); 2185 /// } else { 2186 /// baz(5); 2187 /// } 2188 /// } 2189 /// 2190 /// void bar() { foo(true); } 2191 /// } // namespace N 2192 /// \endcode 2193 BS_WebKit, 2194 /// Configure each individual brace in ``BraceWrapping``. 2195 BS_Custom 2196 }; 2197 2198 /// The brace breaking style to use. 2199 /// \version 3.7 2200 BraceBreakingStyle BreakBeforeBraces; 2201 2202 /// Different ways to break before concept declarations. 2203 enum BreakBeforeConceptDeclarationsStyle : int8_t { 2204 /// Keep the template declaration line together with ``concept``. 2205 /// \code 2206 /// template <typename T> concept C = ...; 2207 /// \endcode 2208 BBCDS_Never, 2209 /// Breaking between template declaration and ``concept`` is allowed. The 2210 /// actual behavior depends on the content and line breaking rules and 2211 /// penalties. 2212 BBCDS_Allowed, 2213 /// Always break before ``concept``, putting it in the line after the 2214 /// template declaration. 2215 /// \code 2216 /// template <typename T> 2217 /// concept C = ...; 2218 /// \endcode 2219 BBCDS_Always, 2220 }; 2221 2222 /// The concept declaration style to use. 2223 /// \version 12 2224 BreakBeforeConceptDeclarationsStyle BreakBeforeConceptDeclarations; 2225 2226 /// Different ways to break ASM parameters. 2227 enum BreakBeforeInlineASMColonStyle : int8_t { 2228 /// No break before inline ASM colon. 2229 /// \code 2230 /// asm volatile("string", : : val); 2231 /// \endcode 2232 BBIAS_Never, 2233 /// Break before inline ASM colon if the line length is longer than column 2234 /// limit. 2235 /// \code 2236 /// asm volatile("string", : : val); 2237 /// asm("cmoveq %1, %2, %[result]" 2238 /// : [result] "=r"(result) 2239 /// : "r"(test), "r"(new), "[result]"(old)); 2240 /// \endcode 2241 BBIAS_OnlyMultiline, 2242 /// Always break before inline ASM colon. 2243 /// \code 2244 /// asm volatile("string", 2245 /// : 2246 /// : val); 2247 /// \endcode 2248 BBIAS_Always, 2249 }; 2250 2251 /// The inline ASM colon style to use. 2252 /// \version 16 2253 BreakBeforeInlineASMColonStyle BreakBeforeInlineASMColon; 2254 2255 /// If ``true``, ternary operators will be placed after line breaks. 2256 /// \code 2257 /// true: 2258 /// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription 2259 /// ? firstValue 2260 /// : SecondValueVeryVeryVeryVeryLong; 2261 /// 2262 /// false: 2263 /// veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ? 2264 /// firstValue : 2265 /// SecondValueVeryVeryVeryVeryLong; 2266 /// \endcode 2267 /// \version 3.7 2268 bool BreakBeforeTernaryOperators; 2269 2270 /// Different ways to break binary operations. 2271 enum BreakBinaryOperationsStyle : int8_t { 2272 /// Don't break binary operations 2273 /// \code 2274 /// aaa + bbbb * ccccc - ddddd + 2275 /// eeeeeeeeeeeeeeee; 2276 /// \endcode 2277 BBO_Never, 2278 2279 /// Binary operations will either be all on the same line, or each operation 2280 /// will have one line each. 2281 /// \code 2282 /// aaa + 2283 /// bbbb * 2284 /// ccccc - 2285 /// ddddd + 2286 /// eeeeeeeeeeeeeeee; 2287 /// \endcode 2288 BBO_OnePerLine, 2289 2290 /// Binary operations of a particular precedence that exceed the column 2291 /// limit will have one line each. 2292 /// \code 2293 /// aaa + 2294 /// bbbb * ccccc - 2295 /// ddddd + 2296 /// eeeeeeeeeeeeeeee; 2297 /// \endcode 2298 BBO_RespectPrecedence 2299 }; 2300 2301 /// The break binary operations style to use. 2302 /// \version 20 2303 BreakBinaryOperationsStyle BreakBinaryOperations; 2304 2305 /// Different ways to break initializers. 2306 enum BreakConstructorInitializersStyle : int8_t { 2307 /// Break constructor initializers before the colon and after the commas. 2308 /// \code 2309 /// Constructor() 2310 /// : initializer1(), 2311 /// initializer2() 2312 /// \endcode 2313 BCIS_BeforeColon, 2314 /// Break constructor initializers before the colon and commas, and align 2315 /// the commas with the colon. 2316 /// \code 2317 /// Constructor() 2318 /// : initializer1() 2319 /// , initializer2() 2320 /// \endcode 2321 BCIS_BeforeComma, 2322 /// Break constructor initializers after the colon and commas. 2323 /// \code 2324 /// Constructor() : 2325 /// initializer1(), 2326 /// initializer2() 2327 /// \endcode 2328 BCIS_AfterColon 2329 }; 2330 2331 /// The break constructor initializers style to use. 2332 /// \version 5 2333 BreakConstructorInitializersStyle BreakConstructorInitializers; 2334 2335 /// If ``true``, clang-format will always break before function definition 2336 /// parameters. 2337 /// \code 2338 /// true: 2339 /// void functionDefinition( 2340 /// int A, int B) {} 2341 /// 2342 /// false: 2343 /// void functionDefinition(int A, int B) {} 2344 /// 2345 /// \endcode 2346 /// \version 19 2347 bool BreakFunctionDefinitionParameters; 2348 2349 /// Break after each annotation on a field in Java files. 2350 /// \code{.java} 2351 /// true: false: 2352 /// @Partial vs. @Partial @Mock DataLoad loader; 2353 /// @Mock 2354 /// DataLoad loader; 2355 /// \endcode 2356 /// \version 3.8 2357 bool BreakAfterJavaFieldAnnotations; 2358 2359 /// Allow breaking string literals when formatting. 2360 /// 2361 /// In C, C++, and Objective-C: 2362 /// \code 2363 /// true: 2364 /// const char* x = "veryVeryVeryVeryVeryVe" 2365 /// "ryVeryVeryVeryVeryVery" 2366 /// "VeryLongString"; 2367 /// 2368 /// false: 2369 /// const char* x = 2370 /// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString"; 2371 /// \endcode 2372 /// 2373 /// In C# and Java: 2374 /// \code 2375 /// true: 2376 /// string x = "veryVeryVeryVeryVeryVe" + 2377 /// "ryVeryVeryVeryVeryVery" + 2378 /// "VeryLongString"; 2379 /// 2380 /// false: 2381 /// string x = 2382 /// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString"; 2383 /// \endcode 2384 /// 2385 /// C# interpolated strings are not broken. 2386 /// 2387 /// In Verilog: 2388 /// \code 2389 /// true: 2390 /// string x = {"veryVeryVeryVeryVeryVe", 2391 /// "ryVeryVeryVeryVeryVery", 2392 /// "VeryLongString"}; 2393 /// 2394 /// false: 2395 /// string x = 2396 /// "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString"; 2397 /// \endcode 2398 /// 2399 /// \version 3.9 2400 bool BreakStringLiterals; 2401 2402 /// The column limit. 2403 /// 2404 /// A column limit of ``0`` means that there is no column limit. In this case, 2405 /// clang-format will respect the input's line breaking decisions within 2406 /// statements unless they contradict other rules. 2407 /// \version 3.7 2408 unsigned ColumnLimit; 2409 2410 /// A regular expression that describes comments with special meaning, 2411 /// which should not be split into lines or otherwise changed. 2412 /// \code 2413 /// // CommentPragmas: '^ FOOBAR pragma:' 2414 /// // Will leave the following line unaffected 2415 /// #include <vector> // FOOBAR pragma: keep 2416 /// \endcode 2417 /// \version 3.7 2418 std::string CommentPragmas; 2419 2420 /// Different ways to break inheritance list. 2421 enum BreakInheritanceListStyle : int8_t { 2422 /// Break inheritance list before the colon and after the commas. 2423 /// \code 2424 /// class Foo 2425 /// : Base1, 2426 /// Base2 2427 /// {}; 2428 /// \endcode 2429 BILS_BeforeColon, 2430 /// Break inheritance list before the colon and commas, and align 2431 /// the commas with the colon. 2432 /// \code 2433 /// class Foo 2434 /// : Base1 2435 /// , Base2 2436 /// {}; 2437 /// \endcode 2438 BILS_BeforeComma, 2439 /// Break inheritance list after the colon and commas. 2440 /// \code 2441 /// class Foo : 2442 /// Base1, 2443 /// Base2 2444 /// {}; 2445 /// \endcode 2446 BILS_AfterColon, 2447 /// Break inheritance list only after the commas. 2448 /// \code 2449 /// class Foo : Base1, 2450 /// Base2 2451 /// {}; 2452 /// \endcode 2453 BILS_AfterComma, 2454 }; 2455 2456 /// The inheritance list style to use. 2457 /// \version 7 2458 BreakInheritanceListStyle BreakInheritanceList; 2459 2460 /// The template declaration breaking style to use. 2461 /// \version 19 2462 BreakTemplateDeclarationsStyle BreakTemplateDeclarations; 2463 2464 /// If ``true``, consecutive namespace declarations will be on the same 2465 /// line. If ``false``, each namespace is declared on a new line. 2466 /// \code 2467 /// true: 2468 /// namespace Foo { namespace Bar { 2469 /// }} 2470 /// 2471 /// false: 2472 /// namespace Foo { 2473 /// namespace Bar { 2474 /// } 2475 /// } 2476 /// \endcode 2477 /// 2478 /// If it does not fit on a single line, the overflowing namespaces get 2479 /// wrapped: 2480 /// \code 2481 /// namespace Foo { namespace Bar { 2482 /// namespace Extra { 2483 /// }}} 2484 /// \endcode 2485 /// \version 5 2486 bool CompactNamespaces; 2487 2488 /// This option is **deprecated**. See ``CurrentLine`` of 2489 /// ``PackConstructorInitializers``. 2490 /// \version 3.7 2491 // bool ConstructorInitializerAllOnOneLineOrOnePerLine; 2492 2493 /// The number of characters to use for indentation of constructor 2494 /// initializer lists as well as inheritance lists. 2495 /// \version 3.7 2496 unsigned ConstructorInitializerIndentWidth; 2497 2498 /// Indent width for line continuations. 2499 /// \code 2500 /// ContinuationIndentWidth: 2 2501 /// 2502 /// int i = // VeryVeryVeryVeryVeryLongComment 2503 /// longFunction( // Again a long comment 2504 /// arg); 2505 /// \endcode 2506 /// \version 3.7 2507 unsigned ContinuationIndentWidth; 2508 2509 /// If ``true``, format braced lists as best suited for C++11 braced 2510 /// lists. 2511 /// 2512 /// Important differences: 2513 /// 2514 /// * No spaces inside the braced list. 2515 /// * No line break before the closing brace. 2516 /// * Indentation with the continuation indent, not with the block indent. 2517 /// 2518 /// Fundamentally, C++11 braced lists are formatted exactly like function 2519 /// calls would be formatted in their place. If the braced list follows a name 2520 /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were 2521 /// the parentheses of a function call with that name. If there is no name, 2522 /// a zero-length name is assumed. 2523 /// \code 2524 /// true: false: 2525 /// vector<int> x{1, 2, 3, 4}; vs. vector<int> x{ 1, 2, 3, 4 }; 2526 /// vector<T> x{{}, {}, {}, {}}; vector<T> x{ {}, {}, {}, {} }; 2527 /// f(MyMap[{composite, key}]); f(MyMap[{ composite, key }]); 2528 /// new int[3]{1, 2, 3}; new int[3]{ 1, 2, 3 }; 2529 /// \endcode 2530 /// \version 3.4 2531 bool Cpp11BracedListStyle; 2532 2533 /// This option is **deprecated**. See ``DeriveLF`` and ``DeriveCRLF`` of 2534 /// ``LineEnding``. 2535 /// \version 10 2536 // bool DeriveLineEnding; 2537 2538 /// If ``true``, analyze the formatted file for the most common 2539 /// alignment of ``&`` and ``*``. 2540 /// Pointer and reference alignment styles are going to be updated according 2541 /// to the preferences found in the file. 2542 /// ``PointerAlignment`` is then used only as fallback. 2543 /// \version 3.7 2544 bool DerivePointerAlignment; 2545 2546 /// Disables formatting completely. 2547 /// \version 3.7 2548 bool DisableFormat; 2549 2550 /// Different styles for empty line after access modifiers. 2551 /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of 2552 /// empty lines between two access modifiers. 2553 enum EmptyLineAfterAccessModifierStyle : int8_t { 2554 /// Remove all empty lines after access modifiers. 2555 /// \code 2556 /// struct foo { 2557 /// private: 2558 /// int i; 2559 /// protected: 2560 /// int j; 2561 /// /* comment */ 2562 /// public: 2563 /// foo() {} 2564 /// private: 2565 /// protected: 2566 /// }; 2567 /// \endcode 2568 ELAAMS_Never, 2569 /// Keep existing empty lines after access modifiers. 2570 /// MaxEmptyLinesToKeep is applied instead. 2571 ELAAMS_Leave, 2572 /// Always add empty line after access modifiers if there are none. 2573 /// MaxEmptyLinesToKeep is applied also. 2574 /// \code 2575 /// struct foo { 2576 /// private: 2577 /// 2578 /// int i; 2579 /// protected: 2580 /// 2581 /// int j; 2582 /// /* comment */ 2583 /// public: 2584 /// 2585 /// foo() {} 2586 /// private: 2587 /// 2588 /// protected: 2589 /// 2590 /// }; 2591 /// \endcode 2592 ELAAMS_Always, 2593 }; 2594 2595 /// Defines when to put an empty line after access modifiers. 2596 /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of 2597 /// empty lines between two access modifiers. 2598 /// \version 13 2599 EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier; 2600 2601 /// Different styles for empty line before access modifiers. 2602 enum EmptyLineBeforeAccessModifierStyle : int8_t { 2603 /// Remove all empty lines before access modifiers. 2604 /// \code 2605 /// struct foo { 2606 /// private: 2607 /// int i; 2608 /// protected: 2609 /// int j; 2610 /// /* comment */ 2611 /// public: 2612 /// foo() {} 2613 /// private: 2614 /// protected: 2615 /// }; 2616 /// \endcode 2617 ELBAMS_Never, 2618 /// Keep existing empty lines before access modifiers. 2619 ELBAMS_Leave, 2620 /// Add empty line only when access modifier starts a new logical block. 2621 /// Logical block is a group of one or more member fields or functions. 2622 /// \code 2623 /// struct foo { 2624 /// private: 2625 /// int i; 2626 /// 2627 /// protected: 2628 /// int j; 2629 /// /* comment */ 2630 /// public: 2631 /// foo() {} 2632 /// 2633 /// private: 2634 /// protected: 2635 /// }; 2636 /// \endcode 2637 ELBAMS_LogicalBlock, 2638 /// Always add empty line before access modifiers unless access modifier 2639 /// is at the start of struct or class definition. 2640 /// \code 2641 /// struct foo { 2642 /// private: 2643 /// int i; 2644 /// 2645 /// protected: 2646 /// int j; 2647 /// /* comment */ 2648 /// 2649 /// public: 2650 /// foo() {} 2651 /// 2652 /// private: 2653 /// 2654 /// protected: 2655 /// }; 2656 /// \endcode 2657 ELBAMS_Always, 2658 }; 2659 2660 /// Defines in which cases to put empty line before access modifiers. 2661 /// \version 12 2662 EmptyLineBeforeAccessModifierStyle EmptyLineBeforeAccessModifier; 2663 2664 /// If ``true``, clang-format detects whether function calls and 2665 /// definitions are formatted with one parameter per line. 2666 /// 2667 /// Each call can be bin-packed, one-per-line or inconclusive. If it is 2668 /// inconclusive, e.g. completely on one line, but a decision needs to be 2669 /// made, clang-format analyzes whether there are other bin-packed cases in 2670 /// the input file and act accordingly. 2671 /// 2672 /// \note 2673 /// This is an experimental flag, that might go away or be renamed. Do 2674 /// not use this in config files, etc. Use at your own risk. 2675 /// \endnote 2676 /// \version 3.7 2677 bool ExperimentalAutoDetectBinPacking; 2678 2679 /// If ``true``, clang-format adds missing namespace end comments for 2680 /// namespaces and fixes invalid existing ones. This doesn't affect short 2681 /// namespaces, which are controlled by ``ShortNamespaceLines``. 2682 /// \code 2683 /// true: false: 2684 /// namespace longNamespace { vs. namespace longNamespace { 2685 /// void foo(); void foo(); 2686 /// void bar(); void bar(); 2687 /// } // namespace a } 2688 /// namespace shortNamespace { namespace shortNamespace { 2689 /// void baz(); void baz(); 2690 /// } } 2691 /// \endcode 2692 /// \version 5 2693 bool FixNamespaceComments; 2694 2695 /// A vector of macros that should be interpreted as foreach loops 2696 /// instead of as function calls. 2697 /// 2698 /// These are expected to be macros of the form: 2699 /// \code 2700 /// FOREACH(<variable-declaration>, ...) 2701 /// <loop-body> 2702 /// \endcode 2703 /// 2704 /// In the .clang-format configuration file, this can be configured like: 2705 /// \code{.yaml} 2706 /// ForEachMacros: [RANGES_FOR, FOREACH] 2707 /// \endcode 2708 /// 2709 /// For example: BOOST_FOREACH. 2710 /// \version 3.7 2711 std::vector<std::string> ForEachMacros; 2712 2713 tooling::IncludeStyle IncludeStyle; 2714 2715 /// A vector of macros that should be interpreted as conditionals 2716 /// instead of as function calls. 2717 /// 2718 /// These are expected to be macros of the form: 2719 /// \code 2720 /// IF(...) 2721 /// <conditional-body> 2722 /// else IF(...) 2723 /// <conditional-body> 2724 /// \endcode 2725 /// 2726 /// In the .clang-format configuration file, this can be configured like: 2727 /// \code{.yaml} 2728 /// IfMacros: [IF] 2729 /// \endcode 2730 /// 2731 /// For example: `KJ_IF_MAYBE 2732 /// <https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#maybes>`_ 2733 /// \version 13 2734 std::vector<std::string> IfMacros; 2735 2736 /// Specify whether access modifiers should have their own indentation level. 2737 /// 2738 /// When ``false``, access modifiers are indented (or outdented) relative to 2739 /// the record members, respecting the ``AccessModifierOffset``. Record 2740 /// members are indented one level below the record. 2741 /// When ``true``, access modifiers get their own indentation level. As a 2742 /// consequence, record members are always indented 2 levels below the record, 2743 /// regardless of the access modifier presence. Value of the 2744 /// ``AccessModifierOffset`` is ignored. 2745 /// \code 2746 /// false: true: 2747 /// class C { vs. class C { 2748 /// class D { class D { 2749 /// void bar(); void bar(); 2750 /// protected: protected: 2751 /// D(); D(); 2752 /// }; }; 2753 /// public: public: 2754 /// C(); C(); 2755 /// }; }; 2756 /// void foo() { void foo() { 2757 /// return 1; return 1; 2758 /// } } 2759 /// \endcode 2760 /// \version 13 2761 bool IndentAccessModifiers; 2762 2763 /// Indent case label blocks one level from the case label. 2764 /// 2765 /// When ``false``, the block following the case label uses the same 2766 /// indentation level as for the case label, treating the case label the same 2767 /// as an if-statement. 2768 /// When ``true``, the block gets indented as a scope block. 2769 /// \code 2770 /// false: true: 2771 /// switch (fool) { vs. switch (fool) { 2772 /// case 1: { case 1: 2773 /// bar(); { 2774 /// } break; bar(); 2775 /// default: { } 2776 /// plop(); break; 2777 /// } default: 2778 /// } { 2779 /// plop(); 2780 /// } 2781 /// } 2782 /// \endcode 2783 /// \version 11 2784 bool IndentCaseBlocks; 2785 2786 /// Indent case labels one level from the switch statement. 2787 /// 2788 /// When ``false``, use the same indentation level as for the switch 2789 /// statement. Switch statement body is always indented one level more than 2790 /// case labels (except the first block following the case label, which 2791 /// itself indents the code - unless IndentCaseBlocks is enabled). 2792 /// \code 2793 /// false: true: 2794 /// switch (fool) { vs. switch (fool) { 2795 /// case 1: case 1: 2796 /// bar(); bar(); 2797 /// break; break; 2798 /// default: default: 2799 /// plop(); plop(); 2800 /// } } 2801 /// \endcode 2802 /// \version 3.3 2803 bool IndentCaseLabels; 2804 2805 /// If ``true``, clang-format will indent the body of an ``export { ... }`` 2806 /// block. This doesn't affect the formatting of anything else related to 2807 /// exported declarations. 2808 /// \code 2809 /// true: false: 2810 /// export { vs. export { 2811 /// void foo(); void foo(); 2812 /// void bar(); void bar(); 2813 /// } } 2814 /// \endcode 2815 /// \version 20 2816 bool IndentExportBlock; 2817 2818 /// Indents extern blocks 2819 enum IndentExternBlockStyle : int8_t { 2820 /// Backwards compatible with AfterExternBlock's indenting. 2821 /// \code 2822 /// IndentExternBlock: AfterExternBlock 2823 /// BraceWrapping.AfterExternBlock: true 2824 /// extern "C" 2825 /// { 2826 /// void foo(); 2827 /// } 2828 /// \endcode 2829 /// 2830 /// \code 2831 /// IndentExternBlock: AfterExternBlock 2832 /// BraceWrapping.AfterExternBlock: false 2833 /// extern "C" { 2834 /// void foo(); 2835 /// } 2836 /// \endcode 2837 IEBS_AfterExternBlock, 2838 /// Does not indent extern blocks. 2839 /// \code 2840 /// extern "C" { 2841 /// void foo(); 2842 /// } 2843 /// \endcode 2844 IEBS_NoIndent, 2845 /// Indents extern blocks. 2846 /// \code 2847 /// extern "C" { 2848 /// void foo(); 2849 /// } 2850 /// \endcode 2851 IEBS_Indent, 2852 }; 2853 2854 /// IndentExternBlockStyle is the type of indenting of extern blocks. 2855 /// \version 11 2856 IndentExternBlockStyle IndentExternBlock; 2857 2858 /// Indent goto labels. 2859 /// 2860 /// When ``false``, goto labels are flushed left. 2861 /// \code 2862 /// true: false: 2863 /// int f() { vs. int f() { 2864 /// if (foo()) { if (foo()) { 2865 /// label1: label1: 2866 /// bar(); bar(); 2867 /// } } 2868 /// label2: label2: 2869 /// return 1; return 1; 2870 /// } } 2871 /// \endcode 2872 /// \version 10 2873 bool IndentGotoLabels; 2874 2875 /// Options for indenting preprocessor directives. 2876 enum PPDirectiveIndentStyle : int8_t { 2877 /// Does not indent any directives. 2878 /// \code 2879 /// #if FOO 2880 /// #if BAR 2881 /// #include <foo> 2882 /// #endif 2883 /// #endif 2884 /// \endcode 2885 PPDIS_None, 2886 /// Indents directives after the hash. 2887 /// \code 2888 /// #if FOO 2889 /// # if BAR 2890 /// # include <foo> 2891 /// # endif 2892 /// #endif 2893 /// \endcode 2894 PPDIS_AfterHash, 2895 /// Indents directives before the hash. 2896 /// \code 2897 /// #if FOO 2898 /// #if BAR 2899 /// #include <foo> 2900 /// #endif 2901 /// #endif 2902 /// \endcode 2903 PPDIS_BeforeHash 2904 }; 2905 2906 /// The preprocessor directive indenting style to use. 2907 /// \version 6 2908 PPDirectiveIndentStyle IndentPPDirectives; 2909 2910 /// Indent the requires clause in a template. This only applies when 2911 /// ``RequiresClausePosition`` is ``OwnLine``, ``OwnLineWithBrace``, 2912 /// or ``WithFollowing``. 2913 /// 2914 /// In clang-format 12, 13 and 14 it was named ``IndentRequires``. 2915 /// \code 2916 /// true: 2917 /// template <typename It> 2918 /// requires Iterator<It> 2919 /// void sort(It begin, It end) { 2920 /// //.... 2921 /// } 2922 /// 2923 /// false: 2924 /// template <typename It> 2925 /// requires Iterator<It> 2926 /// void sort(It begin, It end) { 2927 /// //.... 2928 /// } 2929 /// \endcode 2930 /// \version 15 2931 bool IndentRequiresClause; 2932 2933 /// The number of columns to use for indentation. 2934 /// \code 2935 /// IndentWidth: 3 2936 /// 2937 /// void f() { 2938 /// someFunction(); 2939 /// if (true, false) { 2940 /// f(); 2941 /// } 2942 /// } 2943 /// \endcode 2944 /// \version 3.7 2945 unsigned IndentWidth; 2946 2947 /// Indent if a function definition or declaration is wrapped after the 2948 /// type. 2949 /// \code 2950 /// true: 2951 /// LoooooooooooooooooooooooooooooooooooooooongReturnType 2952 /// LoooooooooooooooooooooooooooooooongFunctionDeclaration(); 2953 /// 2954 /// false: 2955 /// LoooooooooooooooooooooooooooooooooooooooongReturnType 2956 /// LoooooooooooooooooooooooooooooooongFunctionDeclaration(); 2957 /// \endcode 2958 /// \version 3.7 2959 bool IndentWrappedFunctionNames; 2960 2961 /// Insert braces after control statements (``if``, ``else``, ``for``, ``do``, 2962 /// and ``while``) in C++ unless the control statements are inside macro 2963 /// definitions or the braces would enclose preprocessor directives. 2964 /// \warning 2965 /// Setting this option to ``true`` could lead to incorrect code formatting 2966 /// due to clang-format's lack of complete semantic information. As such, 2967 /// extra care should be taken to review code changes made by this option. 2968 /// \endwarning 2969 /// \code 2970 /// false: true: 2971 /// 2972 /// if (isa<FunctionDecl>(D)) vs. if (isa<FunctionDecl>(D)) { 2973 /// handleFunctionDecl(D); handleFunctionDecl(D); 2974 /// else if (isa<VarDecl>(D)) } else if (isa<VarDecl>(D)) { 2975 /// handleVarDecl(D); handleVarDecl(D); 2976 /// else } else { 2977 /// return; return; 2978 /// } 2979 /// 2980 /// while (i--) vs. while (i--) { 2981 /// for (auto *A : D.attrs()) for (auto *A : D.attrs()) { 2982 /// handleAttr(A); handleAttr(A); 2983 /// } 2984 /// } 2985 /// 2986 /// do vs. do { 2987 /// --i; --i; 2988 /// while (i); } while (i); 2989 /// \endcode 2990 /// \version 15 2991 bool InsertBraces; 2992 2993 /// Insert a newline at end of file if missing. 2994 /// \version 16 2995 bool InsertNewlineAtEOF; 2996 2997 /// The style of inserting trailing commas into container literals. 2998 enum TrailingCommaStyle : int8_t { 2999 /// Do not insert trailing commas. 3000 TCS_None, 3001 /// Insert trailing commas in container literals that were wrapped over 3002 /// multiple lines. Note that this is conceptually incompatible with 3003 /// bin-packing, because the trailing comma is used as an indicator 3004 /// that a container should be formatted one-per-line (i.e. not bin-packed). 3005 /// So inserting a trailing comma counteracts bin-packing. 3006 TCS_Wrapped, 3007 }; 3008 3009 /// If set to ``TCS_Wrapped`` will insert trailing commas in container 3010 /// literals (arrays and objects) that wrap across multiple lines. 3011 /// It is currently only available for JavaScript 3012 /// and disabled by default ``TCS_None``. 3013 /// ``InsertTrailingCommas`` cannot be used together with ``BinPackArguments`` 3014 /// as inserting the comma disables bin-packing. 3015 /// \code 3016 /// TSC_Wrapped: 3017 /// const someArray = [ 3018 /// aaaaaaaaaaaaaaaaaaaaaaaaaa, 3019 /// aaaaaaaaaaaaaaaaaaaaaaaaaa, 3020 /// aaaaaaaaaaaaaaaaaaaaaaaaaa, 3021 /// // ^ inserted 3022 /// ] 3023 /// \endcode 3024 /// \version 11 3025 TrailingCommaStyle InsertTrailingCommas; 3026 3027 /// Separator format of integer literals of different bases. 3028 /// 3029 /// If negative, remove separators. If ``0``, leave the literal as is. If 3030 /// positive, insert separators between digits starting from the rightmost 3031 /// digit. 3032 /// 3033 /// For example, the config below will leave separators in binary literals 3034 /// alone, insert separators in decimal literals to separate the digits into 3035 /// groups of 3, and remove separators in hexadecimal literals. 3036 /// \code 3037 /// IntegerLiteralSeparator: 3038 /// Binary: 0 3039 /// Decimal: 3 3040 /// Hex: -1 3041 /// \endcode 3042 /// 3043 /// You can also specify a minimum number of digits (``BinaryMinDigits``, 3044 /// ``DecimalMinDigits``, and ``HexMinDigits``) the integer literal must 3045 /// have in order for the separators to be inserted. 3046 struct IntegerLiteralSeparatorStyle { 3047 /// Format separators in binary literals. 3048 /// \code{.text} 3049 /// /* -1: */ b = 0b100111101101; 3050 /// /* 0: */ b = 0b10011'11'0110'1; 3051 /// /* 3: */ b = 0b100'111'101'101; 3052 /// /* 4: */ b = 0b1001'1110'1101; 3053 /// \endcode 3054 int8_t Binary; 3055 /// Format separators in binary literals with a minimum number of digits. 3056 /// \code{.text} 3057 /// // Binary: 3 3058 /// // BinaryMinDigits: 7 3059 /// b1 = 0b101101; 3060 /// b2 = 0b1'101'101; 3061 /// \endcode 3062 int8_t BinaryMinDigits; 3063 /// Format separators in decimal literals. 3064 /// \code{.text} 3065 /// /* -1: */ d = 18446744073709550592ull; 3066 /// /* 0: */ d = 184467'440737'0'95505'92ull; 3067 /// /* 3: */ d = 18'446'744'073'709'550'592ull; 3068 /// \endcode 3069 int8_t Decimal; 3070 /// Format separators in decimal literals with a minimum number of digits. 3071 /// \code{.text} 3072 /// // Decimal: 3 3073 /// // DecimalMinDigits: 5 3074 /// d1 = 2023; 3075 /// d2 = 10'000; 3076 /// \endcode 3077 int8_t DecimalMinDigits; 3078 /// Format separators in hexadecimal literals. 3079 /// \code{.text} 3080 /// /* -1: */ h = 0xDEADBEEFDEADBEEFuz; 3081 /// /* 0: */ h = 0xDEAD'BEEF'DE'AD'BEE'Fuz; 3082 /// /* 2: */ h = 0xDE'AD'BE'EF'DE'AD'BE'EFuz; 3083 /// \endcode 3084 int8_t Hex; 3085 /// Format separators in hexadecimal literals with a minimum number of 3086 /// digits. 3087 /// \code{.text} 3088 /// // Hex: 2 3089 /// // HexMinDigits: 6 3090 /// h1 = 0xABCDE; 3091 /// h2 = 0xAB'CD'EF; 3092 /// \endcode 3093 int8_t HexMinDigits; 3094 bool operator==(const IntegerLiteralSeparatorStyle &R) const { 3095 return Binary == R.Binary && BinaryMinDigits == R.BinaryMinDigits && 3096 Decimal == R.Decimal && DecimalMinDigits == R.DecimalMinDigits && 3097 Hex == R.Hex && HexMinDigits == R.HexMinDigits; 3098 } 3099 }; 3100 3101 /// Format integer literal separators (``'`` for C++ and ``_`` for C#, Java, 3102 /// and JavaScript). 3103 /// \version 16 3104 IntegerLiteralSeparatorStyle IntegerLiteralSeparator; 3105 3106 /// A vector of prefixes ordered by the desired groups for Java imports. 3107 /// 3108 /// One group's prefix can be a subset of another - the longest prefix is 3109 /// always matched. Within a group, the imports are ordered lexicographically. 3110 /// Static imports are grouped separately and follow the same group rules. 3111 /// By default, static imports are placed before non-static imports, 3112 /// but this behavior is changed by another option, 3113 /// ``SortJavaStaticImport``. 3114 /// 3115 /// In the .clang-format configuration file, this can be configured like 3116 /// in the following yaml example. This will result in imports being 3117 /// formatted as in the Java example below. 3118 /// \code{.yaml} 3119 /// JavaImportGroups: [com.example, com, org] 3120 /// \endcode 3121 /// 3122 /// \code{.java} 3123 /// import static com.example.function1; 3124 /// 3125 /// import static com.test.function2; 3126 /// 3127 /// import static org.example.function3; 3128 /// 3129 /// import com.example.ClassA; 3130 /// import com.example.Test; 3131 /// import com.example.a.ClassB; 3132 /// 3133 /// import com.test.ClassC; 3134 /// 3135 /// import org.example.ClassD; 3136 /// \endcode 3137 /// \version 8 3138 std::vector<std::string> JavaImportGroups; 3139 3140 /// Quotation styles for JavaScript strings. Does not affect template 3141 /// strings. 3142 enum JavaScriptQuoteStyle : int8_t { 3143 /// Leave string quotes as they are. 3144 /// \code{.js} 3145 /// string1 = "foo"; 3146 /// string2 = 'bar'; 3147 /// \endcode 3148 JSQS_Leave, 3149 /// Always use single quotes. 3150 /// \code{.js} 3151 /// string1 = 'foo'; 3152 /// string2 = 'bar'; 3153 /// \endcode 3154 JSQS_Single, 3155 /// Always use double quotes. 3156 /// \code{.js} 3157 /// string1 = "foo"; 3158 /// string2 = "bar"; 3159 /// \endcode 3160 JSQS_Double 3161 }; 3162 3163 /// The JavaScriptQuoteStyle to use for JavaScript strings. 3164 /// \version 3.9 3165 JavaScriptQuoteStyle JavaScriptQuotes; 3166 3167 // clang-format off 3168 /// Whether to wrap JavaScript import/export statements. 3169 /// \code{.js} 3170 /// true: 3171 /// import { 3172 /// VeryLongImportsAreAnnoying, 3173 /// VeryLongImportsAreAnnoying, 3174 /// VeryLongImportsAreAnnoying, 3175 /// } from "some/module.js" 3176 /// 3177 /// false: 3178 /// import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js" 3179 /// \endcode 3180 /// \version 3.9 3181 bool JavaScriptWrapImports; 3182 // clang-format on 3183 3184 /// Options regarding which empty lines are kept. 3185 /// 3186 /// For example, the config below will remove empty lines at start of the 3187 /// file, end of the file, and start of blocks. 3188 /// 3189 /// \code 3190 /// KeepEmptyLines: 3191 /// AtEndOfFile: false 3192 /// AtStartOfBlock: false 3193 /// AtStartOfFile: false 3194 /// \endcode 3195 struct KeepEmptyLinesStyle { 3196 /// Keep empty lines at end of file. 3197 bool AtEndOfFile; 3198 /// Keep empty lines at start of a block. 3199 /// \code 3200 /// true: false: 3201 /// if (foo) { vs. if (foo) { 3202 /// bar(); 3203 /// bar(); } 3204 /// } 3205 /// \endcode 3206 bool AtStartOfBlock; 3207 /// Keep empty lines at start of file. 3208 bool AtStartOfFile; 3209 bool operator==(const KeepEmptyLinesStyle &R) const { 3210 return AtEndOfFile == R.AtEndOfFile && 3211 AtStartOfBlock == R.AtStartOfBlock && 3212 AtStartOfFile == R.AtStartOfFile; 3213 } 3214 }; 3215 /// Which empty lines are kept. See ``MaxEmptyLinesToKeep`` for how many 3216 /// consecutive empty lines are kept. 3217 /// \version 19 3218 KeepEmptyLinesStyle KeepEmptyLines; 3219 3220 /// This option is **deprecated**. See ``AtEndOfFile`` of ``KeepEmptyLines``. 3221 /// \version 17 3222 // bool KeepEmptyLinesAtEOF; 3223 3224 /// This option is **deprecated**. See ``AtStartOfBlock`` of 3225 /// ``KeepEmptyLines``. 3226 /// \version 3.7 3227 // bool KeepEmptyLinesAtTheStartOfBlocks; 3228 3229 /// Keep the form feed character if it's immediately preceded and followed by 3230 /// a newline. Multiple form feeds and newlines within a whitespace range are 3231 /// replaced with a single newline and form feed followed by the remaining 3232 /// newlines. 3233 /// \version 20 3234 bool KeepFormFeed; 3235 3236 /// Indentation logic for lambda bodies. 3237 enum LambdaBodyIndentationKind : int8_t { 3238 /// Align lambda body relative to the lambda signature. This is the default. 3239 /// \code 3240 /// someMethod( 3241 /// [](SomeReallyLongLambdaSignatureArgument foo) { 3242 /// return; 3243 /// }); 3244 /// \endcode 3245 LBI_Signature, 3246 /// For statements within block scope, align lambda body relative to the 3247 /// indentation level of the outer scope the lambda signature resides in. 3248 /// \code 3249 /// someMethod( 3250 /// [](SomeReallyLongLambdaSignatureArgument foo) { 3251 /// return; 3252 /// }); 3253 /// 3254 /// someMethod(someOtherMethod( 3255 /// [](SomeReallyLongLambdaSignatureArgument foo) { 3256 /// return; 3257 /// })); 3258 /// \endcode 3259 LBI_OuterScope, 3260 }; 3261 3262 /// The indentation style of lambda bodies. ``Signature`` (the default) 3263 /// causes the lambda body to be indented one additional level relative to 3264 /// the indentation level of the signature. ``OuterScope`` forces the lambda 3265 /// body to be indented one additional level relative to the parent scope 3266 /// containing the lambda signature. 3267 /// \version 13 3268 LambdaBodyIndentationKind LambdaBodyIndentation; 3269 3270 /// Supported languages. 3271 /// 3272 /// When stored in a configuration file, specifies the language, that the 3273 /// configuration targets. When passed to the ``reformat()`` function, enables 3274 /// syntax features specific to the language. 3275 enum LanguageKind : int8_t { 3276 /// Do not use. 3277 LK_None, 3278 /// Should be used for C, C++. 3279 LK_Cpp, 3280 /// Should be used for C#. 3281 LK_CSharp, 3282 /// Should be used for Java. 3283 LK_Java, 3284 /// Should be used for JavaScript. 3285 LK_JavaScript, 3286 /// Should be used for JSON. 3287 LK_Json, 3288 /// Should be used for Objective-C, Objective-C++. 3289 LK_ObjC, 3290 /// Should be used for Protocol Buffers 3291 /// (https://developers.google.com/protocol-buffers/). 3292 LK_Proto, 3293 /// Should be used for TableGen code. 3294 LK_TableGen, 3295 /// Should be used for Protocol Buffer messages in text format 3296 /// (https://developers.google.com/protocol-buffers/). 3297 LK_TextProto, 3298 /// Should be used for Verilog and SystemVerilog. 3299 /// https://standards.ieee.org/ieee/1800/6700/ 3300 /// https://sci-hub.st/10.1109/IEEESTD.2018.8299595 3301 LK_Verilog 3302 }; 3303 bool isCpp() const { return Language == LK_Cpp || Language == LK_ObjC; } 3304 bool isCSharp() const { return Language == LK_CSharp; } 3305 bool isJson() const { return Language == LK_Json; } 3306 bool isJavaScript() const { return Language == LK_JavaScript; } 3307 bool isVerilog() const { return Language == LK_Verilog; } 3308 bool isProto() const { 3309 return Language == LK_Proto || Language == LK_TextProto; 3310 } 3311 bool isTableGen() const { return Language == LK_TableGen; } 3312 3313 /// Language, this format style is targeted at. 3314 /// \version 3.5 3315 LanguageKind Language; 3316 3317 /// Line ending style. 3318 enum LineEndingStyle : int8_t { 3319 /// Use ``\n``. 3320 LE_LF, 3321 /// Use ``\r\n``. 3322 LE_CRLF, 3323 /// Use ``\n`` unless the input has more lines ending in ``\r\n``. 3324 LE_DeriveLF, 3325 /// Use ``\r\n`` unless the input has more lines ending in ``\n``. 3326 LE_DeriveCRLF, 3327 }; 3328 3329 /// Line ending style (``\n`` or ``\r\n``) to use. 3330 /// \version 16 3331 LineEndingStyle LineEnding; 3332 3333 /// A regular expression matching macros that start a block. 3334 /// \code 3335 /// # With: 3336 /// MacroBlockBegin: "^NS_MAP_BEGIN|\ 3337 /// NS_TABLE_HEAD$" 3338 /// MacroBlockEnd: "^\ 3339 /// NS_MAP_END|\ 3340 /// NS_TABLE_.*_END$" 3341 /// 3342 /// NS_MAP_BEGIN 3343 /// foo(); 3344 /// NS_MAP_END 3345 /// 3346 /// NS_TABLE_HEAD 3347 /// bar(); 3348 /// NS_TABLE_FOO_END 3349 /// 3350 /// # Without: 3351 /// NS_MAP_BEGIN 3352 /// foo(); 3353 /// NS_MAP_END 3354 /// 3355 /// NS_TABLE_HEAD 3356 /// bar(); 3357 /// NS_TABLE_FOO_END 3358 /// \endcode 3359 /// \version 3.7 3360 std::string MacroBlockBegin; 3361 3362 /// A regular expression matching macros that end a block. 3363 /// \version 3.7 3364 std::string MacroBlockEnd; 3365 3366 /// A list of macros of the form \c <definition>=<expansion> . 3367 /// 3368 /// Code will be parsed with macros expanded, in order to determine how to 3369 /// interpret and format the macro arguments. 3370 /// 3371 /// For example, the code: 3372 /// \code 3373 /// A(a*b); 3374 /// \endcode 3375 /// 3376 /// will usually be interpreted as a call to a function A, and the 3377 /// multiplication expression will be formatted as ``a * b``. 3378 /// 3379 /// If we specify the macro definition: 3380 /// \code{.yaml} 3381 /// Macros: 3382 /// - A(x)=x 3383 /// \endcode 3384 /// 3385 /// the code will now be parsed as a declaration of the variable b of type a*, 3386 /// and formatted as ``a* b`` (depending on pointer-binding rules). 3387 /// 3388 /// Features and restrictions: 3389 /// * Both function-like macros and object-like macros are supported. 3390 /// * Macro arguments must be used exactly once in the expansion. 3391 /// * No recursive expansion; macros referencing other macros will be 3392 /// ignored. 3393 /// * Overloading by arity is supported: for example, given the macro 3394 /// definitions A=x, A()=y, A(a)=a 3395 /// 3396 /// \code 3397 /// A; -> x; 3398 /// A(); -> y; 3399 /// A(z); -> z; 3400 /// A(a, b); // will not be expanded. 3401 /// \endcode 3402 /// 3403 /// \version 17 3404 std::vector<std::string> Macros; 3405 3406 /// The maximum number of consecutive empty lines to keep. 3407 /// \code 3408 /// MaxEmptyLinesToKeep: 1 vs. MaxEmptyLinesToKeep: 0 3409 /// int f() { int f() { 3410 /// int = 1; int i = 1; 3411 /// i = foo(); 3412 /// i = foo(); return i; 3413 /// } 3414 /// return i; 3415 /// } 3416 /// \endcode 3417 /// \version 3.7 3418 unsigned MaxEmptyLinesToKeep; 3419 3420 /// Different ways to indent namespace contents. 3421 enum NamespaceIndentationKind : int8_t { 3422 /// Don't indent in namespaces. 3423 /// \code 3424 /// namespace out { 3425 /// int i; 3426 /// namespace in { 3427 /// int i; 3428 /// } 3429 /// } 3430 /// \endcode 3431 NI_None, 3432 /// Indent only in inner namespaces (nested in other namespaces). 3433 /// \code 3434 /// namespace out { 3435 /// int i; 3436 /// namespace in { 3437 /// int i; 3438 /// } 3439 /// } 3440 /// \endcode 3441 NI_Inner, 3442 /// Indent in all namespaces. 3443 /// \code 3444 /// namespace out { 3445 /// int i; 3446 /// namespace in { 3447 /// int i; 3448 /// } 3449 /// } 3450 /// \endcode 3451 NI_All 3452 }; 3453 3454 /// The indentation used for namespaces. 3455 /// \version 3.7 3456 NamespaceIndentationKind NamespaceIndentation; 3457 3458 /// A vector of macros which are used to open namespace blocks. 3459 /// 3460 /// These are expected to be macros of the form: 3461 /// \code 3462 /// NAMESPACE(<namespace-name>, ...) { 3463 /// <namespace-content> 3464 /// } 3465 /// \endcode 3466 /// 3467 /// For example: TESTSUITE 3468 /// \version 9 3469 std::vector<std::string> NamespaceMacros; 3470 3471 /// Controls bin-packing Objective-C protocol conformance list 3472 /// items into as few lines as possible when they go over ``ColumnLimit``. 3473 /// 3474 /// If ``Auto`` (the default), delegates to the value in 3475 /// ``BinPackParameters``. If that is ``BinPack``, bin-packs Objective-C 3476 /// protocol conformance list items into as few lines as possible 3477 /// whenever they go over ``ColumnLimit``. 3478 /// 3479 /// If ``Always``, always bin-packs Objective-C protocol conformance 3480 /// list items into as few lines as possible whenever they go over 3481 /// ``ColumnLimit``. 3482 /// 3483 /// If ``Never``, lays out Objective-C protocol conformance list items 3484 /// onto individual lines whenever they go over ``ColumnLimit``. 3485 /// 3486 /// \code{.objc} 3487 /// Always (or Auto, if BinPackParameters==BinPack): 3488 /// @interface ccccccccccccc () < 3489 /// ccccccccccccc, ccccccccccccc, 3490 /// ccccccccccccc, ccccccccccccc> { 3491 /// } 3492 /// 3493 /// Never (or Auto, if BinPackParameters!=BinPack): 3494 /// @interface ddddddddddddd () < 3495 /// ddddddddddddd, 3496 /// ddddddddddddd, 3497 /// ddddddddddddd, 3498 /// ddddddddddddd> { 3499 /// } 3500 /// \endcode 3501 /// \version 7 3502 BinPackStyle ObjCBinPackProtocolList; 3503 3504 /// The number of characters to use for indentation of ObjC blocks. 3505 /// \code{.objc} 3506 /// ObjCBlockIndentWidth: 4 3507 /// 3508 /// [operation setCompletionBlock:^{ 3509 /// [self onOperationDone]; 3510 /// }]; 3511 /// \endcode 3512 /// \version 3.7 3513 unsigned ObjCBlockIndentWidth; 3514 3515 /// Break parameters list into lines when there is nested block 3516 /// parameters in a function call. 3517 /// \code 3518 /// false: 3519 /// - (void)_aMethod 3520 /// { 3521 /// [self.test1 t:self w:self callback:^(typeof(self) self, NSNumber 3522 /// *u, NSNumber *v) { 3523 /// u = c; 3524 /// }] 3525 /// } 3526 /// true: 3527 /// - (void)_aMethod 3528 /// { 3529 /// [self.test1 t:self 3530 /// w:self 3531 /// callback:^(typeof(self) self, NSNumber *u, NSNumber *v) { 3532 /// u = c; 3533 /// }] 3534 /// } 3535 /// \endcode 3536 /// \version 11 3537 bool ObjCBreakBeforeNestedBlockParam; 3538 3539 /// The order in which ObjC property attributes should appear. 3540 /// 3541 /// Attributes in code will be sorted in the order specified. Any attributes 3542 /// encountered that are not mentioned in this array will be sorted last, in 3543 /// stable order. Comments between attributes will leave the attributes 3544 /// untouched. 3545 /// \warning 3546 /// Using this option could lead to incorrect code formatting due to 3547 /// clang-format's lack of complete semantic information. As such, extra 3548 /// care should be taken to review code changes made by this option. 3549 /// \endwarning 3550 /// \code{.yaml} 3551 /// ObjCPropertyAttributeOrder: [ 3552 /// class, direct, 3553 /// atomic, nonatomic, 3554 /// assign, retain, strong, copy, weak, unsafe_unretained, 3555 /// readonly, readwrite, getter, setter, 3556 /// nullable, nonnull, null_resettable, null_unspecified 3557 /// ] 3558 /// \endcode 3559 /// \version 18 3560 std::vector<std::string> ObjCPropertyAttributeOrder; 3561 3562 /// Add a space after ``@property`` in Objective-C, i.e. use 3563 /// ``@property (readonly)`` instead of ``@property(readonly)``. 3564 /// \version 3.7 3565 bool ObjCSpaceAfterProperty; 3566 3567 /// Add a space in front of an Objective-C protocol list, i.e. use 3568 /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``. 3569 /// \version 3.7 3570 bool ObjCSpaceBeforeProtocolList; 3571 3572 /// Different ways to try to fit all constructor initializers on a line. 3573 enum PackConstructorInitializersStyle : int8_t { 3574 /// Always put each constructor initializer on its own line. 3575 /// \code 3576 /// Constructor() 3577 /// : a(), 3578 /// b() 3579 /// \endcode 3580 PCIS_Never, 3581 /// Bin-pack constructor initializers. 3582 /// \code 3583 /// Constructor() 3584 /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), 3585 /// cccccccccccccccccccc() 3586 /// \endcode 3587 PCIS_BinPack, 3588 /// Put all constructor initializers on the current line if they fit. 3589 /// Otherwise, put each one on its own line. 3590 /// \code 3591 /// Constructor() : a(), b() 3592 /// 3593 /// Constructor() 3594 /// : aaaaaaaaaaaaaaaaaaaa(), 3595 /// bbbbbbbbbbbbbbbbbbbb(), 3596 /// ddddddddddddd() 3597 /// \endcode 3598 PCIS_CurrentLine, 3599 /// Same as ``PCIS_CurrentLine`` except that if all constructor initializers 3600 /// do not fit on the current line, try to fit them on the next line. 3601 /// \code 3602 /// Constructor() : a(), b() 3603 /// 3604 /// Constructor() 3605 /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd() 3606 /// 3607 /// Constructor() 3608 /// : aaaaaaaaaaaaaaaaaaaa(), 3609 /// bbbbbbbbbbbbbbbbbbbb(), 3610 /// cccccccccccccccccccc() 3611 /// \endcode 3612 PCIS_NextLine, 3613 /// Put all constructor initializers on the next line if they fit. 3614 /// Otherwise, put each one on its own line. 3615 /// \code 3616 /// Constructor() 3617 /// : a(), b() 3618 /// 3619 /// Constructor() 3620 /// : aaaaaaaaaaaaaaaaaaaa(), bbbbbbbbbbbbbbbbbbbb(), ddddddddddddd() 3621 /// 3622 /// Constructor() 3623 /// : aaaaaaaaaaaaaaaaaaaa(), 3624 /// bbbbbbbbbbbbbbbbbbbb(), 3625 /// cccccccccccccccccccc() 3626 /// \endcode 3627 PCIS_NextLineOnly, 3628 }; 3629 3630 /// The pack constructor initializers style to use. 3631 /// \version 14 3632 PackConstructorInitializersStyle PackConstructorInitializers; 3633 3634 /// The penalty for breaking around an assignment operator. 3635 /// \version 5 3636 unsigned PenaltyBreakAssignment; 3637 3638 /// The penalty for breaking a function call after ``call(``. 3639 /// \version 3.7 3640 unsigned PenaltyBreakBeforeFirstCallParameter; 3641 3642 /// The penalty for breaking before a member access operator (``.``, ``->``). 3643 /// \version 20 3644 unsigned PenaltyBreakBeforeMemberAccess; 3645 3646 /// The penalty for each line break introduced inside a comment. 3647 /// \version 3.7 3648 unsigned PenaltyBreakComment; 3649 3650 /// The penalty for breaking before the first ``<<``. 3651 /// \version 3.7 3652 unsigned PenaltyBreakFirstLessLess; 3653 3654 /// The penalty for breaking after ``(``. 3655 /// \version 14 3656 unsigned PenaltyBreakOpenParenthesis; 3657 3658 /// The penalty for breaking after ``::``. 3659 /// \version 18 3660 unsigned PenaltyBreakScopeResolution; 3661 3662 /// The penalty for each line break introduced inside a string literal. 3663 /// \version 3.7 3664 unsigned PenaltyBreakString; 3665 3666 /// The penalty for breaking after template declaration. 3667 /// \version 7 3668 unsigned PenaltyBreakTemplateDeclaration; 3669 3670 /// The penalty for each character outside of the column limit. 3671 /// \version 3.7 3672 unsigned PenaltyExcessCharacter; 3673 3674 /// Penalty for each character of whitespace indentation 3675 /// (counted relative to leading non-whitespace column). 3676 /// \version 12 3677 unsigned PenaltyIndentedWhitespace; 3678 3679 /// Penalty for putting the return type of a function onto its own line. 3680 /// \version 3.7 3681 unsigned PenaltyReturnTypeOnItsOwnLine; 3682 3683 /// The ``&``, ``&&`` and ``*`` alignment style. 3684 enum PointerAlignmentStyle : int8_t { 3685 /// Align pointer to the left. 3686 /// \code 3687 /// int* a; 3688 /// \endcode 3689 PAS_Left, 3690 /// Align pointer to the right. 3691 /// \code 3692 /// int *a; 3693 /// \endcode 3694 PAS_Right, 3695 /// Align pointer in the middle. 3696 /// \code 3697 /// int * a; 3698 /// \endcode 3699 PAS_Middle 3700 }; 3701 3702 /// Pointer and reference alignment style. 3703 /// \version 3.7 3704 PointerAlignmentStyle PointerAlignment; 3705 3706 /// The number of columns to use for indentation of preprocessor statements. 3707 /// When set to -1 (default) ``IndentWidth`` is used also for preprocessor 3708 /// statements. 3709 /// \code 3710 /// PPIndentWidth: 1 3711 /// 3712 /// #ifdef __linux__ 3713 /// # define FOO 3714 /// #else 3715 /// # define BAR 3716 /// #endif 3717 /// \endcode 3718 /// \version 13 3719 int PPIndentWidth; 3720 3721 /// Different specifiers and qualifiers alignment styles. 3722 enum QualifierAlignmentStyle : int8_t { 3723 /// Don't change specifiers/qualifiers to either Left or Right alignment 3724 /// (default). 3725 /// \code 3726 /// int const a; 3727 /// const int *a; 3728 /// \endcode 3729 QAS_Leave, 3730 /// Change specifiers/qualifiers to be left-aligned. 3731 /// \code 3732 /// const int a; 3733 /// const int *a; 3734 /// \endcode 3735 QAS_Left, 3736 /// Change specifiers/qualifiers to be right-aligned. 3737 /// \code 3738 /// int const a; 3739 /// int const *a; 3740 /// \endcode 3741 QAS_Right, 3742 /// Change specifiers/qualifiers to be aligned based on ``QualifierOrder``. 3743 /// With: 3744 /// \code{.yaml} 3745 /// QualifierOrder: [inline, static, type, const] 3746 /// \endcode 3747 /// 3748 /// \code 3749 /// 3750 /// int const a; 3751 /// int const *a; 3752 /// \endcode 3753 QAS_Custom 3754 }; 3755 3756 /// Different ways to arrange specifiers and qualifiers (e.g. const/volatile). 3757 /// \warning 3758 /// Setting ``QualifierAlignment`` to something other than ``Leave``, COULD 3759 /// lead to incorrect code formatting due to incorrect decisions made due to 3760 /// clang-formats lack of complete semantic information. 3761 /// As such extra care should be taken to review code changes made by the use 3762 /// of this option. 3763 /// \endwarning 3764 /// \version 14 3765 QualifierAlignmentStyle QualifierAlignment; 3766 3767 /// The order in which the qualifiers appear. 3768 /// The order is an array that can contain any of the following: 3769 /// 3770 /// * ``const`` 3771 /// * ``inline`` 3772 /// * ``static`` 3773 /// * ``friend`` 3774 /// * ``constexpr`` 3775 /// * ``volatile`` 3776 /// * ``restrict`` 3777 /// * ``type`` 3778 /// 3779 /// \note 3780 /// It must contain ``type``. 3781 /// \endnote 3782 /// 3783 /// Items to the left of ``type`` will be placed to the left of the type and 3784 /// aligned in the order supplied. Items to the right of ``type`` will be 3785 /// placed to the right of the type and aligned in the order supplied. 3786 /// 3787 /// \code{.yaml} 3788 /// QualifierOrder: [inline, static, type, const, volatile] 3789 /// \endcode 3790 /// \version 14 3791 std::vector<std::string> QualifierOrder; 3792 3793 /// See documentation of ``RawStringFormats``. 3794 struct RawStringFormat { 3795 /// The language of this raw string. 3796 LanguageKind Language; 3797 /// A list of raw string delimiters that match this language. 3798 std::vector<std::string> Delimiters; 3799 /// A list of enclosing function names that match this language. 3800 std::vector<std::string> EnclosingFunctions; 3801 /// The canonical delimiter for this language. 3802 std::string CanonicalDelimiter; 3803 /// The style name on which this raw string format is based on. 3804 /// If not specified, the raw string format is based on the style that this 3805 /// format is based on. 3806 std::string BasedOnStyle; 3807 bool operator==(const RawStringFormat &Other) const { 3808 return Language == Other.Language && Delimiters == Other.Delimiters && 3809 EnclosingFunctions == Other.EnclosingFunctions && 3810 CanonicalDelimiter == Other.CanonicalDelimiter && 3811 BasedOnStyle == Other.BasedOnStyle; 3812 } 3813 }; 3814 3815 /// Defines hints for detecting supported languages code blocks in raw 3816 /// strings. 3817 /// 3818 /// A raw string with a matching delimiter or a matching enclosing function 3819 /// name will be reformatted assuming the specified language based on the 3820 /// style for that language defined in the .clang-format file. If no style has 3821 /// been defined in the .clang-format file for the specific language, a 3822 /// predefined style given by ``BasedOnStyle`` is used. If ``BasedOnStyle`` is 3823 /// not found, the formatting is based on ``LLVM`` style. A matching delimiter 3824 /// takes precedence over a matching enclosing function name for determining 3825 /// the language of the raw string contents. 3826 /// 3827 /// If a canonical delimiter is specified, occurrences of other delimiters for 3828 /// the same language will be updated to the canonical if possible. 3829 /// 3830 /// There should be at most one specification per language and each delimiter 3831 /// and enclosing function should not occur in multiple specifications. 3832 /// 3833 /// To configure this in the .clang-format file, use: 3834 /// \code{.yaml} 3835 /// RawStringFormats: 3836 /// - Language: TextProto 3837 /// Delimiters: 3838 /// - pb 3839 /// - proto 3840 /// EnclosingFunctions: 3841 /// - PARSE_TEXT_PROTO 3842 /// BasedOnStyle: google 3843 /// - Language: Cpp 3844 /// Delimiters: 3845 /// - cc 3846 /// - cpp 3847 /// BasedOnStyle: LLVM 3848 /// CanonicalDelimiter: cc 3849 /// \endcode 3850 /// \version 6 3851 std::vector<RawStringFormat> RawStringFormats; 3852 3853 /// \brief The ``&`` and ``&&`` alignment style. 3854 enum ReferenceAlignmentStyle : int8_t { 3855 /// Align reference like ``PointerAlignment``. 3856 RAS_Pointer, 3857 /// Align reference to the left. 3858 /// \code 3859 /// int& a; 3860 /// \endcode 3861 RAS_Left, 3862 /// Align reference to the right. 3863 /// \code 3864 /// int &a; 3865 /// \endcode 3866 RAS_Right, 3867 /// Align reference in the middle. 3868 /// \code 3869 /// int & a; 3870 /// \endcode 3871 RAS_Middle 3872 }; 3873 3874 /// \brief Reference alignment style (overrides ``PointerAlignment`` for 3875 /// references). 3876 /// \version 13 3877 ReferenceAlignmentStyle ReferenceAlignment; 3878 3879 // clang-format off 3880 /// \brief Types of comment reflow style. 3881 enum ReflowCommentsStyle : int8_t { 3882 /// Leave comments untouched. 3883 /// \code 3884 /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information 3885 /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */ 3886 /// /* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information 3887 /// * and a misaligned second line */ 3888 /// \endcode 3889 RCS_Never, 3890 /// Only apply indentation rules, moving comments left or right, without 3891 /// changing formatting inside the comments. 3892 /// \code 3893 /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information 3894 /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */ 3895 /// /* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information 3896 /// * and a misaligned second line */ 3897 /// \endcode 3898 RCS_IndentOnly, 3899 /// Apply indentation rules and reflow long comments into new lines, trying 3900 /// to obey the ``ColumnLimit``. 3901 /// \code 3902 /// // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of 3903 /// // information 3904 /// /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of 3905 /// * information */ 3906 /// /* third veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of 3907 /// * information and a misaligned second line */ 3908 /// \endcode 3909 RCS_Always 3910 }; 3911 // clang-format on 3912 3913 /// \brief Comment reformatting style. 3914 /// \version 3.8 3915 ReflowCommentsStyle ReflowComments; 3916 3917 /// Remove optional braces of control statements (``if``, ``else``, ``for``, 3918 /// and ``while``) in C++ according to the LLVM coding style. 3919 /// \warning 3920 /// This option will be renamed and expanded to support other styles. 3921 /// \endwarning 3922 /// \warning 3923 /// Setting this option to ``true`` could lead to incorrect code formatting 3924 /// due to clang-format's lack of complete semantic information. As such, 3925 /// extra care should be taken to review code changes made by this option. 3926 /// \endwarning 3927 /// \code 3928 /// false: true: 3929 /// 3930 /// if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D)) 3931 /// handleFunctionDecl(D); handleFunctionDecl(D); 3932 /// } else if (isa<VarDecl>(D)) { else if (isa<VarDecl>(D)) 3933 /// handleVarDecl(D); handleVarDecl(D); 3934 /// } 3935 /// 3936 /// if (isa<VarDecl>(D)) { vs. if (isa<VarDecl>(D)) { 3937 /// for (auto *A : D.attrs()) { for (auto *A : D.attrs()) 3938 /// if (shouldProcessAttr(A)) { if (shouldProcessAttr(A)) 3939 /// handleAttr(A); handleAttr(A); 3940 /// } } 3941 /// } 3942 /// } 3943 /// 3944 /// if (isa<FunctionDecl>(D)) { vs. if (isa<FunctionDecl>(D)) 3945 /// for (auto *A : D.attrs()) { for (auto *A : D.attrs()) 3946 /// handleAttr(A); handleAttr(A); 3947 /// } 3948 /// } 3949 /// 3950 /// if (auto *D = (T)(D)) { vs. if (auto *D = (T)(D)) { 3951 /// if (shouldProcess(D)) { if (shouldProcess(D)) 3952 /// handleVarDecl(D); handleVarDecl(D); 3953 /// } else { else 3954 /// markAsIgnored(D); markAsIgnored(D); 3955 /// } } 3956 /// } 3957 /// 3958 /// if (a) { vs. if (a) 3959 /// b(); b(); 3960 /// } else { else if (c) 3961 /// if (c) { d(); 3962 /// d(); else 3963 /// } else { e(); 3964 /// e(); 3965 /// } 3966 /// } 3967 /// \endcode 3968 /// \version 14 3969 bool RemoveBracesLLVM; 3970 3971 /// Remove empty lines within unwrapped lines. 3972 /// \code 3973 /// false: true: 3974 /// 3975 /// int c vs. int c = a + b; 3976 /// 3977 /// = a + b; 3978 /// 3979 /// enum : unsigned vs. enum : unsigned { 3980 /// AA = 0, 3981 /// { BB 3982 /// AA = 0, } myEnum; 3983 /// BB 3984 /// } myEnum; 3985 /// 3986 /// while ( vs. while (true) { 3987 /// } 3988 /// true) { 3989 /// } 3990 /// \endcode 3991 /// \version 20 3992 bool RemoveEmptyLinesInUnwrappedLines; 3993 3994 /// Types of redundant parentheses to remove. 3995 enum RemoveParenthesesStyle : int8_t { 3996 /// Do not remove parentheses. 3997 /// \code 3998 /// class __declspec((dllimport)) X {}; 3999 /// co_return (((0))); 4000 /// return ((a + b) - ((c + d))); 4001 /// \endcode 4002 RPS_Leave, 4003 /// Replace multiple parentheses with single parentheses. 4004 /// \code 4005 /// class __declspec(dllimport) X {}; 4006 /// co_return (0); 4007 /// return ((a + b) - (c + d)); 4008 /// \endcode 4009 RPS_MultipleParentheses, 4010 /// Also remove parentheses enclosing the expression in a 4011 /// ``return``/``co_return`` statement. 4012 /// \code 4013 /// class __declspec(dllimport) X {}; 4014 /// co_return 0; 4015 /// return (a + b) - (c + d); 4016 /// \endcode 4017 RPS_ReturnStatement, 4018 }; 4019 4020 /// Remove redundant parentheses. 4021 /// \warning 4022 /// Setting this option to any value other than ``Leave`` could lead to 4023 /// incorrect code formatting due to clang-format's lack of complete semantic 4024 /// information. As such, extra care should be taken to review code changes 4025 /// made by this option. 4026 /// \endwarning 4027 /// \version 17 4028 RemoveParenthesesStyle RemoveParentheses; 4029 4030 /// Remove semicolons after the closing braces of functions and 4031 /// constructors/destructors. 4032 /// \warning 4033 /// Setting this option to ``true`` could lead to incorrect code formatting 4034 /// due to clang-format's lack of complete semantic information. As such, 4035 /// extra care should be taken to review code changes made by this option. 4036 /// \endwarning 4037 /// \code 4038 /// false: true: 4039 /// 4040 /// int max(int a, int b) { int max(int a, int b) { 4041 /// return a > b ? a : b; return a > b ? a : b; 4042 /// }; } 4043 /// 4044 /// \endcode 4045 /// \version 16 4046 bool RemoveSemicolon; 4047 4048 /// \brief The possible positions for the requires clause. The 4049 /// ``IndentRequires`` option is only used if the ``requires`` is put on the 4050 /// start of a line. 4051 enum RequiresClausePositionStyle : int8_t { 4052 /// Always put the ``requires`` clause on its own line (possibly followed by 4053 /// a semicolon). 4054 /// \code 4055 /// template <typename T> 4056 /// requires C<T> 4057 /// struct Foo {... 4058 /// 4059 /// template <typename T> 4060 /// void bar(T t) 4061 /// requires C<T>; 4062 /// 4063 /// template <typename T> 4064 /// requires C<T> 4065 /// void bar(T t) {... 4066 /// 4067 /// template <typename T> 4068 /// void baz(T t) 4069 /// requires C<T> 4070 /// {... 4071 /// \endcode 4072 RCPS_OwnLine, 4073 /// As with ``OwnLine``, except, unless otherwise prohibited, place a 4074 /// following open brace (of a function definition) to follow on the same 4075 /// line. 4076 /// \code 4077 /// void bar(T t) 4078 /// requires C<T> { 4079 /// return; 4080 /// } 4081 /// 4082 /// void bar(T t) 4083 /// requires C<T> {} 4084 /// 4085 /// template <typename T> 4086 /// requires C<T> 4087 /// void baz(T t) { 4088 /// ... 4089 /// \endcode 4090 RCPS_OwnLineWithBrace, 4091 /// Try to put the clause together with the preceding part of a declaration. 4092 /// For class templates: stick to the template declaration. 4093 /// For function templates: stick to the template declaration. 4094 /// For function declaration followed by a requires clause: stick to the 4095 /// parameter list. 4096 /// \code 4097 /// template <typename T> requires C<T> 4098 /// struct Foo {... 4099 /// 4100 /// template <typename T> requires C<T> 4101 /// void bar(T t) {... 4102 /// 4103 /// template <typename T> 4104 /// void baz(T t) requires C<T> 4105 /// {... 4106 /// \endcode 4107 RCPS_WithPreceding, 4108 /// Try to put the ``requires`` clause together with the class or function 4109 /// declaration. 4110 /// \code 4111 /// template <typename T> 4112 /// requires C<T> struct Foo {... 4113 /// 4114 /// template <typename T> 4115 /// requires C<T> void bar(T t) {... 4116 /// 4117 /// template <typename T> 4118 /// void baz(T t) 4119 /// requires C<T> {... 4120 /// \endcode 4121 RCPS_WithFollowing, 4122 /// Try to put everything in the same line if possible. Otherwise normal 4123 /// line breaking rules take over. 4124 /// \code 4125 /// // Fitting: 4126 /// template <typename T> requires C<T> struct Foo {... 4127 /// 4128 /// template <typename T> requires C<T> void bar(T t) {... 4129 /// 4130 /// template <typename T> void bar(T t) requires C<T> {... 4131 /// 4132 /// // Not fitting, one possible example: 4133 /// template <typename LongName> 4134 /// requires C<LongName> 4135 /// struct Foo {... 4136 /// 4137 /// template <typename LongName> 4138 /// requires C<LongName> 4139 /// void bar(LongName ln) { 4140 /// 4141 /// template <typename LongName> 4142 /// void bar(LongName ln) 4143 /// requires C<LongName> { 4144 /// \endcode 4145 RCPS_SingleLine, 4146 }; 4147 4148 /// \brief The position of the ``requires`` clause. 4149 /// \version 15 4150 RequiresClausePositionStyle RequiresClausePosition; 4151 4152 /// Indentation logic for requires expression bodies. 4153 enum RequiresExpressionIndentationKind : int8_t { 4154 /// Align requires expression body relative to the indentation level of the 4155 /// outer scope the requires expression resides in. 4156 /// This is the default. 4157 /// \code 4158 /// template <typename T> 4159 /// concept C = requires(T t) { 4160 /// ... 4161 /// } 4162 /// \endcode 4163 REI_OuterScope, 4164 /// Align requires expression body relative to the ``requires`` keyword. 4165 /// \code 4166 /// template <typename T> 4167 /// concept C = requires(T t) { 4168 /// ... 4169 /// } 4170 /// \endcode 4171 REI_Keyword, 4172 }; 4173 4174 /// The indentation used for requires expression bodies. 4175 /// \version 16 4176 RequiresExpressionIndentationKind RequiresExpressionIndentation; 4177 4178 /// \brief The style if definition blocks should be separated. 4179 enum SeparateDefinitionStyle : int8_t { 4180 /// Leave definition blocks as they are. 4181 SDS_Leave, 4182 /// Insert an empty line between definition blocks. 4183 SDS_Always, 4184 /// Remove any empty line between definition blocks. 4185 SDS_Never 4186 }; 4187 4188 /// Specifies the use of empty lines to separate definition blocks, including 4189 /// classes, structs, enums, and functions. 4190 /// \code 4191 /// Never v.s. Always 4192 /// #include <cstring> #include <cstring> 4193 /// struct Foo { 4194 /// int a, b, c; struct Foo { 4195 /// }; int a, b, c; 4196 /// namespace Ns { }; 4197 /// class Bar { 4198 /// public: namespace Ns { 4199 /// struct Foobar { class Bar { 4200 /// int a; public: 4201 /// int b; struct Foobar { 4202 /// }; int a; 4203 /// private: int b; 4204 /// int t; }; 4205 /// int method1() { 4206 /// // ... private: 4207 /// } int t; 4208 /// enum List { 4209 /// ITEM1, int method1() { 4210 /// ITEM2 // ... 4211 /// }; } 4212 /// template<typename T> 4213 /// int method2(T x) { enum List { 4214 /// // ... ITEM1, 4215 /// } ITEM2 4216 /// int i, j, k; }; 4217 /// int method3(int par) { 4218 /// // ... template<typename T> 4219 /// } int method2(T x) { 4220 /// }; // ... 4221 /// class C {}; } 4222 /// } 4223 /// int i, j, k; 4224 /// 4225 /// int method3(int par) { 4226 /// // ... 4227 /// } 4228 /// }; 4229 /// 4230 /// class C {}; 4231 /// } 4232 /// \endcode 4233 /// \version 14 4234 SeparateDefinitionStyle SeparateDefinitionBlocks; 4235 4236 /// The maximal number of unwrapped lines that a short namespace spans. 4237 /// Defaults to 1. 4238 /// 4239 /// This determines the maximum length of short namespaces by counting 4240 /// unwrapped lines (i.e. containing neither opening nor closing 4241 /// namespace brace) and makes ``FixNamespaceComments`` omit adding 4242 /// end comments for those. 4243 /// \code 4244 /// ShortNamespaceLines: 1 vs. ShortNamespaceLines: 0 4245 /// namespace a { namespace a { 4246 /// int foo; int foo; 4247 /// } } // namespace a 4248 /// 4249 /// ShortNamespaceLines: 1 vs. ShortNamespaceLines: 0 4250 /// namespace b { namespace b { 4251 /// int foo; int foo; 4252 /// int bar; int bar; 4253 /// } // namespace b } // namespace b 4254 /// \endcode 4255 /// \version 13 4256 unsigned ShortNamespaceLines; 4257 4258 /// Do not format macro definition body. 4259 /// \version 18 4260 bool SkipMacroDefinitionBody; 4261 4262 /// Include sorting options. 4263 enum SortIncludesOptions : int8_t { 4264 /// Includes are never sorted. 4265 /// \code 4266 /// #include "B/A.h" 4267 /// #include "A/B.h" 4268 /// #include "a/b.h" 4269 /// #include "A/b.h" 4270 /// #include "B/a.h" 4271 /// \endcode 4272 SI_Never, 4273 /// Includes are sorted in an ASCIIbetical or case sensitive fashion. 4274 /// \code 4275 /// #include "A/B.h" 4276 /// #include "A/b.h" 4277 /// #include "B/A.h" 4278 /// #include "B/a.h" 4279 /// #include "a/b.h" 4280 /// \endcode 4281 SI_CaseSensitive, 4282 /// Includes are sorted in an alphabetical or case insensitive fashion. 4283 /// \code 4284 /// #include "A/B.h" 4285 /// #include "A/b.h" 4286 /// #include "a/b.h" 4287 /// #include "B/A.h" 4288 /// #include "B/a.h" 4289 /// \endcode 4290 SI_CaseInsensitive, 4291 }; 4292 4293 /// Controls if and how clang-format will sort ``#includes``. 4294 /// \version 3.8 4295 SortIncludesOptions SortIncludes; 4296 4297 /// Position for Java Static imports. 4298 enum SortJavaStaticImportOptions : int8_t { 4299 /// Static imports are placed before non-static imports. 4300 /// \code{.java} 4301 /// import static org.example.function1; 4302 /// 4303 /// import org.example.ClassA; 4304 /// \endcode 4305 SJSIO_Before, 4306 /// Static imports are placed after non-static imports. 4307 /// \code{.java} 4308 /// import org.example.ClassA; 4309 /// 4310 /// import static org.example.function1; 4311 /// \endcode 4312 SJSIO_After, 4313 }; 4314 4315 /// When sorting Java imports, by default static imports are placed before 4316 /// non-static imports. If ``JavaStaticImportAfterImport`` is ``After``, 4317 /// static imports are placed after non-static imports. 4318 /// \version 12 4319 SortJavaStaticImportOptions SortJavaStaticImport; 4320 4321 /// Using declaration sorting options. 4322 enum SortUsingDeclarationsOptions : int8_t { 4323 /// Using declarations are never sorted. 4324 /// \code 4325 /// using std::chrono::duration_cast; 4326 /// using std::move; 4327 /// using boost::regex; 4328 /// using boost::regex_constants::icase; 4329 /// using std::string; 4330 /// \endcode 4331 SUD_Never, 4332 /// Using declarations are sorted in the order defined as follows: 4333 /// Split the strings by ``::`` and discard any initial empty strings. Sort 4334 /// the lists of names lexicographically, and within those groups, names are 4335 /// in case-insensitive lexicographic order. 4336 /// \code 4337 /// using boost::regex; 4338 /// using boost::regex_constants::icase; 4339 /// using std::chrono::duration_cast; 4340 /// using std::move; 4341 /// using std::string; 4342 /// \endcode 4343 SUD_Lexicographic, 4344 /// Using declarations are sorted in the order defined as follows: 4345 /// Split the strings by ``::`` and discard any initial empty strings. The 4346 /// last element of each list is a non-namespace name; all others are 4347 /// namespace names. Sort the lists of names lexicographically, where the 4348 /// sort order of individual names is that all non-namespace names come 4349 /// before all namespace names, and within those groups, names are in 4350 /// case-insensitive lexicographic order. 4351 /// \code 4352 /// using boost::regex; 4353 /// using boost::regex_constants::icase; 4354 /// using std::move; 4355 /// using std::string; 4356 /// using std::chrono::duration_cast; 4357 /// \endcode 4358 SUD_LexicographicNumeric, 4359 }; 4360 4361 /// Controls if and how clang-format will sort using declarations. 4362 /// \version 5 4363 SortUsingDeclarationsOptions SortUsingDeclarations; 4364 4365 /// If ``true``, a space is inserted after C style casts. 4366 /// \code 4367 /// true: false: 4368 /// (int) i; vs. (int)i; 4369 /// \endcode 4370 /// \version 3.5 4371 bool SpaceAfterCStyleCast; 4372 4373 /// If ``true``, a space is inserted after the logical not operator (``!``). 4374 /// \code 4375 /// true: false: 4376 /// ! someExpression(); vs. !someExpression(); 4377 /// \endcode 4378 /// \version 9 4379 bool SpaceAfterLogicalNot; 4380 4381 /// If \c true, a space will be inserted after the ``template`` keyword. 4382 /// \code 4383 /// true: false: 4384 /// template <int> void foo(); vs. template<int> void foo(); 4385 /// \endcode 4386 /// \version 4 4387 bool SpaceAfterTemplateKeyword; 4388 4389 /// Different ways to put a space before opening parentheses. 4390 enum SpaceAroundPointerQualifiersStyle : int8_t { 4391 /// Don't ensure spaces around pointer qualifiers and use PointerAlignment 4392 /// instead. 4393 /// \code 4394 /// PointerAlignment: Left PointerAlignment: Right 4395 /// void* const* x = NULL; vs. void *const *x = NULL; 4396 /// \endcode 4397 SAPQ_Default, 4398 /// Ensure that there is a space before pointer qualifiers. 4399 /// \code 4400 /// PointerAlignment: Left PointerAlignment: Right 4401 /// void* const* x = NULL; vs. void * const *x = NULL; 4402 /// \endcode 4403 SAPQ_Before, 4404 /// Ensure that there is a space after pointer qualifiers. 4405 /// \code 4406 /// PointerAlignment: Left PointerAlignment: Right 4407 /// void* const * x = NULL; vs. void *const *x = NULL; 4408 /// \endcode 4409 SAPQ_After, 4410 /// Ensure that there is a space both before and after pointer qualifiers. 4411 /// \code 4412 /// PointerAlignment: Left PointerAlignment: Right 4413 /// void* const * x = NULL; vs. void * const *x = NULL; 4414 /// \endcode 4415 SAPQ_Both, 4416 }; 4417 4418 /// Defines in which cases to put a space before or after pointer qualifiers 4419 /// \version 12 4420 SpaceAroundPointerQualifiersStyle SpaceAroundPointerQualifiers; 4421 4422 /// If ``false``, spaces will be removed before assignment operators. 4423 /// \code 4424 /// true: false: 4425 /// int a = 5; vs. int a= 5; 4426 /// a += 42; a+= 42; 4427 /// \endcode 4428 /// \version 3.7 4429 bool SpaceBeforeAssignmentOperators; 4430 4431 /// If ``false``, spaces will be removed before case colon. 4432 /// \code 4433 /// true: false 4434 /// switch (x) { vs. switch (x) { 4435 /// case 1 : break; case 1: break; 4436 /// } } 4437 /// \endcode 4438 /// \version 12 4439 bool SpaceBeforeCaseColon; 4440 4441 /// If ``true``, a space will be inserted before a C++11 braced list 4442 /// used to initialize an object (after the preceding identifier or type). 4443 /// \code 4444 /// true: false: 4445 /// Foo foo { bar }; vs. Foo foo{ bar }; 4446 /// Foo {}; Foo{}; 4447 /// vector<int> { 1, 2, 3 }; vector<int>{ 1, 2, 3 }; 4448 /// new int[3] { 1, 2, 3 }; new int[3]{ 1, 2, 3 }; 4449 /// \endcode 4450 /// \version 7 4451 bool SpaceBeforeCpp11BracedList; 4452 4453 /// If ``false``, spaces will be removed before constructor initializer 4454 /// colon. 4455 /// \code 4456 /// true: false: 4457 /// Foo::Foo() : a(a) {} Foo::Foo(): a(a) {} 4458 /// \endcode 4459 /// \version 7 4460 bool SpaceBeforeCtorInitializerColon; 4461 4462 /// If ``false``, spaces will be removed before inheritance colon. 4463 /// \code 4464 /// true: false: 4465 /// class Foo : Bar {} vs. class Foo: Bar {} 4466 /// \endcode 4467 /// \version 7 4468 bool SpaceBeforeInheritanceColon; 4469 4470 /// If ``true``, a space will be added before a JSON colon. For other 4471 /// languages, e.g. JavaScript, use ``SpacesInContainerLiterals`` instead. 4472 /// \code 4473 /// true: false: 4474 /// { { 4475 /// "key" : "value" vs. "key": "value" 4476 /// } } 4477 /// \endcode 4478 /// \version 17 4479 bool SpaceBeforeJsonColon; 4480 4481 /// Different ways to put a space before opening parentheses. 4482 enum SpaceBeforeParensStyle : int8_t { 4483 /// This is **deprecated** and replaced by ``Custom`` below, with all 4484 /// ``SpaceBeforeParensOptions`` but ``AfterPlacementOperator`` set to 4485 /// ``false``. 4486 SBPO_Never, 4487 /// Put a space before opening parentheses only after control statement 4488 /// keywords (``for/if/while...``). 4489 /// \code 4490 /// void f() { 4491 /// if (true) { 4492 /// f(); 4493 /// } 4494 /// } 4495 /// \endcode 4496 SBPO_ControlStatements, 4497 /// Same as ``SBPO_ControlStatements`` except this option doesn't apply to 4498 /// ForEach and If macros. This is useful in projects where ForEach/If 4499 /// macros are treated as function calls instead of control statements. 4500 /// ``SBPO_ControlStatementsExceptForEachMacros`` remains an alias for 4501 /// backward compatibility. 4502 /// \code 4503 /// void f() { 4504 /// Q_FOREACH(...) { 4505 /// f(); 4506 /// } 4507 /// } 4508 /// \endcode 4509 SBPO_ControlStatementsExceptControlMacros, 4510 /// Put a space before opening parentheses only if the parentheses are not 4511 /// empty. 4512 /// \code 4513 /// void() { 4514 /// if (true) { 4515 /// f(); 4516 /// g (x, y, z); 4517 /// } 4518 /// } 4519 /// \endcode 4520 SBPO_NonEmptyParentheses, 4521 /// Always put a space before opening parentheses, except when it's 4522 /// prohibited by the syntax rules (in function-like macro definitions) or 4523 /// when determined by other style rules (after unary operators, opening 4524 /// parentheses, etc.) 4525 /// \code 4526 /// void f () { 4527 /// if (true) { 4528 /// f (); 4529 /// } 4530 /// } 4531 /// \endcode 4532 SBPO_Always, 4533 /// Configure each individual space before parentheses in 4534 /// ``SpaceBeforeParensOptions``. 4535 SBPO_Custom, 4536 }; 4537 4538 /// Defines in which cases to put a space before opening parentheses. 4539 /// \version 3.5 4540 SpaceBeforeParensStyle SpaceBeforeParens; 4541 4542 /// Precise control over the spacing before parentheses. 4543 /// \code 4544 /// # Should be declared this way: 4545 /// SpaceBeforeParens: Custom 4546 /// SpaceBeforeParensOptions: 4547 /// AfterControlStatements: true 4548 /// AfterFunctionDefinitionName: true 4549 /// \endcode 4550 struct SpaceBeforeParensCustom { 4551 /// If ``true``, put space between control statement keywords 4552 /// (for/if/while...) and opening parentheses. 4553 /// \code 4554 /// true: false: 4555 /// if (...) {} vs. if(...) {} 4556 /// \endcode 4557 bool AfterControlStatements; 4558 /// If ``true``, put space between foreach macros and opening parentheses. 4559 /// \code 4560 /// true: false: 4561 /// FOREACH (...) vs. FOREACH(...) 4562 /// <loop-body> <loop-body> 4563 /// \endcode 4564 bool AfterForeachMacros; 4565 /// If ``true``, put a space between function declaration name and opening 4566 /// parentheses. 4567 /// \code 4568 /// true: false: 4569 /// void f (); vs. void f(); 4570 /// \endcode 4571 bool AfterFunctionDeclarationName; 4572 /// If ``true``, put a space between function definition name and opening 4573 /// parentheses. 4574 /// \code 4575 /// true: false: 4576 /// void f () {} vs. void f() {} 4577 /// \endcode 4578 bool AfterFunctionDefinitionName; 4579 /// If ``true``, put space between if macros and opening parentheses. 4580 /// \code 4581 /// true: false: 4582 /// IF (...) vs. IF(...) 4583 /// <conditional-body> <conditional-body> 4584 /// \endcode 4585 bool AfterIfMacros; 4586 /// If ``true``, put a space between operator overloading and opening 4587 /// parentheses. 4588 /// \code 4589 /// true: false: 4590 /// void operator++ (int a); vs. void operator++(int a); 4591 /// object.operator++ (10); object.operator++(10); 4592 /// \endcode 4593 bool AfterOverloadedOperator; 4594 /// If ``true``, put a space between operator ``new``/``delete`` and opening 4595 /// parenthesis. 4596 /// \code 4597 /// true: false: 4598 /// new (buf) T; vs. new(buf) T; 4599 /// delete (buf) T; delete(buf) T; 4600 /// \endcode 4601 bool AfterPlacementOperator; 4602 /// If ``true``, put space between requires keyword in a requires clause and 4603 /// opening parentheses, if there is one. 4604 /// \code 4605 /// true: false: 4606 /// template<typename T> vs. template<typename T> 4607 /// requires (A<T> && B<T>) requires(A<T> && B<T>) 4608 /// ... ... 4609 /// \endcode 4610 bool AfterRequiresInClause; 4611 /// If ``true``, put space between requires keyword in a requires expression 4612 /// and opening parentheses. 4613 /// \code 4614 /// true: false: 4615 /// template<typename T> vs. template<typename T> 4616 /// concept C = requires (T t) { concept C = requires(T t) { 4617 /// ... ... 4618 /// } } 4619 /// \endcode 4620 bool AfterRequiresInExpression; 4621 /// If ``true``, put a space before opening parentheses only if the 4622 /// parentheses are not empty. 4623 /// \code 4624 /// true: false: 4625 /// void f (int a); vs. void f(); 4626 /// f (a); f(); 4627 /// \endcode 4628 bool BeforeNonEmptyParentheses; 4629 4630 SpaceBeforeParensCustom() 4631 : AfterControlStatements(false), AfterForeachMacros(false), 4632 AfterFunctionDeclarationName(false), 4633 AfterFunctionDefinitionName(false), AfterIfMacros(false), 4634 AfterOverloadedOperator(false), AfterPlacementOperator(true), 4635 AfterRequiresInClause(false), AfterRequiresInExpression(false), 4636 BeforeNonEmptyParentheses(false) {} 4637 4638 bool operator==(const SpaceBeforeParensCustom &Other) const { 4639 return AfterControlStatements == Other.AfterControlStatements && 4640 AfterForeachMacros == Other.AfterForeachMacros && 4641 AfterFunctionDeclarationName == 4642 Other.AfterFunctionDeclarationName && 4643 AfterFunctionDefinitionName == Other.AfterFunctionDefinitionName && 4644 AfterIfMacros == Other.AfterIfMacros && 4645 AfterOverloadedOperator == Other.AfterOverloadedOperator && 4646 AfterPlacementOperator == Other.AfterPlacementOperator && 4647 AfterRequiresInClause == Other.AfterRequiresInClause && 4648 AfterRequiresInExpression == Other.AfterRequiresInExpression && 4649 BeforeNonEmptyParentheses == Other.BeforeNonEmptyParentheses; 4650 } 4651 }; 4652 4653 /// Control of individual space before parentheses. 4654 /// 4655 /// If ``SpaceBeforeParens`` is set to ``Custom``, use this to specify 4656 /// how each individual space before parentheses case should be handled. 4657 /// Otherwise, this is ignored. 4658 /// \code{.yaml} 4659 /// # Example of usage: 4660 /// SpaceBeforeParens: Custom 4661 /// SpaceBeforeParensOptions: 4662 /// AfterControlStatements: true 4663 /// AfterFunctionDefinitionName: true 4664 /// \endcode 4665 /// \version 14 4666 SpaceBeforeParensCustom SpaceBeforeParensOptions; 4667 4668 /// If ``true``, spaces will be before ``[``. 4669 /// Lambdas will not be affected. Only the first ``[`` will get a space added. 4670 /// \code 4671 /// true: false: 4672 /// int a [5]; vs. int a[5]; 4673 /// int a [5][5]; vs. int a[5][5]; 4674 /// \endcode 4675 /// \version 10 4676 bool SpaceBeforeSquareBrackets; 4677 4678 /// If ``false``, spaces will be removed before range-based for loop 4679 /// colon. 4680 /// \code 4681 /// true: false: 4682 /// for (auto v : values) {} vs. for(auto v: values) {} 4683 /// \endcode 4684 /// \version 7 4685 bool SpaceBeforeRangeBasedForLoopColon; 4686 4687 /// If ``true``, spaces will be inserted into ``{}``. 4688 /// \code 4689 /// true: false: 4690 /// void f() { } vs. void f() {} 4691 /// while (true) { } while (true) {} 4692 /// \endcode 4693 /// \version 10 4694 bool SpaceInEmptyBlock; 4695 4696 /// If ``true``, spaces may be inserted into ``()``. 4697 /// This option is **deprecated**. See ``InEmptyParentheses`` of 4698 /// ``SpacesInParensOptions``. 4699 /// \version 3.7 4700 // bool SpaceInEmptyParentheses; 4701 4702 /// The number of spaces before trailing line comments 4703 /// (``//`` - comments). 4704 /// 4705 /// This does not affect trailing block comments (``/*`` - comments) as those 4706 /// commonly have different usage patterns and a number of special cases. In 4707 /// the case of Verilog, it doesn't affect a comment right after the opening 4708 /// parenthesis in the port or parameter list in a module header, because it 4709 /// is probably for the port on the following line instead of the parenthesis 4710 /// it follows. 4711 /// \code 4712 /// SpacesBeforeTrailingComments: 3 4713 /// void f() { 4714 /// if (true) { // foo1 4715 /// f(); // bar 4716 /// } // foo 4717 /// } 4718 /// \endcode 4719 /// \version 3.7 4720 unsigned SpacesBeforeTrailingComments; 4721 4722 /// Styles for adding spacing after ``<`` and before ``>`` 4723 /// in template argument lists. 4724 enum SpacesInAnglesStyle : int8_t { 4725 /// Remove spaces after ``<`` and before ``>``. 4726 /// \code 4727 /// static_cast<int>(arg); 4728 /// std::function<void(int)> fct; 4729 /// \endcode 4730 SIAS_Never, 4731 /// Add spaces after ``<`` and before ``>``. 4732 /// \code 4733 /// static_cast< int >(arg); 4734 /// std::function< void(int) > fct; 4735 /// \endcode 4736 SIAS_Always, 4737 /// Keep a single space after ``<`` and before ``>`` if any spaces were 4738 /// present. Option ``Standard: Cpp03`` takes precedence. 4739 SIAS_Leave 4740 }; 4741 /// The SpacesInAnglesStyle to use for template argument lists. 4742 /// \version 3.4 4743 SpacesInAnglesStyle SpacesInAngles; 4744 4745 /// If ``true``, spaces will be inserted around if/for/switch/while 4746 /// conditions. 4747 /// This option is **deprecated**. See ``InConditionalStatements`` of 4748 /// ``SpacesInParensOptions``. 4749 /// \version 10 4750 // bool SpacesInConditionalStatement; 4751 4752 /// If ``true``, spaces are inserted inside container literals (e.g. ObjC and 4753 /// Javascript array and dict literals). For JSON, use 4754 /// ``SpaceBeforeJsonColon`` instead. 4755 /// \code{.js} 4756 /// true: false: 4757 /// var arr = [ 1, 2, 3 ]; vs. var arr = [1, 2, 3]; 4758 /// f({a : 1, b : 2, c : 3}); f({a: 1, b: 2, c: 3}); 4759 /// \endcode 4760 /// \version 3.7 4761 bool SpacesInContainerLiterals; 4762 4763 /// If ``true``, spaces may be inserted into C style casts. 4764 /// This option is **deprecated**. See ``InCStyleCasts`` of 4765 /// ``SpacesInParensOptions``. 4766 /// \version 3.7 4767 // bool SpacesInCStyleCastParentheses; 4768 4769 /// Control of spaces within a single line comment. 4770 struct SpacesInLineComment { 4771 /// The minimum number of spaces at the start of the comment. 4772 unsigned Minimum; 4773 /// The maximum number of spaces at the start of the comment. 4774 unsigned Maximum; 4775 }; 4776 4777 /// How many spaces are allowed at the start of a line comment. To disable the 4778 /// maximum set it to ``-1``, apart from that the maximum takes precedence 4779 /// over the minimum. 4780 /// \code 4781 /// Minimum = 1 4782 /// Maximum = -1 4783 /// // One space is forced 4784 /// 4785 /// // but more spaces are possible 4786 /// 4787 /// Minimum = 0 4788 /// Maximum = 0 4789 /// //Forces to start every comment directly after the slashes 4790 /// \endcode 4791 /// 4792 /// Note that in line comment sections the relative indent of the subsequent 4793 /// lines is kept, that means the following: 4794 /// \code 4795 /// before: after: 4796 /// Minimum: 1 4797 /// //if (b) { // if (b) { 4798 /// // return true; // return true; 4799 /// //} // } 4800 /// 4801 /// Maximum: 0 4802 /// /// List: ///List: 4803 /// /// - Foo /// - Foo 4804 /// /// - Bar /// - Bar 4805 /// \endcode 4806 /// 4807 /// This option has only effect if ``ReflowComments`` is set to ``true``. 4808 /// \version 13 4809 SpacesInLineComment SpacesInLineCommentPrefix; 4810 4811 /// Different ways to put a space before opening and closing parentheses. 4812 enum SpacesInParensStyle : int8_t { 4813 /// Never put a space in parentheses. 4814 /// \code 4815 /// void f() { 4816 /// if(true) { 4817 /// f(); 4818 /// } 4819 /// } 4820 /// \endcode 4821 SIPO_Never, 4822 /// Configure each individual space in parentheses in 4823 /// `SpacesInParensOptions`. 4824 SIPO_Custom, 4825 }; 4826 4827 /// If ``true``, spaces will be inserted after ``(`` and before ``)``. 4828 /// This option is **deprecated**. The previous behavior is preserved by using 4829 /// ``SpacesInParens`` with ``Custom`` and by setting all 4830 /// ``SpacesInParensOptions`` to ``true`` except for ``InCStyleCasts`` and 4831 /// ``InEmptyParentheses``. 4832 /// \version 3.7 4833 // bool SpacesInParentheses; 4834 4835 /// Defines in which cases spaces will be inserted after ``(`` and before 4836 /// ``)``. 4837 /// \version 17 4838 SpacesInParensStyle SpacesInParens; 4839 4840 /// Precise control over the spacing in parentheses. 4841 /// \code 4842 /// # Should be declared this way: 4843 /// SpacesInParens: Custom 4844 /// SpacesInParensOptions: 4845 /// ExceptDoubleParentheses: false 4846 /// InConditionalStatements: true 4847 /// Other: true 4848 /// \endcode 4849 struct SpacesInParensCustom { 4850 /// Override any of the following options to prevent addition of space 4851 /// when both opening and closing parentheses use multiple parentheses. 4852 /// \code 4853 /// true: 4854 /// __attribute__(( noreturn )) 4855 /// __decltype__(( x )) 4856 /// if (( a = b )) 4857 /// \endcode 4858 /// false: 4859 /// Uses the applicable option. 4860 bool ExceptDoubleParentheses; 4861 /// Put a space in parentheses only inside conditional statements 4862 /// (``for/if/while/switch...``). 4863 /// \code 4864 /// true: false: 4865 /// if ( a ) { ... } vs. if (a) { ... } 4866 /// while ( i < 5 ) { ... } while (i < 5) { ... } 4867 /// \endcode 4868 bool InConditionalStatements; 4869 /// Put a space in C style casts. 4870 /// \code 4871 /// true: false: 4872 /// x = ( int32 )y vs. x = (int32)y 4873 /// y = (( int (*)(int) )foo)(x); y = ((int (*)(int))foo)(x); 4874 /// \endcode 4875 bool InCStyleCasts; 4876 /// Insert a space in empty parentheses, i.e. ``()``. 4877 /// \code 4878 /// true: false: 4879 /// void f( ) { vs. void f() { 4880 /// int x[] = {foo( ), bar( )}; int x[] = {foo(), bar()}; 4881 /// if (true) { if (true) { 4882 /// f( ); f(); 4883 /// } } 4884 /// } } 4885 /// \endcode 4886 bool InEmptyParentheses; 4887 /// Put a space in parentheses not covered by preceding options. 4888 /// \code 4889 /// true: false: 4890 /// t f( Deleted & ) & = delete; vs. t f(Deleted &) & = delete; 4891 /// \endcode 4892 bool Other; 4893 4894 SpacesInParensCustom() 4895 : ExceptDoubleParentheses(false), InConditionalStatements(false), 4896 InCStyleCasts(false), InEmptyParentheses(false), Other(false) {} 4897 4898 SpacesInParensCustom(bool ExceptDoubleParentheses, 4899 bool InConditionalStatements, bool InCStyleCasts, 4900 bool InEmptyParentheses, bool Other) 4901 : ExceptDoubleParentheses(ExceptDoubleParentheses), 4902 InConditionalStatements(InConditionalStatements), 4903 InCStyleCasts(InCStyleCasts), InEmptyParentheses(InEmptyParentheses), 4904 Other(Other) {} 4905 4906 bool operator==(const SpacesInParensCustom &R) const { 4907 return ExceptDoubleParentheses == R.ExceptDoubleParentheses && 4908 InConditionalStatements == R.InConditionalStatements && 4909 InCStyleCasts == R.InCStyleCasts && 4910 InEmptyParentheses == R.InEmptyParentheses && Other == R.Other; 4911 } 4912 bool operator!=(const SpacesInParensCustom &R) const { 4913 return !(*this == R); 4914 } 4915 }; 4916 4917 /// Control of individual spaces in parentheses. 4918 /// 4919 /// If ``SpacesInParens`` is set to ``Custom``, use this to specify 4920 /// how each individual space in parentheses case should be handled. 4921 /// Otherwise, this is ignored. 4922 /// \code{.yaml} 4923 /// # Example of usage: 4924 /// SpacesInParens: Custom 4925 /// SpacesInParensOptions: 4926 /// ExceptDoubleParentheses: false 4927 /// InConditionalStatements: true 4928 /// InEmptyParentheses: true 4929 /// \endcode 4930 /// \version 17 4931 SpacesInParensCustom SpacesInParensOptions; 4932 4933 /// If ``true``, spaces will be inserted after ``[`` and before ``]``. 4934 /// Lambdas without arguments or unspecified size array declarations will not 4935 /// be affected. 4936 /// \code 4937 /// true: false: 4938 /// int a[ 5 ]; vs. int a[5]; 4939 /// std::unique_ptr<int[]> foo() {} // Won't be affected 4940 /// \endcode 4941 /// \version 3.7 4942 bool SpacesInSquareBrackets; 4943 4944 /// Supported language standards for parsing and formatting C++ constructs. 4945 /// \code 4946 /// Latest: vector<set<int>> 4947 /// c++03 vs. vector<set<int> > 4948 /// \endcode 4949 /// 4950 /// The correct way to spell a specific language version is e.g. ``c++11``. 4951 /// The historical aliases ``Cpp03`` and ``Cpp11`` are deprecated. 4952 enum LanguageStandard : int8_t { 4953 /// Parse and format as C++03. 4954 /// ``Cpp03`` is a deprecated alias for ``c++03`` 4955 LS_Cpp03, // c++03 4956 /// Parse and format as C++11. 4957 LS_Cpp11, // c++11 4958 /// Parse and format as C++14. 4959 LS_Cpp14, // c++14 4960 /// Parse and format as C++17. 4961 LS_Cpp17, // c++17 4962 /// Parse and format as C++20. 4963 LS_Cpp20, // c++20 4964 /// Parse and format using the latest supported language version. 4965 /// ``Cpp11`` is a deprecated alias for ``Latest`` 4966 LS_Latest, 4967 /// Automatic detection based on the input. 4968 LS_Auto, 4969 }; 4970 4971 /// Parse and format C++ constructs compatible with this standard. 4972 /// \code 4973 /// c++03: latest: 4974 /// vector<set<int> > x; vs. vector<set<int>> x; 4975 /// \endcode 4976 /// \version 3.7 4977 LanguageStandard Standard; 4978 4979 /// Macros which are ignored in front of a statement, as if they were an 4980 /// attribute. So that they are not parsed as identifier, for example for Qts 4981 /// emit. 4982 /// \code 4983 /// AlignConsecutiveDeclarations: true 4984 /// StatementAttributeLikeMacros: [] 4985 /// unsigned char data = 'x'; 4986 /// emit signal(data); // This is parsed as variable declaration. 4987 /// 4988 /// AlignConsecutiveDeclarations: true 4989 /// StatementAttributeLikeMacros: [emit] 4990 /// unsigned char data = 'x'; 4991 /// emit signal(data); // Now it's fine again. 4992 /// \endcode 4993 /// \version 12 4994 std::vector<std::string> StatementAttributeLikeMacros; 4995 4996 /// A vector of macros that should be interpreted as complete statements. 4997 /// 4998 /// Typical macros are expressions and require a semicolon to be added. 4999 /// Sometimes this is not the case, and this allows to make clang-format aware 5000 /// of such cases. 5001 /// 5002 /// For example: Q_UNUSED 5003 /// \version 8 5004 std::vector<std::string> StatementMacros; 5005 5006 /// Works only when TableGenBreakInsideDAGArg is not DontBreak. 5007 /// The string list needs to consist of identifiers in TableGen. 5008 /// If any identifier is specified, this limits the line breaks by 5009 /// TableGenBreakInsideDAGArg option only on DAGArg values beginning with 5010 /// the specified identifiers. 5011 /// 5012 /// For example the configuration, 5013 /// \code{.yaml} 5014 /// TableGenBreakInsideDAGArg: BreakAll 5015 /// TableGenBreakingDAGArgOperators: [ins, outs] 5016 /// \endcode 5017 /// 5018 /// makes the line break only occurs inside DAGArgs beginning with the 5019 /// specified identifiers ``ins`` and ``outs``. 5020 /// 5021 /// \code 5022 /// let DAGArgIns = (ins 5023 /// i32:$src1, 5024 /// i32:$src2 5025 /// ); 5026 /// let DAGArgOtherID = (other i32:$other1, i32:$other2); 5027 /// let DAGArgBang = (!cast<SomeType>("Some") i32:$src1, i32:$src2) 5028 /// \endcode 5029 /// \version 19 5030 std::vector<std::string> TableGenBreakingDAGArgOperators; 5031 5032 /// Different ways to control the format inside TableGen DAGArg. 5033 enum DAGArgStyle : int8_t { 5034 /// Never break inside DAGArg. 5035 /// \code 5036 /// let DAGArgIns = (ins i32:$src1, i32:$src2); 5037 /// \endcode 5038 DAS_DontBreak, 5039 /// Break inside DAGArg after each list element but for the last. 5040 /// This aligns to the first element. 5041 /// \code 5042 /// let DAGArgIns = (ins i32:$src1, 5043 /// i32:$src2); 5044 /// \endcode 5045 DAS_BreakElements, 5046 /// Break inside DAGArg after the operator and the all elements. 5047 /// \code 5048 /// let DAGArgIns = (ins 5049 /// i32:$src1, 5050 /// i32:$src2 5051 /// ); 5052 /// \endcode 5053 DAS_BreakAll, 5054 }; 5055 5056 /// The styles of the line break inside the DAGArg in TableGen. 5057 /// \version 19 5058 DAGArgStyle TableGenBreakInsideDAGArg; 5059 5060 /// The number of columns used for tab stops. 5061 /// \version 3.7 5062 unsigned TabWidth; 5063 5064 /// A vector of non-keyword identifiers that should be interpreted as template 5065 /// names. 5066 /// 5067 /// A ``<`` after a template name is annotated as a template opener instead of 5068 /// a binary operator. 5069 /// 5070 /// \version 20 5071 std::vector<std::string> TemplateNames; 5072 5073 /// A vector of non-keyword identifiers that should be interpreted as type 5074 /// names. 5075 /// 5076 /// A ``*``, ``&``, or ``&&`` between a type name and another non-keyword 5077 /// identifier is annotated as a pointer or reference token instead of a 5078 /// binary operator. 5079 /// 5080 /// \version 17 5081 std::vector<std::string> TypeNames; 5082 5083 /// \brief A vector of macros that should be interpreted as type declarations 5084 /// instead of as function calls. 5085 /// 5086 /// These are expected to be macros of the form: 5087 /// \code 5088 /// STACK_OF(...) 5089 /// \endcode 5090 /// 5091 /// In the .clang-format configuration file, this can be configured like: 5092 /// \code{.yaml} 5093 /// TypenameMacros: [STACK_OF, LIST] 5094 /// \endcode 5095 /// 5096 /// For example: OpenSSL STACK_OF, BSD LIST_ENTRY. 5097 /// \version 9 5098 std::vector<std::string> TypenameMacros; 5099 5100 /// This option is **deprecated**. See ``LF`` and ``CRLF`` of ``LineEnding``. 5101 /// \version 10 5102 // bool UseCRLF; 5103 5104 /// Different ways to use tab in formatting. 5105 enum UseTabStyle : int8_t { 5106 /// Never use tab. 5107 UT_Never, 5108 /// Use tabs only for indentation. 5109 UT_ForIndentation, 5110 /// Fill all leading whitespace with tabs, and use spaces for alignment that 5111 /// appears within a line (e.g. consecutive assignments and declarations). 5112 UT_ForContinuationAndIndentation, 5113 /// Use tabs for line continuation and indentation, and spaces for 5114 /// alignment. 5115 UT_AlignWithSpaces, 5116 /// Use tabs whenever we need to fill whitespace that spans at least from 5117 /// one tab stop to the next one. 5118 UT_Always 5119 }; 5120 5121 /// The way to use tab characters in the resulting file. 5122 /// \version 3.7 5123 UseTabStyle UseTab; 5124 5125 /// A vector of non-keyword identifiers that should be interpreted as variable 5126 /// template names. 5127 /// 5128 /// A ``)`` after a variable template instantiation is **not** annotated as 5129 /// the closing parenthesis of C-style cast operator. 5130 /// 5131 /// \version 20 5132 std::vector<std::string> VariableTemplates; 5133 5134 /// For Verilog, put each port on its own line in module instantiations. 5135 /// \code 5136 /// true: 5137 /// ffnand ff1(.q(), 5138 /// .qbar(out1), 5139 /// .clear(in1), 5140 /// .preset(in2)); 5141 /// 5142 /// false: 5143 /// ffnand ff1(.q(), .qbar(out1), .clear(in1), .preset(in2)); 5144 /// \endcode 5145 /// \version 17 5146 bool VerilogBreakBetweenInstancePorts; 5147 5148 /// A vector of macros which are whitespace-sensitive and should not 5149 /// be touched. 5150 /// 5151 /// These are expected to be macros of the form: 5152 /// \code 5153 /// STRINGIZE(...) 5154 /// \endcode 5155 /// 5156 /// In the .clang-format configuration file, this can be configured like: 5157 /// \code{.yaml} 5158 /// WhitespaceSensitiveMacros: [STRINGIZE, PP_STRINGIZE] 5159 /// \endcode 5160 /// 5161 /// For example: BOOST_PP_STRINGIZE 5162 /// \version 11 5163 std::vector<std::string> WhitespaceSensitiveMacros; 5164 5165 /// Different styles for wrapping namespace body with empty lines. 5166 enum WrapNamespaceBodyWithEmptyLinesStyle : int8_t { 5167 /// Remove all empty lines at the beginning and the end of namespace body. 5168 /// \code 5169 /// namespace N1 { 5170 /// namespace N2 5171 /// function(); 5172 /// } 5173 /// } 5174 /// \endcode 5175 WNBWELS_Never, 5176 /// Always have at least one empty line at the beginning and the end of 5177 /// namespace body except that the number of empty lines between consecutive 5178 /// nested namespace definitions is not increased. 5179 /// \code 5180 /// namespace N1 { 5181 /// namespace N2 { 5182 /// 5183 /// function(); 5184 /// 5185 /// } 5186 /// } 5187 /// \endcode 5188 WNBWELS_Always, 5189 /// Keep existing newlines at the beginning and the end of namespace body. 5190 /// ``MaxEmptyLinesToKeep`` still applies. 5191 WNBWELS_Leave 5192 }; 5193 5194 /// Wrap namespace body with empty lines. 5195 /// \version 20 5196 WrapNamespaceBodyWithEmptyLinesStyle WrapNamespaceBodyWithEmptyLines; 5197 5198 bool operator==(const FormatStyle &R) const { 5199 return AccessModifierOffset == R.AccessModifierOffset && 5200 AlignAfterOpenBracket == R.AlignAfterOpenBracket && 5201 AlignArrayOfStructures == R.AlignArrayOfStructures && 5202 AlignConsecutiveAssignments == R.AlignConsecutiveAssignments && 5203 AlignConsecutiveBitFields == R.AlignConsecutiveBitFields && 5204 AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations && 5205 AlignConsecutiveMacros == R.AlignConsecutiveMacros && 5206 AlignConsecutiveShortCaseStatements == 5207 R.AlignConsecutiveShortCaseStatements && 5208 AlignConsecutiveTableGenBreakingDAGArgColons == 5209 R.AlignConsecutiveTableGenBreakingDAGArgColons && 5210 AlignConsecutiveTableGenCondOperatorColons == 5211 R.AlignConsecutiveTableGenCondOperatorColons && 5212 AlignConsecutiveTableGenDefinitionColons == 5213 R.AlignConsecutiveTableGenDefinitionColons && 5214 AlignEscapedNewlines == R.AlignEscapedNewlines && 5215 AlignOperands == R.AlignOperands && 5216 AlignTrailingComments == R.AlignTrailingComments && 5217 AllowAllArgumentsOnNextLine == R.AllowAllArgumentsOnNextLine && 5218 AllowAllParametersOfDeclarationOnNextLine == 5219 R.AllowAllParametersOfDeclarationOnNextLine && 5220 AllowBreakBeforeNoexceptSpecifier == 5221 R.AllowBreakBeforeNoexceptSpecifier && 5222 AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine && 5223 AllowShortCaseExpressionOnASingleLine == 5224 R.AllowShortCaseExpressionOnASingleLine && 5225 AllowShortCaseLabelsOnASingleLine == 5226 R.AllowShortCaseLabelsOnASingleLine && 5227 AllowShortCompoundRequirementOnASingleLine == 5228 R.AllowShortCompoundRequirementOnASingleLine && 5229 AllowShortEnumsOnASingleLine == R.AllowShortEnumsOnASingleLine && 5230 AllowShortFunctionsOnASingleLine == 5231 R.AllowShortFunctionsOnASingleLine && 5232 AllowShortIfStatementsOnASingleLine == 5233 R.AllowShortIfStatementsOnASingleLine && 5234 AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine && 5235 AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine && 5236 AllowShortNamespacesOnASingleLine == 5237 R.AllowShortNamespacesOnASingleLine && 5238 AlwaysBreakBeforeMultilineStrings == 5239 R.AlwaysBreakBeforeMultilineStrings && 5240 AttributeMacros == R.AttributeMacros && 5241 BinPackArguments == R.BinPackArguments && 5242 BinPackParameters == R.BinPackParameters && 5243 BitFieldColonSpacing == R.BitFieldColonSpacing && 5244 BracedInitializerIndentWidth == R.BracedInitializerIndentWidth && 5245 BreakAdjacentStringLiterals == R.BreakAdjacentStringLiterals && 5246 BreakAfterAttributes == R.BreakAfterAttributes && 5247 BreakAfterJavaFieldAnnotations == R.BreakAfterJavaFieldAnnotations && 5248 BreakAfterReturnType == R.BreakAfterReturnType && 5249 BreakArrays == R.BreakArrays && 5250 BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators && 5251 BreakBeforeBraces == R.BreakBeforeBraces && 5252 BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations && 5253 BreakBeforeInlineASMColon == R.BreakBeforeInlineASMColon && 5254 BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators && 5255 BreakBinaryOperations == R.BreakBinaryOperations && 5256 BreakConstructorInitializers == R.BreakConstructorInitializers && 5257 BreakFunctionDefinitionParameters == 5258 R.BreakFunctionDefinitionParameters && 5259 BreakInheritanceList == R.BreakInheritanceList && 5260 BreakStringLiterals == R.BreakStringLiterals && 5261 BreakTemplateDeclarations == R.BreakTemplateDeclarations && 5262 ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas && 5263 CompactNamespaces == R.CompactNamespaces && 5264 ConstructorInitializerIndentWidth == 5265 R.ConstructorInitializerIndentWidth && 5266 ContinuationIndentWidth == R.ContinuationIndentWidth && 5267 Cpp11BracedListStyle == R.Cpp11BracedListStyle && 5268 DerivePointerAlignment == R.DerivePointerAlignment && 5269 DisableFormat == R.DisableFormat && 5270 EmptyLineAfterAccessModifier == R.EmptyLineAfterAccessModifier && 5271 EmptyLineBeforeAccessModifier == R.EmptyLineBeforeAccessModifier && 5272 ExperimentalAutoDetectBinPacking == 5273 R.ExperimentalAutoDetectBinPacking && 5274 FixNamespaceComments == R.FixNamespaceComments && 5275 ForEachMacros == R.ForEachMacros && 5276 IncludeStyle.IncludeBlocks == R.IncludeStyle.IncludeBlocks && 5277 IncludeStyle.IncludeCategories == R.IncludeStyle.IncludeCategories && 5278 IncludeStyle.IncludeIsMainRegex == 5279 R.IncludeStyle.IncludeIsMainRegex && 5280 IncludeStyle.IncludeIsMainSourceRegex == 5281 R.IncludeStyle.IncludeIsMainSourceRegex && 5282 IncludeStyle.MainIncludeChar == R.IncludeStyle.MainIncludeChar && 5283 IndentAccessModifiers == R.IndentAccessModifiers && 5284 IndentCaseBlocks == R.IndentCaseBlocks && 5285 IndentCaseLabels == R.IndentCaseLabels && 5286 IndentExportBlock == R.IndentExportBlock && 5287 IndentExternBlock == R.IndentExternBlock && 5288 IndentGotoLabels == R.IndentGotoLabels && 5289 IndentPPDirectives == R.IndentPPDirectives && 5290 IndentRequiresClause == R.IndentRequiresClause && 5291 IndentWidth == R.IndentWidth && 5292 IndentWrappedFunctionNames == R.IndentWrappedFunctionNames && 5293 InsertBraces == R.InsertBraces && 5294 InsertNewlineAtEOF == R.InsertNewlineAtEOF && 5295 IntegerLiteralSeparator == R.IntegerLiteralSeparator && 5296 JavaImportGroups == R.JavaImportGroups && 5297 JavaScriptQuotes == R.JavaScriptQuotes && 5298 JavaScriptWrapImports == R.JavaScriptWrapImports && 5299 KeepEmptyLines == R.KeepEmptyLines && 5300 KeepFormFeed == R.KeepFormFeed && Language == R.Language && 5301 LambdaBodyIndentation == R.LambdaBodyIndentation && 5302 LineEnding == R.LineEnding && MacroBlockBegin == R.MacroBlockBegin && 5303 MacroBlockEnd == R.MacroBlockEnd && Macros == R.Macros && 5304 MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep && 5305 NamespaceIndentation == R.NamespaceIndentation && 5306 NamespaceMacros == R.NamespaceMacros && 5307 ObjCBinPackProtocolList == R.ObjCBinPackProtocolList && 5308 ObjCBlockIndentWidth == R.ObjCBlockIndentWidth && 5309 ObjCBreakBeforeNestedBlockParam == 5310 R.ObjCBreakBeforeNestedBlockParam && 5311 ObjCPropertyAttributeOrder == R.ObjCPropertyAttributeOrder && 5312 ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty && 5313 ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList && 5314 PackConstructorInitializers == R.PackConstructorInitializers && 5315 PenaltyBreakAssignment == R.PenaltyBreakAssignment && 5316 PenaltyBreakBeforeFirstCallParameter == 5317 R.PenaltyBreakBeforeFirstCallParameter && 5318 PenaltyBreakBeforeMemberAccess == R.PenaltyBreakBeforeMemberAccess && 5319 PenaltyBreakComment == R.PenaltyBreakComment && 5320 PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess && 5321 PenaltyBreakOpenParenthesis == R.PenaltyBreakOpenParenthesis && 5322 PenaltyBreakScopeResolution == R.PenaltyBreakScopeResolution && 5323 PenaltyBreakString == R.PenaltyBreakString && 5324 PenaltyBreakTemplateDeclaration == 5325 R.PenaltyBreakTemplateDeclaration && 5326 PenaltyExcessCharacter == R.PenaltyExcessCharacter && 5327 PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine && 5328 PointerAlignment == R.PointerAlignment && 5329 QualifierAlignment == R.QualifierAlignment && 5330 QualifierOrder == R.QualifierOrder && 5331 RawStringFormats == R.RawStringFormats && 5332 ReferenceAlignment == R.ReferenceAlignment && 5333 RemoveBracesLLVM == R.RemoveBracesLLVM && 5334 RemoveEmptyLinesInUnwrappedLines == 5335 R.RemoveEmptyLinesInUnwrappedLines && 5336 RemoveParentheses == R.RemoveParentheses && 5337 RemoveSemicolon == R.RemoveSemicolon && 5338 RequiresClausePosition == R.RequiresClausePosition && 5339 RequiresExpressionIndentation == R.RequiresExpressionIndentation && 5340 SeparateDefinitionBlocks == R.SeparateDefinitionBlocks && 5341 ShortNamespaceLines == R.ShortNamespaceLines && 5342 SkipMacroDefinitionBody == R.SkipMacroDefinitionBody && 5343 SortIncludes == R.SortIncludes && 5344 SortJavaStaticImport == R.SortJavaStaticImport && 5345 SpaceAfterCStyleCast == R.SpaceAfterCStyleCast && 5346 SpaceAfterLogicalNot == R.SpaceAfterLogicalNot && 5347 SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword && 5348 SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators && 5349 SpaceBeforeCaseColon == R.SpaceBeforeCaseColon && 5350 SpaceBeforeCpp11BracedList == R.SpaceBeforeCpp11BracedList && 5351 SpaceBeforeCtorInitializerColon == 5352 R.SpaceBeforeCtorInitializerColon && 5353 SpaceBeforeInheritanceColon == R.SpaceBeforeInheritanceColon && 5354 SpaceBeforeJsonColon == R.SpaceBeforeJsonColon && 5355 SpaceBeforeParens == R.SpaceBeforeParens && 5356 SpaceBeforeParensOptions == R.SpaceBeforeParensOptions && 5357 SpaceAroundPointerQualifiers == R.SpaceAroundPointerQualifiers && 5358 SpaceBeforeRangeBasedForLoopColon == 5359 R.SpaceBeforeRangeBasedForLoopColon && 5360 SpaceBeforeSquareBrackets == R.SpaceBeforeSquareBrackets && 5361 SpaceInEmptyBlock == R.SpaceInEmptyBlock && 5362 SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments && 5363 SpacesInAngles == R.SpacesInAngles && 5364 SpacesInContainerLiterals == R.SpacesInContainerLiterals && 5365 SpacesInLineCommentPrefix.Minimum == 5366 R.SpacesInLineCommentPrefix.Minimum && 5367 SpacesInLineCommentPrefix.Maximum == 5368 R.SpacesInLineCommentPrefix.Maximum && 5369 SpacesInParens == R.SpacesInParens && 5370 SpacesInParensOptions == R.SpacesInParensOptions && 5371 SpacesInSquareBrackets == R.SpacesInSquareBrackets && 5372 Standard == R.Standard && 5373 StatementAttributeLikeMacros == R.StatementAttributeLikeMacros && 5374 StatementMacros == R.StatementMacros && 5375 TableGenBreakingDAGArgOperators == 5376 R.TableGenBreakingDAGArgOperators && 5377 TableGenBreakInsideDAGArg == R.TableGenBreakInsideDAGArg && 5378 TabWidth == R.TabWidth && TemplateNames == R.TemplateNames && 5379 TypeNames == R.TypeNames && TypenameMacros == R.TypenameMacros && 5380 UseTab == R.UseTab && VariableTemplates == R.VariableTemplates && 5381 VerilogBreakBetweenInstancePorts == 5382 R.VerilogBreakBetweenInstancePorts && 5383 WhitespaceSensitiveMacros == R.WhitespaceSensitiveMacros && 5384 WrapNamespaceBodyWithEmptyLines == R.WrapNamespaceBodyWithEmptyLines; 5385 } 5386 5387 std::optional<FormatStyle> GetLanguageStyle(LanguageKind Language) const; 5388 5389 // Stores per-language styles. A FormatStyle instance inside has an empty 5390 // StyleSet. A FormatStyle instance returned by the Get method has its 5391 // StyleSet set to a copy of the originating StyleSet, effectively keeping the 5392 // internal representation of that StyleSet alive. 5393 // 5394 // The memory management and ownership reminds of a birds nest: chicks 5395 // leaving the nest take photos of the nest with them. 5396 struct FormatStyleSet { 5397 typedef std::map<FormatStyle::LanguageKind, FormatStyle> MapType; 5398 5399 std::optional<FormatStyle> Get(FormatStyle::LanguageKind Language) const; 5400 5401 // Adds \p Style to this FormatStyleSet. Style must not have an associated 5402 // FormatStyleSet. 5403 // Style.Language should be different than LK_None. If this FormatStyleSet 5404 // already contains an entry for Style.Language, that gets replaced with the 5405 // passed Style. 5406 void Add(FormatStyle Style); 5407 5408 // Clears this FormatStyleSet. 5409 void Clear(); 5410 5411 private: 5412 std::shared_ptr<MapType> Styles; 5413 }; 5414 5415 static FormatStyleSet BuildStyleSetFromConfiguration( 5416 const FormatStyle &MainStyle, 5417 const std::vector<FormatStyle> &ConfigurationStyles); 5418 5419 private: 5420 FormatStyleSet StyleSet; 5421 5422 friend std::error_code 5423 parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style, 5424 bool AllowUnknownOptions, 5425 llvm::SourceMgr::DiagHandlerTy DiagHandler, 5426 void *DiagHandlerCtxt); 5427 }; 5428 5429 /// Returns a format style complying with the LLVM coding standards: 5430 /// http://llvm.org/docs/CodingStandards.html. 5431 FormatStyle getLLVMStyle( 5432 FormatStyle::LanguageKind Language = FormatStyle::LanguageKind::LK_Cpp); 5433 5434 /// Returns a format style complying with one of Google's style guides: 5435 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml. 5436 /// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml. 5437 /// https://developers.google.com/protocol-buffers/docs/style. 5438 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language); 5439 5440 /// Returns a format style complying with Chromium's style guide: 5441 /// http://www.chromium.org/developers/coding-style. 5442 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language); 5443 5444 /// Returns a format style complying with Mozilla's style guide: 5445 /// https://firefox-source-docs.mozilla.org/code-quality/coding-style/index.html. 5446 FormatStyle getMozillaStyle(); 5447 5448 /// Returns a format style complying with Webkit's style guide: 5449 /// http://www.webkit.org/coding/coding-style.html 5450 FormatStyle getWebKitStyle(); 5451 5452 /// Returns a format style complying with GNU Coding Standards: 5453 /// http://www.gnu.org/prep/standards/standards.html 5454 FormatStyle getGNUStyle(); 5455 5456 /// Returns a format style complying with Microsoft style guide: 5457 /// https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017 5458 FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language); 5459 5460 FormatStyle getClangFormatStyle(); 5461 5462 /// Returns style indicating formatting should be not applied at all. 5463 FormatStyle getNoStyle(); 5464 5465 /// Gets a predefined style for the specified language by name. 5466 /// 5467 /// Currently supported names: LLVM, Google, Chromium, Mozilla. Names are 5468 /// compared case-insensitively. 5469 /// 5470 /// Returns ``true`` if the Style has been set. 5471 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language, 5472 FormatStyle *Style); 5473 5474 /// Parse configuration from YAML-formatted text. 5475 /// 5476 /// Style->Language is used to get the base style, if the ``BasedOnStyle`` 5477 /// option is present. 5478 /// 5479 /// The FormatStyleSet of Style is reset. 5480 /// 5481 /// When ``BasedOnStyle`` is not present, options not present in the YAML 5482 /// document, are retained in \p Style. 5483 /// 5484 /// If AllowUnknownOptions is true, no errors are emitted if unknown 5485 /// format options are occurred. 5486 /// 5487 /// If set all diagnostics are emitted through the DiagHandler. 5488 std::error_code 5489 parseConfiguration(llvm::MemoryBufferRef Config, FormatStyle *Style, 5490 bool AllowUnknownOptions = false, 5491 llvm::SourceMgr::DiagHandlerTy DiagHandler = nullptr, 5492 void *DiagHandlerCtx = nullptr); 5493 5494 /// Like above but accepts an unnamed buffer. 5495 inline std::error_code parseConfiguration(StringRef Config, FormatStyle *Style, 5496 bool AllowUnknownOptions = false) { 5497 return parseConfiguration(llvm::MemoryBufferRef(Config, "YAML"), Style, 5498 AllowUnknownOptions); 5499 } 5500 5501 /// Gets configuration in a YAML string. 5502 std::string configurationAsText(const FormatStyle &Style); 5503 5504 /// Returns the replacements necessary to sort all ``#include`` blocks 5505 /// that are affected by ``Ranges``. 5506 tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code, 5507 ArrayRef<tooling::Range> Ranges, 5508 StringRef FileName, 5509 unsigned *Cursor = nullptr); 5510 5511 /// Returns the replacements corresponding to applying and formatting 5512 /// \p Replaces on success; otheriwse, return an llvm::Error carrying 5513 /// llvm::StringError. 5514 Expected<tooling::Replacements> 5515 formatReplacements(StringRef Code, const tooling::Replacements &Replaces, 5516 const FormatStyle &Style); 5517 5518 /// Returns the replacements corresponding to applying \p Replaces and 5519 /// cleaning up the code after that on success; otherwise, return an llvm::Error 5520 /// carrying llvm::StringError. 5521 /// This also supports inserting/deleting C++ #include directives: 5522 /// * If a replacement has offset UINT_MAX, length 0, and a replacement text 5523 /// that is an #include directive, this will insert the #include into the 5524 /// correct block in the \p Code. 5525 /// * If a replacement has offset UINT_MAX, length 1, and a replacement text 5526 /// that is the name of the header to be removed, the header will be removed 5527 /// from \p Code if it exists. 5528 /// The include manipulation is done via ``tooling::HeaderInclude``, see its 5529 /// documentation for more details on how include insertion points are found and 5530 /// what edits are produced. 5531 Expected<tooling::Replacements> 5532 cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces, 5533 const FormatStyle &Style); 5534 5535 /// Represents the status of a formatting attempt. 5536 struct FormattingAttemptStatus { 5537 /// A value of ``false`` means that any of the affected ranges were not 5538 /// formatted due to a non-recoverable syntax error. 5539 bool FormatComplete = true; 5540 5541 /// If ``FormatComplete`` is false, ``Line`` records a one-based 5542 /// original line number at which a syntax error might have occurred. This is 5543 /// based on a best-effort analysis and could be imprecise. 5544 unsigned Line = 0; 5545 }; 5546 5547 /// Reformats the given \p Ranges in \p Code. 5548 /// 5549 /// Each range is extended on either end to its next bigger logic unit, i.e. 5550 /// everything that might influence its formatting or might be influenced by its 5551 /// formatting. 5552 /// 5553 /// Returns the ``Replacements`` necessary to make all \p Ranges comply with 5554 /// \p Style. 5555 /// 5556 /// If ``Status`` is non-null, its value will be populated with the status of 5557 /// this formatting attempt. See \c FormattingAttemptStatus. 5558 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, 5559 ArrayRef<tooling::Range> Ranges, 5560 StringRef FileName = "<stdin>", 5561 FormattingAttemptStatus *Status = nullptr); 5562 5563 /// Same as above, except if ``IncompleteFormat`` is non-null, its value 5564 /// will be set to true if any of the affected ranges were not formatted due to 5565 /// a non-recoverable syntax error. 5566 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code, 5567 ArrayRef<tooling::Range> Ranges, 5568 StringRef FileName, bool *IncompleteFormat); 5569 5570 /// Clean up any erroneous/redundant code in the given \p Ranges in \p 5571 /// Code. 5572 /// 5573 /// Returns the ``Replacements`` that clean up all \p Ranges in \p Code. 5574 tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, 5575 ArrayRef<tooling::Range> Ranges, 5576 StringRef FileName = "<stdin>"); 5577 5578 /// Fix namespace end comments in the given \p Ranges in \p Code. 5579 /// 5580 /// Returns the ``Replacements`` that fix the namespace comments in all 5581 /// \p Ranges in \p Code. 5582 tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style, 5583 StringRef Code, 5584 ArrayRef<tooling::Range> Ranges, 5585 StringRef FileName = "<stdin>"); 5586 5587 /// Inserts or removes empty lines separating definition blocks including 5588 /// classes, structs, functions, namespaces, and enums in the given \p Ranges in 5589 /// \p Code. 5590 /// 5591 /// Returns the ``Replacements`` that inserts or removes empty lines separating 5592 /// definition blocks in all \p Ranges in \p Code. 5593 tooling::Replacements separateDefinitionBlocks(const FormatStyle &Style, 5594 StringRef Code, 5595 ArrayRef<tooling::Range> Ranges, 5596 StringRef FileName = "<stdin>"); 5597 5598 /// Sort consecutive using declarations in the given \p Ranges in 5599 /// \p Code. 5600 /// 5601 /// Returns the ``Replacements`` that sort the using declarations in all 5602 /// \p Ranges in \p Code. 5603 tooling::Replacements sortUsingDeclarations(const FormatStyle &Style, 5604 StringRef Code, 5605 ArrayRef<tooling::Range> Ranges, 5606 StringRef FileName = "<stdin>"); 5607 5608 /// Returns the ``LangOpts`` that the formatter expects you to set. 5609 /// 5610 /// \param Style determines specific settings for lexing mode. 5611 LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle()); 5612 5613 /// Description to be used for help text for a ``llvm::cl`` option for 5614 /// specifying format style. The description is closely related to the operation 5615 /// of ``getStyle()``. 5616 extern const char *StyleOptionHelpDescription; 5617 5618 /// The suggested format style to use by default. This allows tools using 5619 /// ``getStyle`` to have a consistent default style. 5620 /// Different builds can modify the value to the preferred styles. 5621 extern const char *DefaultFormatStyle; 5622 5623 /// The suggested predefined style to use as the fallback style in ``getStyle``. 5624 /// Different builds can modify the value to the preferred styles. 5625 extern const char *DefaultFallbackStyle; 5626 5627 /// Construct a FormatStyle based on ``StyleName``. 5628 /// 5629 /// ``StyleName`` can take several forms: 5630 /// * "{<key>: <value>, ...}" - Set specic style parameters. 5631 /// * "<style name>" - One of the style names supported by getPredefinedStyle(). 5632 /// * "file" - Load style configuration from a file called ``.clang-format`` 5633 /// located in one of the parent directories of ``FileName`` or the current 5634 /// directory if ``FileName`` is empty. 5635 /// * "file:<format_file_path>" to explicitly specify the configuration file to 5636 /// use. 5637 /// 5638 /// \param[in] StyleName Style name to interpret according to the description 5639 /// above. 5640 /// \param[in] FileName Path to start search for .clang-format if ``StyleName`` 5641 /// == "file". 5642 /// \param[in] FallbackStyle The name of a predefined style used to fallback to 5643 /// in case \p StyleName is "file" and no file can be found. 5644 /// \param[in] Code The actual code to be formatted. Used to determine the 5645 /// language if the filename isn't sufficient. 5646 /// \param[in] FS The underlying file system, in which the file resides. By 5647 /// default, the file system is the real file system. 5648 /// \param[in] AllowUnknownOptions If true, unknown format options only 5649 /// emit a warning. If false, errors are emitted on unknown format 5650 /// options. 5651 /// 5652 /// \returns FormatStyle as specified by ``StyleName``. If ``StyleName`` is 5653 /// "file" and no file is found, returns ``FallbackStyle``. If no style could be 5654 /// determined, returns an Error. 5655 Expected<FormatStyle> 5656 getStyle(StringRef StyleName, StringRef FileName, StringRef FallbackStyle, 5657 StringRef Code = "", llvm::vfs::FileSystem *FS = nullptr, 5658 bool AllowUnknownOptions = false, 5659 llvm::SourceMgr::DiagHandlerTy DiagHandler = nullptr); 5660 5661 // Guesses the language from the ``FileName`` and ``Code`` to be formatted. 5662 // Defaults to FormatStyle::LK_Cpp. 5663 FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code); 5664 5665 // Returns a string representation of ``Language``. 5666 inline StringRef getLanguageName(FormatStyle::LanguageKind Language) { 5667 switch (Language) { 5668 case FormatStyle::LK_Cpp: 5669 return "C++"; 5670 case FormatStyle::LK_CSharp: 5671 return "CSharp"; 5672 case FormatStyle::LK_ObjC: 5673 return "Objective-C"; 5674 case FormatStyle::LK_Java: 5675 return "Java"; 5676 case FormatStyle::LK_JavaScript: 5677 return "JavaScript"; 5678 case FormatStyle::LK_Json: 5679 return "Json"; 5680 case FormatStyle::LK_Proto: 5681 return "Proto"; 5682 case FormatStyle::LK_TableGen: 5683 return "TableGen"; 5684 case FormatStyle::LK_TextProto: 5685 return "TextProto"; 5686 case FormatStyle::LK_Verilog: 5687 return "Verilog"; 5688 default: 5689 return "Unknown"; 5690 } 5691 } 5692 5693 bool isClangFormatOn(StringRef Comment); 5694 bool isClangFormatOff(StringRef Comment); 5695 5696 } // end namespace format 5697 } // end namespace clang 5698 5699 template <> 5700 struct std::is_error_code_enum<clang::format::ParseError> : std::true_type {}; 5701 5702 #endif // LLVM_CLANG_FORMAT_FORMAT_H 5703