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 "ContinuationIndenter.h"
17 #include "TokenAnnotator.h"
18 #include "UnwrappedLineFormatter.h"
19 #include "UnwrappedLineParser.h"
20 #include "WhitespaceManager.h"
21 #include "clang/Basic/Diagnostic.h"
22 #include "clang/Basic/DiagnosticOptions.h"
23 #include "clang/Basic/SourceManager.h"
24 #include "clang/Format/Format.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/YAMLTraits.h"
31 #include <queue>
32 #include <string>
33 
34 #define DEBUG_TYPE "format-formatter"
35 
36 using clang::format::FormatStyle;
37 
38 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
39 
40 namespace llvm {
41 namespace yaml {
42 template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
43   static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
44     IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
45     IO.enumCase(Value, "Java", FormatStyle::LK_Java);
46     IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
47     IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
48   }
49 };
50 
51 template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> {
52   static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
53     IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03);
54     IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03);
55     IO.enumCase(Value, "Cpp11", FormatStyle::LS_Cpp11);
56     IO.enumCase(Value, "C++11", FormatStyle::LS_Cpp11);
57     IO.enumCase(Value, "Auto", FormatStyle::LS_Auto);
58   }
59 };
60 
61 template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
62   static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
63     IO.enumCase(Value, "Never", FormatStyle::UT_Never);
64     IO.enumCase(Value, "false", FormatStyle::UT_Never);
65     IO.enumCase(Value, "Always", FormatStyle::UT_Always);
66     IO.enumCase(Value, "true", FormatStyle::UT_Always);
67     IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
68   }
69 };
70 
71 template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
72   static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
73     IO.enumCase(Value, "None", FormatStyle::SFS_None);
74     IO.enumCase(Value, "false", FormatStyle::SFS_None);
75     IO.enumCase(Value, "All", FormatStyle::SFS_All);
76     IO.enumCase(Value, "true", FormatStyle::SFS_All);
77     IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
78     IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
79   }
80 };
81 
82 template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
83   static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
84     IO.enumCase(Value, "All", FormatStyle::BOS_All);
85     IO.enumCase(Value, "true", FormatStyle::BOS_All);
86     IO.enumCase(Value, "None", FormatStyle::BOS_None);
87     IO.enumCase(Value, "false", FormatStyle::BOS_None);
88     IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
89   }
90 };
91 
92 template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
93   static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
94     IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
95     IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
96     IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
97     IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
98     IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
99   }
100 };
101 
102 template <>
103 struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
104   static void enumeration(IO &IO,
105                           FormatStyle::NamespaceIndentationKind &Value) {
106     IO.enumCase(Value, "None", FormatStyle::NI_None);
107     IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
108     IO.enumCase(Value, "All", FormatStyle::NI_All);
109   }
110 };
111 
112 template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
113   static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
114     IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
115     IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
116     IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
117 
118     // For backward compatibility.
119     IO.enumCase(Value, "true", FormatStyle::PAS_Left);
120     IO.enumCase(Value, "false", FormatStyle::PAS_Right);
121   }
122 };
123 
124 template <>
125 struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
126   static void enumeration(IO &IO,
127                           FormatStyle::SpaceBeforeParensOptions &Value) {
128     IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
129     IO.enumCase(Value, "ControlStatements",
130                 FormatStyle::SBPO_ControlStatements);
131     IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
132 
133     // For backward compatibility.
134     IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
135     IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
136   }
137 };
138 
139 template <> struct MappingTraits<FormatStyle> {
140   static void mapping(IO &IO, FormatStyle &Style) {
141     // When reading, read the language first, we need it for getPredefinedStyle.
142     IO.mapOptional("Language", Style.Language);
143 
144     if (IO.outputting()) {
145       StringRef StylesArray[] = {"LLVM",    "Google", "Chromium",
146                                  "Mozilla", "WebKit", "GNU"};
147       ArrayRef<StringRef> Styles(StylesArray);
148       for (size_t i = 0, e = Styles.size(); i < e; ++i) {
149         StringRef StyleName(Styles[i]);
150         FormatStyle PredefinedStyle;
151         if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
152             Style == PredefinedStyle) {
153           IO.mapOptional("# BasedOnStyle", StyleName);
154           break;
155         }
156       }
157     } else {
158       StringRef BasedOnStyle;
159       IO.mapOptional("BasedOnStyle", BasedOnStyle);
160       if (!BasedOnStyle.empty()) {
161         FormatStyle::LanguageKind OldLanguage = Style.Language;
162         FormatStyle::LanguageKind Language =
163             ((FormatStyle *)IO.getContext())->Language;
164         if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
165           IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
166           return;
167         }
168         Style.Language = OldLanguage;
169       }
170     }
171 
172     IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
173     IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
174     IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft);
175     IO.mapOptional("AlignOperands", Style.AlignOperands);
176     IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
177     IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
178                    Style.AllowAllParametersOfDeclarationOnNextLine);
179     IO.mapOptional("AllowShortBlocksOnASingleLine",
180                    Style.AllowShortBlocksOnASingleLine);
181     IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
182                    Style.AllowShortCaseLabelsOnASingleLine);
183     IO.mapOptional("AllowShortIfStatementsOnASingleLine",
184                    Style.AllowShortIfStatementsOnASingleLine);
185     IO.mapOptional("AllowShortLoopsOnASingleLine",
186                    Style.AllowShortLoopsOnASingleLine);
187     IO.mapOptional("AllowShortFunctionsOnASingleLine",
188                    Style.AllowShortFunctionsOnASingleLine);
189     IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
190                    Style.AlwaysBreakAfterDefinitionReturnType);
191     IO.mapOptional("AlwaysBreakTemplateDeclarations",
192                    Style.AlwaysBreakTemplateDeclarations);
193     IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
194                    Style.AlwaysBreakBeforeMultilineStrings);
195     IO.mapOptional("BreakBeforeBinaryOperators",
196                    Style.BreakBeforeBinaryOperators);
197     IO.mapOptional("BreakBeforeTernaryOperators",
198                    Style.BreakBeforeTernaryOperators);
199     IO.mapOptional("BreakConstructorInitializersBeforeComma",
200                    Style.BreakConstructorInitializersBeforeComma);
201     IO.mapOptional("BinPackParameters", Style.BinPackParameters);
202     IO.mapOptional("BinPackArguments", Style.BinPackArguments);
203     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
204     IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
205                    Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
206     IO.mapOptional("ConstructorInitializerIndentWidth",
207                    Style.ConstructorInitializerIndentWidth);
208     IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
209     IO.mapOptional("ExperimentalAutoDetectBinPacking",
210                    Style.ExperimentalAutoDetectBinPacking);
211     IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
212     IO.mapOptional("IndentWrappedFunctionNames",
213                    Style.IndentWrappedFunctionNames);
214     IO.mapOptional("IndentFunctionDeclarationAfterType",
215                    Style.IndentWrappedFunctionNames);
216     IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
217     IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
218                    Style.KeepEmptyLinesAtTheStartOfBlocks);
219     IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
220     IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
221     IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
222     IO.mapOptional("ObjCSpaceBeforeProtocolList",
223                    Style.ObjCSpaceBeforeProtocolList);
224     IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
225                    Style.PenaltyBreakBeforeFirstCallParameter);
226     IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
227     IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
228     IO.mapOptional("PenaltyBreakFirstLessLess",
229                    Style.PenaltyBreakFirstLessLess);
230     IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
231     IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
232                    Style.PenaltyReturnTypeOnItsOwnLine);
233     IO.mapOptional("PointerAlignment", Style.PointerAlignment);
234     IO.mapOptional("SpacesBeforeTrailingComments",
235                    Style.SpacesBeforeTrailingComments);
236     IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
237     IO.mapOptional("Standard", Style.Standard);
238     IO.mapOptional("IndentWidth", Style.IndentWidth);
239     IO.mapOptional("TabWidth", Style.TabWidth);
240     IO.mapOptional("UseTab", Style.UseTab);
241     IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
242     IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
243     IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
244     IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
245     IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
246     IO.mapOptional("SpacesInCStyleCastParentheses",
247                    Style.SpacesInCStyleCastParentheses);
248     IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
249     IO.mapOptional("SpacesInContainerLiterals",
250                    Style.SpacesInContainerLiterals);
251     IO.mapOptional("SpaceBeforeAssignmentOperators",
252                    Style.SpaceBeforeAssignmentOperators);
253     IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
254     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
255     IO.mapOptional("ForEachMacros", Style.ForEachMacros);
256 
257     // For backward compatibility.
258     if (!IO.outputting()) {
259       IO.mapOptional("SpaceAfterControlStatementKeyword",
260                      Style.SpaceBeforeParens);
261       IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
262       IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
263     }
264     IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
265     IO.mapOptional("DisableFormat", Style.DisableFormat);
266   }
267 };
268 
269 // Allows to read vector<FormatStyle> while keeping default values.
270 // IO.getContext() should contain a pointer to the FormatStyle structure, that
271 // will be used to get default values for missing keys.
272 // If the first element has no Language specified, it will be treated as the
273 // default one for the following elements.
274 template <> struct DocumentListTraits<std::vector<FormatStyle>> {
275   static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
276     return Seq.size();
277   }
278   static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
279                               size_t Index) {
280     if (Index >= Seq.size()) {
281       assert(Index == Seq.size());
282       FormatStyle Template;
283       if (Seq.size() > 0 && Seq[0].Language == FormatStyle::LK_None) {
284         Template = Seq[0];
285       } else {
286         Template = *((const FormatStyle *)IO.getContext());
287         Template.Language = FormatStyle::LK_None;
288       }
289       Seq.resize(Index + 1, Template);
290     }
291     return Seq[Index];
292   }
293 };
294 }
295 }
296 
297 namespace clang {
298 namespace format {
299 
300 const std::error_category &getParseCategory() {
301   static ParseErrorCategory C;
302   return C;
303 }
304 std::error_code make_error_code(ParseError e) {
305   return std::error_code(static_cast<int>(e), getParseCategory());
306 }
307 
308 const char *ParseErrorCategory::name() const LLVM_NOEXCEPT {
309   return "clang-format.parse_error";
310 }
311 
312 std::string ParseErrorCategory::message(int EV) const {
313   switch (static_cast<ParseError>(EV)) {
314   case ParseError::Success:
315     return "Success";
316   case ParseError::Error:
317     return "Invalid argument";
318   case ParseError::Unsuitable:
319     return "Unsuitable";
320   }
321   llvm_unreachable("unexpected parse error");
322 }
323 
324 FormatStyle getLLVMStyle() {
325   FormatStyle LLVMStyle;
326   LLVMStyle.Language = FormatStyle::LK_Cpp;
327   LLVMStyle.AccessModifierOffset = -2;
328   LLVMStyle.AlignEscapedNewlinesLeft = false;
329   LLVMStyle.AlignAfterOpenBracket = true;
330   LLVMStyle.AlignOperands = true;
331   LLVMStyle.AlignTrailingComments = true;
332   LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
333   LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
334   LLVMStyle.AllowShortBlocksOnASingleLine = false;
335   LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
336   LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
337   LLVMStyle.AllowShortLoopsOnASingleLine = false;
338   LLVMStyle.AlwaysBreakAfterDefinitionReturnType = false;
339   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
340   LLVMStyle.AlwaysBreakTemplateDeclarations = false;
341   LLVMStyle.BinPackParameters = true;
342   LLVMStyle.BinPackArguments = true;
343   LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
344   LLVMStyle.BreakBeforeTernaryOperators = true;
345   LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
346   LLVMStyle.BreakConstructorInitializersBeforeComma = false;
347   LLVMStyle.ColumnLimit = 80;
348   LLVMStyle.CommentPragmas = "^ IWYU pragma:";
349   LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
350   LLVMStyle.ConstructorInitializerIndentWidth = 4;
351   LLVMStyle.ContinuationIndentWidth = 4;
352   LLVMStyle.Cpp11BracedListStyle = true;
353   LLVMStyle.DerivePointerAlignment = false;
354   LLVMStyle.ExperimentalAutoDetectBinPacking = false;
355   LLVMStyle.ForEachMacros.push_back("foreach");
356   LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
357   LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
358   LLVMStyle.IndentCaseLabels = false;
359   LLVMStyle.IndentWrappedFunctionNames = false;
360   LLVMStyle.IndentWidth = 2;
361   LLVMStyle.TabWidth = 8;
362   LLVMStyle.MaxEmptyLinesToKeep = 1;
363   LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
364   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
365   LLVMStyle.ObjCBlockIndentWidth = 2;
366   LLVMStyle.ObjCSpaceAfterProperty = false;
367   LLVMStyle.ObjCSpaceBeforeProtocolList = true;
368   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
369   LLVMStyle.SpacesBeforeTrailingComments = 1;
370   LLVMStyle.Standard = FormatStyle::LS_Cpp11;
371   LLVMStyle.UseTab = FormatStyle::UT_Never;
372   LLVMStyle.SpacesInParentheses = false;
373   LLVMStyle.SpacesInSquareBrackets = false;
374   LLVMStyle.SpaceInEmptyParentheses = false;
375   LLVMStyle.SpacesInContainerLiterals = true;
376   LLVMStyle.SpacesInCStyleCastParentheses = false;
377   LLVMStyle.SpaceAfterCStyleCast = false;
378   LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
379   LLVMStyle.SpaceBeforeAssignmentOperators = true;
380   LLVMStyle.SpacesInAngles = false;
381 
382   LLVMStyle.PenaltyBreakComment = 300;
383   LLVMStyle.PenaltyBreakFirstLessLess = 120;
384   LLVMStyle.PenaltyBreakString = 1000;
385   LLVMStyle.PenaltyExcessCharacter = 1000000;
386   LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
387   LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
388 
389   LLVMStyle.DisableFormat = false;
390 
391   return LLVMStyle;
392 }
393 
394 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
395   FormatStyle GoogleStyle = getLLVMStyle();
396   GoogleStyle.Language = Language;
397 
398   GoogleStyle.AccessModifierOffset = -1;
399   GoogleStyle.AlignEscapedNewlinesLeft = true;
400   GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
401   GoogleStyle.AllowShortLoopsOnASingleLine = true;
402   GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
403   GoogleStyle.AlwaysBreakTemplateDeclarations = true;
404   GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
405   GoogleStyle.DerivePointerAlignment = true;
406   GoogleStyle.IndentCaseLabels = true;
407   GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
408   GoogleStyle.ObjCSpaceAfterProperty = false;
409   GoogleStyle.ObjCSpaceBeforeProtocolList = false;
410   GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
411   GoogleStyle.SpacesBeforeTrailingComments = 2;
412   GoogleStyle.Standard = FormatStyle::LS_Auto;
413 
414   GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
415   GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
416 
417   if (Language == FormatStyle::LK_Java) {
418     GoogleStyle.AlignAfterOpenBracket = false;
419     GoogleStyle.AlignOperands = false;
420     GoogleStyle.AlignTrailingComments = false;
421     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
422     GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
423     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
424     GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
425     GoogleStyle.ColumnLimit = 100;
426     GoogleStyle.SpaceAfterCStyleCast = true;
427     GoogleStyle.SpacesBeforeTrailingComments = 1;
428   } else if (Language == FormatStyle::LK_JavaScript) {
429     GoogleStyle.BreakBeforeTernaryOperators = false;
430     GoogleStyle.MaxEmptyLinesToKeep = 3;
431     GoogleStyle.SpacesInContainerLiterals = false;
432     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
433     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
434   } else if (Language == FormatStyle::LK_Proto) {
435     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
436     GoogleStyle.SpacesInContainerLiterals = false;
437   }
438 
439   return GoogleStyle;
440 }
441 
442 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
443   FormatStyle ChromiumStyle = getGoogleStyle(Language);
444   if (Language == FormatStyle::LK_Java) {
445     ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
446     ChromiumStyle.IndentWidth = 4;
447     ChromiumStyle.ContinuationIndentWidth = 8;
448   } else {
449     ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
450     ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
451     ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
452     ChromiumStyle.AllowShortLoopsOnASingleLine = false;
453     ChromiumStyle.BinPackParameters = false;
454     ChromiumStyle.DerivePointerAlignment = false;
455   }
456   return ChromiumStyle;
457 }
458 
459 FormatStyle getMozillaStyle() {
460   FormatStyle MozillaStyle = getLLVMStyle();
461   MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
462   MozillaStyle.Cpp11BracedListStyle = false;
463   MozillaStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
464   MozillaStyle.DerivePointerAlignment = true;
465   MozillaStyle.IndentCaseLabels = true;
466   MozillaStyle.ObjCSpaceAfterProperty = true;
467   MozillaStyle.ObjCSpaceBeforeProtocolList = false;
468   MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
469   MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
470   MozillaStyle.Standard = FormatStyle::LS_Cpp03;
471   return MozillaStyle;
472 }
473 
474 FormatStyle getWebKitStyle() {
475   FormatStyle Style = getLLVMStyle();
476   Style.AccessModifierOffset = -4;
477   Style.AlignAfterOpenBracket = false;
478   Style.AlignOperands = false;
479   Style.AlignTrailingComments = false;
480   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
481   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
482   Style.BreakConstructorInitializersBeforeComma = true;
483   Style.Cpp11BracedListStyle = false;
484   Style.ColumnLimit = 0;
485   Style.IndentWidth = 4;
486   Style.NamespaceIndentation = FormatStyle::NI_Inner;
487   Style.ObjCBlockIndentWidth = 4;
488   Style.ObjCSpaceAfterProperty = true;
489   Style.PointerAlignment = FormatStyle::PAS_Left;
490   Style.Standard = FormatStyle::LS_Cpp03;
491   return Style;
492 }
493 
494 FormatStyle getGNUStyle() {
495   FormatStyle Style = getLLVMStyle();
496   Style.AlwaysBreakAfterDefinitionReturnType = true;
497   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
498   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
499   Style.BreakBeforeTernaryOperators = true;
500   Style.Cpp11BracedListStyle = false;
501   Style.ColumnLimit = 79;
502   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
503   Style.Standard = FormatStyle::LS_Cpp03;
504   return Style;
505 }
506 
507 FormatStyle getNoStyle() {
508   FormatStyle NoStyle = getLLVMStyle();
509   NoStyle.DisableFormat = true;
510   return NoStyle;
511 }
512 
513 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
514                         FormatStyle *Style) {
515   if (Name.equals_lower("llvm")) {
516     *Style = getLLVMStyle();
517   } else if (Name.equals_lower("chromium")) {
518     *Style = getChromiumStyle(Language);
519   } else if (Name.equals_lower("mozilla")) {
520     *Style = getMozillaStyle();
521   } else if (Name.equals_lower("google")) {
522     *Style = getGoogleStyle(Language);
523   } else if (Name.equals_lower("webkit")) {
524     *Style = getWebKitStyle();
525   } else if (Name.equals_lower("gnu")) {
526     *Style = getGNUStyle();
527   } else if (Name.equals_lower("none")) {
528     *Style = getNoStyle();
529   } else {
530     return false;
531   }
532 
533   Style->Language = Language;
534   return true;
535 }
536 
537 std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
538   assert(Style);
539   FormatStyle::LanguageKind Language = Style->Language;
540   assert(Language != FormatStyle::LK_None);
541   if (Text.trim().empty())
542     return make_error_code(ParseError::Error);
543 
544   std::vector<FormatStyle> Styles;
545   llvm::yaml::Input Input(Text);
546   // DocumentListTraits<vector<FormatStyle>> uses the context to get default
547   // values for the fields, keys for which are missing from the configuration.
548   // Mapping also uses the context to get the language to find the correct
549   // base style.
550   Input.setContext(Style);
551   Input >> Styles;
552   if (Input.error())
553     return Input.error();
554 
555   for (unsigned i = 0; i < Styles.size(); ++i) {
556     // Ensures that only the first configuration can skip the Language option.
557     if (Styles[i].Language == FormatStyle::LK_None && i != 0)
558       return make_error_code(ParseError::Error);
559     // Ensure that each language is configured at most once.
560     for (unsigned j = 0; j < i; ++j) {
561       if (Styles[i].Language == Styles[j].Language) {
562         DEBUG(llvm::dbgs()
563               << "Duplicate languages in the config file on positions " << j
564               << " and " << i << "\n");
565         return make_error_code(ParseError::Error);
566       }
567     }
568   }
569   // Look for a suitable configuration starting from the end, so we can
570   // find the configuration for the specific language first, and the default
571   // configuration (which can only be at slot 0) after it.
572   for (int i = Styles.size() - 1; i >= 0; --i) {
573     if (Styles[i].Language == Language ||
574         Styles[i].Language == FormatStyle::LK_None) {
575       *Style = Styles[i];
576       Style->Language = Language;
577       return make_error_code(ParseError::Success);
578     }
579   }
580   return make_error_code(ParseError::Unsuitable);
581 }
582 
583 std::string configurationAsText(const FormatStyle &Style) {
584   std::string Text;
585   llvm::raw_string_ostream Stream(Text);
586   llvm::yaml::Output Output(Stream);
587   // We use the same mapping method for input and output, so we need a non-const
588   // reference here.
589   FormatStyle NonConstStyle = Style;
590   Output << NonConstStyle;
591   return Stream.str();
592 }
593 
594 namespace {
595 
596 class FormatTokenLexer {
597 public:
598   FormatTokenLexer(SourceManager &SourceMgr, FileID ID, FormatStyle &Style,
599                    encoding::Encoding Encoding)
600       : FormatTok(nullptr), IsFirstToken(true), GreaterStashed(false),
601         LessStashed(false), Column(0), TrailingWhitespace(0),
602         SourceMgr(SourceMgr), ID(ID), Style(Style),
603         IdentTable(getFormattingLangOpts(Style)), Keywords(IdentTable),
604         Encoding(Encoding), FirstInLineIndex(0), FormattingDisabled(false) {
605     Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
606                         getFormattingLangOpts(Style)));
607     Lex->SetKeepWhitespaceMode(true);
608 
609     for (const std::string &ForEachMacro : Style.ForEachMacros)
610       ForEachMacros.push_back(&IdentTable.get(ForEachMacro));
611     std::sort(ForEachMacros.begin(), ForEachMacros.end());
612   }
613 
614   ArrayRef<FormatToken *> lex() {
615     assert(Tokens.empty());
616     assert(FirstInLineIndex == 0);
617     do {
618       Tokens.push_back(getNextToken());
619       tryMergePreviousTokens();
620       if (Tokens.back()->NewlinesBefore > 0 || Tokens.back()->IsMultiline)
621         FirstInLineIndex = Tokens.size() - 1;
622     } while (Tokens.back()->Tok.isNot(tok::eof));
623     return Tokens;
624   }
625 
626   const AdditionalKeywords &getKeywords() { return Keywords; }
627 
628 private:
629   void tryMergePreviousTokens() {
630     if (tryMerge_TMacro())
631       return;
632     if (tryMergeConflictMarkers())
633       return;
634     if (tryMergeLessLess())
635       return;
636 
637     if (Style.Language == FormatStyle::LK_JavaScript) {
638       if (tryMergeJSRegexLiteral())
639         return;
640       if (tryMergeEscapeSequence())
641         return;
642       if (tryMergeTemplateString())
643         return;
644 
645       static const tok::TokenKind JSIdentity[] = {tok::equalequal, tok::equal};
646       static const tok::TokenKind JSNotIdentity[] = {tok::exclaimequal,
647                                                      tok::equal};
648       static const tok::TokenKind JSShiftEqual[] = {tok::greater, tok::greater,
649                                                     tok::greaterequal};
650       static const tok::TokenKind JSRightArrow[] = {tok::equal, tok::greater};
651       // FIXME: We probably need to change token type to mimic operator with the
652       // correct priority.
653       if (tryMergeTokens(JSIdentity))
654         return;
655       if (tryMergeTokens(JSNotIdentity))
656         return;
657       if (tryMergeTokens(JSShiftEqual))
658         return;
659       if (tryMergeTokens(JSRightArrow))
660         return;
661     }
662   }
663 
664   bool tryMergeLessLess() {
665     // Merge X,less,less,Y into X,lessless,Y unless X or Y is less.
666     if (Tokens.size() < 3)
667       return false;
668 
669     bool FourthTokenIsLess = false;
670     if (Tokens.size() > 3)
671       FourthTokenIsLess = (Tokens.end() - 4)[0]->is(tok::less);
672 
673     auto First = Tokens.end() - 3;
674     if (First[2]->is(tok::less) || First[1]->isNot(tok::less) ||
675         First[0]->isNot(tok::less) || FourthTokenIsLess)
676       return false;
677 
678     // Only merge if there currently is no whitespace between the two "<".
679     if (First[1]->WhitespaceRange.getBegin() !=
680         First[1]->WhitespaceRange.getEnd())
681       return false;
682 
683     First[0]->Tok.setKind(tok::lessless);
684     First[0]->TokenText = "<<";
685     First[0]->ColumnWidth += 1;
686     Tokens.erase(Tokens.end() - 2);
687     return true;
688   }
689 
690   bool tryMergeTokens(ArrayRef<tok::TokenKind> Kinds) {
691     if (Tokens.size() < Kinds.size())
692       return false;
693 
694     SmallVectorImpl<FormatToken *>::const_iterator First =
695         Tokens.end() - Kinds.size();
696     if (!First[0]->is(Kinds[0]))
697       return false;
698     unsigned AddLength = 0;
699     for (unsigned i = 1; i < Kinds.size(); ++i) {
700       if (!First[i]->is(Kinds[i]) ||
701           First[i]->WhitespaceRange.getBegin() !=
702               First[i]->WhitespaceRange.getEnd())
703         return false;
704       AddLength += First[i]->TokenText.size();
705     }
706     Tokens.resize(Tokens.size() - Kinds.size() + 1);
707     First[0]->TokenText = StringRef(First[0]->TokenText.data(),
708                                     First[0]->TokenText.size() + AddLength);
709     First[0]->ColumnWidth += AddLength;
710     return true;
711   }
712 
713   // Tries to merge an escape sequence, i.e. a "\\" and the following
714   // character. Use e.g. inside JavaScript regex literals.
715   bool tryMergeEscapeSequence() {
716     if (Tokens.size() < 2)
717       return false;
718     FormatToken *Previous = Tokens[Tokens.size() - 2];
719     if (Previous->isNot(tok::unknown) || Previous->TokenText != "\\")
720       return false;
721     ++Previous->ColumnWidth;
722     StringRef Text = Previous->TokenText;
723     Previous->TokenText = StringRef(Text.data(), Text.size() + 1);
724     resetLexer(SourceMgr.getFileOffset(Tokens.back()->Tok.getLocation()) + 1);
725     Tokens.resize(Tokens.size() - 1);
726     Column = Previous->OriginalColumn + Previous->ColumnWidth;
727     return true;
728   }
729 
730   // Try to determine whether the current token ends a JavaScript regex literal.
731   // We heuristically assume that this is a regex literal if we find two
732   // unescaped slashes on a line and the token before the first slash is one of
733   // "(;,{}![:?", a binary operator or 'return', as those cannot be followed by
734   // a division.
735   bool tryMergeJSRegexLiteral() {
736     if (Tokens.size() < 2)
737       return false;
738     // If a regex literal ends in "\//", this gets represented by an unknown
739     // token "\" and a comment.
740     bool MightEndWithEscapedSlash =
741         Tokens.back()->is(tok::comment) &&
742         Tokens.back()->TokenText.startswith("//") &&
743         Tokens[Tokens.size() - 2]->TokenText == "\\";
744     if (!MightEndWithEscapedSlash &&
745         (Tokens.back()->isNot(tok::slash) ||
746          (Tokens[Tokens.size() - 2]->is(tok::unknown) &&
747           Tokens[Tokens.size() - 2]->TokenText == "\\")))
748       return false;
749     unsigned TokenCount = 0;
750     unsigned LastColumn = Tokens.back()->OriginalColumn;
751     for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; ++I) {
752       ++TokenCount;
753       if (I[0]->is(tok::slash) && I + 1 != E &&
754           (I[1]->isOneOf(tok::l_paren, tok::semi, tok::l_brace, tok::r_brace,
755                          tok::exclaim, tok::l_square, tok::colon, tok::comma,
756                          tok::question, tok::kw_return) ||
757            I[1]->isBinaryOperator())) {
758         if (MightEndWithEscapedSlash) {
759           // This regex literal ends in '\//'. Skip past the '//' of the last
760           // token and re-start lexing from there.
761           SourceLocation Loc = Tokens.back()->Tok.getLocation();
762           resetLexer(SourceMgr.getFileOffset(Loc) + 2);
763         }
764         Tokens.resize(Tokens.size() - TokenCount);
765         Tokens.back()->Tok.setKind(tok::unknown);
766         Tokens.back()->Type = TT_RegexLiteral;
767         Tokens.back()->ColumnWidth += LastColumn - I[0]->OriginalColumn;
768         return true;
769       }
770 
771       // There can't be a newline inside a regex literal.
772       if (I[0]->NewlinesBefore > 0)
773         return false;
774     }
775     return false;
776   }
777 
778   bool tryMergeTemplateString() {
779     if (Tokens.size() < 2)
780       return false;
781 
782     FormatToken *EndBacktick = Tokens.back();
783     if (!(EndBacktick->is(tok::unknown) && EndBacktick->TokenText == "`"))
784       return false;
785 
786     unsigned TokenCount = 0;
787     bool IsMultiline = false;
788     unsigned EndColumnInFirstLine = 0;
789     for (auto I = Tokens.rbegin() + 1, E = Tokens.rend(); I != E; I++) {
790       ++TokenCount;
791       if (I[0]->NewlinesBefore > 0 || I[0]->IsMultiline)
792         IsMultiline = true;
793 
794       // If there was a preceding template string, this must be the start of a
795       // template string, not the end.
796       if (I[0]->is(TT_TemplateString))
797         return false;
798 
799       if (I[0]->isNot(tok::unknown) || I[0]->TokenText != "`") {
800         // Keep track of the rhs offset of the last token to wrap across lines -
801         // its the rhs offset of the first line of the template string, used to
802         // determine its width.
803         if (I[0]->IsMultiline)
804           EndColumnInFirstLine = I[0]->OriginalColumn + I[0]->ColumnWidth;
805         // If the token has newlines, the token before it (if it exists) is the
806         // rhs end of the previous line.
807         if (I[0]->NewlinesBefore > 0 && (I + 1 != E))
808           EndColumnInFirstLine = I[1]->OriginalColumn + I[1]->ColumnWidth;
809 
810         continue;
811       }
812 
813       Tokens.resize(Tokens.size() - TokenCount);
814       Tokens.back()->Type = TT_TemplateString;
815       const char *EndOffset = EndBacktick->TokenText.data() + 1;
816       Tokens.back()->TokenText =
817           StringRef(Tokens.back()->TokenText.data(),
818                     EndOffset - Tokens.back()->TokenText.data());
819       if (IsMultiline) {
820         // ColumnWidth is from backtick to last token in line.
821         // LastLineColumnWidth is 0 to backtick.
822         // x = `some content
823         //     until here`;
824         Tokens.back()->ColumnWidth =
825             EndColumnInFirstLine - Tokens.back()->OriginalColumn;
826         Tokens.back()->LastLineColumnWidth = EndBacktick->OriginalColumn;
827         Tokens.back()->IsMultiline = true;
828       } else {
829         // Token simply spans from start to end, +1 for the ` itself.
830         Tokens.back()->ColumnWidth =
831             EndBacktick->OriginalColumn - Tokens.back()->OriginalColumn + 1;
832       }
833       return true;
834     }
835     return false;
836   }
837 
838   bool tryMerge_TMacro() {
839     if (Tokens.size() < 4)
840       return false;
841     FormatToken *Last = Tokens.back();
842     if (!Last->is(tok::r_paren))
843       return false;
844 
845     FormatToken *String = Tokens[Tokens.size() - 2];
846     if (!String->is(tok::string_literal) || String->IsMultiline)
847       return false;
848 
849     if (!Tokens[Tokens.size() - 3]->is(tok::l_paren))
850       return false;
851 
852     FormatToken *Macro = Tokens[Tokens.size() - 4];
853     if (Macro->TokenText != "_T")
854       return false;
855 
856     const char *Start = Macro->TokenText.data();
857     const char *End = Last->TokenText.data() + Last->TokenText.size();
858     String->TokenText = StringRef(Start, End - Start);
859     String->IsFirst = Macro->IsFirst;
860     String->LastNewlineOffset = Macro->LastNewlineOffset;
861     String->WhitespaceRange = Macro->WhitespaceRange;
862     String->OriginalColumn = Macro->OriginalColumn;
863     String->ColumnWidth = encoding::columnWidthWithTabs(
864         String->TokenText, String->OriginalColumn, Style.TabWidth, Encoding);
865     String->NewlinesBefore = Macro->NewlinesBefore;
866     String->HasUnescapedNewline = Macro->HasUnescapedNewline;
867 
868     Tokens.pop_back();
869     Tokens.pop_back();
870     Tokens.pop_back();
871     Tokens.back() = String;
872     return true;
873   }
874 
875   bool tryMergeConflictMarkers() {
876     if (Tokens.back()->NewlinesBefore == 0 && Tokens.back()->isNot(tok::eof))
877       return false;
878 
879     // Conflict lines look like:
880     // <marker> <text from the vcs>
881     // For example:
882     // >>>>>>> /file/in/file/system at revision 1234
883     //
884     // We merge all tokens in a line that starts with a conflict marker
885     // into a single token with a special token type that the unwrapped line
886     // parser will use to correctly rebuild the underlying code.
887 
888     FileID ID;
889     // Get the position of the first token in the line.
890     unsigned FirstInLineOffset;
891     std::tie(ID, FirstInLineOffset) = SourceMgr.getDecomposedLoc(
892         Tokens[FirstInLineIndex]->getStartOfNonWhitespace());
893     StringRef Buffer = SourceMgr.getBuffer(ID)->getBuffer();
894     // Calculate the offset of the start of the current line.
895     auto LineOffset = Buffer.rfind('\n', FirstInLineOffset);
896     if (LineOffset == StringRef::npos) {
897       LineOffset = 0;
898     } else {
899       ++LineOffset;
900     }
901 
902     auto FirstSpace = Buffer.find_first_of(" \n", LineOffset);
903     StringRef LineStart;
904     if (FirstSpace == StringRef::npos) {
905       LineStart = Buffer.substr(LineOffset);
906     } else {
907       LineStart = Buffer.substr(LineOffset, FirstSpace - LineOffset);
908     }
909 
910     TokenType Type = TT_Unknown;
911     if (LineStart == "<<<<<<<" || LineStart == ">>>>") {
912       Type = TT_ConflictStart;
913     } else if (LineStart == "|||||||" || LineStart == "=======" ||
914                LineStart == "====") {
915       Type = TT_ConflictAlternative;
916     } else if (LineStart == ">>>>>>>" || LineStart == "<<<<") {
917       Type = TT_ConflictEnd;
918     }
919 
920     if (Type != TT_Unknown) {
921       FormatToken *Next = Tokens.back();
922 
923       Tokens.resize(FirstInLineIndex + 1);
924       // We do not need to build a complete token here, as we will skip it
925       // during parsing anyway (as we must not touch whitespace around conflict
926       // markers).
927       Tokens.back()->Type = Type;
928       Tokens.back()->Tok.setKind(tok::kw___unknown_anytype);
929 
930       Tokens.push_back(Next);
931       return true;
932     }
933 
934     return false;
935   }
936 
937   FormatToken *getStashedToken() {
938     // Create a synthesized second '>' or '<' token.
939     Token Tok = FormatTok->Tok;
940     StringRef TokenText = FormatTok->TokenText;
941 
942     unsigned OriginalColumn = FormatTok->OriginalColumn;
943     FormatTok = new (Allocator.Allocate()) FormatToken;
944     FormatTok->Tok = Tok;
945     SourceLocation TokLocation =
946         FormatTok->Tok.getLocation().getLocWithOffset(Tok.getLength() - 1);
947     FormatTok->Tok.setLocation(TokLocation);
948     FormatTok->WhitespaceRange = SourceRange(TokLocation, TokLocation);
949     FormatTok->TokenText = TokenText;
950     FormatTok->ColumnWidth = 1;
951     FormatTok->OriginalColumn = OriginalColumn + 1;
952 
953     return FormatTok;
954   }
955 
956   FormatToken *getNextToken() {
957     if (GreaterStashed) {
958       GreaterStashed = false;
959       return getStashedToken();
960     }
961     if (LessStashed) {
962       LessStashed = false;
963       return getStashedToken();
964     }
965 
966     FormatTok = new (Allocator.Allocate()) FormatToken;
967     readRawToken(*FormatTok);
968     SourceLocation WhitespaceStart =
969         FormatTok->Tok.getLocation().getLocWithOffset(-TrailingWhitespace);
970     FormatTok->IsFirst = IsFirstToken;
971     IsFirstToken = false;
972 
973     // Consume and record whitespace until we find a significant token.
974     unsigned WhitespaceLength = TrailingWhitespace;
975     while (FormatTok->Tok.is(tok::unknown)) {
976       // FIXME: This miscounts tok:unknown tokens that are not just
977       // whitespace, e.g. a '`' character.
978       for (int i = 0, e = FormatTok->TokenText.size(); i != e; ++i) {
979         switch (FormatTok->TokenText[i]) {
980         case '\n':
981           ++FormatTok->NewlinesBefore;
982           // FIXME: This is technically incorrect, as it could also
983           // be a literal backslash at the end of the line.
984           if (i == 0 || (FormatTok->TokenText[i - 1] != '\\' &&
985                          (FormatTok->TokenText[i - 1] != '\r' || i == 1 ||
986                           FormatTok->TokenText[i - 2] != '\\')))
987             FormatTok->HasUnescapedNewline = true;
988           FormatTok->LastNewlineOffset = WhitespaceLength + i + 1;
989           Column = 0;
990           break;
991         case '\r':
992           FormatTok->LastNewlineOffset = WhitespaceLength + i + 1;
993           Column = 0;
994           break;
995         case '\f':
996         case '\v':
997           Column = 0;
998           break;
999         case ' ':
1000           ++Column;
1001           break;
1002         case '\t':
1003           Column += Style.TabWidth - Column % Style.TabWidth;
1004           break;
1005         case '\\':
1006           if (i + 1 == e || (FormatTok->TokenText[i + 1] != '\r' &&
1007                              FormatTok->TokenText[i + 1] != '\n'))
1008             FormatTok->Type = TT_ImplicitStringLiteral;
1009           break;
1010         default:
1011           FormatTok->Type = TT_ImplicitStringLiteral;
1012           ++Column;
1013           break;
1014         }
1015       }
1016 
1017       if (FormatTok->is(TT_ImplicitStringLiteral))
1018         break;
1019       WhitespaceLength += FormatTok->Tok.getLength();
1020 
1021       readRawToken(*FormatTok);
1022     }
1023 
1024     // In case the token starts with escaped newlines, we want to
1025     // take them into account as whitespace - this pattern is quite frequent
1026     // in macro definitions.
1027     // FIXME: Add a more explicit test.
1028     while (FormatTok->TokenText.size() > 1 && FormatTok->TokenText[0] == '\\' &&
1029            FormatTok->TokenText[1] == '\n') {
1030       ++FormatTok->NewlinesBefore;
1031       WhitespaceLength += 2;
1032       Column = 0;
1033       FormatTok->TokenText = FormatTok->TokenText.substr(2);
1034     }
1035 
1036     FormatTok->WhitespaceRange = SourceRange(
1037         WhitespaceStart, WhitespaceStart.getLocWithOffset(WhitespaceLength));
1038 
1039     FormatTok->OriginalColumn = Column;
1040 
1041     TrailingWhitespace = 0;
1042     if (FormatTok->Tok.is(tok::comment)) {
1043       // FIXME: Add the trimmed whitespace to Column.
1044       StringRef UntrimmedText = FormatTok->TokenText;
1045       FormatTok->TokenText = FormatTok->TokenText.rtrim(" \t\v\f");
1046       TrailingWhitespace = UntrimmedText.size() - FormatTok->TokenText.size();
1047     } else if (FormatTok->Tok.is(tok::raw_identifier)) {
1048       IdentifierInfo &Info = IdentTable.get(FormatTok->TokenText);
1049       FormatTok->Tok.setIdentifierInfo(&Info);
1050       FormatTok->Tok.setKind(Info.getTokenID());
1051       if (Style.Language == FormatStyle::LK_Java &&
1052           FormatTok->isOneOf(tok::kw_struct, tok::kw_union, tok::kw_delete)) {
1053         FormatTok->Tok.setKind(tok::identifier);
1054         FormatTok->Tok.setIdentifierInfo(nullptr);
1055       }
1056     } else if (FormatTok->Tok.is(tok::greatergreater)) {
1057       FormatTok->Tok.setKind(tok::greater);
1058       FormatTok->TokenText = FormatTok->TokenText.substr(0, 1);
1059       GreaterStashed = true;
1060     } else if (FormatTok->Tok.is(tok::lessless)) {
1061       FormatTok->Tok.setKind(tok::less);
1062       FormatTok->TokenText = FormatTok->TokenText.substr(0, 1);
1063       LessStashed = true;
1064     }
1065 
1066     // Now FormatTok is the next non-whitespace token.
1067 
1068     StringRef Text = FormatTok->TokenText;
1069     size_t FirstNewlinePos = Text.find('\n');
1070     if (FirstNewlinePos == StringRef::npos) {
1071       // FIXME: ColumnWidth actually depends on the start column, we need to
1072       // take this into account when the token is moved.
1073       FormatTok->ColumnWidth =
1074           encoding::columnWidthWithTabs(Text, Column, Style.TabWidth, Encoding);
1075       Column += FormatTok->ColumnWidth;
1076     } else {
1077       FormatTok->IsMultiline = true;
1078       // FIXME: ColumnWidth actually depends on the start column, we need to
1079       // take this into account when the token is moved.
1080       FormatTok->ColumnWidth = encoding::columnWidthWithTabs(
1081           Text.substr(0, FirstNewlinePos), Column, Style.TabWidth, Encoding);
1082 
1083       // The last line of the token always starts in column 0.
1084       // Thus, the length can be precomputed even in the presence of tabs.
1085       FormatTok->LastLineColumnWidth = encoding::columnWidthWithTabs(
1086           Text.substr(Text.find_last_of('\n') + 1), 0, Style.TabWidth,
1087           Encoding);
1088       Column = FormatTok->LastLineColumnWidth;
1089     }
1090 
1091     FormatTok->IsForEachMacro =
1092         std::binary_search(ForEachMacros.begin(), ForEachMacros.end(),
1093                            FormatTok->Tok.getIdentifierInfo());
1094 
1095     return FormatTok;
1096   }
1097 
1098   FormatToken *FormatTok;
1099   bool IsFirstToken;
1100   bool GreaterStashed, LessStashed;
1101   unsigned Column;
1102   unsigned TrailingWhitespace;
1103   std::unique_ptr<Lexer> Lex;
1104   SourceManager &SourceMgr;
1105   FileID ID;
1106   FormatStyle &Style;
1107   IdentifierTable IdentTable;
1108   AdditionalKeywords Keywords;
1109   encoding::Encoding Encoding;
1110   llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
1111   // Index (in 'Tokens') of the last token that starts a new line.
1112   unsigned FirstInLineIndex;
1113   SmallVector<FormatToken *, 16> Tokens;
1114   SmallVector<IdentifierInfo *, 8> ForEachMacros;
1115 
1116   bool FormattingDisabled;
1117 
1118   void readRawToken(FormatToken &Tok) {
1119     Lex->LexFromRawLexer(Tok.Tok);
1120     Tok.TokenText = StringRef(SourceMgr.getCharacterData(Tok.Tok.getLocation()),
1121                               Tok.Tok.getLength());
1122     // For formatting, treat unterminated string literals like normal string
1123     // literals.
1124     if (Tok.is(tok::unknown)) {
1125       if (!Tok.TokenText.empty() && Tok.TokenText[0] == '"') {
1126         Tok.Tok.setKind(tok::string_literal);
1127         Tok.IsUnterminatedLiteral = true;
1128       } else if (Style.Language == FormatStyle::LK_JavaScript &&
1129                  Tok.TokenText == "''") {
1130         Tok.Tok.setKind(tok::char_constant);
1131       }
1132     }
1133 
1134     if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format on" ||
1135                                  Tok.TokenText == "/* clang-format on */")) {
1136       FormattingDisabled = false;
1137     }
1138 
1139     Tok.Finalized = FormattingDisabled;
1140 
1141     if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format off" ||
1142                                  Tok.TokenText == "/* clang-format off */")) {
1143       FormattingDisabled = true;
1144     }
1145   }
1146 
1147   void resetLexer(unsigned Offset) {
1148     StringRef Buffer = SourceMgr.getBufferData(ID);
1149     Lex.reset(new Lexer(SourceMgr.getLocForStartOfFile(ID),
1150                         getFormattingLangOpts(Style), Buffer.begin(),
1151                         Buffer.begin() + Offset, Buffer.end()));
1152     Lex->SetKeepWhitespaceMode(true);
1153   }
1154 };
1155 
1156 static StringRef getLanguageName(FormatStyle::LanguageKind Language) {
1157   switch (Language) {
1158   case FormatStyle::LK_Cpp:
1159     return "C++";
1160   case FormatStyle::LK_Java:
1161     return "Java";
1162   case FormatStyle::LK_JavaScript:
1163     return "JavaScript";
1164   case FormatStyle::LK_Proto:
1165     return "Proto";
1166   default:
1167     return "Unknown";
1168   }
1169 }
1170 
1171 class Formatter : public UnwrappedLineConsumer {
1172 public:
1173   Formatter(const FormatStyle &Style, SourceManager &SourceMgr, FileID ID,
1174             ArrayRef<CharSourceRange> Ranges)
1175       : Style(Style), ID(ID), SourceMgr(SourceMgr),
1176         Whitespaces(SourceMgr, Style,
1177                     inputUsesCRLF(SourceMgr.getBufferData(ID))),
1178         Ranges(Ranges.begin(), Ranges.end()), UnwrappedLines(1),
1179         Encoding(encoding::detectEncoding(SourceMgr.getBufferData(ID))) {
1180     DEBUG(llvm::dbgs() << "File encoding: "
1181                        << (Encoding == encoding::Encoding_UTF8 ? "UTF8"
1182                                                                : "unknown")
1183                        << "\n");
1184     DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language)
1185                        << "\n");
1186   }
1187 
1188   tooling::Replacements format() {
1189     tooling::Replacements Result;
1190     FormatTokenLexer Tokens(SourceMgr, ID, Style, Encoding);
1191 
1192     UnwrappedLineParser Parser(Style, Tokens.getKeywords(), Tokens.lex(),
1193                                *this);
1194     bool StructuralError = Parser.parse();
1195     assert(UnwrappedLines.rbegin()->empty());
1196     for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE;
1197          ++Run) {
1198       DEBUG(llvm::dbgs() << "Run " << Run << "...\n");
1199       SmallVector<AnnotatedLine *, 16> AnnotatedLines;
1200       for (unsigned i = 0, e = UnwrappedLines[Run].size(); i != e; ++i) {
1201         AnnotatedLines.push_back(new AnnotatedLine(UnwrappedLines[Run][i]));
1202       }
1203       tooling::Replacements RunResult =
1204           format(AnnotatedLines, StructuralError, Tokens);
1205       DEBUG({
1206         llvm::dbgs() << "Replacements for run " << Run << ":\n";
1207         for (tooling::Replacements::iterator I = RunResult.begin(),
1208                                              E = RunResult.end();
1209              I != E; ++I) {
1210           llvm::dbgs() << I->toString() << "\n";
1211         }
1212       });
1213       for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1214         delete AnnotatedLines[i];
1215       }
1216       Result.insert(RunResult.begin(), RunResult.end());
1217       Whitespaces.reset();
1218     }
1219     return Result;
1220   }
1221 
1222   tooling::Replacements format(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1223                                bool StructuralError, FormatTokenLexer &Tokens) {
1224     TokenAnnotator Annotator(Style, Tokens.getKeywords());
1225     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1226       Annotator.annotate(*AnnotatedLines[i]);
1227     }
1228     deriveLocalStyle(AnnotatedLines);
1229     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1230       Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
1231     }
1232     computeAffectedLines(AnnotatedLines.begin(), AnnotatedLines.end());
1233 
1234     Annotator.setCommentLineLevels(AnnotatedLines);
1235     ContinuationIndenter Indenter(Style, Tokens.getKeywords(), SourceMgr,
1236                                   Whitespaces, Encoding,
1237                                   BinPackInconclusiveFunctions);
1238     UnwrappedLineFormatter Formatter(&Indenter, &Whitespaces, Style,
1239                                      Tokens.getKeywords());
1240     Formatter.format(AnnotatedLines, /*DryRun=*/false);
1241     return Whitespaces.generateReplacements();
1242   }
1243 
1244 private:
1245   // Determines which lines are affected by the SourceRanges given as input.
1246   // Returns \c true if at least one line between I and E or one of their
1247   // children is affected.
1248   bool computeAffectedLines(SmallVectorImpl<AnnotatedLine *>::iterator I,
1249                             SmallVectorImpl<AnnotatedLine *>::iterator E) {
1250     bool SomeLineAffected = false;
1251     const AnnotatedLine *PreviousLine = nullptr;
1252     while (I != E) {
1253       AnnotatedLine *Line = *I;
1254       Line->LeadingEmptyLinesAffected = affectsLeadingEmptyLines(*Line->First);
1255 
1256       // If a line is part of a preprocessor directive, it needs to be formatted
1257       // if any token within the directive is affected.
1258       if (Line->InPPDirective) {
1259         FormatToken *Last = Line->Last;
1260         SmallVectorImpl<AnnotatedLine *>::iterator PPEnd = I + 1;
1261         while (PPEnd != E && !(*PPEnd)->First->HasUnescapedNewline) {
1262           Last = (*PPEnd)->Last;
1263           ++PPEnd;
1264         }
1265 
1266         if (affectsTokenRange(*Line->First, *Last,
1267                               /*IncludeLeadingNewlines=*/false)) {
1268           SomeLineAffected = true;
1269           markAllAsAffected(I, PPEnd);
1270         }
1271         I = PPEnd;
1272         continue;
1273       }
1274 
1275       if (nonPPLineAffected(Line, PreviousLine))
1276         SomeLineAffected = true;
1277 
1278       PreviousLine = Line;
1279       ++I;
1280     }
1281     return SomeLineAffected;
1282   }
1283 
1284   // Determines whether 'Line' is affected by the SourceRanges given as input.
1285   // Returns \c true if line or one if its children is affected.
1286   bool nonPPLineAffected(AnnotatedLine *Line,
1287                          const AnnotatedLine *PreviousLine) {
1288     bool SomeLineAffected = false;
1289     Line->ChildrenAffected =
1290         computeAffectedLines(Line->Children.begin(), Line->Children.end());
1291     if (Line->ChildrenAffected)
1292       SomeLineAffected = true;
1293 
1294     // Stores whether one of the line's tokens is directly affected.
1295     bool SomeTokenAffected = false;
1296     // Stores whether we need to look at the leading newlines of the next token
1297     // in order to determine whether it was affected.
1298     bool IncludeLeadingNewlines = false;
1299 
1300     // Stores whether the first child line of any of this line's tokens is
1301     // affected.
1302     bool SomeFirstChildAffected = false;
1303 
1304     for (FormatToken *Tok = Line->First; Tok; Tok = Tok->Next) {
1305       // Determine whether 'Tok' was affected.
1306       if (affectsTokenRange(*Tok, *Tok, IncludeLeadingNewlines))
1307         SomeTokenAffected = true;
1308 
1309       // Determine whether the first child of 'Tok' was affected.
1310       if (!Tok->Children.empty() && Tok->Children.front()->Affected)
1311         SomeFirstChildAffected = true;
1312 
1313       IncludeLeadingNewlines = Tok->Children.empty();
1314     }
1315 
1316     // Was this line moved, i.e. has it previously been on the same line as an
1317     // affected line?
1318     bool LineMoved = PreviousLine && PreviousLine->Affected &&
1319                      Line->First->NewlinesBefore == 0;
1320 
1321     bool IsContinuedComment =
1322         Line->First->is(tok::comment) && Line->First->Next == nullptr &&
1323         Line->First->NewlinesBefore < 2 && PreviousLine &&
1324         PreviousLine->Affected && PreviousLine->Last->is(tok::comment);
1325 
1326     if (SomeTokenAffected || SomeFirstChildAffected || LineMoved ||
1327         IsContinuedComment) {
1328       Line->Affected = true;
1329       SomeLineAffected = true;
1330     }
1331     return SomeLineAffected;
1332   }
1333 
1334   // Marks all lines between I and E as well as all their children as affected.
1335   void markAllAsAffected(SmallVectorImpl<AnnotatedLine *>::iterator I,
1336                          SmallVectorImpl<AnnotatedLine *>::iterator E) {
1337     while (I != E) {
1338       (*I)->Affected = true;
1339       markAllAsAffected((*I)->Children.begin(), (*I)->Children.end());
1340       ++I;
1341     }
1342   }
1343 
1344   // Returns true if the range from 'First' to 'Last' intersects with one of the
1345   // input ranges.
1346   bool affectsTokenRange(const FormatToken &First, const FormatToken &Last,
1347                          bool IncludeLeadingNewlines) {
1348     SourceLocation Start = First.WhitespaceRange.getBegin();
1349     if (!IncludeLeadingNewlines)
1350       Start = Start.getLocWithOffset(First.LastNewlineOffset);
1351     SourceLocation End = Last.getStartOfNonWhitespace();
1352     End = End.getLocWithOffset(Last.TokenText.size());
1353     CharSourceRange Range = CharSourceRange::getCharRange(Start, End);
1354     return affectsCharSourceRange(Range);
1355   }
1356 
1357   // Returns true if one of the input ranges intersect the leading empty lines
1358   // before 'Tok'.
1359   bool affectsLeadingEmptyLines(const FormatToken &Tok) {
1360     CharSourceRange EmptyLineRange = CharSourceRange::getCharRange(
1361         Tok.WhitespaceRange.getBegin(),
1362         Tok.WhitespaceRange.getBegin().getLocWithOffset(Tok.LastNewlineOffset));
1363     return affectsCharSourceRange(EmptyLineRange);
1364   }
1365 
1366   // Returns true if 'Range' intersects with one of the input ranges.
1367   bool affectsCharSourceRange(const CharSourceRange &Range) {
1368     for (SmallVectorImpl<CharSourceRange>::const_iterator I = Ranges.begin(),
1369                                                           E = Ranges.end();
1370          I != E; ++I) {
1371       if (!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(), I->getBegin()) &&
1372           !SourceMgr.isBeforeInTranslationUnit(I->getEnd(), Range.getBegin()))
1373         return true;
1374     }
1375     return false;
1376   }
1377 
1378   static bool inputUsesCRLF(StringRef Text) {
1379     return Text.count('\r') * 2 > Text.count('\n');
1380   }
1381 
1382   void
1383   deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
1384     unsigned CountBoundToVariable = 0;
1385     unsigned CountBoundToType = 0;
1386     bool HasCpp03IncompatibleFormat = false;
1387     bool HasBinPackedFunction = false;
1388     bool HasOnePerLineFunction = false;
1389     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1390       if (!AnnotatedLines[i]->First->Next)
1391         continue;
1392       FormatToken *Tok = AnnotatedLines[i]->First->Next;
1393       while (Tok->Next) {
1394         if (Tok->is(TT_PointerOrReference)) {
1395           bool SpacesBefore =
1396               Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
1397           bool SpacesAfter = Tok->Next->WhitespaceRange.getBegin() !=
1398                              Tok->Next->WhitespaceRange.getEnd();
1399           if (SpacesBefore && !SpacesAfter)
1400             ++CountBoundToVariable;
1401           else if (!SpacesBefore && SpacesAfter)
1402             ++CountBoundToType;
1403         }
1404 
1405         if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
1406           if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
1407             HasCpp03IncompatibleFormat = true;
1408           if (Tok->is(TT_TemplateCloser) &&
1409               Tok->Previous->is(TT_TemplateCloser))
1410             HasCpp03IncompatibleFormat = true;
1411         }
1412 
1413         if (Tok->PackingKind == PPK_BinPacked)
1414           HasBinPackedFunction = true;
1415         if (Tok->PackingKind == PPK_OnePerLine)
1416           HasOnePerLineFunction = true;
1417 
1418         Tok = Tok->Next;
1419       }
1420     }
1421     if (Style.DerivePointerAlignment) {
1422       if (CountBoundToType > CountBoundToVariable)
1423         Style.PointerAlignment = FormatStyle::PAS_Left;
1424       else if (CountBoundToType < CountBoundToVariable)
1425         Style.PointerAlignment = FormatStyle::PAS_Right;
1426     }
1427     if (Style.Standard == FormatStyle::LS_Auto) {
1428       Style.Standard = HasCpp03IncompatibleFormat ? FormatStyle::LS_Cpp11
1429                                                   : FormatStyle::LS_Cpp03;
1430     }
1431     BinPackInconclusiveFunctions =
1432         HasBinPackedFunction || !HasOnePerLineFunction;
1433   }
1434 
1435   void consumeUnwrappedLine(const UnwrappedLine &TheLine) override {
1436     assert(!UnwrappedLines.empty());
1437     UnwrappedLines.back().push_back(TheLine);
1438   }
1439 
1440   void finishRun() override {
1441     UnwrappedLines.push_back(SmallVector<UnwrappedLine, 16>());
1442   }
1443 
1444   FormatStyle Style;
1445   FileID ID;
1446   SourceManager &SourceMgr;
1447   WhitespaceManager Whitespaces;
1448   SmallVector<CharSourceRange, 8> Ranges;
1449   SmallVector<SmallVector<UnwrappedLine, 16>, 2> UnwrappedLines;
1450 
1451   encoding::Encoding Encoding;
1452   bool BinPackInconclusiveFunctions;
1453 };
1454 
1455 } // end anonymous namespace
1456 
1457 tooling::Replacements reformat(const FormatStyle &Style, Lexer &Lex,
1458                                SourceManager &SourceMgr,
1459                                ArrayRef<CharSourceRange> Ranges) {
1460   if (Style.DisableFormat)
1461     return tooling::Replacements();
1462   return reformat(Style, SourceMgr,
1463                   SourceMgr.getFileID(Lex.getSourceLocation()), Ranges);
1464 }
1465 
1466 tooling::Replacements reformat(const FormatStyle &Style,
1467                                SourceManager &SourceMgr, FileID ID,
1468                                ArrayRef<CharSourceRange> Ranges) {
1469   if (Style.DisableFormat)
1470     return tooling::Replacements();
1471   Formatter formatter(Style, SourceMgr, ID, Ranges);
1472   return formatter.format();
1473 }
1474 
1475 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
1476                                ArrayRef<tooling::Range> Ranges,
1477                                StringRef FileName) {
1478   if (Style.DisableFormat)
1479     return tooling::Replacements();
1480 
1481   FileManager Files((FileSystemOptions()));
1482   DiagnosticsEngine Diagnostics(
1483       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
1484       new DiagnosticOptions);
1485   SourceManager SourceMgr(Diagnostics, Files);
1486   std::unique_ptr<llvm::MemoryBuffer> Buf =
1487       llvm::MemoryBuffer::getMemBuffer(Code, FileName);
1488   const clang::FileEntry *Entry =
1489       Files.getVirtualFile(FileName, Buf->getBufferSize(), 0);
1490   SourceMgr.overrideFileContents(Entry, std::move(Buf));
1491   FileID ID =
1492       SourceMgr.createFileID(Entry, SourceLocation(), clang::SrcMgr::C_User);
1493   SourceLocation StartOfFile = SourceMgr.getLocForStartOfFile(ID);
1494   std::vector<CharSourceRange> CharRanges;
1495   for (const tooling::Range &Range : Ranges) {
1496     SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
1497     SourceLocation End = Start.getLocWithOffset(Range.getLength());
1498     CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
1499   }
1500   return reformat(Style, SourceMgr, ID, CharRanges);
1501 }
1502 
1503 LangOptions getFormattingLangOpts(const FormatStyle &Style) {
1504   LangOptions LangOpts;
1505   LangOpts.CPlusPlus = 1;
1506   LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
1507   LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
1508   LangOpts.LineComment = 1;
1509   bool AlternativeOperators = Style.Language != FormatStyle::LK_JavaScript &&
1510                               Style.Language != FormatStyle::LK_Java;
1511   LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
1512   LangOpts.Bool = 1;
1513   LangOpts.ObjC1 = 1;
1514   LangOpts.ObjC2 = 1;
1515   LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
1516   return LangOpts;
1517 }
1518 
1519 const char *StyleOptionHelpDescription =
1520     "Coding style, currently supports:\n"
1521     "  LLVM, Google, Chromium, Mozilla, WebKit.\n"
1522     "Use -style=file to load style configuration from\n"
1523     ".clang-format file located in one of the parent\n"
1524     "directories of the source file (or current\n"
1525     "directory for stdin).\n"
1526     "Use -style=\"{key: value, ...}\" to set specific\n"
1527     "parameters, e.g.:\n"
1528     "  -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
1529 
1530 static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
1531   if (FileName.endswith(".java")) {
1532     return FormatStyle::LK_Java;
1533   } else if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts")) {
1534     // JavaScript or TypeScript.
1535     return FormatStyle::LK_JavaScript;
1536   } else if (FileName.endswith_lower(".proto") ||
1537              FileName.endswith_lower(".protodevel")) {
1538     return FormatStyle::LK_Proto;
1539   }
1540   return FormatStyle::LK_Cpp;
1541 }
1542 
1543 FormatStyle getStyle(StringRef StyleName, StringRef FileName,
1544                      StringRef FallbackStyle) {
1545   FormatStyle Style = getLLVMStyle();
1546   Style.Language = getLanguageByFileName(FileName);
1547   if (!getPredefinedStyle(FallbackStyle, Style.Language, &Style)) {
1548     llvm::errs() << "Invalid fallback style \"" << FallbackStyle
1549                  << "\" using LLVM style\n";
1550     return Style;
1551   }
1552 
1553   if (StyleName.startswith("{")) {
1554     // Parse YAML/JSON style from the command line.
1555     if (std::error_code ec = parseConfiguration(StyleName, &Style)) {
1556       llvm::errs() << "Error parsing -style: " << ec.message() << ", using "
1557                    << FallbackStyle << " style\n";
1558     }
1559     return Style;
1560   }
1561 
1562   if (!StyleName.equals_lower("file")) {
1563     if (!getPredefinedStyle(StyleName, Style.Language, &Style))
1564       llvm::errs() << "Invalid value for -style, using " << FallbackStyle
1565                    << " style\n";
1566     return Style;
1567   }
1568 
1569   // Look for .clang-format/_clang-format file in the file's parent directories.
1570   SmallString<128> UnsuitableConfigFiles;
1571   SmallString<128> Path(FileName);
1572   llvm::sys::fs::make_absolute(Path);
1573   for (StringRef Directory = Path; !Directory.empty();
1574        Directory = llvm::sys::path::parent_path(Directory)) {
1575     if (!llvm::sys::fs::is_directory(Directory))
1576       continue;
1577     SmallString<128> ConfigFile(Directory);
1578 
1579     llvm::sys::path::append(ConfigFile, ".clang-format");
1580     DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
1581     bool IsFile = false;
1582     // Ignore errors from is_regular_file: we only need to know if we can read
1583     // the file or not.
1584     llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
1585 
1586     if (!IsFile) {
1587       // Try _clang-format too, since dotfiles are not commonly used on Windows.
1588       ConfigFile = Directory;
1589       llvm::sys::path::append(ConfigFile, "_clang-format");
1590       DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
1591       llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
1592     }
1593 
1594     if (IsFile) {
1595       llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
1596           llvm::MemoryBuffer::getFile(ConfigFile.c_str());
1597       if (std::error_code EC = Text.getError()) {
1598         llvm::errs() << EC.message() << "\n";
1599         break;
1600       }
1601       if (std::error_code ec =
1602               parseConfiguration(Text.get()->getBuffer(), &Style)) {
1603         if (ec == ParseError::Unsuitable) {
1604           if (!UnsuitableConfigFiles.empty())
1605             UnsuitableConfigFiles.append(", ");
1606           UnsuitableConfigFiles.append(ConfigFile);
1607           continue;
1608         }
1609         llvm::errs() << "Error reading " << ConfigFile << ": " << ec.message()
1610                      << "\n";
1611         break;
1612       }
1613       DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n");
1614       return Style;
1615     }
1616   }
1617   llvm::errs() << "Can't find usable .clang-format, using " << FallbackStyle
1618                << " style\n";
1619   if (!UnsuitableConfigFiles.empty()) {
1620     llvm::errs() << "Configuration file(s) do(es) not support "
1621                  << getLanguageName(Style.Language) << ": "
1622                  << UnsuitableConfigFiles << "\n";
1623   }
1624   return Style;
1625 }
1626 
1627 } // namespace format
1628 } // namespace clang
1629