contrib/llvm/tools/clang/include/clang/Format/Format.h

   1 //===--- Format.h - Format C++ code -----------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// Various functions to configurably format source code.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_FORMAT_FORMAT_H
  16 #define LLVM_CLANG_FORMAT_FORMAT_H
  17
  18 #include "clang/Basic/LangOptions.h"
  19 #include "clang/Tooling/Core/Replacement.h"
  20 #include "llvm/ADT/ArrayRef.h"
  21 #include <system_error>
  22
  23 namespace clang {
  24
  25 class Lexer;
  26 class SourceManager;
  27 class DiagnosticConsumer;
  28
  29 namespace format {
  30
  31 enum class ParseError { Success = 0, Error, Unsuitable };
  32 class ParseErrorCategory final : public std::error_category {
  33 public:
  34   const char *name() const LLVM_NOEXCEPT override;
  35   std::string message(int EV) const override;
  36 };
  37 const std::error_category &getParseCategory();
  38 std::error_code make_error_code(ParseError e);
  39
  40 /// \brief The \c FormatStyle is used to configure the formatting to follow
  41 /// specific guidelines.
  42 struct FormatStyle {
  43   /// \brief Supported languages. When stored in a configuration file, specifies
  44   /// the language, that the configuration targets. When passed to the
  45   /// reformat() function, enables syntax features specific to the language.
  46   enum LanguageKind {
  47     /// Do not use.
  48     LK_None,
  49     /// Should be used for C, C++, ObjectiveC, ObjectiveC++.
  50     LK_Cpp,
  51     /// Should be used for Java.
  52     LK_Java,
  53     /// Should be used for JavaScript.
  54     LK_JavaScript,
  55     /// Should be used for Protocol Buffers
  56     /// (https://developers.google.com/protocol-buffers/).
  57     LK_Proto
  58   };
  59
  60   /// \brief Language, this format style is targeted at.
  61   LanguageKind Language;
  62
  63   /// \brief The column limit.
  64   ///
  65   /// A column limit of \c 0 means that there is no column limit. In this case,
  66   /// clang-format will respect the input's line breaking decisions within
  67   /// statements unless they contradict other rules.
  68   unsigned ColumnLimit;
  69
  70   /// \brief The maximum number of consecutive empty lines to keep.
  71   unsigned MaxEmptyLinesToKeep;
  72
  73   /// \brief If true, empty lines at the start of blocks are kept.
  74   bool KeepEmptyLinesAtTheStartOfBlocks;
  75
  76   /// \brief The penalty for each line break introduced inside a comment.
  77   unsigned PenaltyBreakComment;
  78
  79   /// \brief The penalty for each line break introduced inside a string literal.
  80   unsigned PenaltyBreakString;
  81
  82   /// \brief The penalty for each character outside of the column limit.
  83   unsigned PenaltyExcessCharacter;
  84
  85   /// \brief The penalty for breaking before the first \c <<.
  86   unsigned PenaltyBreakFirstLessLess;
  87
  88   /// \brief The penalty for breaking a function call after "call(".
  89   unsigned PenaltyBreakBeforeFirstCallParameter;
  90
  91   /// \brief The & and * alignment style.
  92   enum PointerAlignmentStyle {
  93     /// Align pointer to the left.
  94     PAS_Left,
  95     /// Align pointer to the right.
  96     PAS_Right,
  97     /// Align pointer in the middle.
  98     PAS_Middle
  99   };
 100
 101   /// Pointer and reference alignment style.
 102   PointerAlignmentStyle PointerAlignment;
 103
 104   /// \brief If \c true, analyze the formatted file for the most common
 105   /// alignment of & and *. \c PointerAlignment is then used only as fallback.
 106   bool DerivePointerAlignment;
 107
 108   /// \brief The extra indent or outdent of access modifiers, e.g. \c public:.
 109   int AccessModifierOffset;
 110
 111   /// \brief Supported language standards.
 112   enum LanguageStandard {
 113     /// Use C++03-compatible syntax.
 114     LS_Cpp03,
 115     /// Use features of C++11 (e.g. \c A<A<int>> instead of
 116     /// <tt>A<A<int> ></tt>).
 117     LS_Cpp11,
 118     /// Automatic detection based on the input.
 119     LS_Auto
 120   };
 121
 122   /// \brief Format compatible with this standard, e.g. use
 123   /// <tt>A<A<int> ></tt> instead of \c A<A<int>> for LS_Cpp03.
 124   LanguageStandard Standard;
 125
 126   /// \brief Indent case labels one level from the switch statement.
 127   ///
 128   /// When \c false, use the same indentation level as for the switch statement.
 129   /// Switch statement body is always indented one level more than case labels.
 130   bool IndentCaseLabels;
 131
 132   /// \brief Indent if a function definition or declaration is wrapped after the
 133   /// type.
 134   bool IndentWrappedFunctionNames;
 135
 136   /// \brief Different ways to indent namespace contents.
 137   enum NamespaceIndentationKind {
 138     /// Don't indent in namespaces.
 139     NI_None,
 140     /// Indent only in inner namespaces (nested in other namespaces).
 141     NI_Inner,
 142     /// Indent in all namespaces.
 143     NI_All
 144   };
 145
 146   /// \brief The indentation used for namespaces.
 147   NamespaceIndentationKind NamespaceIndentation;
 148
 149   /// \brief The number of spaces before trailing line comments
 150   /// (\c // - comments).
 151   ///
 152   /// This does not affect trailing block comments (\c /**/ - comments) as those
 153   /// commonly have different usage patterns and a number of special cases.
 154   unsigned SpacesBeforeTrailingComments;
 155
 156   /// \brief If \c false, a function declaration's or function definition's
 157   /// parameters will either all be on the same line or will have one line each.
 158   bool BinPackParameters;
 159
 160   /// \brief If \c false, a function call's arguments will either be all on the
 161   /// same line or will have one line each.
 162   bool BinPackArguments;
 163
 164   /// \brief If \c true, clang-format detects whether function calls and
 165   /// definitions are formatted with one parameter per line.
 166   ///
 167   /// Each call can be bin-packed, one-per-line or inconclusive. If it is
 168   /// inconclusive, e.g. completely on one line, but a decision needs to be
 169   /// made, clang-format analyzes whether there are other bin-packed cases in
 170   /// the input file and act accordingly.
 171   ///
 172   /// NOTE: This is an experimental flag, that might go away or be renamed. Do
 173   /// not use this in config files, etc. Use at your own risk.
 174   bool ExperimentalAutoDetectBinPacking;
 175
 176   /// \brief Allow putting all parameters of a function declaration onto
 177   /// the next line even if \c BinPackParameters is \c false.
 178   bool AllowAllParametersOfDeclarationOnNextLine;
 179
 180   /// \brief Penalty for putting the return type of a function onto its own
 181   /// line.
 182   unsigned PenaltyReturnTypeOnItsOwnLine;
 183
 184   /// \brief If the constructor initializers don't fit on a line, put each
 185   /// initializer on its own line.
 186   bool ConstructorInitializerAllOnOneLineOrOnePerLine;
 187
 188   /// \brief Always break constructor initializers before commas and align
 189   /// the commas with the colon.
 190   bool BreakConstructorInitializersBeforeComma;
 191
 192   /// \brief Allows contracting simple braced statements to a single line.
 193   ///
 194   /// E.g., this allows <tt>if (a) { return; }</tt> to be put on a single line.
 195   bool AllowShortBlocksOnASingleLine;
 196
 197   /// \brief If \c true, <tt>if (a) return;</tt> can be put on a single
 198   /// line.
 199   bool AllowShortIfStatementsOnASingleLine;
 200
 201   /// \brief If \c true, <tt>while (true) continue;</tt> can be put on a
 202   /// single line.
 203   bool AllowShortLoopsOnASingleLine;
 204
 205   /// \brief If \c true, short case labels will be contracted to a single line.
 206   bool AllowShortCaseLabelsOnASingleLine;
 207
 208   /// \brief Different styles for merging short functions containing at most one
 209   /// statement.
 210   enum ShortFunctionStyle {
 211     /// \brief Never merge functions into a single line.
 212     SFS_None,
 213     /// \brief Only merge functions defined inside a class.
 214     SFS_Inline,
 215     /// \brief Only merge empty functions.
 216     SFS_Empty,
 217     /// \brief Merge all functions fitting on a single line.
 218     SFS_All,
 219   };
 220
 221   /// \brief Dependent on the value, <tt>int f() { return 0; }</tt> can be put
 222   /// on a single line.
 223   ShortFunctionStyle AllowShortFunctionsOnASingleLine;
 224
 225   /// \brief Add a space after \c @property in Objective-C, i.e. use
 226   /// <tt>\@property (readonly)</tt> instead of <tt>\@property(readonly)</tt>.
 227   bool ObjCSpaceAfterProperty;
 228
 229   /// \brief Add a space in front of an Objective-C protocol list, i.e. use
 230   /// <tt>Foo <Protocol></tt> instead of \c Foo<Protocol>.
 231   bool ObjCSpaceBeforeProtocolList;
 232
 233   /// \brief If \c true, horizontally aligns arguments after an open bracket.
 234   ///
 235   /// This applies to round brackets (parentheses), angle brackets and square
 236   /// brackets. This will result in formattings like
 237   /// \code
 238   /// someLongFunction(argument1,
 239   ///                  argument2);
 240   /// \endcode
 241   bool AlignAfterOpenBracket;
 242
 243   /// \brief If \c true, horizontally align operands of binary and ternary
 244   /// expressions.
 245   bool AlignOperands;
 246
 247   /// \brief If \c true, aligns trailing comments.
 248   bool AlignTrailingComments;
 249
 250   /// \brief If \c true, aligns consecutive assignments.
 251   ///
 252   /// This will align the assignment operators of consecutive lines. This
 253   /// will result in formattings like
 254   /// \code
 255   /// int aaaa = 12;
 256   /// int b    = 23;
 257   /// int ccc  = 23;
 258   /// \endcode
 259   bool AlignConsecutiveAssignments;
 260
 261   /// \brief If \c true, aligns escaped newlines as far left as possible.
 262   /// Otherwise puts them into the right-most column.
 263   bool AlignEscapedNewlinesLeft;
 264
 265   /// \brief The number of columns to use for indentation.
 266   unsigned IndentWidth;
 267
 268   /// \brief The number of columns used for tab stops.
 269   unsigned TabWidth;
 270
 271   /// \brief The number of characters to use for indentation of constructor
 272   /// initializer lists.
 273   unsigned ConstructorInitializerIndentWidth;
 274
 275   /// \brief The number of characters to use for indentation of ObjC blocks.
 276   unsigned ObjCBlockIndentWidth;
 277
 278   /// \brief If \c true, always break after function definition return types.
 279   ///
 280   /// More truthfully called 'break before the identifier following the type
 281   /// in a function definition'. PenaltyReturnTypeOnItsOwnLine becomes
 282   /// irrelevant.
 283   bool AlwaysBreakAfterDefinitionReturnType;
 284
 285   /// \brief If \c true, always break after the <tt>template<...></tt> of a
 286   /// template declaration.
 287   bool AlwaysBreakTemplateDeclarations;
 288
 289   /// \brief If \c true, always break before multiline string literals.
 290   bool AlwaysBreakBeforeMultilineStrings;
 291
 292   /// \brief Different ways to use tab in formatting.
 293   enum UseTabStyle {
 294     /// Never use tab.
 295     UT_Never,
 296     /// Use tabs only for indentation.
 297     UT_ForIndentation,
 298     /// Use tabs whenever we need to fill whitespace that spans at least from
 299     /// one tab stop to the next one.
 300     UT_Always
 301   };
 302
 303   /// \brief The way to use tab characters in the resulting file.
 304   UseTabStyle UseTab;
 305
 306   /// \brief The style of breaking before or after binary operators.
 307   enum BinaryOperatorStyle {
 308     /// Break after operators.
 309     BOS_None,
 310     /// Break before operators that aren't assignments.
 311     BOS_NonAssignment,
 312     /// Break before operators.
 313     BOS_All,
 314   };
 315
 316   /// \brief The way to wrap binary operators.
 317   BinaryOperatorStyle BreakBeforeBinaryOperators;
 318
 319   /// \brief If \c true, ternary operators will be placed after line breaks.
 320   bool BreakBeforeTernaryOperators;
 321
 322   /// \brief Different ways to attach braces to their surrounding context.
 323   enum BraceBreakingStyle {
 324     /// Always attach braces to surrounding context.
 325     BS_Attach,
 326     /// Like \c Attach, but break before braces on function, namespace and
 327     /// class definitions.
 328     BS_Linux,
 329     /// Like \c Attach, but break before function definitions, and 'else'.
 330     BS_Stroustrup,
 331     /// Always break before braces.
 332     BS_Allman,
 333     /// Always break before braces and add an extra level of indentation to
 334     /// braces of control statements, not to those of class, function
 335     /// or other definitions.
 336     BS_GNU
 337   };
 338
 339   /// \brief The brace breaking style to use.
 340   BraceBreakingStyle BreakBeforeBraces;
 341
 342   /// \brief If \c true, format braced lists as best suited for C++11 braced
 343   /// lists.
 344   ///
 345   /// Important differences:
 346   /// - No spaces inside the braced list.
 347   /// - No line break before the closing brace.
 348   /// - Indentation with the continuation indent, not with the block indent.
 349   ///
 350   /// Fundamentally, C++11 braced lists are formatted exactly like function
 351   /// calls would be formatted in their place. If the braced list follows a name
 352   /// (e.g. a type or variable name), clang-format formats as if the \c {} were
 353   /// the parentheses of a function call with that name. If there is no name,
 354   /// a zero-length name is assumed.
 355   bool Cpp11BracedListStyle;
 356
 357   /// \brief If \c true, spaces will be inserted after '(' and before ')'.
 358   bool SpacesInParentheses;
 359
 360   /// \brief If \c true, spaces will be inserted after '<' and before '>' in
 361   /// template argument lists
 362   bool SpacesInAngles;
 363
 364   /// \brief If \c true, spaces will be inserted after '[' and before ']'.
 365   bool SpacesInSquareBrackets;
 366
 367   /// \brief If \c true, spaces may be inserted into '()'.
 368   bool SpaceInEmptyParentheses;
 369
 370   /// \brief If \c true, spaces are inserted inside container literals (e.g.
 371   /// ObjC and Javascript array and dict literals).
 372   bool SpacesInContainerLiterals;
 373
 374   /// \brief If \c true, spaces may be inserted into C style casts.
 375   bool SpacesInCStyleCastParentheses;
 376
 377   /// \brief If \c true, a space may be inserted after C style casts.
 378   bool SpaceAfterCStyleCast;
 379
 380   /// \brief Different ways to put a space before opening parentheses.
 381   enum SpaceBeforeParensOptions {
 382     /// Never put a space before opening parentheses.
 383     SBPO_Never,
 384     /// Put a space before opening parentheses only after control statement
 385     /// keywords (<tt>for/if/while...</tt>).
 386     SBPO_ControlStatements,
 387     /// Always put a space before opening parentheses, except when it's
 388     /// prohibited by the syntax rules (in function-like macro definitions) or
 389     /// when determined by other style rules (after unary operators, opening
 390     /// parentheses, etc.)
 391     SBPO_Always
 392   };
 393
 394   /// \brief Defines in which cases to put a space before opening parentheses.
 395   SpaceBeforeParensOptions SpaceBeforeParens;
 396
 397   /// \brief If \c false, spaces will be removed before assignment operators.
 398   bool SpaceBeforeAssignmentOperators;
 399
 400   /// \brief Indent width for line continuations.
 401   unsigned ContinuationIndentWidth;
 402
 403   /// \brief A regular expression that describes comments with special meaning,
 404   /// which should not be split into lines or otherwise changed.
 405   std::string CommentPragmas;
 406
 407   /// \brief Disables formatting at all.
 408   bool DisableFormat;
 409
 410   /// \brief A vector of macros that should be interpreted as foreach loops
 411   /// instead of as function calls.
 412   ///
 413   /// These are expected to be macros of the form:
 414   /// \code
 415   /// FOREACH(<variable-declaration>, ...)
 416   ///   <loop-body>
 417   /// \endcode
 418   ///
 419   /// For example: BOOST_FOREACH.
 420   std::vector<std::string> ForEachMacros;
 421
 422   bool operator==(const FormatStyle &R) const {
 423     return AccessModifierOffset == R.AccessModifierOffset &&
 424            AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
 425            AlignOperands == R.AlignOperands &&
 426            AlignEscapedNewlinesLeft == R.AlignEscapedNewlinesLeft &&
 427            AlignTrailingComments == R.AlignTrailingComments &&
 428            AllowAllParametersOfDeclarationOnNextLine ==
 429                R.AllowAllParametersOfDeclarationOnNextLine &&
 430            AllowShortFunctionsOnASingleLine ==
 431                R.AllowShortFunctionsOnASingleLine &&
 432            AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
 433            AllowShortIfStatementsOnASingleLine ==
 434                R.AllowShortIfStatementsOnASingleLine &&
 435            AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
 436            AlwaysBreakAfterDefinitionReturnType ==
 437                R.AlwaysBreakAfterDefinitionReturnType &&
 438            AlwaysBreakTemplateDeclarations ==
 439                R.AlwaysBreakTemplateDeclarations &&
 440            AlwaysBreakBeforeMultilineStrings ==
 441                R.AlwaysBreakBeforeMultilineStrings &&
 442            BinPackParameters == R.BinPackParameters &&
 443            BinPackArguments == R.BinPackArguments &&
 444            BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
 445            BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
 446            BreakBeforeBraces == R.BreakBeforeBraces &&
 447            BreakConstructorInitializersBeforeComma ==
 448                R.BreakConstructorInitializersBeforeComma &&
 449            ColumnLimit == R.ColumnLimit &&
 450            ConstructorInitializerAllOnOneLineOrOnePerLine ==
 451                R.ConstructorInitializerAllOnOneLineOrOnePerLine &&
 452            ConstructorInitializerIndentWidth ==
 453                R.ConstructorInitializerIndentWidth &&
 454            DerivePointerAlignment == R.DerivePointerAlignment &&
 455            ExperimentalAutoDetectBinPacking ==
 456                R.ExperimentalAutoDetectBinPacking &&
 457            IndentCaseLabels == R.IndentCaseLabels &&
 458            IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
 459            IndentWidth == R.IndentWidth && Language == R.Language &&
 460            MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
 461            KeepEmptyLinesAtTheStartOfBlocks ==
 462                R.KeepEmptyLinesAtTheStartOfBlocks &&
 463            NamespaceIndentation == R.NamespaceIndentation &&
 464            ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
 465            ObjCSpaceAfterProperty == R.ObjCSpaceAfterProperty &&
 466            ObjCSpaceBeforeProtocolList == R.ObjCSpaceBeforeProtocolList &&
 467            PenaltyBreakComment == R.PenaltyBreakComment &&
 468            PenaltyBreakFirstLessLess == R.PenaltyBreakFirstLessLess &&
 469            PenaltyBreakString == R.PenaltyBreakString &&
 470            PenaltyExcessCharacter == R.PenaltyExcessCharacter &&
 471            PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine &&
 472            PointerAlignment == R.PointerAlignment &&
 473            SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments &&
 474            Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
 475            Standard == R.Standard && TabWidth == R.TabWidth &&
 476            UseTab == R.UseTab && SpacesInParentheses == R.SpacesInParentheses &&
 477            SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
 478            SpacesInAngles == R.SpacesInAngles &&
 479            SpaceInEmptyParentheses == R.SpaceInEmptyParentheses &&
 480            SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
 481            SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
 482            SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
 483            SpaceBeforeParens == R.SpaceBeforeParens &&
 484            SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
 485            ContinuationIndentWidth == R.ContinuationIndentWidth &&
 486            CommentPragmas == R.CommentPragmas &&
 487            ForEachMacros == R.ForEachMacros;
 488   }
 489 };
 490
 491 /// \brief Returns a format style complying with the LLVM coding standards:
 492 /// http://llvm.org/docs/CodingStandards.html.
 493 FormatStyle getLLVMStyle();
 494
 495 /// \brief Returns a format style complying with one of Google's style guides:
 496 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.
 497 /// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
 498 /// https://developers.google.com/protocol-buffers/docs/style.
 499 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language);
 500
 501 /// \brief Returns a format style complying with Chromium's style guide:
 502 /// http://www.chromium.org/developers/coding-style.
 503 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language);
 504
 505 /// \brief Returns a format style complying with Mozilla's style guide:
 506 /// https://developer.mozilla.org/en-US/docs/Developer_Guide/Coding_Style.
 507 FormatStyle getMozillaStyle();
 508
 509 /// \brief Returns a format style complying with Webkit's style guide:
 510 /// http://www.webkit.org/coding/coding-style.html
 511 FormatStyle getWebKitStyle();
 512
 513 /// \brief Returns a format style complying with GNU Coding Standards:
 514 /// http://www.gnu.org/prep/standards/standards.html
 515 FormatStyle getGNUStyle();
 516
 517 /// \brief Returns style indicating formatting should be not applied at all.
 518 FormatStyle getNoStyle();
 519
 520 /// \brief Gets a predefined style for the specified language by name.
 521 ///
 522 /// Currently supported names: LLVM, Google, Chromium, Mozilla. Names are
 523 /// compared case-insensitively.
 524 ///
 525 /// Returns \c true if the Style has been set.
 526 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
 527                         FormatStyle *Style);
 528
 529 /// \brief Parse configuration from YAML-formatted text.
 530 ///
 531 /// Style->Language is used to get the base style, if the \c BasedOnStyle
 532 /// option is present.
 533 ///
 534 /// When \c BasedOnStyle is not present, options not present in the YAML
 535 /// document, are retained in \p Style.
 536 std::error_code parseConfiguration(StringRef Text, FormatStyle *Style);
 537
 538 /// \brief Gets configuration in a YAML string.
 539 std::string configurationAsText(const FormatStyle &Style);
 540
 541 /// \brief Reformats the given \p Ranges in the file \p ID.
 542 ///
 543 /// Each range is extended on either end to its next bigger logic unit, i.e.
 544 /// everything that might influence its formatting or might be influenced by its
 545 /// formatting.
 546 ///
 547 /// Returns the \c Replacements necessary to make all \p Ranges comply with
 548 /// \p Style.
 549 ///
 550 /// If \c IncompleteFormat is non-null, its value will be set to true if any
 551 /// of the affected ranges were not formatted due to a non-recoverable syntax
 552 /// error.
 553 tooling::Replacements reformat(const FormatStyle &Style,
 554                                SourceManager &SourceMgr, FileID ID,
 555                                ArrayRef<CharSourceRange> Ranges,
 556                                bool *IncompleteFormat = nullptr);
 557
 558 /// \brief Reformats the given \p Ranges in \p Code.
 559 ///
 560 /// Otherwise identical to the reformat() function using a file ID.
 561 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
 562                                ArrayRef<tooling::Range> Ranges,
 563                                StringRef FileName = "<stdin>",
 564                                bool *IncompleteFormat = nullptr);
 565
 566 /// \brief Returns the \c LangOpts that the formatter expects you to set.
 567 ///
 568 /// \param Style determines specific settings for lexing mode.
 569 LangOptions getFormattingLangOpts(const FormatStyle &Style = getLLVMStyle());
 570
 571 /// \brief Description to be used for help text for a llvm::cl option for
 572 /// specifying format style. The description is closely related to the operation
 573 /// of getStyle().
 574 extern const char *StyleOptionHelpDescription;
 575
 576 /// \brief Construct a FormatStyle based on \c StyleName.
 577 ///
 578 /// \c StyleName can take several forms:
 579 /// \li "{<key>: <value>, ...}" - Set specic style parameters.
 580 /// \li "<style name>" - One of the style names supported by
 581 /// getPredefinedStyle().
 582 /// \li "file" - Load style configuration from a file called '.clang-format'
 583 /// located in one of the parent directories of \c FileName or the current
 584 /// directory if \c FileName is empty.
 585 ///
 586 /// \param[in] StyleName Style name to interpret according to the description
 587 /// above.
 588 /// \param[in] FileName Path to start search for .clang-format if \c StyleName
 589 /// == "file".
 590 /// \param[in] FallbackStyle The name of a predefined style used to fallback to
 591 /// in case the style can't be determined from \p StyleName.
 592 ///
 593 /// \returns FormatStyle as specified by \c StyleName. If no style could be
 594 /// determined, the default is LLVM Style (see getLLVMStyle()).
 595 FormatStyle getStyle(StringRef StyleName, StringRef FileName,
 596                      StringRef FallbackStyle);
 597
 598 } // end namespace format
 599 } // end namespace clang
 600
 601 namespace std {
 602 template <>
 603 struct is_error_code_enum<clang::format::ParseError> : std::true_type {};
 604 }
 605
 606 #endif // LLVM_CLANG_FORMAT_FORMAT_H