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 "AffectedRangeManager.h"
  18 #include "ContinuationIndenter.h"
  19 #include "FormatTokenLexer.h"
  20 #include "SortJavaScriptImports.h"
  21 #include "TokenAnalyzer.h"
  22 #include "TokenAnnotator.h"
  23 #include "UnwrappedLineFormatter.h"
  24 #include "UnwrappedLineParser.h"
  25 #include "WhitespaceManager.h"
  26 #include "clang/Basic/Diagnostic.h"
  27 #include "clang/Basic/DiagnosticOptions.h"
  28 #include "clang/Basic/SourceManager.h"
  29 #include "clang/Basic/VirtualFileSystem.h"
  30 #include "clang/Lex/Lexer.h"
  31 #include "llvm/ADT/STLExtras.h"
  32 #include "llvm/Support/Allocator.h"
  33 #include "llvm/Support/Debug.h"
  34 #include "llvm/Support/Path.h"
  35 #include "llvm/Support/Regex.h"
  36 #include "llvm/Support/YAMLTraits.h"
  37 #include <algorithm>
  38 #include <memory>
  39 #include <string>
  40
  41 #define DEBUG_TYPE "format-formatter"
  42
  43 using clang::format::FormatStyle;
  44
  45 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
  46 LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::IncludeCategory)
  47
  48 namespace llvm {
  49 namespace yaml {
  50 template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
  51   static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
  52     IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
  53     IO.enumCase(Value, "Java", FormatStyle::LK_Java);
  54     IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
  55     IO.enumCase(Value, "ObjC", FormatStyle::LK_ObjC);
  56     IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
  57     IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
  58   }
  59 };
  60
  61 template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> {
  62   static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
  63     IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03);
  64     IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03);
  65     IO.enumCase(Value, "Cpp11", FormatStyle::LS_Cpp11);
  66     IO.enumCase(Value, "C++11", FormatStyle::LS_Cpp11);
  67     IO.enumCase(Value, "Auto", FormatStyle::LS_Auto);
  68   }
  69 };
  70
  71 template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
  72   static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
  73     IO.enumCase(Value, "Never", FormatStyle::UT_Never);
  74     IO.enumCase(Value, "false", FormatStyle::UT_Never);
  75     IO.enumCase(Value, "Always", FormatStyle::UT_Always);
  76     IO.enumCase(Value, "true", FormatStyle::UT_Always);
  77     IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
  78     IO.enumCase(Value, "ForContinuationAndIndentation",
  79                 FormatStyle::UT_ForContinuationAndIndentation);
  80   }
  81 };
  82
  83 template <> struct ScalarEnumerationTraits<FormatStyle::JavaScriptQuoteStyle> {
  84   static void enumeration(IO &IO, FormatStyle::JavaScriptQuoteStyle &Value) {
  85     IO.enumCase(Value, "Leave", FormatStyle::JSQS_Leave);
  86     IO.enumCase(Value, "Single", FormatStyle::JSQS_Single);
  87     IO.enumCase(Value, "Double", FormatStyle::JSQS_Double);
  88   }
  89 };
  90
  91 template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
  92   static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
  93     IO.enumCase(Value, "None", FormatStyle::SFS_None);
  94     IO.enumCase(Value, "false", FormatStyle::SFS_None);
  95     IO.enumCase(Value, "All", FormatStyle::SFS_All);
  96     IO.enumCase(Value, "true", FormatStyle::SFS_All);
  97     IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
  98     IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
  99   }
 100 };
 101
 102 template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
 103   static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
 104     IO.enumCase(Value, "All", FormatStyle::BOS_All);
 105     IO.enumCase(Value, "true", FormatStyle::BOS_All);
 106     IO.enumCase(Value, "None", FormatStyle::BOS_None);
 107     IO.enumCase(Value, "false", FormatStyle::BOS_None);
 108     IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
 109   }
 110 };
 111
 112 template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
 113   static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
 114     IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
 115     IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
 116     IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla);
 117     IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
 118     IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
 119     IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
 120     IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit);
 121     IO.enumCase(Value, "Custom", FormatStyle::BS_Custom);
 122   }
 123 };
 124
 125 template <>
 126 struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
 127   static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
 128     IO.enumCase(Value, "None", FormatStyle::RTBS_None);
 129     IO.enumCase(Value, "All", FormatStyle::RTBS_All);
 130     IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
 131     IO.enumCase(Value, "TopLevelDefinitions",
 132                 FormatStyle::RTBS_TopLevelDefinitions);
 133     IO.enumCase(Value, "AllDefinitions", FormatStyle::RTBS_AllDefinitions);
 134   }
 135 };
 136
 137 template <>
 138 struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
 139   static void
 140   enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) {
 141     IO.enumCase(Value, "None", FormatStyle::DRTBS_None);
 142     IO.enumCase(Value, "All", FormatStyle::DRTBS_All);
 143     IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel);
 144
 145     // For backward compatibility.
 146     IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
 147     IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
 148   }
 149 };
 150
 151 template <>
 152 struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
 153   static void enumeration(IO &IO,
 154                           FormatStyle::NamespaceIndentationKind &Value) {
 155     IO.enumCase(Value, "None", FormatStyle::NI_None);
 156     IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
 157     IO.enumCase(Value, "All", FormatStyle::NI_All);
 158   }
 159 };
 160
 161 template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
 162   static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
 163     IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
 164     IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign);
 165     IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
 166
 167     // For backward compatibility.
 168     IO.enumCase(Value, "true", FormatStyle::BAS_Align);
 169     IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
 170   }
 171 };
 172
 173 template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
 174   static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
 175     IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
 176     IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
 177     IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
 178
 179     // For backward compatibility.
 180     IO.enumCase(Value, "true", FormatStyle::PAS_Left);
 181     IO.enumCase(Value, "false", FormatStyle::PAS_Right);
 182   }
 183 };
 184
 185 template <>
 186 struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
 187   static void enumeration(IO &IO,
 188                           FormatStyle::SpaceBeforeParensOptions &Value) {
 189     IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
 190     IO.enumCase(Value, "ControlStatements",
 191                 FormatStyle::SBPO_ControlStatements);
 192     IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
 193
 194     // For backward compatibility.
 195     IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
 196     IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
 197   }
 198 };
 199
 200 template <> struct MappingTraits<FormatStyle> {
 201   static void mapping(IO &IO, FormatStyle &Style) {
 202     // When reading, read the language first, we need it for getPredefinedStyle.
 203     IO.mapOptional("Language", Style.Language);
 204
 205     if (IO.outputting()) {
 206       StringRef StylesArray[] = {"LLVM",    "Google", "Chromium",
 207                                  "Mozilla", "WebKit", "GNU"};
 208       ArrayRef<StringRef> Styles(StylesArray);
 209       for (size_t i = 0, e = Styles.size(); i < e; ++i) {
 210         StringRef StyleName(Styles[i]);
 211         FormatStyle PredefinedStyle;
 212         if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
 213             Style == PredefinedStyle) {
 214           IO.mapOptional("# BasedOnStyle", StyleName);
 215           break;
 216         }
 217       }
 218     } else {
 219       StringRef BasedOnStyle;
 220       IO.mapOptional("BasedOnStyle", BasedOnStyle);
 221       if (!BasedOnStyle.empty()) {
 222         FormatStyle::LanguageKind OldLanguage = Style.Language;
 223         FormatStyle::LanguageKind Language =
 224             ((FormatStyle *)IO.getContext())->Language;
 225         if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
 226           IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
 227           return;
 228         }
 229         Style.Language = OldLanguage;
 230       }
 231     }
 232
 233     // For backward compatibility.
 234     if (!IO.outputting()) {
 235       IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
 236       IO.mapOptional("IndentFunctionDeclarationAfterType",
 237                      Style.IndentWrappedFunctionNames);
 238       IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
 239       IO.mapOptional("SpaceAfterControlStatementKeyword",
 240                      Style.SpaceBeforeParens);
 241     }
 242
 243     IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
 244     IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
 245     IO.mapOptional("AlignConsecutiveAssignments",
 246                    Style.AlignConsecutiveAssignments);
 247     IO.mapOptional("AlignConsecutiveDeclarations",
 248                    Style.AlignConsecutiveDeclarations);
 249     IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft);
 250     IO.mapOptional("AlignOperands", Style.AlignOperands);
 251     IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
 252     IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
 253                    Style.AllowAllParametersOfDeclarationOnNextLine);
 254     IO.mapOptional("AllowShortBlocksOnASingleLine",
 255                    Style.AllowShortBlocksOnASingleLine);
 256     IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
 257                    Style.AllowShortCaseLabelsOnASingleLine);
 258     IO.mapOptional("AllowShortFunctionsOnASingleLine",
 259                    Style.AllowShortFunctionsOnASingleLine);
 260     IO.mapOptional("AllowShortIfStatementsOnASingleLine",
 261                    Style.AllowShortIfStatementsOnASingleLine);
 262     IO.mapOptional("AllowShortLoopsOnASingleLine",
 263                    Style.AllowShortLoopsOnASingleLine);
 264     IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
 265                    Style.AlwaysBreakAfterDefinitionReturnType);
 266     IO.mapOptional("AlwaysBreakAfterReturnType",
 267                    Style.AlwaysBreakAfterReturnType);
 268     // If AlwaysBreakAfterDefinitionReturnType was specified but
 269     // AlwaysBreakAfterReturnType was not, initialize the latter from the
 270     // former for backwards compatibility.
 271     if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
 272         Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
 273       if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
 274         Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
 275       else if (Style.AlwaysBreakAfterDefinitionReturnType ==
 276                FormatStyle::DRTBS_TopLevel)
 277         Style.AlwaysBreakAfterReturnType =
 278             FormatStyle::RTBS_TopLevelDefinitions;
 279     }
 280
 281     IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
 282                    Style.AlwaysBreakBeforeMultilineStrings);
 283     IO.mapOptional("AlwaysBreakTemplateDeclarations",
 284                    Style.AlwaysBreakTemplateDeclarations);
 285     IO.mapOptional("BinPackArguments", Style.BinPackArguments);
 286     IO.mapOptional("BinPackParameters", Style.BinPackParameters);
 287     IO.mapOptional("BraceWrapping", Style.BraceWrapping);
 288     IO.mapOptional("BreakBeforeBinaryOperators",
 289                    Style.BreakBeforeBinaryOperators);
 290     IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
 291     IO.mapOptional("BreakBeforeTernaryOperators",
 292                    Style.BreakBeforeTernaryOperators);
 293     IO.mapOptional("BreakConstructorInitializersBeforeComma",
 294                    Style.BreakConstructorInitializersBeforeComma);
 295     IO.mapOptional("BreakAfterJavaFieldAnnotations",
 296                    Style.BreakAfterJavaFieldAnnotations);
 297     IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
 298     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
 299     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
 300     IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
 301                    Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
 302     IO.mapOptional("ConstructorInitializerIndentWidth",
 303                    Style.ConstructorInitializerIndentWidth);
 304     IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
 305     IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
 306     IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
 307     IO.mapOptional("DisableFormat", Style.DisableFormat);
 308     IO.mapOptional("ExperimentalAutoDetectBinPacking",
 309                    Style.ExperimentalAutoDetectBinPacking);
 310     IO.mapOptional("ForEachMacros", Style.ForEachMacros);
 311     IO.mapOptional("IncludeCategories", Style.IncludeCategories);
 312     IO.mapOptional("IncludeIsMainRegex", Style.IncludeIsMainRegex);
 313     IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
 314     IO.mapOptional("IndentWidth", Style.IndentWidth);
 315     IO.mapOptional("IndentWrappedFunctionNames",
 316                    Style.IndentWrappedFunctionNames);
 317     IO.mapOptional("JavaScriptQuotes", Style.JavaScriptQuotes);
 318     IO.mapOptional("JavaScriptWrapImports", Style.JavaScriptWrapImports);
 319     IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
 320                    Style.KeepEmptyLinesAtTheStartOfBlocks);
 321     IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
 322     IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
 323     IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
 324     IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
 325     IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
 326     IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
 327     IO.mapOptional("ObjCSpaceBeforeProtocolList",
 328                    Style.ObjCSpaceBeforeProtocolList);
 329     IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
 330                    Style.PenaltyBreakBeforeFirstCallParameter);
 331     IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
 332     IO.mapOptional("PenaltyBreakFirstLessLess",
 333                    Style.PenaltyBreakFirstLessLess);
 334     IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
 335     IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
 336     IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
 337                    Style.PenaltyReturnTypeOnItsOwnLine);
 338     IO.mapOptional("PointerAlignment", Style.PointerAlignment);
 339     IO.mapOptional("ReflowComments", Style.ReflowComments);
 340     IO.mapOptional("SortIncludes", Style.SortIncludes);
 341     IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
 342     IO.mapOptional("SpaceAfterTemplateKeyword", Style.SpaceAfterTemplateKeyword);
 343     IO.mapOptional("SpaceBeforeAssignmentOperators",
 344                    Style.SpaceBeforeAssignmentOperators);
 345     IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
 346     IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
 347     IO.mapOptional("SpacesBeforeTrailingComments",
 348                    Style.SpacesBeforeTrailingComments);
 349     IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
 350     IO.mapOptional("SpacesInContainerLiterals",
 351                    Style.SpacesInContainerLiterals);
 352     IO.mapOptional("SpacesInCStyleCastParentheses",
 353                    Style.SpacesInCStyleCastParentheses);
 354     IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
 355     IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
 356     IO.mapOptional("Standard", Style.Standard);
 357     IO.mapOptional("TabWidth", Style.TabWidth);
 358     IO.mapOptional("UseTab", Style.UseTab);
 359   }
 360 };
 361
 362 template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
 363   static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
 364     IO.mapOptional("AfterClass", Wrapping.AfterClass);
 365     IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
 366     IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
 367     IO.mapOptional("AfterFunction", Wrapping.AfterFunction);
 368     IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace);
 369     IO.mapOptional("AfterObjCDeclaration", Wrapping.AfterObjCDeclaration);
 370     IO.mapOptional("AfterStruct", Wrapping.AfterStruct);
 371     IO.mapOptional("AfterUnion", Wrapping.AfterUnion);
 372     IO.mapOptional("BeforeCatch", Wrapping.BeforeCatch);
 373     IO.mapOptional("BeforeElse", Wrapping.BeforeElse);
 374     IO.mapOptional("IndentBraces", Wrapping.IndentBraces);
 375   }
 376 };
 377
 378 template <> struct MappingTraits<FormatStyle::IncludeCategory> {
 379   static void mapping(IO &IO, FormatStyle::IncludeCategory &Category) {
 380     IO.mapOptional("Regex", Category.Regex);
 381     IO.mapOptional("Priority", Category.Priority);
 382   }
 383 };
 384
 385 // Allows to read vector<FormatStyle> while keeping default values.
 386 // IO.getContext() should contain a pointer to the FormatStyle structure, that
 387 // will be used to get default values for missing keys.
 388 // If the first element has no Language specified, it will be treated as the
 389 // default one for the following elements.
 390 template <> struct DocumentListTraits<std::vector<FormatStyle>> {
 391   static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
 392     return Seq.size();
 393   }
 394   static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
 395                               size_t Index) {
 396     if (Index >= Seq.size()) {
 397       assert(Index == Seq.size());
 398       FormatStyle Template;
 399       if (Seq.size() > 0 && Seq[0].Language == FormatStyle::LK_None) {
 400         Template = Seq[0];
 401       } else {
 402         Template = *((const FormatStyle *)IO.getContext());
 403         Template.Language = FormatStyle::LK_None;
 404       }
 405       Seq.resize(Index + 1, Template);
 406     }
 407     return Seq[Index];
 408   }
 409 };
 410 } // namespace yaml
 411 } // namespace llvm
 412
 413 namespace clang {
 414 namespace format {
 415
 416 const std::error_category &getParseCategory() {
 417   static ParseErrorCategory C;
 418   return C;
 419 }
 420 std::error_code make_error_code(ParseError e) {
 421   return std::error_code(static_cast<int>(e), getParseCategory());
 422 }
 423
 424 const char *ParseErrorCategory::name() const noexcept {
 425   return "clang-format.parse_error";
 426 }
 427
 428 std::string ParseErrorCategory::message(int EV) const {
 429   switch (static_cast<ParseError>(EV)) {
 430   case ParseError::Success:
 431     return "Success";
 432   case ParseError::Error:
 433     return "Invalid argument";
 434   case ParseError::Unsuitable:
 435     return "Unsuitable";
 436   }
 437   llvm_unreachable("unexpected parse error");
 438 }
 439
 440 static FormatStyle expandPresets(const FormatStyle &Style) {
 441   if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
 442     return Style;
 443   FormatStyle Expanded = Style;
 444   Expanded.BraceWrapping = {false, false, false, false, false, false,
 445                             false, false, false, false, false};
 446   switch (Style.BreakBeforeBraces) {
 447   case FormatStyle::BS_Linux:
 448     Expanded.BraceWrapping.AfterClass = true;
 449     Expanded.BraceWrapping.AfterFunction = true;
 450     Expanded.BraceWrapping.AfterNamespace = true;
 451     break;
 452   case FormatStyle::BS_Mozilla:
 453     Expanded.BraceWrapping.AfterClass = true;
 454     Expanded.BraceWrapping.AfterEnum = true;
 455     Expanded.BraceWrapping.AfterFunction = true;
 456     Expanded.BraceWrapping.AfterStruct = true;
 457     Expanded.BraceWrapping.AfterUnion = true;
 458     break;
 459   case FormatStyle::BS_Stroustrup:
 460     Expanded.BraceWrapping.AfterFunction = true;
 461     Expanded.BraceWrapping.BeforeCatch = true;
 462     Expanded.BraceWrapping.BeforeElse = true;
 463     break;
 464   case FormatStyle::BS_Allman:
 465     Expanded.BraceWrapping.AfterClass = true;
 466     Expanded.BraceWrapping.AfterControlStatement = true;
 467     Expanded.BraceWrapping.AfterEnum = true;
 468     Expanded.BraceWrapping.AfterFunction = true;
 469     Expanded.BraceWrapping.AfterNamespace = true;
 470     Expanded.BraceWrapping.AfterObjCDeclaration = true;
 471     Expanded.BraceWrapping.AfterStruct = true;
 472     Expanded.BraceWrapping.BeforeCatch = true;
 473     Expanded.BraceWrapping.BeforeElse = true;
 474     break;
 475   case FormatStyle::BS_GNU:
 476     Expanded.BraceWrapping = {true, true, true, true, true, true,
 477                               true, true, true, true, true};
 478     break;
 479   case FormatStyle::BS_WebKit:
 480     Expanded.BraceWrapping.AfterFunction = true;
 481     break;
 482   default:
 483     break;
 484   }
 485   return Expanded;
 486 }
 487
 488 FormatStyle getLLVMStyle() {
 489   FormatStyle LLVMStyle;
 490   LLVMStyle.Language = FormatStyle::LK_Cpp;
 491   LLVMStyle.AccessModifierOffset = -2;
 492   LLVMStyle.AlignEscapedNewlinesLeft = false;
 493   LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
 494   LLVMStyle.AlignOperands = true;
 495   LLVMStyle.AlignTrailingComments = true;
 496   LLVMStyle.AlignConsecutiveAssignments = false;
 497   LLVMStyle.AlignConsecutiveDeclarations = false;
 498   LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
 499   LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
 500   LLVMStyle.AllowShortBlocksOnASingleLine = false;
 501   LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
 502   LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
 503   LLVMStyle.AllowShortLoopsOnASingleLine = false;
 504   LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
 505   LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
 506   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
 507   LLVMStyle.AlwaysBreakTemplateDeclarations = false;
 508   LLVMStyle.BinPackParameters = true;
 509   LLVMStyle.BinPackArguments = true;
 510   LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
 511   LLVMStyle.BreakBeforeTernaryOperators = true;
 512   LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
 513   LLVMStyle.BraceWrapping = {false, false, false, false, false, false,
 514                              false, false, false, false, false};
 515   LLVMStyle.BreakAfterJavaFieldAnnotations = false;
 516   LLVMStyle.BreakConstructorInitializersBeforeComma = false;
 517   LLVMStyle.BreakStringLiterals = true;
 518   LLVMStyle.ColumnLimit = 80;
 519   LLVMStyle.CommentPragmas = "^ IWYU pragma:";
 520   LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
 521   LLVMStyle.ConstructorInitializerIndentWidth = 4;
 522   LLVMStyle.ContinuationIndentWidth = 4;
 523   LLVMStyle.Cpp11BracedListStyle = true;
 524   LLVMStyle.DerivePointerAlignment = false;
 525   LLVMStyle.ExperimentalAutoDetectBinPacking = false;
 526   LLVMStyle.ForEachMacros.push_back("foreach");
 527   LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
 528   LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
 529   LLVMStyle.IncludeCategories = {{"^\"(llvm|llvm-c|clang|clang-c)/", 2},
 530                                  {"^(<|\"(gtest|isl|json)/)", 3},
 531                                  {".*", 1}};
 532   LLVMStyle.IncludeIsMainRegex = "$";
 533   LLVMStyle.IndentCaseLabels = false;
 534   LLVMStyle.IndentWrappedFunctionNames = false;
 535   LLVMStyle.IndentWidth = 2;
 536   LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
 537   LLVMStyle.JavaScriptWrapImports = true;
 538   LLVMStyle.TabWidth = 8;
 539   LLVMStyle.MaxEmptyLinesToKeep = 1;
 540   LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
 541   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
 542   LLVMStyle.ObjCBlockIndentWidth = 2;
 543   LLVMStyle.ObjCSpaceAfterProperty = false;
 544   LLVMStyle.ObjCSpaceBeforeProtocolList = true;
 545   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
 546   LLVMStyle.SpacesBeforeTrailingComments = 1;
 547   LLVMStyle.Standard = FormatStyle::LS_Cpp11;
 548   LLVMStyle.UseTab = FormatStyle::UT_Never;
 549   LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
 550   LLVMStyle.ReflowComments = true;
 551   LLVMStyle.SpacesInParentheses = false;
 552   LLVMStyle.SpacesInSquareBrackets = false;
 553   LLVMStyle.SpaceInEmptyParentheses = false;
 554   LLVMStyle.SpacesInContainerLiterals = true;
 555   LLVMStyle.SpacesInCStyleCastParentheses = false;
 556   LLVMStyle.SpaceAfterCStyleCast = false;
 557   LLVMStyle.SpaceAfterTemplateKeyword = true;
 558   LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
 559   LLVMStyle.SpaceBeforeAssignmentOperators = true;
 560   LLVMStyle.SpacesInAngles = false;
 561
 562   LLVMStyle.PenaltyBreakComment = 300;
 563   LLVMStyle.PenaltyBreakFirstLessLess = 120;
 564   LLVMStyle.PenaltyBreakString = 1000;
 565   LLVMStyle.PenaltyExcessCharacter = 1000000;
 566   LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
 567   LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
 568
 569   LLVMStyle.DisableFormat = false;
 570   LLVMStyle.SortIncludes = true;
 571
 572   return LLVMStyle;
 573 }
 574
 575 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
 576   FormatStyle GoogleStyle = getLLVMStyle();
 577   GoogleStyle.Language = Language;
 578
 579   GoogleStyle.AccessModifierOffset = -1;
 580   GoogleStyle.AlignEscapedNewlinesLeft = true;
 581   GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
 582   GoogleStyle.AllowShortLoopsOnASingleLine = true;
 583   GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
 584   GoogleStyle.AlwaysBreakTemplateDeclarations = true;
 585   GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
 586   GoogleStyle.DerivePointerAlignment = true;
 587   GoogleStyle.IncludeCategories = {{"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
 588   GoogleStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
 589   GoogleStyle.IndentCaseLabels = true;
 590   GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
 591   GoogleStyle.ObjCSpaceAfterProperty = false;
 592   GoogleStyle.ObjCSpaceBeforeProtocolList = false;
 593   GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
 594   GoogleStyle.SpacesBeforeTrailingComments = 2;
 595   GoogleStyle.Standard = FormatStyle::LS_Auto;
 596
 597   GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
 598   GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
 599
 600   if (Language == FormatStyle::LK_Java) {
 601     GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
 602     GoogleStyle.AlignOperands = false;
 603     GoogleStyle.AlignTrailingComments = false;
 604     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
 605     GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
 606     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
 607     GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
 608     GoogleStyle.ColumnLimit = 100;
 609     GoogleStyle.SpaceAfterCStyleCast = true;
 610     GoogleStyle.SpacesBeforeTrailingComments = 1;
 611   } else if (Language == FormatStyle::LK_JavaScript) {
 612     GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
 613     GoogleStyle.AlignOperands = false;
 614     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
 615     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
 616     GoogleStyle.BreakBeforeTernaryOperators = false;
 617     GoogleStyle.CommentPragmas =
 618         "(taze:|@(export|requirecss|return|returns|see|visibility)) ";
 619     GoogleStyle.MaxEmptyLinesToKeep = 3;
 620     GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
 621     GoogleStyle.SpacesInContainerLiterals = false;
 622     GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
 623     GoogleStyle.JavaScriptWrapImports = false;
 624   } else if (Language == FormatStyle::LK_Proto) {
 625     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
 626     GoogleStyle.SpacesInContainerLiterals = false;
 627   } else if (Language == FormatStyle::LK_ObjC) {
 628     GoogleStyle.ColumnLimit = 100;
 629   }
 630
 631   return GoogleStyle;
 632 }
 633
 634 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
 635   FormatStyle ChromiumStyle = getGoogleStyle(Language);
 636   if (Language == FormatStyle::LK_Java) {
 637     ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
 638     ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
 639     ChromiumStyle.ContinuationIndentWidth = 8;
 640     ChromiumStyle.IndentWidth = 4;
 641   } else if (Language == FormatStyle::LK_JavaScript) {
 642     ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
 643     ChromiumStyle.AllowShortLoopsOnASingleLine = false;
 644   } else {
 645     ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
 646     ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
 647     ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
 648     ChromiumStyle.AllowShortLoopsOnASingleLine = false;
 649     ChromiumStyle.BinPackParameters = false;
 650     ChromiumStyle.DerivePointerAlignment = false;
 651   }
 652   ChromiumStyle.SortIncludes = false;
 653   return ChromiumStyle;
 654 }
 655
 656 FormatStyle getMozillaStyle() {
 657   FormatStyle MozillaStyle = getLLVMStyle();
 658   MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
 659   MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
 660   MozillaStyle.AlwaysBreakAfterReturnType =
 661       FormatStyle::RTBS_TopLevel;
 662   MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
 663       FormatStyle::DRTBS_TopLevel;
 664   MozillaStyle.AlwaysBreakTemplateDeclarations = true;
 665   MozillaStyle.BinPackParameters = false;
 666   MozillaStyle.BinPackArguments = false;
 667   MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
 668   MozillaStyle.BreakConstructorInitializersBeforeComma = true;
 669   MozillaStyle.ConstructorInitializerIndentWidth = 2;
 670   MozillaStyle.ContinuationIndentWidth = 2;
 671   MozillaStyle.Cpp11BracedListStyle = false;
 672   MozillaStyle.IndentCaseLabels = true;
 673   MozillaStyle.ObjCSpaceAfterProperty = true;
 674   MozillaStyle.ObjCSpaceBeforeProtocolList = false;
 675   MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
 676   MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
 677   MozillaStyle.SpaceAfterTemplateKeyword = false;
 678   return MozillaStyle;
 679 }
 680
 681 FormatStyle getWebKitStyle() {
 682   FormatStyle Style = getLLVMStyle();
 683   Style.AccessModifierOffset = -4;
 684   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
 685   Style.AlignOperands = false;
 686   Style.AlignTrailingComments = false;
 687   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
 688   Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
 689   Style.BreakConstructorInitializersBeforeComma = true;
 690   Style.Cpp11BracedListStyle = false;
 691   Style.ColumnLimit = 0;
 692   Style.IndentWidth = 4;
 693   Style.NamespaceIndentation = FormatStyle::NI_Inner;
 694   Style.ObjCBlockIndentWidth = 4;
 695   Style.ObjCSpaceAfterProperty = true;
 696   Style.PointerAlignment = FormatStyle::PAS_Left;
 697   return Style;
 698 }
 699
 700 FormatStyle getGNUStyle() {
 701   FormatStyle Style = getLLVMStyle();
 702   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
 703   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
 704   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
 705   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
 706   Style.BreakBeforeTernaryOperators = true;
 707   Style.Cpp11BracedListStyle = false;
 708   Style.ColumnLimit = 79;
 709   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
 710   Style.Standard = FormatStyle::LS_Cpp03;
 711   return Style;
 712 }
 713
 714 FormatStyle getNoStyle() {
 715   FormatStyle NoStyle = getLLVMStyle();
 716   NoStyle.DisableFormat = true;
 717   NoStyle.SortIncludes = false;
 718   return NoStyle;
 719 }
 720
 721 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
 722                         FormatStyle *Style) {
 723   if (Name.equals_lower("llvm")) {
 724     *Style = getLLVMStyle();
 725   } else if (Name.equals_lower("chromium")) {
 726     *Style = getChromiumStyle(Language);
 727   } else if (Name.equals_lower("mozilla")) {
 728     *Style = getMozillaStyle();
 729   } else if (Name.equals_lower("google")) {
 730     *Style = getGoogleStyle(Language);
 731   } else if (Name.equals_lower("webkit")) {
 732     *Style = getWebKitStyle();
 733   } else if (Name.equals_lower("gnu")) {
 734     *Style = getGNUStyle();
 735   } else if (Name.equals_lower("none")) {
 736     *Style = getNoStyle();
 737   } else {
 738     return false;
 739   }
 740
 741   Style->Language = Language;
 742   return true;
 743 }
 744
 745 std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
 746   assert(Style);
 747   FormatStyle::LanguageKind Language = Style->Language;
 748   assert(Language != FormatStyle::LK_None);
 749   if (Text.trim().empty())
 750     return make_error_code(ParseError::Error);
 751
 752   std::vector<FormatStyle> Styles;
 753   llvm::yaml::Input Input(Text);
 754   // DocumentListTraits<vector<FormatStyle>> uses the context to get default
 755   // values for the fields, keys for which are missing from the configuration.
 756   // Mapping also uses the context to get the language to find the correct
 757   // base style.
 758   Input.setContext(Style);
 759   Input >> Styles;
 760   if (Input.error())
 761     return Input.error();
 762
 763   for (unsigned i = 0; i < Styles.size(); ++i) {
 764     // Ensures that only the first configuration can skip the Language option.
 765     if (Styles[i].Language == FormatStyle::LK_None && i != 0)
 766       return make_error_code(ParseError::Error);
 767     // Ensure that each language is configured at most once.
 768     for (unsigned j = 0; j < i; ++j) {
 769       if (Styles[i].Language == Styles[j].Language) {
 770         DEBUG(llvm::dbgs()
 771               << "Duplicate languages in the config file on positions " << j
 772               << " and " << i << "\n");
 773         return make_error_code(ParseError::Error);
 774       }
 775     }
 776   }
 777   // Look for a suitable configuration starting from the end, so we can
 778   // find the configuration for the specific language first, and the default
 779   // configuration (which can only be at slot 0) after it.
 780   for (int i = Styles.size() - 1; i >= 0; --i) {
 781     if (Styles[i].Language == Language ||
 782         Styles[i].Language == FormatStyle::LK_None) {
 783       *Style = Styles[i];
 784       Style->Language = Language;
 785       return make_error_code(ParseError::Success);
 786     }
 787   }
 788   return make_error_code(ParseError::Unsuitable);
 789 }
 790
 791 std::string configurationAsText(const FormatStyle &Style) {
 792   std::string Text;
 793   llvm::raw_string_ostream Stream(Text);
 794   llvm::yaml::Output Output(Stream);
 795   // We use the same mapping method for input and output, so we need a non-const
 796   // reference here.
 797   FormatStyle NonConstStyle = expandPresets(Style);
 798   Output << NonConstStyle;
 799   return Stream.str();
 800 }
 801
 802 namespace {
 803
 804 class JavaScriptRequoter : public TokenAnalyzer {
 805 public:
 806   JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
 807       : TokenAnalyzer(Env, Style) {}
 808
 809   tooling::Replacements
 810   analyze(TokenAnnotator &Annotator,
 811           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
 812           FormatTokenLexer &Tokens) override {
 813     AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
 814                                           AnnotatedLines.end());
 815     tooling::Replacements Result;
 816     requoteJSStringLiteral(AnnotatedLines, Result);
 817     return Result;
 818   }
 819
 820 private:
 821   // Replaces double/single-quoted string literal as appropriate, re-escaping
 822   // the contents in the process.
 823   void requoteJSStringLiteral(SmallVectorImpl<AnnotatedLine *> &Lines,
 824                               tooling::Replacements &Result) {
 825     for (AnnotatedLine *Line : Lines) {
 826       requoteJSStringLiteral(Line->Children, Result);
 827       if (!Line->Affected)
 828         continue;
 829       for (FormatToken *FormatTok = Line->First; FormatTok;
 830            FormatTok = FormatTok->Next) {
 831         StringRef Input = FormatTok->TokenText;
 832         if (FormatTok->Finalized || !FormatTok->isStringLiteral() ||
 833             // NB: testing for not starting with a double quote to avoid
 834             // breaking `template strings`.
 835             (Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
 836              !Input.startswith("\"")) ||
 837             (Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
 838              !Input.startswith("\'")))
 839           continue;
 840
 841         // Change start and end quote.
 842         bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
 843         SourceLocation Start = FormatTok->Tok.getLocation();
 844         auto Replace = [&](SourceLocation Start, unsigned Length,
 845                            StringRef ReplacementText) {
 846           auto Err = Result.add(tooling::Replacement(
 847               Env.getSourceManager(), Start, Length, ReplacementText));
 848           // FIXME: handle error. For now, print error message and skip the
 849           // replacement for release version.
 850           if (Err) {
 851             llvm::errs() << llvm::toString(std::move(Err)) << "\n";
 852             assert(false);
 853           }
 854         };
 855         Replace(Start, 1, IsSingle ? "'" : "\"");
 856         Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
 857                 IsSingle ? "'" : "\"");
 858
 859         // Escape internal quotes.
 860         bool Escaped = false;
 861         for (size_t i = 1; i < Input.size() - 1; i++) {
 862           switch (Input[i]) {
 863           case '\\':
 864             if (!Escaped && i + 1 < Input.size() &&
 865                 ((IsSingle && Input[i + 1] == '"') ||
 866                  (!IsSingle && Input[i + 1] == '\''))) {
 867               // Remove this \, it's escaping a " or ' that no longer needs
 868               // escaping
 869               Replace(Start.getLocWithOffset(i), 1, "");
 870               continue;
 871             }
 872             Escaped = !Escaped;
 873             break;
 874           case '\"':
 875           case '\'':
 876             if (!Escaped && IsSingle == (Input[i] == '\'')) {
 877               // Escape the quote.
 878               Replace(Start.getLocWithOffset(i), 0, "\\");
 879             }
 880             Escaped = false;
 881             break;
 882           default:
 883             Escaped = false;
 884             break;
 885           }
 886         }
 887       }
 888     }
 889   }
 890 };
 891
 892 class Formatter : public TokenAnalyzer {
 893 public:
 894   Formatter(const Environment &Env, const FormatStyle &Style,
 895             bool *IncompleteFormat)
 896       : TokenAnalyzer(Env, Style), IncompleteFormat(IncompleteFormat) {}
 897
 898   tooling::Replacements
 899   analyze(TokenAnnotator &Annotator,
 900           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
 901           FormatTokenLexer &Tokens) override {
 902     tooling::Replacements Result;
 903     deriveLocalStyle(AnnotatedLines);
 904     AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
 905                                           AnnotatedLines.end());
 906     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
 907       Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
 908     }
 909     Annotator.setCommentLineLevels(AnnotatedLines);
 910
 911     WhitespaceManager Whitespaces(
 912         Env.getSourceManager(), Style,
 913         inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
 914     ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
 915                                   Env.getSourceManager(), Whitespaces, Encoding,
 916                                   BinPackInconclusiveFunctions);
 917     UnwrappedLineFormatter(&Indenter, &Whitespaces, Style, Tokens.getKeywords(),
 918                            IncompleteFormat)
 919         .format(AnnotatedLines);
 920     for (const auto &R : Whitespaces.generateReplacements())
 921       if (Result.add(R))
 922         return Result;
 923     return Result;
 924   }
 925
 926 private:
 927
 928   static bool inputUsesCRLF(StringRef Text) {
 929     return Text.count('\r') * 2 > Text.count('\n');
 930   }
 931
 932   bool
 933   hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
 934     for (const AnnotatedLine *Line : Lines) {
 935       if (hasCpp03IncompatibleFormat(Line->Children))
 936         return true;
 937       for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
 938         if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
 939           if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
 940             return true;
 941           if (Tok->is(TT_TemplateCloser) &&
 942               Tok->Previous->is(TT_TemplateCloser))
 943             return true;
 944         }
 945       }
 946     }
 947     return false;
 948   }
 949
 950   int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
 951     int AlignmentDiff = 0;
 952     for (const AnnotatedLine *Line : Lines) {
 953       AlignmentDiff += countVariableAlignments(Line->Children);
 954       for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
 955         if (!Tok->is(TT_PointerOrReference))
 956           continue;
 957         bool SpaceBefore =
 958             Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
 959         bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
 960                           Tok->Next->WhitespaceRange.getEnd();
 961         if (SpaceBefore && !SpaceAfter)
 962           ++AlignmentDiff;
 963         if (!SpaceBefore && SpaceAfter)
 964           --AlignmentDiff;
 965       }
 966     }
 967     return AlignmentDiff;
 968   }
 969
 970   void
 971   deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
 972     bool HasBinPackedFunction = false;
 973     bool HasOnePerLineFunction = false;
 974     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
 975       if (!AnnotatedLines[i]->First->Next)
 976         continue;
 977       FormatToken *Tok = AnnotatedLines[i]->First->Next;
 978       while (Tok->Next) {
 979         if (Tok->PackingKind == PPK_BinPacked)
 980           HasBinPackedFunction = true;
 981         if (Tok->PackingKind == PPK_OnePerLine)
 982           HasOnePerLineFunction = true;
 983
 984         Tok = Tok->Next;
 985       }
 986     }
 987     if (Style.DerivePointerAlignment)
 988       Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
 989                                    ? FormatStyle::PAS_Left
 990                                    : FormatStyle::PAS_Right;
 991     if (Style.Standard == FormatStyle::LS_Auto)
 992       Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
 993                            ? FormatStyle::LS_Cpp11
 994                            : FormatStyle::LS_Cpp03;
 995     BinPackInconclusiveFunctions =
 996         HasBinPackedFunction || !HasOnePerLineFunction;
 997   }
 998
 999   bool BinPackInconclusiveFunctions;
1000   bool *IncompleteFormat;
1001 };
1002
1003 // This class clean up the erroneous/redundant code around the given ranges in
1004 // file.
1005 class Cleaner : public TokenAnalyzer {
1006 public:
1007   Cleaner(const Environment &Env, const FormatStyle &Style)
1008       : TokenAnalyzer(Env, Style),
1009         DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
1010
1011   // FIXME: eliminate unused parameters.
1012   tooling::Replacements
1013   analyze(TokenAnnotator &Annotator,
1014           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1015           FormatTokenLexer &Tokens) override {
1016     // FIXME: in the current implementation the granularity of affected range
1017     // is an annotated line. However, this is not sufficient. Furthermore,
1018     // redundant code introduced by replacements does not necessarily
1019     // intercept with ranges of replacements that result in the redundancy.
1020     // To determine if some redundant code is actually introduced by
1021     // replacements(e.g. deletions), we need to come up with a more
1022     // sophisticated way of computing affected ranges.
1023     AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
1024                                           AnnotatedLines.end());
1025
1026     checkEmptyNamespace(AnnotatedLines);
1027
1028     for (auto &Line : AnnotatedLines) {
1029       if (Line->Affected) {
1030         cleanupRight(Line->First, tok::comma, tok::comma);
1031         cleanupRight(Line->First, TT_CtorInitializerColon, tok::comma);
1032         cleanupRight(Line->First, tok::l_paren, tok::comma);
1033         cleanupLeft(Line->First, tok::comma, tok::r_paren);
1034         cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
1035         cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
1036         cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
1037       }
1038     }
1039
1040     return generateFixes();
1041   }
1042
1043 private:
1044   bool containsOnlyComments(const AnnotatedLine &Line) {
1045     for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
1046       if (Tok->isNot(tok::comment))
1047         return false;
1048     }
1049     return true;
1050   }
1051
1052   // Iterate through all lines and remove any empty (nested) namespaces.
1053   void checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
1054     std::set<unsigned> DeletedLines;
1055     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1056       auto &Line = *AnnotatedLines[i];
1057       if (Line.startsWith(tok::kw_namespace) ||
1058           Line.startsWith(tok::kw_inline, tok::kw_namespace)) {
1059         checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
1060       }
1061     }
1062
1063     for (auto Line : DeletedLines) {
1064       FormatToken *Tok = AnnotatedLines[Line]->First;
1065       while (Tok) {
1066         deleteToken(Tok);
1067         Tok = Tok->Next;
1068       }
1069     }
1070   }
1071
1072   // The function checks if the namespace, which starts from \p CurrentLine, and
1073   // its nested namespaces are empty and delete them if they are empty. It also
1074   // sets \p NewLine to the last line checked.
1075   // Returns true if the current namespace is empty.
1076   bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1077                            unsigned CurrentLine, unsigned &NewLine,
1078                            std::set<unsigned> &DeletedLines) {
1079     unsigned InitLine = CurrentLine, End = AnnotatedLines.size();
1080     if (Style.BraceWrapping.AfterNamespace) {
1081       // If the left brace is in a new line, we should consume it first so that
1082       // it does not make the namespace non-empty.
1083       // FIXME: error handling if there is no left brace.
1084       if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
1085         NewLine = CurrentLine;
1086         return false;
1087       }
1088     } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
1089       return false;
1090     }
1091     while (++CurrentLine < End) {
1092       if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
1093         break;
1094
1095       if (AnnotatedLines[CurrentLine]->startsWith(tok::kw_namespace) ||
1096           AnnotatedLines[CurrentLine]->startsWith(tok::kw_inline,
1097                                                   tok::kw_namespace)) {
1098         if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
1099                                  DeletedLines))
1100           return false;
1101         CurrentLine = NewLine;
1102         continue;
1103       }
1104
1105       if (containsOnlyComments(*AnnotatedLines[CurrentLine]))
1106         continue;
1107
1108       // If there is anything other than comments or nested namespaces in the
1109       // current namespace, the namespace cannot be empty.
1110       NewLine = CurrentLine;
1111       return false;
1112     }
1113
1114     NewLine = CurrentLine;
1115     if (CurrentLine >= End)
1116       return false;
1117
1118     // Check if the empty namespace is actually affected by changed ranges.
1119     if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
1120             AnnotatedLines[InitLine]->First->Tok.getLocation(),
1121             AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
1122       return false;
1123
1124     for (unsigned i = InitLine; i <= CurrentLine; ++i) {
1125       DeletedLines.insert(i);
1126     }
1127
1128     return true;
1129   }
1130
1131   // Checks pairs {start, start->next},..., {end->previous, end} and deletes one
1132   // of the token in the pair if the left token has \p LK token kind and the
1133   // right token has \p RK token kind. If \p DeleteLeft is true, the left token
1134   // is deleted on match; otherwise, the right token is deleted.
1135   template <typename LeftKind, typename RightKind>
1136   void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
1137                    bool DeleteLeft) {
1138     auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
1139       for (auto *Res = Tok.Next; Res; Res = Res->Next)
1140         if (!Res->is(tok::comment) &&
1141             DeletedTokens.find(Res) == DeletedTokens.end())
1142           return Res;
1143       return nullptr;
1144     };
1145     for (auto *Left = Start; Left;) {
1146       auto *Right = NextNotDeleted(*Left);
1147       if (!Right)
1148         break;
1149       if (Left->is(LK) && Right->is(RK)) {
1150         deleteToken(DeleteLeft ? Left : Right);
1151         for (auto *Tok = Left->Next; Tok && Tok != Right; Tok = Tok->Next)
1152           deleteToken(Tok);
1153         // If the right token is deleted, we should keep the left token
1154         // unchanged and pair it with the new right token.
1155         if (!DeleteLeft)
1156           continue;
1157       }
1158       Left = Right;
1159     }
1160   }
1161
1162   template <typename LeftKind, typename RightKind>
1163   void cleanupLeft(FormatToken *Start, LeftKind LK, RightKind RK) {
1164     cleanupPair(Start, LK, RK, /*DeleteLeft=*/true);
1165   }
1166
1167   template <typename LeftKind, typename RightKind>
1168   void cleanupRight(FormatToken *Start, LeftKind LK, RightKind RK) {
1169     cleanupPair(Start, LK, RK, /*DeleteLeft=*/false);
1170   }
1171
1172   // Delete the given token.
1173   inline void deleteToken(FormatToken *Tok) {
1174     if (Tok)
1175       DeletedTokens.insert(Tok);
1176   }
1177
1178   tooling::Replacements generateFixes() {
1179     tooling::Replacements Fixes;
1180     std::vector<FormatToken *> Tokens;
1181     std::copy(DeletedTokens.begin(), DeletedTokens.end(),
1182               std::back_inserter(Tokens));
1183
1184     // Merge multiple continuous token deletions into one big deletion so that
1185     // the number of replacements can be reduced. This makes computing affected
1186     // ranges more efficient when we run reformat on the changed code.
1187     unsigned Idx = 0;
1188     while (Idx < Tokens.size()) {
1189       unsigned St = Idx, End = Idx;
1190       while ((End + 1) < Tokens.size() &&
1191              Tokens[End]->Next == Tokens[End + 1]) {
1192         End++;
1193       }
1194       auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
1195                                               Tokens[End]->Tok.getEndLoc());
1196       auto Err =
1197           Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
1198       // FIXME: better error handling. for now just print error message and skip
1199       // for the release version.
1200       if (Err) {
1201         llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1202         assert(false && "Fixes must not conflict!");
1203       }
1204       Idx = End + 1;
1205     }
1206
1207     return Fixes;
1208   }
1209
1210   // Class for less-than inequality comparason for the set `RedundantTokens`.
1211   // We store tokens in the order they appear in the translation unit so that
1212   // we do not need to sort them in `generateFixes()`.
1213   struct FormatTokenLess {
1214     FormatTokenLess(const SourceManager &SM) : SM(SM) {}
1215
1216     bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
1217       return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
1218                                           RHS->Tok.getLocation());
1219     }
1220     const SourceManager &SM;
1221   };
1222
1223   // Tokens to be deleted.
1224   std::set<FormatToken *, FormatTokenLess> DeletedTokens;
1225 };
1226
1227 struct IncludeDirective {
1228   StringRef Filename;
1229   StringRef Text;
1230   unsigned Offset;
1231   int Category;
1232 };
1233
1234 } // end anonymous namespace
1235
1236 // Determines whether 'Ranges' intersects with ('Start', 'End').
1237 static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
1238                          unsigned End) {
1239   for (auto Range : Ranges) {
1240     if (Range.getOffset() < End &&
1241         Range.getOffset() + Range.getLength() > Start)
1242       return true;
1243   }
1244   return false;
1245 }
1246
1247 // Returns a pair (Index, OffsetToEOL) describing the position of the cursor
1248 // before sorting/deduplicating. Index is the index of the include under the
1249 // cursor in the original set of includes. If this include has duplicates, it is
1250 // the index of the first of the duplicates as the others are going to be
1251 // removed. OffsetToEOL describes the cursor's position relative to the end of
1252 // its current line.
1253 // If `Cursor` is not on any #include, `Index` will be UINT_MAX.
1254 static std::pair<unsigned, unsigned>
1255 FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
1256                 const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
1257   unsigned CursorIndex = UINT_MAX;
1258   unsigned OffsetToEOL = 0;
1259   for (int i = 0, e = Includes.size(); i != e; ++i) {
1260     unsigned Start = Includes[Indices[i]].Offset;
1261     unsigned End = Start + Includes[Indices[i]].Text.size();
1262     if (!(Cursor >= Start && Cursor < End))
1263       continue;
1264     CursorIndex = Indices[i];
1265     OffsetToEOL = End - Cursor;
1266     // Put the cursor on the only remaining #include among the duplicate
1267     // #includes.
1268     while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
1269       CursorIndex = i;
1270     break;
1271   }
1272   return std::make_pair(CursorIndex, OffsetToEOL);
1273 }
1274
1275 // Sorts and deduplicate a block of includes given by 'Includes' alphabetically
1276 // adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
1277 // source order.
1278 // #include directives with the same text will be deduplicated, and only the
1279 // first #include in the duplicate #includes remains. If the `Cursor` is
1280 // provided and put on a deleted #include, it will be moved to the remaining
1281 // #include in the duplicate #includes.
1282 static void sortCppIncludes(const FormatStyle &Style,
1283                             const SmallVectorImpl<IncludeDirective> &Includes,
1284                             ArrayRef<tooling::Range> Ranges, StringRef FileName,
1285                             tooling::Replacements &Replaces, unsigned *Cursor) {
1286   unsigned IncludesBeginOffset = Includes.front().Offset;
1287   unsigned IncludesEndOffset =
1288       Includes.back().Offset + Includes.back().Text.size();
1289   unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
1290   if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
1291     return;
1292   SmallVector<unsigned, 16> Indices;
1293   for (unsigned i = 0, e = Includes.size(); i != e; ++i)
1294     Indices.push_back(i);
1295   std::stable_sort(
1296       Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
1297         return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
1298                std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
1299       });
1300   // The index of the include on which the cursor will be put after
1301   // sorting/deduplicating.
1302   unsigned CursorIndex;
1303   // The offset from cursor to the end of line.
1304   unsigned CursorToEOLOffset;
1305   if (Cursor)
1306     std::tie(CursorIndex, CursorToEOLOffset) =
1307         FindCursorIndex(Includes, Indices, *Cursor);
1308
1309   // Deduplicate #includes.
1310   Indices.erase(std::unique(Indices.begin(), Indices.end(),
1311                             [&](unsigned LHSI, unsigned RHSI) {
1312                               return Includes[LHSI].Text == Includes[RHSI].Text;
1313                             }),
1314                 Indices.end());
1315
1316   // If the #includes are out of order, we generate a single replacement fixing
1317   // the entire block. Otherwise, no replacement is generated.
1318   if (Indices.size() == Includes.size() &&
1319       std::is_sorted(Indices.begin(), Indices.end()))
1320     return;
1321
1322   std::string result;
1323   for (unsigned Index : Indices) {
1324     if (!result.empty())
1325       result += "\n";
1326     result += Includes[Index].Text;
1327     if (Cursor && CursorIndex == Index)
1328       *Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
1329   }
1330
1331   auto Err = Replaces.add(tooling::Replacement(
1332       FileName, Includes.front().Offset, IncludesBlockSize, result));
1333   // FIXME: better error handling. For now, just skip the replacement for the
1334   // release version.
1335   if (Err) {
1336     llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1337     assert(false);
1338   }
1339 }
1340
1341 namespace {
1342
1343 // This class manages priorities of #include categories and calculates
1344 // priorities for headers.
1345 class IncludeCategoryManager {
1346 public:
1347   IncludeCategoryManager(const FormatStyle &Style, StringRef FileName)
1348       : Style(Style), FileName(FileName) {
1349     FileStem = llvm::sys::path::stem(FileName);
1350     for (const auto &Category : Style.IncludeCategories)
1351       CategoryRegexs.emplace_back(Category.Regex);
1352     IsMainFile = FileName.endswith(".c") || FileName.endswith(".cc") ||
1353                  FileName.endswith(".cpp") || FileName.endswith(".c++") ||
1354                  FileName.endswith(".cxx") || FileName.endswith(".m") ||
1355                  FileName.endswith(".mm");
1356   }
1357
1358   // Returns the priority of the category which \p IncludeName belongs to.
1359   // If \p CheckMainHeader is true and \p IncludeName is a main header, returns
1360   // 0. Otherwise, returns the priority of the matching category or INT_MAX.
1361   int getIncludePriority(StringRef IncludeName, bool CheckMainHeader) {
1362     int Ret = INT_MAX;
1363     for (unsigned i = 0, e = CategoryRegexs.size(); i != e; ++i)
1364       if (CategoryRegexs[i].match(IncludeName)) {
1365         Ret = Style.IncludeCategories[i].Priority;
1366         break;
1367       }
1368     if (CheckMainHeader && IsMainFile && Ret > 0 && isMainHeader(IncludeName))
1369       Ret = 0;
1370     return Ret;
1371   }
1372
1373 private:
1374   bool isMainHeader(StringRef IncludeName) const {
1375     if (!IncludeName.startswith("\""))
1376       return false;
1377     StringRef HeaderStem =
1378         llvm::sys::path::stem(IncludeName.drop_front(1).drop_back(1));
1379     if (FileStem.startswith(HeaderStem)) {
1380       llvm::Regex MainIncludeRegex(
1381           (HeaderStem + Style.IncludeIsMainRegex).str());
1382       if (MainIncludeRegex.match(FileStem))
1383         return true;
1384     }
1385     return false;
1386   }
1387
1388   const FormatStyle &Style;
1389   bool IsMainFile;
1390   StringRef FileName;
1391   StringRef FileStem;
1392   SmallVector<llvm::Regex, 4> CategoryRegexs;
1393 };
1394
1395 const char IncludeRegexPattern[] =
1396     R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
1397
1398 } // anonymous namespace
1399
1400 tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
1401                                       ArrayRef<tooling::Range> Ranges,
1402                                       StringRef FileName,
1403                                       tooling::Replacements &Replaces,
1404                                       unsigned *Cursor) {
1405   unsigned Prev = 0;
1406   unsigned SearchFrom = 0;
1407   llvm::Regex IncludeRegex(IncludeRegexPattern);
1408   SmallVector<StringRef, 4> Matches;
1409   SmallVector<IncludeDirective, 16> IncludesInBlock;
1410
1411   // In compiled files, consider the first #include to be the main #include of
1412   // the file if it is not a system #include. This ensures that the header
1413   // doesn't have hidden dependencies
1414   // (http://llvm.org/docs/CodingStandards.html#include-style).
1415   //
1416   // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
1417   // cases where the first #include is unlikely to be the main header.
1418   IncludeCategoryManager Categories(Style, FileName);
1419   bool FirstIncludeBlock = true;
1420   bool MainIncludeFound = false;
1421   bool FormattingOff = false;
1422
1423   for (;;) {
1424     auto Pos = Code.find('\n', SearchFrom);
1425     StringRef Line =
1426         Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
1427
1428     StringRef Trimmed = Line.trim();
1429     if (Trimmed == "// clang-format off")
1430       FormattingOff = true;
1431     else if (Trimmed == "// clang-format on")
1432       FormattingOff = false;
1433
1434     if (!FormattingOff && !Line.endswith("\\")) {
1435       if (IncludeRegex.match(Line, &Matches)) {
1436         StringRef IncludeName = Matches[2];
1437         int Category = Categories.getIncludePriority(
1438             IncludeName,
1439             /*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
1440         if (Category == 0)
1441           MainIncludeFound = true;
1442         IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
1443       } else if (!IncludesInBlock.empty()) {
1444         sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
1445                         Cursor);
1446         IncludesInBlock.clear();
1447         FirstIncludeBlock = false;
1448       }
1449       Prev = Pos + 1;
1450     }
1451     if (Pos == StringRef::npos || Pos + 1 == Code.size())
1452       break;
1453     SearchFrom = Pos + 1;
1454   }
1455   if (!IncludesInBlock.empty())
1456     sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
1457   return Replaces;
1458 }
1459
1460 tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
1461                                    ArrayRef<tooling::Range> Ranges,
1462                                    StringRef FileName, unsigned *Cursor) {
1463   tooling::Replacements Replaces;
1464   if (!Style.SortIncludes)
1465     return Replaces;
1466   if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
1467     return sortJavaScriptImports(Style, Code, Ranges, FileName);
1468   sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
1469   return Replaces;
1470 }
1471
1472 template <typename T>
1473 static llvm::Expected<tooling::Replacements>
1474 processReplacements(T ProcessFunc, StringRef Code,
1475                     const tooling::Replacements &Replaces,
1476                     const FormatStyle &Style) {
1477   if (Replaces.empty())
1478     return tooling::Replacements();
1479
1480   auto NewCode = applyAllReplacements(Code, Replaces);
1481   if (!NewCode)
1482     return NewCode.takeError();
1483   std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
1484   StringRef FileName = Replaces.begin()->getFilePath();
1485
1486   tooling::Replacements FormatReplaces =
1487       ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
1488
1489   return Replaces.merge(FormatReplaces);
1490 }
1491
1492 llvm::Expected<tooling::Replacements>
1493 formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
1494                    const FormatStyle &Style) {
1495   // We need to use lambda function here since there are two versions of
1496   // `sortIncludes`.
1497   auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
1498                          std::vector<tooling::Range> Ranges,
1499                          StringRef FileName) -> tooling::Replacements {
1500     return sortIncludes(Style, Code, Ranges, FileName);
1501   };
1502   auto SortedReplaces =
1503       processReplacements(SortIncludes, Code, Replaces, Style);
1504   if (!SortedReplaces)
1505     return SortedReplaces.takeError();
1506
1507   // We need to use lambda function here since there are two versions of
1508   // `reformat`.
1509   auto Reformat = [](const FormatStyle &Style, StringRef Code,
1510                      std::vector<tooling::Range> Ranges,
1511                      StringRef FileName) -> tooling::Replacements {
1512     return reformat(Style, Code, Ranges, FileName);
1513   };
1514   return processReplacements(Reformat, Code, *SortedReplaces, Style);
1515 }
1516
1517 namespace {
1518
1519 inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
1520   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
1521          llvm::Regex(IncludeRegexPattern).match(Replace.getReplacementText());
1522 }
1523
1524 inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
1525   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
1526 }
1527
1528 // Returns the offset after skipping a sequence of tokens, matched by \p
1529 // GetOffsetAfterSequence, from the start of the code.
1530 // \p GetOffsetAfterSequence should be a function that matches a sequence of
1531 // tokens and returns an offset after the sequence.
1532 unsigned getOffsetAfterTokenSequence(
1533     StringRef FileName, StringRef Code, const FormatStyle &Style,
1534     std::function<unsigned(const SourceManager &, Lexer &, Token &)>
1535         GetOffsetAfterSequense) {
1536   std::unique_ptr<Environment> Env =
1537       Environment::CreateVirtualEnvironment(Code, FileName, /*Ranges=*/{});
1538   const SourceManager &SourceMgr = Env->getSourceManager();
1539   Lexer Lex(Env->getFileID(), SourceMgr.getBuffer(Env->getFileID()), SourceMgr,
1540             getFormattingLangOpts(Style));
1541   Token Tok;
1542   // Get the first token.
1543   Lex.LexFromRawLexer(Tok);
1544   return GetOffsetAfterSequense(SourceMgr, Lex, Tok);
1545 }
1546
1547 // Check if a sequence of tokens is like "#<Name> <raw_identifier>". If it is,
1548 // \p Tok will be the token after this directive; otherwise, it can be any token
1549 // after the given \p Tok (including \p Tok).
1550 bool checkAndConsumeDirectiveWithName(Lexer &Lex, StringRef Name, Token &Tok) {
1551   bool Matched = Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
1552                  Tok.is(tok::raw_identifier) &&
1553                  Tok.getRawIdentifier() == Name && !Lex.LexFromRawLexer(Tok) &&
1554                  Tok.is(tok::raw_identifier);
1555   if (Matched)
1556     Lex.LexFromRawLexer(Tok);
1557   return Matched;
1558 }
1559
1560 void skipComments(Lexer &Lex, Token &Tok) {
1561   while (Tok.is(tok::comment))
1562     if (Lex.LexFromRawLexer(Tok))
1563       return;
1564 }
1565
1566 // Returns the offset after header guard directives and any comments
1567 // before/after header guards. If no header guard presents in the code, this
1568 // will returns the offset after skipping all comments from the start of the
1569 // code.
1570 unsigned getOffsetAfterHeaderGuardsAndComments(StringRef FileName,
1571                                                StringRef Code,
1572                                                const FormatStyle &Style) {
1573   return getOffsetAfterTokenSequence(
1574       FileName, Code, Style,
1575       [](const SourceManager &SM, Lexer &Lex, Token Tok) {
1576         skipComments(Lex, Tok);
1577         unsigned InitialOffset = SM.getFileOffset(Tok.getLocation());
1578         if (checkAndConsumeDirectiveWithName(Lex, "ifndef", Tok)) {
1579           skipComments(Lex, Tok);
1580           if (checkAndConsumeDirectiveWithName(Lex, "define", Tok))
1581             return SM.getFileOffset(Tok.getLocation());
1582         }
1583         return InitialOffset;
1584       });
1585 }
1586
1587 // Check if a sequence of tokens is like
1588 //    "#include ("header.h" | <header.h>)".
1589 // If it is, \p Tok will be the token after this directive; otherwise, it can be
1590 // any token after the given \p Tok (including \p Tok).
1591 bool checkAndConsumeInclusiveDirective(Lexer &Lex, Token &Tok) {
1592   auto Matched = [&]() {
1593     Lex.LexFromRawLexer(Tok);
1594     return true;
1595   };
1596   if (Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
1597       Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "include") {
1598     if (Lex.LexFromRawLexer(Tok))
1599       return false;
1600     if (Tok.is(tok::string_literal))
1601       return Matched();
1602     if (Tok.is(tok::less)) {
1603       while (!Lex.LexFromRawLexer(Tok) && Tok.isNot(tok::greater)) {
1604       }
1605       if (Tok.is(tok::greater))
1606         return Matched();
1607     }
1608   }
1609   return false;
1610 }
1611
1612 // Returns the offset of the last #include directive after which a new
1613 // #include can be inserted. This ignores #include's after the #include block(s)
1614 // in the beginning of a file to avoid inserting headers into code sections
1615 // where new #include's should not be added by default.
1616 // These code sections include:
1617 //      - raw string literals (containing #include).
1618 //      - #if blocks.
1619 //      - Special #include's among declarations (e.g. functions).
1620 //
1621 // If no #include after which a new #include can be inserted, this returns the
1622 // offset after skipping all comments from the start of the code.
1623 // Inserting after an #include is not allowed if it comes after code that is not
1624 // #include (e.g. pre-processing directive that is not #include, declarations).
1625 unsigned getMaxHeaderInsertionOffset(StringRef FileName, StringRef Code,
1626                                      const FormatStyle &Style) {
1627   return getOffsetAfterTokenSequence(
1628       FileName, Code, Style,
1629       [](const SourceManager &SM, Lexer &Lex, Token Tok) {
1630         skipComments(Lex, Tok);
1631         unsigned MaxOffset = SM.getFileOffset(Tok.getLocation());
1632         while (checkAndConsumeInclusiveDirective(Lex, Tok))
1633           MaxOffset = SM.getFileOffset(Tok.getLocation());
1634         return MaxOffset;
1635       });
1636 }
1637
1638 bool isDeletedHeader(llvm::StringRef HeaderName,
1639                      const std::set<llvm::StringRef> &HeadersToDelete) {
1640   return HeadersToDelete.count(HeaderName) ||
1641          HeadersToDelete.count(HeaderName.trim("\"<>"));
1642 }
1643
1644 // FIXME: insert empty lines between newly created blocks.
1645 tooling::Replacements
1646 fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
1647                         const FormatStyle &Style) {
1648   if (Style.Language != FormatStyle::LanguageKind::LK_Cpp)
1649     return Replaces;
1650
1651   tooling::Replacements HeaderInsertions;
1652   std::set<llvm::StringRef> HeadersToDelete;
1653   tooling::Replacements Result;
1654   for (const auto &R : Replaces) {
1655     if (isHeaderInsertion(R)) {
1656       // Replacements from \p Replaces must be conflict-free already, so we can
1657       // simply consume the error.
1658       llvm::consumeError(HeaderInsertions.add(R));
1659     } else if (isHeaderDeletion(R)) {
1660       HeadersToDelete.insert(R.getReplacementText());
1661     } else if (R.getOffset() == UINT_MAX) {
1662       llvm::errs() << "Insertions other than header #include insertion are "
1663                       "not supported! "
1664                    << R.getReplacementText() << "\n";
1665     } else {
1666       llvm::consumeError(Result.add(R));
1667     }
1668   }
1669   if (HeaderInsertions.empty() && HeadersToDelete.empty())
1670     return Replaces;
1671
1672   llvm::Regex IncludeRegex(IncludeRegexPattern);
1673   llvm::Regex DefineRegex(R"(^[\t\ ]*#[\t\ ]*define[\t\ ]*[^\\]*$)");
1674   SmallVector<StringRef, 4> Matches;
1675
1676   StringRef FileName = Replaces.begin()->getFilePath();
1677   IncludeCategoryManager Categories(Style, FileName);
1678
1679   // Record the offset of the end of the last include in each category.
1680   std::map<int, int> CategoryEndOffsets;
1681   // All possible priorities.
1682   // Add 0 for main header and INT_MAX for headers that are not in any category.
1683   std::set<int> Priorities = {0, INT_MAX};
1684   for (const auto &Category : Style.IncludeCategories)
1685     Priorities.insert(Category.Priority);
1686   int FirstIncludeOffset = -1;
1687   // All new headers should be inserted after this offset.
1688   unsigned MinInsertOffset =
1689       getOffsetAfterHeaderGuardsAndComments(FileName, Code, Style);
1690   StringRef TrimmedCode = Code.drop_front(MinInsertOffset);
1691   // Max insertion offset in the original code.
1692   unsigned MaxInsertOffset =
1693       MinInsertOffset +
1694       getMaxHeaderInsertionOffset(FileName, TrimmedCode, Style);
1695   SmallVector<StringRef, 32> Lines;
1696   TrimmedCode.split(Lines, '\n');
1697   unsigned Offset = MinInsertOffset;
1698   unsigned NextLineOffset;
1699   std::set<StringRef> ExistingIncludes;
1700   for (auto Line : Lines) {
1701     NextLineOffset = std::min(Code.size(), Offset + Line.size() + 1);
1702     if (IncludeRegex.match(Line, &Matches)) {
1703       // The header name with quotes or angle brackets.
1704       StringRef IncludeName = Matches[2];
1705       ExistingIncludes.insert(IncludeName);
1706       // Only record the offset of current #include if we can insert after it.
1707       if (Offset <= MaxInsertOffset) {
1708         int Category = Categories.getIncludePriority(
1709             IncludeName, /*CheckMainHeader=*/FirstIncludeOffset < 0);
1710         CategoryEndOffsets[Category] = NextLineOffset;
1711         if (FirstIncludeOffset < 0)
1712           FirstIncludeOffset = Offset;
1713       }
1714       if (isDeletedHeader(IncludeName, HeadersToDelete)) {
1715         // If this is the last line without trailing newline, we need to make
1716         // sure we don't delete across the file boundary.
1717         unsigned Length = std::min(Line.size() + 1, Code.size() - Offset);
1718         llvm::Error Err =
1719             Result.add(tooling::Replacement(FileName, Offset, Length, ""));
1720         if (Err) {
1721           // Ignore the deletion on conflict.
1722           llvm::errs() << "Failed to add header deletion replacement for "
1723                        << IncludeName << ": " << llvm::toString(std::move(Err))
1724                        << "\n";
1725         }
1726       }
1727     }
1728     Offset = NextLineOffset;
1729   }
1730
1731   // Populate CategoryEndOfssets:
1732   // - Ensure that CategoryEndOffset[Highest] is always populated.
1733   // - If CategoryEndOffset[Priority] isn't set, use the next higher value that
1734   //   is set, up to CategoryEndOffset[Highest].
1735   auto Highest = Priorities.begin();
1736   if (CategoryEndOffsets.find(*Highest) == CategoryEndOffsets.end()) {
1737     if (FirstIncludeOffset >= 0)
1738       CategoryEndOffsets[*Highest] = FirstIncludeOffset;
1739     else
1740       CategoryEndOffsets[*Highest] = MinInsertOffset;
1741   }
1742   // By this point, CategoryEndOffset[Highest] is always set appropriately:
1743   //  - to an appropriate location before/after existing #includes, or
1744   //  - to right after the header guard, or
1745   //  - to the beginning of the file.
1746   for (auto I = ++Priorities.begin(), E = Priorities.end(); I != E; ++I)
1747     if (CategoryEndOffsets.find(*I) == CategoryEndOffsets.end())
1748       CategoryEndOffsets[*I] = CategoryEndOffsets[*std::prev(I)];
1749
1750   bool NeedNewLineAtEnd = !Code.empty() && Code.back() != '\n';
1751   for (const auto &R : HeaderInsertions) {
1752     auto IncludeDirective = R.getReplacementText();
1753     bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
1754     assert(Matched && "Header insertion replacement must have replacement text "
1755                       "'#include ...'");
1756     (void)Matched;
1757     auto IncludeName = Matches[2];
1758     if (ExistingIncludes.find(IncludeName) != ExistingIncludes.end()) {
1759       DEBUG(llvm::dbgs() << "Skip adding existing include : " << IncludeName
1760                          << "\n");
1761       continue;
1762     }
1763     int Category =
1764         Categories.getIncludePriority(IncludeName, /*CheckMainHeader=*/true);
1765     Offset = CategoryEndOffsets[Category];
1766     std::string NewInclude = !IncludeDirective.endswith("\n")
1767                                  ? (IncludeDirective + "\n").str()
1768                                  : IncludeDirective.str();
1769     // When inserting headers at end of the code, also append '\n' to the code
1770     // if it does not end with '\n'.
1771     if (NeedNewLineAtEnd && Offset == Code.size()) {
1772       NewInclude = "\n" + NewInclude;
1773       NeedNewLineAtEnd = false;
1774     }
1775     auto NewReplace = tooling::Replacement(FileName, Offset, 0, NewInclude);
1776     auto Err = Result.add(NewReplace);
1777     if (Err) {
1778       llvm::consumeError(std::move(Err));
1779       unsigned NewOffset = Result.getShiftedCodePosition(Offset);
1780       NewReplace = tooling::Replacement(FileName, NewOffset, 0, NewInclude);
1781       Result = Result.merge(tooling::Replacements(NewReplace));
1782     }
1783   }
1784   return Result;
1785 }
1786
1787 } // anonymous namespace
1788
1789 llvm::Expected<tooling::Replacements>
1790 cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
1791                           const FormatStyle &Style) {
1792   // We need to use lambda function here since there are two versions of
1793   // `cleanup`.
1794   auto Cleanup = [](const FormatStyle &Style, StringRef Code,
1795                     std::vector<tooling::Range> Ranges,
1796                     StringRef FileName) -> tooling::Replacements {
1797     return cleanup(Style, Code, Ranges, FileName);
1798   };
1799   // Make header insertion replacements insert new headers into correct blocks.
1800   tooling::Replacements NewReplaces =
1801       fixCppIncludeInsertions(Code, Replaces, Style);
1802   return processReplacements(Cleanup, Code, NewReplaces, Style);
1803 }
1804
1805 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
1806                                ArrayRef<tooling::Range> Ranges,
1807                                StringRef FileName, bool *IncompleteFormat) {
1808   FormatStyle Expanded = expandPresets(Style);
1809   if (Expanded.DisableFormat)
1810     return tooling::Replacements();
1811
1812   auto Env = Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
1813
1814   if (Style.Language == FormatStyle::LK_JavaScript &&
1815       Style.JavaScriptQuotes != FormatStyle::JSQS_Leave) {
1816     JavaScriptRequoter Requoter(*Env, Expanded);
1817     tooling::Replacements Requotes = Requoter.process();
1818     if (!Requotes.empty()) {
1819       auto NewCode = applyAllReplacements(Code, Requotes);
1820       if (NewCode) {
1821         auto NewEnv = Environment::CreateVirtualEnvironment(
1822             *NewCode, FileName,
1823             tooling::calculateRangesAfterReplacements(Requotes, Ranges));
1824         Formatter Format(*NewEnv, Expanded, IncompleteFormat);
1825         return Requotes.merge(Format.process());
1826       }
1827     }
1828   }
1829
1830   Formatter Format(*Env, Expanded, IncompleteFormat);
1831   return Format.process();
1832 }
1833
1834 tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
1835                               ArrayRef<tooling::Range> Ranges,
1836                               StringRef FileName) {
1837   std::unique_ptr<Environment> Env =
1838       Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
1839   Cleaner Clean(*Env, Style);
1840   return Clean.process();
1841 }
1842
1843 LangOptions getFormattingLangOpts(const FormatStyle &Style) {
1844   LangOptions LangOpts;
1845   LangOpts.CPlusPlus = 1;
1846   LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
1847   LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
1848   LangOpts.LineComment = 1;
1849   bool AlternativeOperators = Style.Language == FormatStyle::LK_Cpp;
1850   LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
1851   LangOpts.Bool = 1;
1852   LangOpts.ObjC1 = 1;
1853   LangOpts.ObjC2 = 1;
1854   LangOpts.MicrosoftExt = 1;    // To get kw___try, kw___finally.
1855   LangOpts.DeclSpecKeyword = 1; // To get __declspec.
1856   return LangOpts;
1857 }
1858
1859 const char *StyleOptionHelpDescription =
1860     "Coding style, currently supports:\n"
1861     "  LLVM, Google, Chromium, Mozilla, WebKit.\n"
1862     "Use -style=file to load style configuration from\n"
1863     ".clang-format file located in one of the parent\n"
1864     "directories of the source file (or current\n"
1865     "directory for stdin).\n"
1866     "Use -style=\"{key: value, ...}\" to set specific\n"
1867     "parameters, e.g.:\n"
1868     "  -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
1869
1870 static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
1871   if (FileName.endswith(".java"))
1872     return FormatStyle::LK_Java;
1873   if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
1874     return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
1875   if (FileName.endswith(".m") || FileName.endswith(".mm"))
1876     return FormatStyle::LK_ObjC;
1877   if (FileName.endswith_lower(".proto") ||
1878       FileName.endswith_lower(".protodevel"))
1879     return FormatStyle::LK_Proto;
1880   if (FileName.endswith_lower(".td"))
1881     return FormatStyle::LK_TableGen;
1882   return FormatStyle::LK_Cpp;
1883 }
1884
1885 FormatStyle getStyle(StringRef StyleName, StringRef FileName,
1886                      StringRef FallbackStyle, StringRef Code,
1887                      vfs::FileSystem *FS) {
1888   if (!FS) {
1889     FS = vfs::getRealFileSystem().get();
1890   }
1891   FormatStyle Style = getLLVMStyle();
1892   Style.Language = getLanguageByFileName(FileName);
1893
1894   // This is a very crude detection of whether a header contains ObjC code that
1895   // should be improved over time and probably be done on tokens, not one the
1896   // bare content of the file.
1897   if (Style.Language == FormatStyle::LK_Cpp && FileName.endswith(".h") &&
1898       (Code.contains("\n- (") || Code.contains("\n+ (")))
1899     Style.Language = FormatStyle::LK_ObjC;
1900
1901   if (!getPredefinedStyle(FallbackStyle, Style.Language, &Style)) {
1902     llvm::errs() << "Invalid fallback style \"" << FallbackStyle
1903                  << "\" using LLVM style\n";
1904     return Style;
1905   }
1906
1907   if (StyleName.startswith("{")) {
1908     // Parse YAML/JSON style from the command line.
1909     if (std::error_code ec = parseConfiguration(StyleName, &Style)) {
1910       llvm::errs() << "Error parsing -style: " << ec.message() << ", using "
1911                    << FallbackStyle << " style\n";
1912     }
1913     return Style;
1914   }
1915
1916   if (!StyleName.equals_lower("file")) {
1917     if (!getPredefinedStyle(StyleName, Style.Language, &Style))
1918       llvm::errs() << "Invalid value for -style, using " << FallbackStyle
1919                    << " style\n";
1920     return Style;
1921   }
1922
1923   // Look for .clang-format/_clang-format file in the file's parent directories.
1924   SmallString<128> UnsuitableConfigFiles;
1925   SmallString<128> Path(FileName);
1926   if (std::error_code EC = FS->makeAbsolute(Path)) {
1927     llvm::errs() << EC.message() << "\n";
1928     return Style;
1929   }
1930
1931   for (StringRef Directory = Path; !Directory.empty();
1932        Directory = llvm::sys::path::parent_path(Directory)) {
1933
1934     auto Status = FS->status(Directory);
1935     if (!Status ||
1936         Status->getType() != llvm::sys::fs::file_type::directory_file) {
1937       continue;
1938     }
1939
1940     SmallString<128> ConfigFile(Directory);
1941
1942     llvm::sys::path::append(ConfigFile, ".clang-format");
1943     DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
1944
1945     Status = FS->status(ConfigFile.str());
1946     bool IsFile =
1947         Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
1948     if (!IsFile) {
1949       // Try _clang-format too, since dotfiles are not commonly used on Windows.
1950       ConfigFile = Directory;
1951       llvm::sys::path::append(ConfigFile, "_clang-format");
1952       DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
1953       Status = FS->status(ConfigFile.str());
1954       IsFile = Status &&
1955                (Status->getType() == llvm::sys::fs::file_type::regular_file);
1956     }
1957
1958     if (IsFile) {
1959       llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
1960           FS->getBufferForFile(ConfigFile.str());
1961       if (std::error_code EC = Text.getError()) {
1962         llvm::errs() << EC.message() << "\n";
1963         break;
1964       }
1965       if (std::error_code ec =
1966               parseConfiguration(Text.get()->getBuffer(), &Style)) {
1967         if (ec == ParseError::Unsuitable) {
1968           if (!UnsuitableConfigFiles.empty())
1969             UnsuitableConfigFiles.append(", ");
1970           UnsuitableConfigFiles.append(ConfigFile);
1971           continue;
1972         }
1973         llvm::errs() << "Error reading " << ConfigFile << ": " << ec.message()
1974                      << "\n";
1975         break;
1976       }
1977       DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n");
1978       return Style;
1979     }
1980   }
1981   if (!UnsuitableConfigFiles.empty()) {
1982     llvm::errs() << "Configuration file(s) do(es) not support "
1983                  << getLanguageName(Style.Language) << ": "
1984                  << UnsuitableConfigFiles << "\n";
1985   }
1986   return Style;
1987 }
1988
1989 } // namespace format
1990 } // namespace clang