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