contrib/llvm/tools/clang/lib/Format/Format.cpp

   1 //===--- Format.cpp - Format C++ code -------------------------------------===//
   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 /// \brief This file implements functions declared in Format.h. This will be
  12 /// split into separate files as we go.
  13 ///
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "clang/Format/Format.h"
  17 #include "ContinuationIndenter.h"
  18 #include "TokenAnnotator.h"
  19 #include "UnwrappedLineFormatter.h"
  20 #include "UnwrappedLineParser.h"
  21 #include "WhitespaceManager.h"
  22 #include "clang/Basic/Diagnostic.h"
  23 #include "clang/Basic/DiagnosticOptions.h"
  24 #include "clang/Basic/SourceManager.h"
  25 #include "clang/Lex/Lexer.h"
  26 #include "llvm/ADT/STLExtras.h"
  27 #include "llvm/Support/Allocator.h"
  28 #include "llvm/Support/Debug.h"
  29 #include "llvm/Support/Path.h"
  30 #include "llvm/Support/Regex.h"
  31 #include "llvm/Support/YAMLTraits.h"
  32 #include <queue>
  33 #include <string>
  34
  35 #define DEBUG_TYPE "format-formatter"
  36
  37 using clang::format::FormatStyle;
  38
  39 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
  40 LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::IncludeCategory)
  41
  42 namespace llvm {
  43 namespace yaml {
  44 template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
  45   static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
  46     IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
  47     IO.enumCase(Value, "Java", FormatStyle::LK_Java);
  48     IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
  49     IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
  50     IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
  51   }
  52 };
  53
  54 template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> {
  55   static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
  56     IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03);
  57     IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03);
  58     IO.enumCase(Value, "Cpp11", FormatStyle::LS_Cpp11);
  59     IO.enumCase(Value, "C++11", FormatStyle::LS_Cpp11);
  60     IO.enumCase(Value, "Auto", FormatStyle::LS_Auto);
  61   }
  62 };
  63
  64 template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
  65   static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
  66     IO.enumCase(Value, "Never", FormatStyle::UT_Never);
  67     IO.enumCase(Value, "false", FormatStyle::UT_Never);
  68     IO.enumCase(Value, "Always", FormatStyle::UT_Always);
  69     IO.enumCase(Value, "true", FormatStyle::UT_Always);
  70     IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
  71   }
  72 };
  73
  74 template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
  75   static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
  76     IO.enumCase(Value, "None", FormatStyle::SFS_None);
  77     IO.enumCase(Value, "false", FormatStyle::SFS_None);
  78     IO.enumCase(Value, "All", FormatStyle::SFS_All);
  79     IO.enumCase(Value, "true", FormatStyle::SFS_All);
  80     IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
  81     IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
  82   }
  83 };
  84
  85 template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
  86   static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
  87     IO.enumCase(Value, "All", FormatStyle::BOS_All);
  88     IO.enumCase(Value, "true", FormatStyle::BOS_All);
  89     IO.enumCase(Value, "None", FormatStyle::BOS_None);
  90     IO.enumCase(Value, "false", FormatStyle::BOS_None);
  91     IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
  92   }
  93 };
  94
  95 template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
  96   static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
  97     IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
  98     IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
  99     IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla);
 100     IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
 101     IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
 102     IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
 103     IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit);
 104     IO.enumCase(Value, "Custom", FormatStyle::BS_Custom);
 105   }
 106 };
 107
 108 template <>
 109 struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
 110   static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
 111     IO.enumCase(Value, "None", FormatStyle::RTBS_None);
 112     IO.enumCase(Value, "All", FormatStyle::RTBS_All);
 113     IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
 114     IO.enumCase(Value, "TopLevelDefinitions",
 115                 FormatStyle::RTBS_TopLevelDefinitions);
 116     IO.enumCase(Value, "AllDefinitions", FormatStyle::RTBS_AllDefinitions);
 117   }
 118 };
 119
 120 template <>
 121 struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
 122   static void
 123   enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) {
 124     IO.enumCase(Value, "None", FormatStyle::DRTBS_None);
 125     IO.enumCase(Value, "All", FormatStyle::DRTBS_All);
 126     IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel);
 127
 128     // For backward compatibility.
 129     IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
 130     IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
 131   }
 132 };
 133
 134 template <>
 135 struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
 136   static void enumeration(IO &IO,
 137                           FormatStyle::NamespaceIndentationKind &Value) {
 138     IO.enumCase(Value, "None", FormatStyle::NI_None);
 139     IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
 140     IO.enumCase(Value, "All", FormatStyle::NI_All);
 141   }
 142 };
 143
 144 template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
 145   static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
 146     IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
 147     IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign);
 148     IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
 149
 150     // For backward compatibility.
 151     IO.enumCase(Value, "true", FormatStyle::BAS_Align);
 152     IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
 153   }
 154 };
 155
 156 template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
 157   static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
 158     IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
 159     IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
 160     IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
 161
 162     // For backward compatibility.
 163     IO.enumCase(Value, "true", FormatStyle::PAS_Left);
 164     IO.enumCase(Value, "false", FormatStyle::PAS_Right);
 165   }
 166 };
 167
 168 template <>
 169 struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
 170   static void enumeration(IO &IO,
 171                           FormatStyle::SpaceBeforeParensOptions &Value) {
 172     IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
 173     IO.enumCase(Value, "ControlStatements",
 174                 FormatStyle::SBPO_ControlStatements);
 175     IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
 176
 177     // For backward compatibility.
 178     IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
 179     IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
 180   }
 181 };
 182
 183 template <> struct MappingTraits<FormatStyle> {
 184   static void mapping(IO &IO, FormatStyle &Style) {
 185     // When reading, read the language first, we need it for getPredefinedStyle.
 186     IO.mapOptional("Language", Style.Language);
 187
 188     if (IO.outputting()) {
 189       StringRef StylesArray[] = {"LLVM",    "Google", "Chromium",
 190                                  "Mozilla", "WebKit", "GNU"};
 191       ArrayRef<StringRef> Styles(StylesArray);
 192       for (size_t i = 0, e = Styles.size(); i < e; ++i) {
 193         StringRef StyleName(Styles[i]);
 194         FormatStyle PredefinedStyle;
 195         if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
 196             Style == PredefinedStyle) {
 197           IO.mapOptional("# BasedOnStyle", StyleName);
 198           break;
 199         }
 200       }
 201     } else {
 202       StringRef BasedOnStyle;
 203       IO.mapOptional("BasedOnStyle", BasedOnStyle);
 204       if (!BasedOnStyle.empty()) {
 205         FormatStyle::LanguageKind OldLanguage = Style.Language;
 206         FormatStyle::LanguageKind Language =
 207             ((FormatStyle *)IO.getContext())->Language;
 208         if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
 209           IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
 210           return;
 211         }
 212         Style.Language = OldLanguage;
 213       }
 214     }
 215
 216     // For backward compatibility.
 217     if (!IO.outputting()) {
 218       IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
 219       IO.mapOptional("IndentFunctionDeclarationAfterType",
 220                      Style.IndentWrappedFunctionNames);
 221       IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
 222       IO.mapOptional("SpaceAfterControlStatementKeyword",
 223                      Style.SpaceBeforeParens);
 224     }
 225
 226     IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
 227     IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
 228     IO.mapOptional("AlignConsecutiveAssignments",
 229                    Style.AlignConsecutiveAssignments);
 230     IO.mapOptional("AlignConsecutiveDeclarations",
 231                    Style.AlignConsecutiveDeclarations);
 232     IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft);
 233     IO.mapOptional("AlignOperands", Style.AlignOperands);
 234     IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
 235     IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
 236                    Style.AllowAllParametersOfDeclarationOnNextLine);
 237     IO.mapOptional("AllowShortBlocksOnASingleLine",
 238                    Style.AllowShortBlocksOnASingleLine);
 239     IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
 240                    Style.AllowShortCaseLabelsOnASingleLine);
 241     IO.mapOptional("AllowShortFunctionsOnASingleLine",
 242                    Style.AllowShortFunctionsOnASingleLine);
 243     IO.mapOptional("AllowShortIfStatementsOnASingleLine",
 244                    Style.AllowShortIfStatementsOnASingleLine);
 245     IO.mapOptional("AllowShortLoopsOnASingleLine",
 246                    Style.AllowShortLoopsOnASingleLine);
 247     IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
 248                    Style.AlwaysBreakAfterDefinitionReturnType);
 249     IO.mapOptional("AlwaysBreakAfterReturnType",
 250                    Style.AlwaysBreakAfterReturnType);
 251     // If AlwaysBreakAfterDefinitionReturnType was specified but
 252     // AlwaysBreakAfterReturnType was not, initialize the latter from the
 253     // former for backwards compatibility.
 254     if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
 255         Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
 256       if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
 257         Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
 258       else if (Style.AlwaysBreakAfterDefinitionReturnType ==
 259                FormatStyle::DRTBS_TopLevel)
 260         Style.AlwaysBreakAfterReturnType =
 261             FormatStyle::RTBS_TopLevelDefinitions;
 262     }
 263
 264     IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
 265                    Style.AlwaysBreakBeforeMultilineStrings);
 266     IO.mapOptional("AlwaysBreakTemplateDeclarations",
 267                    Style.AlwaysBreakTemplateDeclarations);
 268     IO.mapOptional("BinPackArguments", Style.BinPackArguments);
 269     IO.mapOptional("BinPackParameters", Style.BinPackParameters);
 270     IO.mapOptional("BraceWrapping", Style.BraceWrapping);
 271     IO.mapOptional("BreakBeforeBinaryOperators",
 272                    Style.BreakBeforeBinaryOperators);
 273     IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
 274     IO.mapOptional("BreakBeforeTernaryOperators",
 275                    Style.BreakBeforeTernaryOperators);
 276     IO.mapOptional("BreakConstructorInitializersBeforeComma",
 277                    Style.BreakConstructorInitializersBeforeComma);
 278     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
 279     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
 280     IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
 281                    Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
 282     IO.mapOptional("ConstructorInitializerIndentWidth",
 283                    Style.ConstructorInitializerIndentWidth);
 284     IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
 285     IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
 286     IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
 287     IO.mapOptional("DisableFormat", Style.DisableFormat);
 288     IO.mapOptional("ExperimentalAutoDetectBinPacking",
 289                    Style.ExperimentalAutoDetectBinPacking);
 290     IO.mapOptional("ForEachMacros", Style.ForEachMacros);
 291     IO.mapOptional("IncludeCategories", Style.IncludeCategories);
 292     IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
 293     IO.mapOptional("IndentWidth", Style.IndentWidth);
 294     IO.mapOptional("IndentWrappedFunctionNames",
 295                    Style.IndentWrappedFunctionNames);
 296     IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
 297                    Style.KeepEmptyLinesAtTheStartOfBlocks);
 298     IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
 299     IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
 300     IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
 301     IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
 302     IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
 303     IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
 304     IO.mapOptional("ObjCSpaceBeforeProtocolList",
 305                    Style.ObjCSpaceBeforeProtocolList);
 306     IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
 307                    Style.PenaltyBreakBeforeFirstCallParameter);
 308     IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
 309     IO.mapOptional("PenaltyBreakFirstLessLess",
 310                    Style.PenaltyBreakFirstLessLess);
 311     IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
 312     IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
 313     IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
 314                    Style.PenaltyReturnTypeOnItsOwnLine);
 315     IO.mapOptional("PointerAlignment", Style.PointerAlignment);
 316     IO.mapOptional("ReflowComments", Style.ReflowComments);
 317     IO.mapOptional("SortIncludes", Style.SortIncludes);
 318     IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
 319     IO.mapOptional("SpaceBeforeAssignmentOperators",
 320                    Style.SpaceBeforeAssignmentOperators);
 321     IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
 322     IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
 323     IO.mapOptional("SpacesBeforeTrailingComments",
 324                    Style.SpacesBeforeTrailingComments);
 325     IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
 326     IO.mapOptional("SpacesInContainerLiterals",
 327                    Style.SpacesInContainerLiterals);
 328     IO.mapOptional("SpacesInCStyleCastParentheses",
 329                    Style.SpacesInCStyleCastParentheses);
 330     IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
 331     IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
 332     IO.mapOptional("Standard", Style.Standard);
 333     IO.mapOptional("TabWidth", Style.TabWidth);
 334     IO.mapOptional("UseTab", Style.UseTab);
 335   }
 336 };
 337
 338 template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
 339   static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
 340     IO.mapOptional("AfterClass", Wrapping.AfterClass);
 341     IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
 342     IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
 343     IO.mapOptional("AfterFunction", Wrapping.AfterFunction);
 344     IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace);
 345     IO.mapOptional("AfterObjCDeclaration", Wrapping.AfterObjCDeclaration);
 346     IO.mapOptional("AfterStruct", Wrapping.AfterStruct);
 347     IO.mapOptional("AfterUnion", Wrapping.AfterUnion);
 348     IO.mapOptional("BeforeCatch", Wrapping.BeforeCatch);
 349     IO.mapOptional("BeforeElse", Wrapping.BeforeElse);
 350     IO.mapOptional("IndentBraces", Wrapping.IndentBraces);
 351   }
 352 };
 353
 354 template <> struct MappingTraits<FormatStyle::IncludeCategory> {
 355   static void mapping(IO &IO, FormatStyle::IncludeCategory &Category) {
 356     IO.mapOptional("Regex", Category.Regex);
 357     IO.mapOptional("Priority", Category.Priority);
 358   }
 359 };
 360
 361 // Allows to read vector<FormatStyle> while keeping default values.
 362 // IO.getContext() should contain a pointer to the FormatStyle structure, that
 363 // will be used to get default values for missing keys.
 364 // If the first element has no Language specified, it will be treated as the
 365 // default one for the following elements.
 366 template <> struct DocumentListTraits<std::vector<FormatStyle>> {
 367   static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
 368     return Seq.size();
 369   }
 370   static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
 371                               size_t Index) {
 372     if (Index >= Seq.size()) {
 373       assert(Index == Seq.size());
 374       FormatStyle Template;
 375       if (Seq.size() > 0 && Seq[0].Language == FormatStyle::LK_None) {
 376         Template = Seq[0];
 377       } else {
 378         Template = *((const FormatStyle *)IO.getContext());
 379         Template.Language = FormatStyle::LK_None;
 380       }
 381       Seq.resize(Index + 1, Template);
 382     }
 383     return Seq[Index];
 384   }
 385 };
 386 } // namespace yaml
 387 } // namespace llvm
 388
 389 namespace clang {
 390 namespace format {
 391
 392 const std::error_category &getParseCategory() {
 393   static ParseErrorCategory C;
 394   return C;
 395 }
 396 std::error_code make_error_code(ParseError e) {
 397   return std::error_code(static_cast<int>(e), getParseCategory());
 398 }
 399
 400 const char *ParseErrorCategory::name() const LLVM_NOEXCEPT {
 401   return "clang-format.parse_error";
 402 }
 403
 404 std::string ParseErrorCategory::message(int EV) const {
 405   switch (static_cast<ParseError>(EV)) {
 406   case ParseError::Success:
 407     return "Success";
 408   case ParseError::Error:
 409     return "Invalid argument";
 410   case ParseError::Unsuitable:
 411     return "Unsuitable";
 412   }
 413   llvm_unreachable("unexpected parse error");
 414 }
 415
 416 static FormatStyle expandPresets(const FormatStyle &Style) {
 417   if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
 418     return Style;
 419   FormatStyle Expanded = Style;
 420   Expanded.BraceWrapping = {false, false, false, false, false, false,
 421                             false, false, false, false, false};
 422   switch (Style.BreakBeforeBraces) {
 423   case FormatStyle::BS_Linux:
 424     Expanded.BraceWrapping.AfterClass = true;
 425     Expanded.BraceWrapping.AfterFunction = true;
 426     Expanded.BraceWrapping.AfterNamespace = true;
 427     break;
 428   case FormatStyle::BS_Mozilla:
 429     Expanded.BraceWrapping.AfterClass = true;
 430     Expanded.BraceWrapping.AfterEnum = true;
 431     Expanded.BraceWrapping.AfterFunction = true;
 432     Expanded.BraceWrapping.AfterStruct = true;
 433     Expanded.BraceWrapping.AfterUnion = true;
 434     break;
 435   case FormatStyle::BS_Stroustrup:
 436     Expanded.BraceWrapping.AfterFunction = true;
 437     Expanded.BraceWrapping.BeforeCatch = true;
 438     Expanded.BraceWrapping.BeforeElse = true;
 439     break;
 440   case FormatStyle::BS_Allman:
 441     Expanded.BraceWrapping.AfterClass = true;
 442     Expanded.BraceWrapping.AfterControlStatement = true;
 443     Expanded.BraceWrapping.AfterEnum = true;
 444     Expanded.BraceWrapping.AfterFunction = true;
 445     Expanded.BraceWrapping.AfterNamespace = true;
 446     Expanded.BraceWrapping.AfterObjCDeclaration = true;
 447     Expanded.BraceWrapping.AfterStruct = true;
 448     Expanded.BraceWrapping.BeforeCatch = true;
 449     Expanded.BraceWrapping.BeforeElse = true;
 450     break;
 451   case FormatStyle::BS_GNU:
 452     Expanded.BraceWrapping = {true, true, true, true, true, true,
 453                               true, true, true, true, true};
 454     break;
 455   case FormatStyle::BS_WebKit:
 456     Expanded.BraceWrapping.AfterFunction = true;
 457     break;
 458   default:
 459     break;
 460   }
 461   return Expanded;
 462 }
 463
 464 FormatStyle getLLVMStyle() {
 465   FormatStyle LLVMStyle;
 466   LLVMStyle.Language = FormatStyle::LK_Cpp;
 467   LLVMStyle.AccessModifierOffset = -2;
 468   LLVMStyle.AlignEscapedNewlinesLeft = false;
 469   LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
 470   LLVMStyle.AlignOperands = true;
 471   LLVMStyle.AlignTrailingComments = true;
 472   LLVMStyle.AlignConsecutiveAssignments = false;
 473   LLVMStyle.AlignConsecutiveDeclarations = false;
 474   LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
 475   LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
 476   LLVMStyle.AllowShortBlocksOnASingleLine = false;
 477   LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
 478   LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
 479   LLVMStyle.AllowShortLoopsOnASingleLine = false;
 480   LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
 481   LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
 482   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
 483   LLVMStyle.AlwaysBreakTemplateDeclarations = false;
 484   LLVMStyle.BinPackParameters = true;
 485   LLVMStyle.BinPackArguments = true;
 486   LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
 487   LLVMStyle.BreakBeforeTernaryOperators = true;
 488   LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
 489   LLVMStyle.BraceWrapping = {false, false, false, false, false, false,
 490                              false, false, false, false, false};
 491   LLVMStyle.BreakConstructorInitializersBeforeComma = false;
 492   LLVMStyle.BreakAfterJavaFieldAnnotations = false;
 493   LLVMStyle.ColumnLimit = 80;
 494   LLVMStyle.CommentPragmas = "^ IWYU pragma:";
 495   LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
 496   LLVMStyle.ConstructorInitializerIndentWidth = 4;
 497   LLVMStyle.ContinuationIndentWidth = 4;
 498   LLVMStyle.Cpp11BracedListStyle = true;
 499   LLVMStyle.DerivePointerAlignment = false;
 500   LLVMStyle.ExperimentalAutoDetectBinPacking = false;
 501   LLVMStyle.ForEachMacros.push_back("foreach");
 502   LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
 503   LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
 504   LLVMStyle.IncludeCategories = {{"^\"(llvm|llvm-c|clang|clang-c)/", 2},
 505                                  {"^(<|\"(gtest|isl|json)/)", 3},
 506                                  {".*", 1}};
 507   LLVMStyle.IndentCaseLabels = false;
 508   LLVMStyle.IndentWrappedFunctionNames = false;
 509   LLVMStyle.IndentWidth = 2;
 510   LLVMStyle.TabWidth = 8;
 511   LLVMStyle.MaxEmptyLinesToKeep = 1;
 512   LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
 513   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
 514   LLVMStyle.ObjCBlockIndentWidth = 2;
 515   LLVMStyle.ObjCSpaceAfterProperty = false;
 516   LLVMStyle.ObjCSpaceBeforeProtocolList = true;
 517   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
 518   LLVMStyle.SpacesBeforeTrailingComments = 1;
 519   LLVMStyle.Standard = FormatStyle::LS_Cpp11;
 520   LLVMStyle.UseTab = FormatStyle::UT_Never;
 521   LLVMStyle.ReflowComments = true;
 522   LLVMStyle.SpacesInParentheses = false;
 523   LLVMStyle.SpacesInSquareBrackets = false;
 524   LLVMStyle.SpaceInEmptyParentheses = false;
 525   LLVMStyle.SpacesInContainerLiterals = true;
 526   LLVMStyle.SpacesInCStyleCastParentheses = false;
 527   LLVMStyle.SpaceAfterCStyleCast = false;
 528   LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
 529   LLVMStyle.SpaceBeforeAssignmentOperators = true;
 530   LLVMStyle.SpacesInAngles = false;
 531
 532   LLVMStyle.PenaltyBreakComment = 300;
 533   LLVMStyle.PenaltyBreakFirstLessLess = 120;
 534   LLVMStyle.PenaltyBreakString = 1000;
 535   LLVMStyle.PenaltyExcessCharacter = 1000000;
 536   LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
 537   LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
 538
 539   LLVMStyle.DisableFormat = false;
 540   LLVMStyle.SortIncludes = true;
 541
 542   return LLVMStyle;
 543 }
 544
 545 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
 546   FormatStyle GoogleStyle = getLLVMStyle();
 547   GoogleStyle.Language = Language;
 548
 549   GoogleStyle.AccessModifierOffset = -1;
 550   GoogleStyle.AlignEscapedNewlinesLeft = true;
 551   GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
 552   GoogleStyle.AllowShortLoopsOnASingleLine = true;
 553   GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
 554   GoogleStyle.AlwaysBreakTemplateDeclarations = true;
 555   GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
 556   GoogleStyle.DerivePointerAlignment = true;
 557   GoogleStyle.IncludeCategories = {{"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
 558   GoogleStyle.IndentCaseLabels = true;
 559   GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
 560   GoogleStyle.ObjCSpaceAfterProperty = false;
 561   GoogleStyle.ObjCSpaceBeforeProtocolList = false;
 562   GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
 563   GoogleStyle.SpacesBeforeTrailingComments = 2;
 564   GoogleStyle.Standard = FormatStyle::LS_Auto;
 565
 566   GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
 567   GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
 568
 569   if (Language == FormatStyle::LK_Java) {
 570     GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
 571     GoogleStyle.AlignOperands = false;
 572     GoogleStyle.AlignTrailingComments = false;
 573     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
 574     GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
 575     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
 576     GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
 577     GoogleStyle.ColumnLimit = 100;
 578     GoogleStyle.SpaceAfterCStyleCast = true;
 579     GoogleStyle.SpacesBeforeTrailingComments = 1;
 580   } else if (Language == FormatStyle::LK_JavaScript) {
 581     GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
 582     GoogleStyle.AlignOperands = false;
 583     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
 584     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
 585     GoogleStyle.BreakBeforeTernaryOperators = false;
 586     GoogleStyle.CommentPragmas = "@(export|visibility) {";
 587     GoogleStyle.MaxEmptyLinesToKeep = 3;
 588     GoogleStyle.SpacesInContainerLiterals = false;
 589   } else if (Language == FormatStyle::LK_Proto) {
 590     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
 591     GoogleStyle.SpacesInContainerLiterals = false;
 592   }
 593
 594   return GoogleStyle;
 595 }
 596
 597 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
 598   FormatStyle ChromiumStyle = getGoogleStyle(Language);
 599   if (Language == FormatStyle::LK_Java) {
 600     ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
 601     ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
 602     ChromiumStyle.ContinuationIndentWidth = 8;
 603     ChromiumStyle.IndentWidth = 4;
 604   } else {
 605     ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
 606     ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
 607     ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
 608     ChromiumStyle.AllowShortLoopsOnASingleLine = false;
 609     ChromiumStyle.BinPackParameters = false;
 610     ChromiumStyle.DerivePointerAlignment = false;
 611   }
 612   ChromiumStyle.SortIncludes = false;
 613   return ChromiumStyle;
 614 }
 615
 616 FormatStyle getMozillaStyle() {
 617   FormatStyle MozillaStyle = getLLVMStyle();
 618   MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
 619   MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
 620   MozillaStyle.AlwaysBreakAfterReturnType =
 621       FormatStyle::RTBS_TopLevelDefinitions;
 622   MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
 623       FormatStyle::DRTBS_TopLevel;
 624   MozillaStyle.AlwaysBreakTemplateDeclarations = true;
 625   MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
 626   MozillaStyle.BreakConstructorInitializersBeforeComma = true;
 627   MozillaStyle.ConstructorInitializerIndentWidth = 2;
 628   MozillaStyle.ContinuationIndentWidth = 2;
 629   MozillaStyle.Cpp11BracedListStyle = false;
 630   MozillaStyle.IndentCaseLabels = true;
 631   MozillaStyle.ObjCSpaceAfterProperty = true;
 632   MozillaStyle.ObjCSpaceBeforeProtocolList = false;
 633   MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
 634   MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
 635   return MozillaStyle;
 636 }
 637
 638 FormatStyle getWebKitStyle() {
 639   FormatStyle Style = getLLVMStyle();
 640   Style.AccessModifierOffset = -4;
 641   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
 642   Style.AlignOperands = false;
 643   Style.AlignTrailingComments = false;
 644   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
 645   Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
 646   Style.BreakConstructorInitializersBeforeComma = true;
 647   Style.Cpp11BracedListStyle = false;
 648   Style.ColumnLimit = 0;
 649   Style.IndentWidth = 4;
 650   Style.NamespaceIndentation = FormatStyle::NI_Inner;
 651   Style.ObjCBlockIndentWidth = 4;
 652   Style.ObjCSpaceAfterProperty = true;
 653   Style.PointerAlignment = FormatStyle::PAS_Left;
 654   Style.Standard = FormatStyle::LS_Cpp03;
 655   return Style;
 656 }
 657
 658 FormatStyle getGNUStyle() {
 659   FormatStyle Style = getLLVMStyle();
 660   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
 661   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
 662   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
 663   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
 664   Style.BreakBeforeTernaryOperators = true;
 665   Style.Cpp11BracedListStyle = false;
 666   Style.ColumnLimit = 79;
 667   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
 668   Style.Standard = FormatStyle::LS_Cpp03;
 669   return Style;
 670 }
 671
 672 FormatStyle getNoStyle() {
 673   FormatStyle NoStyle = getLLVMStyle();
 674   NoStyle.DisableFormat = true;
 675   NoStyle.SortIncludes = false;
 676   return NoStyle;
 677 }
 678
 679 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
 680                         FormatStyle *Style) {
 681   if (Name.equals_lower("llvm")) {
 682     *Style = getLLVMStyle();
 683   } else if (Name.equals_lower("chromium")) {
 684     *Style = getChromiumStyle(Language);
 685   } else if (Name.equals_lower("mozilla")) {
 686     *Style = getMozillaStyle();
 687   } else if (Name.equals_lower("google")) {
 688     *Style = getGoogleStyle(Language);
 689   } else if (Name.equals_lower("webkit")) {
 690     *Style = getWebKitStyle();
 691   } else if (Name.equals_lower("gnu")) {
 692     *Style = getGNUStyle();
 693   } else if (Name.equals_lower("none")) {
 694     *Style = getNoStyle();
 695   } else {
 696     return false;
 697   }
 698
 699   Style->Language = Language;
 700   return true;
 701 }
 702
 703 std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
 704   assert(Style);
 705   FormatStyle::LanguageKind Language = Style->Language;
 706   assert(Language != FormatStyle::LK_None);
 707   if (Text.trim().empty())
 708     return make_error_code(ParseError::Error);
 709
 710   std::vector<FormatStyle> Styles;
 711   llvm::yaml::Input Input(Text);
 712   // DocumentListTraits<vector<FormatStyle>> uses the context to get default
 713   // values for the fields, keys for which are missing from the configuration.
 714   // Mapping also uses the context to get the language to find the correct
 715   // base style.
 716   Input.setContext(Style);
 717   Input >> Styles;
 718   if (Input.error())
 719     return Input.error();
 720
 721   for (unsigned i = 0; i < Styles.size(); ++i) {
 722     // Ensures that only the first configuration can skip the Language option.
 723     if (Styles[i].Language == FormatStyle::LK_None && i != 0)
 724       return make_error_code(ParseError::Error);
 725     // Ensure that each language is configured at most once.
 726     for (unsigned j = 0; j < i; ++j) {
 727       if (Styles[i].Language == Styles[j].Language) {
 728         DEBUG(llvm::dbgs()
 729               << "Duplicate languages in the config file on positions " << j
 730               << " and " << i << "\n");
 731         return make_error_code(ParseError::Error);
 732       }
 733     }
 734   }
 735   // Look for a suitable configuration starting from the end, so we can
 736   // find the configuration for the specific language first, and the default
 737   // configuration (which can only be at slot 0) after it.
 738   for (int i = Styles.size() - 1; i >= 0; --i) {
 739     if (Styles[i].Language == Language ||
 740         Styles[i].Language == FormatStyle::LK_None) {
 741       *Style = Styles[i];
 742       Style->Language = Language;
 743       return make_error_code(ParseError::Success);
 744     }
 745   }
 746   return make_error_code(ParseError::Unsuitable);
 747 }
 748
 749 std::string configurationAsText(const FormatStyle &Style) {
 750   std::string Text;
 751   llvm::raw_string_ostream Stream(Text);
 752   llvm::yaml::Output Output(Stream);
 753   // We use the same mapping method for input and output, so we need a non-const
 754   // reference here.
 755   FormatStyle NonConstStyle = expandPresets(Style);
 756   Output << NonConstStyle;
 757   return Stream.str();
 758 }
 759
 760 namespace {
 761
 762 class FormatTokenLexer {
 763 public:
 764   FormatTokenLexer(SourceManager &SourceMgr, FileID ID, FormatStyle &Style,
 765                    encoding::Encoding Encoding)
 766       : FormatTok(nullptr), IsFirstToken(true), GreaterStashed(false),
 767         LessStashed(false), Column(0), TrailingWhitespace(0),
 768         SourceMgr(SourceMgr), ID(ID), Style(Style),
 769         IdentTable(getFormattingLangOpts(Style)), Keywords(IdentTable),
 770         Encoding(Encoding), FirstInLineIndex(0), FormattingDisabled(false),
 771         MacroBlockBeginRegex(Style.MacroBlockBegin),
 772         MacroBlockEndRegex(Style.MacroBlockEnd) {
 773     Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
 774                         getFormattingLangOpts(Style)));
 775     Lex->SetKeepWhitespaceMode(true);
 776
 777     for (const std::string &ForEachMacro : Style.ForEachMacros)
 778       ForEachMacros.push_back(&IdentTable.get(ForEachMacro));
 779     std::sort(ForEachMacros.begin(), ForEachMacros.end());
 780   }
 781
 782   ArrayRef<FormatToken *> lex() {
 783     assert(Tokens.empty());
 784     assert(FirstInLineIndex == 0);
 785     do {
 786       Tokens.push_back(getNextToken());
 787       if (Style.Language == FormatStyle::LK_JavaScript)
 788         tryParseJSRegexLiteral();
 789       tryMergePreviousTokens();
 790       if (Tokens.back()->NewlinesBefore > 0 || Tokens.back()->IsMultiline)
 791         FirstInLineIndex = Tokens.size() - 1;
 792     } while (Tokens.back()->Tok.isNot(tok::eof));
 793     return Tokens;
 794   }
 795
 796   const AdditionalKeywords &getKeywords() { return Keywords; }
 797
 798 private:
 799   void tryMergePreviousTokens() {
 800     if (tryMerge_TMacro())
 801       return;
 802     if (tryMergeConflictMarkers())
 803       return;
 804     if (tryMergeLessLess())
 805       return;
 806
 807     if (Style.Language == FormatStyle::LK_JavaScript) {
 808       if (tryMergeTemplateString())
 809         return;
 810
 811       static const tok::TokenKind JSIdentity[] = {tok::equalequal, tok::equal};
 812       static const tok::TokenKind JSNotIdentity[] = {tok::exclaimequal,
 813                                                      tok::equal};
 814       static const tok::TokenKind JSShiftEqual[] = {tok::greater, tok::greater,
 815                                                     tok::greaterequal};
 816       static const tok::TokenKind JSRightArrow[] = {tok::equal, tok::greater};
 817       // FIXME: Investigate what token type gives the correct operator priority.
 818       if (tryMergeTokens(JSIdentity, TT_BinaryOperator))
 819         return;
 820       if (tryMergeTokens(JSNotIdentity, TT_BinaryOperator))
 821         return;
 822       if (tryMergeTokens(JSShiftEqual, TT_BinaryOperator))
 823         return;
 824       if (tryMergeTokens(JSRightArrow, TT_JsFatArrow))
 825         return;
 826     }
 827   }
 828
 829   bool tryMergeLessLess() {
 830     // Merge X,less,less,Y into X,lessless,Y unless X or Y is less.
 831     if (Tokens.size() < 3)
 832       return false;
 833
 834     bool FourthTokenIsLess = false;
 835     if (Tokens.size() > 3)
 836       FourthTokenIsLess = (Tokens.end() - 4)[0]->is(tok::less);
 837
 838     auto First = Tokens.end() - 3;
 839     if (First[2]->is(tok::less) || First[1]->isNot(tok::less) ||
 840         First[0]->isNot(tok::less) || FourthTokenIsLess)
 841       return false;
 842
 843     // Only merge if there currently is no whitespace between the two "<".
 844     if (First[1]->WhitespaceRange.getBegin() !=
 845         First[1]->WhitespaceRange.getEnd())
 846       return false;
 847
 848     First[0]->Tok.setKind(tok::lessless);
 849     First[0]->TokenText = "<<";
 850     First[0]->ColumnWidth += 1;
 851     Tokens.erase(Tokens.end() - 2);
 852     return true;
 853   }
 854
 855   bool tryMergeTokens(ArrayRef<tok::TokenKind> Kinds, TokenType NewType) {
 856     if (Tokens.size() < Kinds.size())
 857       return false;
 858
 859     SmallVectorImpl<FormatToken *>::const_iterator First =
 860         Tokens.end() - Kinds.size();
 861     if (!First[0]->is(Kinds[0]))
 862       return false;
 863     unsigned AddLength = 0;
 864     for (unsigned i = 1; i < Kinds.size(); ++i) {
 865       if (!First[i]->is(Kinds[i]) ||
 866           First[i]->WhitespaceRange.getBegin() !=
 867               First[i]->WhitespaceRange.getEnd())
 868         return false;
 869       AddLength += First[i]->TokenText.size();
 870     }
 871     Tokens.resize(Tokens.size() - Kinds.size() + 1);
 872     First[0]->TokenText = StringRef(First[0]->TokenText.data(),
 873                                     First[0]->TokenText.size() + AddLength);
 874     First[0]->ColumnWidth += AddLength;
 875     First[0]->Type = NewType;
 876     return true;
 877   }
 878
 879   // Returns \c true if \p Tok can only be followed by an operand in JavaScript.
 880   bool precedesOperand(FormatToken *Tok) {
 881     // NB: This is not entirely correct, as an r_paren can introduce an operand
 882     // location in e.g. `if (foo) /bar/.exec(...);`. That is a rare enough
 883     // corner case to not matter in practice, though.
 884     return Tok->isOneOf(tok::period, tok::l_paren, tok::comma, tok::l_brace,
 885                         tok::r_brace, tok::l_square, tok::semi, tok::exclaim,
 886                         tok::colon, tok::question, tok::tilde) ||
 887            Tok->isOneOf(tok::kw_return, tok::kw_do, tok::kw_case, tok::kw_throw,
 888                         tok::kw_else, tok::kw_new, tok::kw_delete, tok::kw_void,
 889                         tok::kw_typeof, Keywords.kw_instanceof,
 890                         Keywords.kw_in) ||
 891            Tok->isBinaryOperator();
 892   }
 893
 894   bool canPrecedeRegexLiteral(FormatToken *Prev) {
 895     if (!Prev)
 896       return true;
 897
 898     // Regex literals can only follow after prefix unary operators, not after
 899     // postfix unary operators. If the '++' is followed by a non-operand
 900     // introducing token, the slash here is the operand and not the start of a
 901     // regex.
 902     if (Prev->isOneOf(tok::plusplus, tok::minusminus))
 903       return (Tokens.size() < 3 || precedesOperand(Tokens[Tokens.size() - 3]));
 904
 905     // The previous token must introduce an operand location where regex
 906     // literals can occur.
 907     if (!precedesOperand(Prev))
 908       return false;
 909
 910     return true;
 911   }
 912
 913   // Tries to parse a JavaScript Regex literal starting at the current token,
 914   // if that begins with a slash and is in a location where JavaScript allows
 915   // regex literals. Changes the current token to a regex literal and updates
 916   // its text if successful.
 917   void tryParseJSRegexLiteral() {
 918     FormatToken *RegexToken = Tokens.back();
 919     if (!RegexToken->isOneOf(tok::slash, tok::slashequal))
 920       return;
 921
 922     FormatToken *Prev = nullptr;
 923     for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; ++I) {
 924       // NB: Because previous pointers are not initialized yet, this cannot use
 925       // Token.getPreviousNonComment.
 926       if ((*I)->isNot(tok::comment)) {
 927         Prev = *I;
 928         break;
 929       }
 930     }
 931
 932     if (!canPrecedeRegexLiteral(Prev))
 933       return;
 934
 935     // 'Manually' lex ahead in the current file buffer.
 936     const char *Offset = Lex->getBufferLocation();
 937     const char *RegexBegin = Offset - RegexToken->TokenText.size();
 938     StringRef Buffer = Lex->getBuffer();
 939     bool InCharacterClass = false;
 940     bool HaveClosingSlash = false;
 941     for (; !HaveClosingSlash && Offset != Buffer.end(); ++Offset) {
 942       // Regular expressions are terminated with a '/', which can only be
 943       // escaped using '\' or a character class between '[' and ']'.
 944       // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.5.
 945       switch (*Offset) {
 946       case '\\':
 947         // Skip the escaped character.
 948         ++Offset;
 949         break;
 950       case '[':
 951         InCharacterClass = true;
 952         break;
 953       case ']':
 954         InCharacterClass = false;
 955         break;
 956       case '/':
 957         if (!InCharacterClass)
 958           HaveClosingSlash = true;
 959         break;
 960       }
 961     }
 962
 963     RegexToken->Type = TT_RegexLiteral;
 964     // Treat regex literals like other string_literals.
 965     RegexToken->Tok.setKind(tok::string_literal);
 966     RegexToken->TokenText = StringRef(RegexBegin, Offset - RegexBegin);
 967     RegexToken->ColumnWidth = RegexToken->TokenText.size();
 968
 969     resetLexer(SourceMgr.getFileOffset(Lex->getSourceLocation(Offset)));
 970   }
 971
 972   bool tryMergeTemplateString() {
 973     if (Tokens.size() < 2)
 974       return false;
 975
 976     FormatToken *EndBacktick = Tokens.back();
 977     // Backticks get lexed as tok::unknown tokens. If a template string contains
 978     // a comment start, it gets lexed as a tok::comment, or tok::unknown if
 979     // unterminated.
 980     if (!EndBacktick->isOneOf(tok::comment, tok::string_literal,
 981                               tok::char_constant, tok::unknown))
 982       return false;
 983     size_t CommentBacktickPos = EndBacktick->TokenText.find('`');
 984     // Unknown token that's not actually a backtick, or a comment that doesn't
 985     // contain a backtick.
 986     if (CommentBacktickPos == StringRef::npos)
 987       return false;
 988
 989     unsigned TokenCount = 0;
 990     bool IsMultiline = false;
 991     unsigned EndColumnInFirstLine =
 992         EndBacktick->OriginalColumn + EndBacktick->ColumnWidth;
 993     for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; I++) {
 994       ++TokenCount;
 995       if (I[0]->IsMultiline)
 996         IsMultiline = true;
 997
 998       // If there was a preceding template string, this must be the start of a
 999       // template string, not the end.
1000       if (I[0]->is(TT_TemplateString))
1001         return false;
1002
1003       if (I[0]->isNot(tok::unknown) || I[0]->TokenText != "`") {
1004         // Keep track of the rhs offset of the last token to wrap across lines -
1005         // its the rhs offset of the first line of the template string, used to
1006         // determine its width.
1007         if (I[0]->IsMultiline)
1008           EndColumnInFirstLine = I[0]->OriginalColumn + I[0]->ColumnWidth;
1009         // If the token has newlines, the token before it (if it exists) is the
1010         // rhs end of the previous line.
1011         if (I[0]->NewlinesBefore > 0 && (I + 1 != E)) {
1012           EndColumnInFirstLine = I[1]->OriginalColumn + I[1]->ColumnWidth;
1013           IsMultiline = true;
1014         }
1015         continue;
1016       }
1017
1018       Tokens.resize(Tokens.size() - TokenCount);
1019       Tokens.back()->Type = TT_TemplateString;
1020       const char *EndOffset =
1021           EndBacktick->TokenText.data() + 1 + CommentBacktickPos;
1022       if (CommentBacktickPos != 0) {
1023         // If the backtick was not the first character (e.g. in a comment),
1024         // re-lex after the backtick position.
1025         SourceLocation Loc = EndBacktick->Tok.getLocation();
1026         resetLexer(SourceMgr.getFileOffset(Loc) + CommentBacktickPos + 1);
1027       }
1028       Tokens.back()->TokenText =
1029           StringRef(Tokens.back()->TokenText.data(),
1030                     EndOffset - Tokens.back()->TokenText.data());
1031
1032       unsigned EndOriginalColumn = EndBacktick->OriginalColumn;
1033       if (EndOriginalColumn == 0) {
1034         SourceLocation Loc = EndBacktick->Tok.getLocation();
1035         EndOriginalColumn = SourceMgr.getSpellingColumnNumber(Loc);
1036       }
1037       // If the ` is further down within the token (e.g. in a comment).
1038       EndOriginalColumn += CommentBacktickPos;
1039
1040       if (IsMultiline) {
1041         // ColumnWidth is from backtick to last token in line.
1042         // LastLineColumnWidth is 0 to backtick.
1043         // x = `some content
1044         //     until here`;
1045         Tokens.back()->ColumnWidth =
1046             EndColumnInFirstLine - Tokens.back()->OriginalColumn;
1047         // +1 for the ` itself.
1048         Tokens.back()->LastLineColumnWidth = EndOriginalColumn + 1;
1049         Tokens.back()->IsMultiline = true;
1050       } else {
1051         // Token simply spans from start to end, +1 for the ` itself.
1052         Tokens.back()->ColumnWidth =
1053             EndOriginalColumn - Tokens.back()->OriginalColumn + 1;
1054       }
1055       return true;
1056     }
1057     return false;
1058   }
1059
1060   bool tryMerge_TMacro() {
1061     if (Tokens.size() < 4)
1062       return false;
1063     FormatToken *Last = Tokens.back();
1064     if (!Last->is(tok::r_paren))
1065       return false;
1066
1067     FormatToken *String = Tokens[Tokens.size() - 2];
1068     if (!String->is(tok::string_literal) || String->IsMultiline)
1069       return false;
1070
1071     if (!Tokens[Tokens.size() - 3]->is(tok::l_paren))
1072       return false;
1073
1074     FormatToken *Macro = Tokens[Tokens.size() - 4];
1075     if (Macro->TokenText != "_T")
1076       return false;
1077
1078     const char *Start = Macro->TokenText.data();
1079     const char *End = Last->TokenText.data() + Last->TokenText.size();
1080     String->TokenText = StringRef(Start, End - Start);
1081     String->IsFirst = Macro->IsFirst;
1082     String->LastNewlineOffset = Macro->LastNewlineOffset;
1083     String->WhitespaceRange = Macro->WhitespaceRange;
1084     String->OriginalColumn = Macro->OriginalColumn;
1085     String->ColumnWidth = encoding::columnWidthWithTabs(
1086         String->TokenText, String->OriginalColumn, Style.TabWidth, Encoding);
1087     String->NewlinesBefore = Macro->NewlinesBefore;
1088     String->HasUnescapedNewline = Macro->HasUnescapedNewline;
1089
1090     Tokens.pop_back();
1091     Tokens.pop_back();
1092     Tokens.pop_back();
1093     Tokens.back() = String;
1094     return true;
1095   }
1096
1097   bool tryMergeConflictMarkers() {
1098     if (Tokens.back()->NewlinesBefore == 0 && Tokens.back()->isNot(tok::eof))
1099       return false;
1100
1101     // Conflict lines look like:
1102     // <marker> <text from the vcs>
1103     // For example:
1104     // >>>>>>> /file/in/file/system at revision 1234
1105     //
1106     // We merge all tokens in a line that starts with a conflict marker
1107     // into a single token with a special token type that the unwrapped line
1108     // parser will use to correctly rebuild the underlying code.
1109
1110     FileID ID;
1111     // Get the position of the first token in the line.
1112     unsigned FirstInLineOffset;
1113     std::tie(ID, FirstInLineOffset) = SourceMgr.getDecomposedLoc(
1114         Tokens[FirstInLineIndex]->getStartOfNonWhitespace());
1115     StringRef Buffer = SourceMgr.getBuffer(ID)->getBuffer();
1116     // Calculate the offset of the start of the current line.
1117     auto LineOffset = Buffer.rfind('\n', FirstInLineOffset);
1118     if (LineOffset == StringRef::npos) {
1119       LineOffset = 0;
1120     } else {
1121       ++LineOffset;
1122     }
1123
1124     auto FirstSpace = Buffer.find_first_of(" \n", LineOffset);
1125     StringRef LineStart;
1126     if (FirstSpace == StringRef::npos) {
1127       LineStart = Buffer.substr(LineOffset);
1128     } else {
1129       LineStart = Buffer.substr(LineOffset, FirstSpace - LineOffset);
1130     }
1131
1132     TokenType Type = TT_Unknown;
1133     if (LineStart == "<<<<<<<" || LineStart == ">>>>") {
1134       Type = TT_ConflictStart;
1135     } else if (LineStart == "|||||||" || LineStart == "=======" ||
1136                LineStart == "====") {
1137       Type = TT_ConflictAlternative;
1138     } else if (LineStart == ">>>>>>>" || LineStart == "<<<<") {
1139       Type = TT_ConflictEnd;
1140     }
1141
1142     if (Type != TT_Unknown) {
1143       FormatToken *Next = Tokens.back();
1144
1145       Tokens.resize(FirstInLineIndex + 1);
1146       // We do not need to build a complete token here, as we will skip it
1147       // during parsing anyway (as we must not touch whitespace around conflict
1148       // markers).
1149       Tokens.back()->Type = Type;
1150       Tokens.back()->Tok.setKind(tok::kw___unknown_anytype);
1151
1152       Tokens.push_back(Next);
1153       return true;
1154     }
1155
1156     return false;
1157   }
1158
1159   FormatToken *getStashedToken() {
1160     // Create a synthesized second '>' or '<' token.
1161     Token Tok = FormatTok->Tok;
1162     StringRef TokenText = FormatTok->TokenText;
1163
1164     unsigned OriginalColumn = FormatTok->OriginalColumn;
1165     FormatTok = new (Allocator.Allocate()) FormatToken;
1166     FormatTok->Tok = Tok;
1167     SourceLocation TokLocation =
1168         FormatTok->Tok.getLocation().getLocWithOffset(Tok.getLength() - 1);
1169     FormatTok->Tok.setLocation(TokLocation);
1170     FormatTok->WhitespaceRange = SourceRange(TokLocation, TokLocation);
1171     FormatTok->TokenText = TokenText;
1172     FormatTok->ColumnWidth = 1;
1173     FormatTok->OriginalColumn = OriginalColumn + 1;
1174
1175     return FormatTok;
1176   }
1177
1178   FormatToken *getNextToken() {
1179     if (GreaterStashed) {
1180       GreaterStashed = false;
1181       return getStashedToken();
1182     }
1183     if (LessStashed) {
1184       LessStashed = false;
1185       return getStashedToken();
1186     }
1187
1188     FormatTok = new (Allocator.Allocate()) FormatToken;
1189     readRawToken(*FormatTok);
1190     SourceLocation WhitespaceStart =
1191         FormatTok->Tok.getLocation().getLocWithOffset(-TrailingWhitespace);
1192     FormatTok->IsFirst = IsFirstToken;
1193     IsFirstToken = false;
1194
1195     // Consume and record whitespace until we find a significant token.
1196     unsigned WhitespaceLength = TrailingWhitespace;
1197     while (FormatTok->Tok.is(tok::unknown)) {
1198       StringRef Text = FormatTok->TokenText;
1199       auto EscapesNewline = [&](int pos) {
1200         // A '\r' here is just part of '\r\n'. Skip it.
1201         if (pos >= 0 && Text[pos] == '\r')
1202           --pos;
1203         // See whether there is an odd number of '\' before this.
1204         unsigned count = 0;
1205         for (; pos >= 0; --pos, ++count)
1206           if (Text[pos] != '\\')
1207             break;
1208         return count & 1;
1209       };
1210       // FIXME: This miscounts tok:unknown tokens that are not just
1211       // whitespace, e.g. a '`' character.
1212       for (int i = 0, e = Text.size(); i != e; ++i) {
1213         switch (Text[i]) {
1214         case '\n':
1215           ++FormatTok->NewlinesBefore;
1216           FormatTok->HasUnescapedNewline = !EscapesNewline(i - 1);
1217           FormatTok->LastNewlineOffset = WhitespaceLength + i + 1;
1218           Column = 0;
1219           break;
1220         case '\r':
1221           FormatTok->LastNewlineOffset = WhitespaceLength + i + 1;
1222           Column = 0;
1223           break;
1224         case '\f':
1225         case '\v':
1226           Column = 0;
1227           break;
1228         case ' ':
1229           ++Column;
1230           break;
1231         case '\t':
1232           Column += Style.TabWidth - Column % Style.TabWidth;
1233           break;
1234         case '\\':
1235           if (i + 1 == e || (Text[i + 1] != '\r' && Text[i + 1] != '\n'))
1236             FormatTok->Type = TT_ImplicitStringLiteral;
1237           break;
1238         default:
1239           FormatTok->Type = TT_ImplicitStringLiteral;
1240           break;
1241         }
1242         if (FormatTok->Type == TT_ImplicitStringLiteral)
1243           break;
1244       }
1245
1246       if (FormatTok->is(TT_ImplicitStringLiteral))
1247         break;
1248       WhitespaceLength += FormatTok->Tok.getLength();
1249
1250       readRawToken(*FormatTok);
1251     }
1252
1253     // In case the token starts with escaped newlines, we want to
1254     // take them into account as whitespace - this pattern is quite frequent
1255     // in macro definitions.
1256     // FIXME: Add a more explicit test.
1257     while (FormatTok->TokenText.size() > 1 && FormatTok->TokenText[0] == '\\' &&
1258            FormatTok->TokenText[1] == '\n') {
1259       ++FormatTok->NewlinesBefore;
1260       WhitespaceLength += 2;
1261       FormatTok->LastNewlineOffset = 2;
1262       Column = 0;
1263       FormatTok->TokenText = FormatTok->TokenText.substr(2);
1264     }
1265
1266     FormatTok->WhitespaceRange = SourceRange(
1267         WhitespaceStart, WhitespaceStart.getLocWithOffset(WhitespaceLength));
1268
1269     FormatTok->OriginalColumn = Column;
1270
1271     TrailingWhitespace = 0;
1272     if (FormatTok->Tok.is(tok::comment)) {
1273       // FIXME: Add the trimmed whitespace to Column.
1274       StringRef UntrimmedText = FormatTok->TokenText;
1275       FormatTok->TokenText = FormatTok->TokenText.rtrim(" \t\v\f");
1276       TrailingWhitespace = UntrimmedText.size() - FormatTok->TokenText.size();
1277     } else if (FormatTok->Tok.is(tok::raw_identifier)) {
1278       IdentifierInfo &Info = IdentTable.get(FormatTok->TokenText);
1279       FormatTok->Tok.setIdentifierInfo(&Info);
1280       FormatTok->Tok.setKind(Info.getTokenID());
1281       if (Style.Language == FormatStyle::LK_Java &&
1282           FormatTok->isOneOf(tok::kw_struct, tok::kw_union, tok::kw_delete,
1283                              tok::kw_operator)) {
1284         FormatTok->Tok.setKind(tok::identifier);
1285         FormatTok->Tok.setIdentifierInfo(nullptr);
1286       } else if (Style.Language == FormatStyle::LK_JavaScript &&
1287                  FormatTok->isOneOf(tok::kw_struct, tok::kw_union,
1288                                     tok::kw_operator)) {
1289         FormatTok->Tok.setKind(tok::identifier);
1290         FormatTok->Tok.setIdentifierInfo(nullptr);
1291       }
1292     } else if (FormatTok->Tok.is(tok::greatergreater)) {
1293       FormatTok->Tok.setKind(tok::greater);
1294       FormatTok->TokenText = FormatTok->TokenText.substr(0, 1);
1295       GreaterStashed = true;
1296     } else if (FormatTok->Tok.is(tok::lessless)) {
1297       FormatTok->Tok.setKind(tok::less);
1298       FormatTok->TokenText = FormatTok->TokenText.substr(0, 1);
1299       LessStashed = true;
1300     }
1301
1302     // Now FormatTok is the next non-whitespace token.
1303
1304     StringRef Text = FormatTok->TokenText;
1305     size_t FirstNewlinePos = Text.find('\n');
1306     if (FirstNewlinePos == StringRef::npos) {
1307       // FIXME: ColumnWidth actually depends on the start column, we need to
1308       // take this into account when the token is moved.
1309       FormatTok->ColumnWidth =
1310           encoding::columnWidthWithTabs(Text, Column, Style.TabWidth, Encoding);
1311       Column += FormatTok->ColumnWidth;
1312     } else {
1313       FormatTok->IsMultiline = true;
1314       // FIXME: ColumnWidth actually depends on the start column, we need to
1315       // take this into account when the token is moved.
1316       FormatTok->ColumnWidth = encoding::columnWidthWithTabs(
1317           Text.substr(0, FirstNewlinePos), Column, Style.TabWidth, Encoding);
1318
1319       // The last line of the token always starts in column 0.
1320       // Thus, the length can be precomputed even in the presence of tabs.
1321       FormatTok->LastLineColumnWidth = encoding::columnWidthWithTabs(
1322           Text.substr(Text.find_last_of('\n') + 1), 0, Style.TabWidth,
1323           Encoding);
1324       Column = FormatTok->LastLineColumnWidth;
1325     }
1326
1327     if (Style.Language == FormatStyle::LK_Cpp) {
1328       if (!(Tokens.size() > 0 && Tokens.back()->Tok.getIdentifierInfo() &&
1329             Tokens.back()->Tok.getIdentifierInfo()->getPPKeywordID() ==
1330                 tok::pp_define) &&
1331           std::find(ForEachMacros.begin(), ForEachMacros.end(),
1332                     FormatTok->Tok.getIdentifierInfo()) != ForEachMacros.end()) {
1333         FormatTok->Type = TT_ForEachMacro;
1334       } else if (FormatTok->is(tok::identifier)) {
1335         if (MacroBlockBeginRegex.match(Text)) {
1336           FormatTok->Type = TT_MacroBlockBegin;
1337         } else if (MacroBlockEndRegex.match(Text)) {
1338           FormatTok->Type = TT_MacroBlockEnd;
1339         }
1340       }
1341     }
1342
1343     return FormatTok;
1344   }
1345
1346   FormatToken *FormatTok;
1347   bool IsFirstToken;
1348   bool GreaterStashed, LessStashed;
1349   unsigned Column;
1350   unsigned TrailingWhitespace;
1351   std::unique_ptr<Lexer> Lex;
1352   SourceManager &SourceMgr;
1353   FileID ID;
1354   FormatStyle &Style;
1355   IdentifierTable IdentTable;
1356   AdditionalKeywords Keywords;
1357   encoding::Encoding Encoding;
1358   llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
1359   // Index (in 'Tokens') of the last token that starts a new line.
1360   unsigned FirstInLineIndex;
1361   SmallVector<FormatToken *, 16> Tokens;
1362   SmallVector<IdentifierInfo *, 8> ForEachMacros;
1363
1364   bool FormattingDisabled;
1365
1366   llvm::Regex MacroBlockBeginRegex;
1367   llvm::Regex MacroBlockEndRegex;
1368
1369   void readRawToken(FormatToken &Tok) {
1370     Lex->LexFromRawLexer(Tok.Tok);
1371     Tok.TokenText = StringRef(SourceMgr.getCharacterData(Tok.Tok.getLocation()),
1372                               Tok.Tok.getLength());
1373     // For formatting, treat unterminated string literals like normal string
1374     // literals.
1375     if (Tok.is(tok::unknown)) {
1376       if (!Tok.TokenText.empty() && Tok.TokenText[0] == '"') {
1377         Tok.Tok.setKind(tok::string_literal);
1378         Tok.IsUnterminatedLiteral = true;
1379       } else if (Style.Language == FormatStyle::LK_JavaScript &&
1380                  Tok.TokenText == "''") {
1381         Tok.Tok.setKind(tok::char_constant);
1382       }
1383     }
1384
1385     if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format on" ||
1386                                  Tok.TokenText == "/* clang-format on */")) {
1387       FormattingDisabled = false;
1388     }
1389
1390     Tok.Finalized = FormattingDisabled;
1391
1392     if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format off" ||
1393                                  Tok.TokenText == "/* clang-format off */")) {
1394       FormattingDisabled = true;
1395     }
1396   }
1397
1398   void resetLexer(unsigned Offset) {
1399     StringRef Buffer = SourceMgr.getBufferData(ID);
1400     Lex.reset(new Lexer(SourceMgr.getLocForStartOfFile(ID),
1401                         getFormattingLangOpts(Style), Buffer.begin(),
1402                         Buffer.begin() + Offset, Buffer.end()));
1403     Lex->SetKeepWhitespaceMode(true);
1404     TrailingWhitespace = 0;
1405   }
1406 };
1407
1408 static StringRef getLanguageName(FormatStyle::LanguageKind Language) {
1409   switch (Language) {
1410   case FormatStyle::LK_Cpp:
1411     return "C++";
1412   case FormatStyle::LK_Java:
1413     return "Java";
1414   case FormatStyle::LK_JavaScript:
1415     return "JavaScript";
1416   case FormatStyle::LK_Proto:
1417     return "Proto";
1418   default:
1419     return "Unknown";
1420   }
1421 }
1422
1423 class Formatter : public UnwrappedLineConsumer {
1424 public:
1425   Formatter(const FormatStyle &Style, SourceManager &SourceMgr, FileID ID,
1426             ArrayRef<CharSourceRange> Ranges)
1427       : Style(Style), ID(ID), SourceMgr(SourceMgr),
1428         Whitespaces(SourceMgr, Style,
1429                     inputUsesCRLF(SourceMgr.getBufferData(ID))),
1430         Ranges(Ranges.begin(), Ranges.end()), UnwrappedLines(1),
1431         Encoding(encoding::detectEncoding(SourceMgr.getBufferData(ID))) {
1432     DEBUG(llvm::dbgs() << "File encoding: "
1433                        << (Encoding == encoding::Encoding_UTF8 ? "UTF8"
1434                                                                : "unknown")
1435                        << "\n");
1436     DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language)
1437                        << "\n");
1438   }
1439
1440   tooling::Replacements format(bool *IncompleteFormat) {
1441     tooling::Replacements Result;
1442     FormatTokenLexer Tokens(SourceMgr, ID, Style, Encoding);
1443
1444     UnwrappedLineParser Parser(Style, Tokens.getKeywords(), Tokens.lex(),
1445                                *this);
1446     Parser.parse();
1447     assert(UnwrappedLines.rbegin()->empty());
1448     for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE;
1449          ++Run) {
1450       DEBUG(llvm::dbgs() << "Run " << Run << "...\n");
1451       SmallVector<AnnotatedLine *, 16> AnnotatedLines;
1452       for (unsigned i = 0, e = UnwrappedLines[Run].size(); i != e; ++i) {
1453         AnnotatedLines.push_back(new AnnotatedLine(UnwrappedLines[Run][i]));
1454       }
1455       tooling::Replacements RunResult =
1456           format(AnnotatedLines, Tokens, IncompleteFormat);
1457       DEBUG({
1458         llvm::dbgs() << "Replacements for run " << Run << ":\n";
1459         for (tooling::Replacements::iterator I = RunResult.begin(),
1460                                              E = RunResult.end();
1461              I != E; ++I) {
1462           llvm::dbgs() << I->toString() << "\n";
1463         }
1464       });
1465       for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1466         delete AnnotatedLines[i];
1467       }
1468       Result.insert(RunResult.begin(), RunResult.end());
1469       Whitespaces.reset();
1470     }
1471     return Result;
1472   }
1473
1474   tooling::Replacements format(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1475                                FormatTokenLexer &Tokens,
1476                                bool *IncompleteFormat) {
1477     TokenAnnotator Annotator(Style, Tokens.getKeywords());
1478     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1479       Annotator.annotate(*AnnotatedLines[i]);
1480     }
1481     deriveLocalStyle(AnnotatedLines);
1482     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1483       Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
1484     }
1485     computeAffectedLines(AnnotatedLines.begin(), AnnotatedLines.end());
1486
1487     Annotator.setCommentLineLevels(AnnotatedLines);
1488     ContinuationIndenter Indenter(Style, Tokens.getKeywords(), SourceMgr,
1489                                   Whitespaces, Encoding,
1490                                   BinPackInconclusiveFunctions);
1491     UnwrappedLineFormatter(&Indenter, &Whitespaces, Style, Tokens.getKeywords(),
1492                            IncompleteFormat)
1493         .format(AnnotatedLines);
1494     return Whitespaces.generateReplacements();
1495   }
1496
1497 private:
1498   // Determines which lines are affected by the SourceRanges given as input.
1499   // Returns \c true if at least one line between I and E or one of their
1500   // children is affected.
1501   bool computeAffectedLines(SmallVectorImpl<AnnotatedLine *>::iterator I,
1502                             SmallVectorImpl<AnnotatedLine *>::iterator E) {
1503     bool SomeLineAffected = false;
1504     const AnnotatedLine *PreviousLine = nullptr;
1505     while (I != E) {
1506       AnnotatedLine *Line = *I;
1507       Line->LeadingEmptyLinesAffected = affectsLeadingEmptyLines(*Line->First);
1508
1509       // If a line is part of a preprocessor directive, it needs to be formatted
1510       // if any token within the directive is affected.
1511       if (Line->InPPDirective) {
1512         FormatToken *Last = Line->Last;
1513         SmallVectorImpl<AnnotatedLine *>::iterator PPEnd = I + 1;
1514         while (PPEnd != E && !(*PPEnd)->First->HasUnescapedNewline) {
1515           Last = (*PPEnd)->Last;
1516           ++PPEnd;
1517         }
1518
1519         if (affectsTokenRange(*Line->First, *Last,
1520                               /*IncludeLeadingNewlines=*/false)) {
1521           SomeLineAffected = true;
1522           markAllAsAffected(I, PPEnd);
1523         }
1524         I = PPEnd;
1525         continue;
1526       }
1527
1528       if (nonPPLineAffected(Line, PreviousLine))
1529         SomeLineAffected = true;
1530
1531       PreviousLine = Line;
1532       ++I;
1533     }
1534     return SomeLineAffected;
1535   }
1536
1537   // Determines whether 'Line' is affected by the SourceRanges given as input.
1538   // Returns \c true if line or one if its children is affected.
1539   bool nonPPLineAffected(AnnotatedLine *Line,
1540                          const AnnotatedLine *PreviousLine) {
1541     bool SomeLineAffected = false;
1542     Line->ChildrenAffected =
1543         computeAffectedLines(Line->Children.begin(), Line->Children.end());
1544     if (Line->ChildrenAffected)
1545       SomeLineAffected = true;
1546
1547     // Stores whether one of the line's tokens is directly affected.
1548     bool SomeTokenAffected = false;
1549     // Stores whether we need to look at the leading newlines of the next token
1550     // in order to determine whether it was affected.
1551     bool IncludeLeadingNewlines = false;
1552
1553     // Stores whether the first child line of any of this line's tokens is
1554     // affected.
1555     bool SomeFirstChildAffected = false;
1556
1557     for (FormatToken *Tok = Line->First; Tok; Tok = Tok->Next) {
1558       // Determine whether 'Tok' was affected.
1559       if (affectsTokenRange(*Tok, *Tok, IncludeLeadingNewlines))
1560         SomeTokenAffected = true;
1561
1562       // Determine whether the first child of 'Tok' was affected.
1563       if (!Tok->Children.empty() && Tok->Children.front()->Affected)
1564         SomeFirstChildAffected = true;
1565
1566       IncludeLeadingNewlines = Tok->Children.empty();
1567     }
1568
1569     // Was this line moved, i.e. has it previously been on the same line as an
1570     // affected line?
1571     bool LineMoved = PreviousLine && PreviousLine->Affected &&
1572                      Line->First->NewlinesBefore == 0;
1573
1574     bool IsContinuedComment =
1575         Line->First->is(tok::comment) && Line->First->Next == nullptr &&
1576         Line->First->NewlinesBefore < 2 && PreviousLine &&
1577         PreviousLine->Affected && PreviousLine->Last->is(tok::comment);
1578
1579     if (SomeTokenAffected || SomeFirstChildAffected || LineMoved ||
1580         IsContinuedComment) {
1581       Line->Affected = true;
1582       SomeLineAffected = true;
1583     }
1584     return SomeLineAffected;
1585   }
1586
1587   // Marks all lines between I and E as well as all their children as affected.
1588   void markAllAsAffected(SmallVectorImpl<AnnotatedLine *>::iterator I,
1589                          SmallVectorImpl<AnnotatedLine *>::iterator E) {
1590     while (I != E) {
1591       (*I)->Affected = true;
1592       markAllAsAffected((*I)->Children.begin(), (*I)->Children.end());
1593       ++I;
1594     }
1595   }
1596
1597   // Returns true if the range from 'First' to 'Last' intersects with one of the
1598   // input ranges.
1599   bool affectsTokenRange(const FormatToken &First, const FormatToken &Last,
1600                          bool IncludeLeadingNewlines) {
1601     SourceLocation Start = First.WhitespaceRange.getBegin();
1602     if (!IncludeLeadingNewlines)
1603       Start = Start.getLocWithOffset(First.LastNewlineOffset);
1604     SourceLocation End = Last.getStartOfNonWhitespace();
1605     End = End.getLocWithOffset(Last.TokenText.size());
1606     CharSourceRange Range = CharSourceRange::getCharRange(Start, End);
1607     return affectsCharSourceRange(Range);
1608   }
1609
1610   // Returns true if one of the input ranges intersect the leading empty lines
1611   // before 'Tok'.
1612   bool affectsLeadingEmptyLines(const FormatToken &Tok) {
1613     CharSourceRange EmptyLineRange = CharSourceRange::getCharRange(
1614         Tok.WhitespaceRange.getBegin(),
1615         Tok.WhitespaceRange.getBegin().getLocWithOffset(Tok.LastNewlineOffset));
1616     return affectsCharSourceRange(EmptyLineRange);
1617   }
1618
1619   // Returns true if 'Range' intersects with one of the input ranges.
1620   bool affectsCharSourceRange(const CharSourceRange &Range) {
1621     for (SmallVectorImpl<CharSourceRange>::const_iterator I = Ranges.begin(),
1622                                                           E = Ranges.end();
1623          I != E; ++I) {
1624       if (!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(), I->getBegin()) &&
1625           !SourceMgr.isBeforeInTranslationUnit(I->getEnd(), Range.getBegin()))
1626         return true;
1627     }
1628     return false;
1629   }
1630
1631   static bool inputUsesCRLF(StringRef Text) {
1632     return Text.count('\r') * 2 > Text.count('\n');
1633   }
1634
1635   bool
1636   hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
1637     for (const AnnotatedLine* Line : Lines) {
1638       if (hasCpp03IncompatibleFormat(Line->Children))
1639         return true;
1640       for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
1641         if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
1642           if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
1643             return true;
1644           if (Tok->is(TT_TemplateCloser) &&
1645               Tok->Previous->is(TT_TemplateCloser))
1646             return true;
1647         }
1648       }
1649     }
1650     return false;
1651   }
1652
1653   int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
1654     int AlignmentDiff = 0;
1655     for (const AnnotatedLine* Line : Lines) {
1656       AlignmentDiff += countVariableAlignments(Line->Children);
1657       for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
1658         if (!Tok->is(TT_PointerOrReference))
1659           continue;
1660         bool SpaceBefore =
1661             Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
1662         bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
1663                           Tok->Next->WhitespaceRange.getEnd();
1664         if (SpaceBefore && !SpaceAfter)
1665           ++AlignmentDiff;
1666         if (!SpaceBefore && SpaceAfter)
1667           --AlignmentDiff;
1668       }
1669     }
1670     return AlignmentDiff;
1671   }
1672
1673   void
1674   deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
1675     bool HasBinPackedFunction = false;
1676     bool HasOnePerLineFunction = false;
1677     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1678       if (!AnnotatedLines[i]->First->Next)
1679         continue;
1680       FormatToken *Tok = AnnotatedLines[i]->First->Next;
1681       while (Tok->Next) {
1682         if (Tok->PackingKind == PPK_BinPacked)
1683           HasBinPackedFunction = true;
1684         if (Tok->PackingKind == PPK_OnePerLine)
1685           HasOnePerLineFunction = true;
1686
1687         Tok = Tok->Next;
1688       }
1689     }
1690     if (Style.DerivePointerAlignment)
1691       Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
1692                                    ? FormatStyle::PAS_Left
1693                                    : FormatStyle::PAS_Right;
1694     if (Style.Standard == FormatStyle::LS_Auto)
1695       Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
1696                            ? FormatStyle::LS_Cpp11
1697                            : FormatStyle::LS_Cpp03;
1698     BinPackInconclusiveFunctions =
1699         HasBinPackedFunction || !HasOnePerLineFunction;
1700   }
1701
1702   void consumeUnwrappedLine(const UnwrappedLine &TheLine) override {
1703     assert(!UnwrappedLines.empty());
1704     UnwrappedLines.back().push_back(TheLine);
1705   }
1706
1707   void finishRun() override {
1708     UnwrappedLines.push_back(SmallVector<UnwrappedLine, 16>());
1709   }
1710
1711   FormatStyle Style;
1712   FileID ID;
1713   SourceManager &SourceMgr;
1714   WhitespaceManager Whitespaces;
1715   SmallVector<CharSourceRange, 8> Ranges;
1716   SmallVector<SmallVector<UnwrappedLine, 16>, 2> UnwrappedLines;
1717
1718   encoding::Encoding Encoding;
1719   bool BinPackInconclusiveFunctions;
1720 };
1721
1722 struct IncludeDirective {
1723   StringRef Filename;
1724   StringRef Text;
1725   unsigned Offset;
1726   int Category;
1727 };
1728
1729 } // end anonymous namespace
1730
1731 // Determines whether 'Ranges' intersects with ('Start', 'End').
1732 static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
1733                          unsigned End) {
1734   for (auto Range : Ranges) {
1735     if (Range.getOffset() < End &&
1736         Range.getOffset() + Range.getLength() > Start)
1737       return true;
1738   }
1739   return false;
1740 }
1741
1742 // Sorts a block of includes given by 'Includes' alphabetically adding the
1743 // necessary replacement to 'Replaces'. 'Includes' must be in strict source
1744 // order.
1745 static void sortIncludes(const FormatStyle &Style,
1746                          const SmallVectorImpl<IncludeDirective> &Includes,
1747                          ArrayRef<tooling::Range> Ranges, StringRef FileName,
1748                          tooling::Replacements &Replaces, unsigned *Cursor) {
1749   if (!affectsRange(Ranges, Includes.front().Offset,
1750                     Includes.back().Offset + Includes.back().Text.size()))
1751     return;
1752   SmallVector<unsigned, 16> Indices;
1753   for (unsigned i = 0, e = Includes.size(); i != e; ++i)
1754     Indices.push_back(i);
1755   std::sort(Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
1756     return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
1757            std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
1758   });
1759
1760   // If the #includes are out of order, we generate a single replacement fixing
1761   // the entire block. Otherwise, no replacement is generated.
1762   bool OutOfOrder = false;
1763   for (unsigned i = 1, e = Indices.size(); i != e; ++i) {
1764     if (Indices[i] != i) {
1765       OutOfOrder = true;
1766       break;
1767     }
1768   }
1769   if (!OutOfOrder)
1770     return;
1771
1772   std::string result;
1773   bool CursorMoved = false;
1774   for (unsigned Index : Indices) {
1775     if (!result.empty())
1776       result += "\n";
1777     result += Includes[Index].Text;
1778
1779     if (Cursor && !CursorMoved) {
1780       unsigned Start = Includes[Index].Offset;
1781       unsigned End = Start + Includes[Index].Text.size();
1782       if (*Cursor >= Start && *Cursor < End) {
1783         *Cursor = Includes.front().Offset + result.size() + *Cursor - End;
1784         CursorMoved = true;
1785       }
1786     }
1787   }
1788
1789   // Sorting #includes shouldn't change their total number of characters.
1790   // This would otherwise mess up 'Ranges'.
1791   assert(result.size() ==
1792          Includes.back().Offset + Includes.back().Text.size() -
1793              Includes.front().Offset);
1794
1795   Replaces.insert(tooling::Replacement(FileName, Includes.front().Offset,
1796                                        result.size(), result));
1797 }
1798
1799 tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
1800                                    ArrayRef<tooling::Range> Ranges,
1801                                    StringRef FileName, unsigned *Cursor) {
1802   tooling::Replacements Replaces;
1803   if (!Style.SortIncludes)
1804     return Replaces;
1805
1806   unsigned Prev = 0;
1807   unsigned SearchFrom = 0;
1808   llvm::Regex IncludeRegex(
1809       R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))");
1810   SmallVector<StringRef, 4> Matches;
1811   SmallVector<IncludeDirective, 16> IncludesInBlock;
1812
1813   // In compiled files, consider the first #include to be the main #include of
1814   // the file if it is not a system #include. This ensures that the header
1815   // doesn't have hidden dependencies
1816   // (http://llvm.org/docs/CodingStandards.html#include-style).
1817   //
1818   // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
1819   // cases where the first #include is unlikely to be the main header.
1820   bool IsSource = FileName.endswith(".c") || FileName.endswith(".cc") ||
1821                   FileName.endswith(".cpp") || FileName.endswith(".c++") ||
1822                   FileName.endswith(".cxx") || FileName.endswith(".m") ||
1823                   FileName.endswith(".mm");
1824   StringRef FileStem = llvm::sys::path::stem(FileName);
1825   bool FirstIncludeBlock = true;
1826   bool MainIncludeFound = false;
1827
1828   // Create pre-compiled regular expressions for the #include categories.
1829   SmallVector<llvm::Regex, 4> CategoryRegexs;
1830   for (const auto &Category : Style.IncludeCategories)
1831     CategoryRegexs.emplace_back(Category.Regex);
1832
1833   bool FormattingOff = false;
1834
1835   for (;;) {
1836     auto Pos = Code.find('\n', SearchFrom);
1837     StringRef Line =
1838         Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
1839
1840     StringRef Trimmed = Line.trim();
1841     if (Trimmed == "// clang-format off")
1842       FormattingOff = true;
1843     else if (Trimmed == "// clang-format on")
1844       FormattingOff = false;
1845
1846     if (!FormattingOff && !Line.endswith("\\")) {
1847       if (IncludeRegex.match(Line, &Matches)) {
1848         StringRef IncludeName = Matches[2];
1849         int Category = INT_MAX;
1850         for (unsigned i = 0, e = CategoryRegexs.size(); i != e; ++i) {
1851           if (CategoryRegexs[i].match(IncludeName)) {
1852             Category = Style.IncludeCategories[i].Priority;
1853             break;
1854           }
1855         }
1856         if (IsSource && !MainIncludeFound && Category > 0 &&
1857             FirstIncludeBlock && IncludeName.startswith("\"")) {
1858           StringRef HeaderStem =
1859               llvm::sys::path::stem(IncludeName.drop_front(1).drop_back(1));
1860           if (FileStem.startswith(HeaderStem)) {
1861             Category = 0;
1862             MainIncludeFound = true;
1863           }
1864         }
1865         IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
1866       } else if (!IncludesInBlock.empty()) {
1867         sortIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
1868                      Cursor);
1869         IncludesInBlock.clear();
1870         FirstIncludeBlock = false;
1871       }
1872       Prev = Pos + 1;
1873     }
1874     if (Pos == StringRef::npos || Pos + 1 == Code.size())
1875       break;
1876     SearchFrom = Pos + 1;
1877   }
1878   if (!IncludesInBlock.empty())
1879     sortIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
1880   return Replaces;
1881 }
1882
1883 tooling::Replacements reformat(const FormatStyle &Style,
1884                                SourceManager &SourceMgr, FileID ID,
1885                                ArrayRef<CharSourceRange> Ranges,
1886                                bool *IncompleteFormat) {
1887   FormatStyle Expanded = expandPresets(Style);
1888   if (Expanded.DisableFormat)
1889     return tooling::Replacements();
1890   Formatter formatter(Expanded, SourceMgr, ID, Ranges);
1891   return formatter.format(IncompleteFormat);
1892 }
1893
1894 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
1895                                ArrayRef<tooling::Range> Ranges,
1896                                StringRef FileName, bool *IncompleteFormat) {
1897   if (Style.DisableFormat)
1898     return tooling::Replacements();
1899
1900   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
1901       new vfs::InMemoryFileSystem);
1902   FileManager Files(FileSystemOptions(), InMemoryFileSystem);
1903   DiagnosticsEngine Diagnostics(
1904       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
1905       new DiagnosticOptions);
1906   SourceManager SourceMgr(Diagnostics, Files);
1907   InMemoryFileSystem->addFile(
1908       FileName, 0, llvm::MemoryBuffer::getMemBuffer(
1909                        Code, FileName, /*RequiresNullTerminator=*/false));
1910   FileID ID = SourceMgr.createFileID(Files.getFile(FileName), SourceLocation(),
1911                                      clang::SrcMgr::C_User);
1912   SourceLocation StartOfFile = SourceMgr.getLocForStartOfFile(ID);
1913   std::vector<CharSourceRange> CharRanges;
1914   for (const tooling::Range &Range : Ranges) {
1915     SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
1916     SourceLocation End = Start.getLocWithOffset(Range.getLength());
1917     CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
1918   }
1919   return reformat(Style, SourceMgr, ID, CharRanges, IncompleteFormat);
1920 }
1921
1922 LangOptions getFormattingLangOpts(const FormatStyle &Style) {
1923   LangOptions LangOpts;
1924   LangOpts.CPlusPlus = 1;
1925   LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
1926   LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
1927   LangOpts.LineComment = 1;
1928   bool AlternativeOperators = Style.Language == FormatStyle::LK_Cpp;
1929   LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
1930   LangOpts.Bool = 1;
1931   LangOpts.ObjC1 = 1;
1932   LangOpts.ObjC2 = 1;
1933   LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
1934   LangOpts.DeclSpecKeyword = 1; // To get __declspec.
1935   return LangOpts;
1936 }
1937
1938 const char *StyleOptionHelpDescription =
1939     "Coding style, currently supports:\n"
1940     "  LLVM, Google, Chromium, Mozilla, WebKit.\n"
1941     "Use -style=file to load style configuration from\n"
1942     ".clang-format file located in one of the parent\n"
1943     "directories of the source file (or current\n"
1944     "directory for stdin).\n"
1945     "Use -style=\"{key: value, ...}\" to set specific\n"
1946     "parameters, e.g.:\n"
1947     "  -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
1948
1949 static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
1950   if (FileName.endswith(".java"))
1951     return FormatStyle::LK_Java;
1952   if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
1953     return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
1954   if (FileName.endswith_lower(".proto") ||
1955       FileName.endswith_lower(".protodevel"))
1956     return FormatStyle::LK_Proto;
1957   if (FileName.endswith_lower(".td"))
1958     return FormatStyle::LK_TableGen;
1959   return FormatStyle::LK_Cpp;
1960 }
1961
1962 FormatStyle getStyle(StringRef StyleName, StringRef FileName,
1963                      StringRef FallbackStyle) {
1964   FormatStyle Style = getLLVMStyle();
1965   Style.Language = getLanguageByFileName(FileName);
1966   if (!getPredefinedStyle(FallbackStyle, Style.Language, &Style)) {
1967     llvm::errs() << "Invalid fallback style \"" << FallbackStyle
1968                  << "\" using LLVM style\n";
1969     return Style;
1970   }
1971
1972   if (StyleName.startswith("{")) {
1973     // Parse YAML/JSON style from the command line.
1974     if (std::error_code ec = parseConfiguration(StyleName, &Style)) {
1975       llvm::errs() << "Error parsing -style: " << ec.message() << ", using "
1976                    << FallbackStyle << " style\n";
1977     }
1978     return Style;
1979   }
1980
1981   if (!StyleName.equals_lower("file")) {
1982     if (!getPredefinedStyle(StyleName, Style.Language, &Style))
1983       llvm::errs() << "Invalid value for -style, using " << FallbackStyle
1984                    << " style\n";
1985     return Style;
1986   }
1987
1988   // Look for .clang-format/_clang-format file in the file's parent directories.
1989   SmallString<128> UnsuitableConfigFiles;
1990   SmallString<128> Path(FileName);
1991   llvm::sys::fs::make_absolute(Path);
1992   for (StringRef Directory = Path; !Directory.empty();
1993        Directory = llvm::sys::path::parent_path(Directory)) {
1994     if (!llvm::sys::fs::is_directory(Directory))
1995       continue;
1996     SmallString<128> ConfigFile(Directory);
1997
1998     llvm::sys::path::append(ConfigFile, ".clang-format");
1999     DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
2000     bool IsFile = false;
2001     // Ignore errors from is_regular_file: we only need to know if we can read
2002     // the file or not.
2003     llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
2004
2005     if (!IsFile) {
2006       // Try _clang-format too, since dotfiles are not commonly used on Windows.
2007       ConfigFile = Directory;
2008       llvm::sys::path::append(ConfigFile, "_clang-format");
2009       DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
2010       llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
2011     }
2012
2013     if (IsFile) {
2014       llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
2015           llvm::MemoryBuffer::getFile(ConfigFile.c_str());
2016       if (std::error_code EC = Text.getError()) {
2017         llvm::errs() << EC.message() << "\n";
2018         break;
2019       }
2020       if (std::error_code ec =
2021               parseConfiguration(Text.get()->getBuffer(), &Style)) {
2022         if (ec == ParseError::Unsuitable) {
2023           if (!UnsuitableConfigFiles.empty())
2024             UnsuitableConfigFiles.append(", ");
2025           UnsuitableConfigFiles.append(ConfigFile);
2026           continue;
2027         }
2028         llvm::errs() << "Error reading " << ConfigFile << ": " << ec.message()
2029                      << "\n";
2030         break;
2031       }
2032       DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n");
2033       return Style;
2034     }
2035   }
2036   if (!UnsuitableConfigFiles.empty()) {
2037     llvm::errs() << "Configuration file(s) do(es) not support "
2038                  << getLanguageName(Style.Language) << ": "
2039                  << UnsuitableConfigFiles << "\n";
2040   }
2041   return Style;
2042 }
2043
2044 } // namespace format
2045 } // namespace clang