1 //===--- Format.cpp - Format C++ code -------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief This file implements functions declared in Format.h. This will be
12 /// split into separate files as we go.
14 //===----------------------------------------------------------------------===//
16 #include "clang/Format/Format.h"
17 #include "ContinuationIndenter.h"
18 #include "TokenAnnotator.h"
19 #include "UnwrappedLineFormatter.h"
20 #include "UnwrappedLineParser.h"
21 #include "WhitespaceManager.h"
22 #include "clang/Basic/Diagnostic.h"
23 #include "clang/Basic/DiagnosticOptions.h"
24 #include "clang/Basic/SourceManager.h"
25 #include "clang/Lex/Lexer.h"
26 #include "llvm/ADT/STLExtras.h"
27 #include "llvm/Support/Allocator.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/Path.h"
30 #include "llvm/Support/Regex.h"
31 #include "llvm/Support/YAMLTraits.h"
35 #define DEBUG_TYPE "format-formatter"
37 using clang::format::FormatStyle;
39 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
40 LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::IncludeCategory)
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);
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);
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);
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);
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);
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);
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);
121 struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
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);
128 // For backward compatibility.
129 IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
130 IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
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);
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);
150 // For backward compatibility.
151 IO.enumCase(Value, "true", FormatStyle::BAS_Align);
152 IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
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);
162 // For backward compatibility.
163 IO.enumCase(Value, "true", FormatStyle::PAS_Left);
164 IO.enumCase(Value, "false", FormatStyle::PAS_Right);
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);
177 // For backward compatibility.
178 IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
179 IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
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);
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);
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));
212 Style.Language = OldLanguage;
216 // For backward compatibility.
217 if (!IO.outputting()) {
218 IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
219 IO.mapOptional("IndentFunctionDeclarationAfterType",
220 Style.IndentWrappedFunctionNames);
221 IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
222 IO.mapOptional("SpaceAfterControlStatementKeyword",
223 Style.SpaceBeforeParens);
226 IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
227 IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
228 IO.mapOptional("AlignConsecutiveAssignments",
229 Style.AlignConsecutiveAssignments);
230 IO.mapOptional("AlignConsecutiveDeclarations",
231 Style.AlignConsecutiveDeclarations);
232 IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft);
233 IO.mapOptional("AlignOperands", Style.AlignOperands);
234 IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
235 IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
236 Style.AllowAllParametersOfDeclarationOnNextLine);
237 IO.mapOptional("AllowShortBlocksOnASingleLine",
238 Style.AllowShortBlocksOnASingleLine);
239 IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
240 Style.AllowShortCaseLabelsOnASingleLine);
241 IO.mapOptional("AllowShortFunctionsOnASingleLine",
242 Style.AllowShortFunctionsOnASingleLine);
243 IO.mapOptional("AllowShortIfStatementsOnASingleLine",
244 Style.AllowShortIfStatementsOnASingleLine);
245 IO.mapOptional("AllowShortLoopsOnASingleLine",
246 Style.AllowShortLoopsOnASingleLine);
247 IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
248 Style.AlwaysBreakAfterDefinitionReturnType);
249 IO.mapOptional("AlwaysBreakAfterReturnType",
250 Style.AlwaysBreakAfterReturnType);
251 // If AlwaysBreakAfterDefinitionReturnType was specified but
252 // AlwaysBreakAfterReturnType was not, initialize the latter from the
253 // former for backwards compatibility.
254 if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
255 Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
256 if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
257 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
258 else if (Style.AlwaysBreakAfterDefinitionReturnType ==
259 FormatStyle::DRTBS_TopLevel)
260 Style.AlwaysBreakAfterReturnType =
261 FormatStyle::RTBS_TopLevelDefinitions;
264 IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
265 Style.AlwaysBreakBeforeMultilineStrings);
266 IO.mapOptional("AlwaysBreakTemplateDeclarations",
267 Style.AlwaysBreakTemplateDeclarations);
268 IO.mapOptional("BinPackArguments", Style.BinPackArguments);
269 IO.mapOptional("BinPackParameters", Style.BinPackParameters);
270 IO.mapOptional("BraceWrapping", Style.BraceWrapping);
271 IO.mapOptional("BreakBeforeBinaryOperators",
272 Style.BreakBeforeBinaryOperators);
273 IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
274 IO.mapOptional("BreakBeforeTernaryOperators",
275 Style.BreakBeforeTernaryOperators);
276 IO.mapOptional("BreakConstructorInitializersBeforeComma",
277 Style.BreakConstructorInitializersBeforeComma);
278 IO.mapOptional("ColumnLimit", Style.ColumnLimit);
279 IO.mapOptional("CommentPragmas", Style.CommentPragmas);
280 IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
281 Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
282 IO.mapOptional("ConstructorInitializerIndentWidth",
283 Style.ConstructorInitializerIndentWidth);
284 IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
285 IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
286 IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
287 IO.mapOptional("DisableFormat", Style.DisableFormat);
288 IO.mapOptional("ExperimentalAutoDetectBinPacking",
289 Style.ExperimentalAutoDetectBinPacking);
290 IO.mapOptional("ForEachMacros", Style.ForEachMacros);
291 IO.mapOptional("IncludeCategories", Style.IncludeCategories);
292 IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
293 IO.mapOptional("IndentWidth", Style.IndentWidth);
294 IO.mapOptional("IndentWrappedFunctionNames",
295 Style.IndentWrappedFunctionNames);
296 IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
297 Style.KeepEmptyLinesAtTheStartOfBlocks);
298 IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
299 IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
300 IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
301 IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
302 IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
303 IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
304 IO.mapOptional("ObjCSpaceBeforeProtocolList",
305 Style.ObjCSpaceBeforeProtocolList);
306 IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
307 Style.PenaltyBreakBeforeFirstCallParameter);
308 IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
309 IO.mapOptional("PenaltyBreakFirstLessLess",
310 Style.PenaltyBreakFirstLessLess);
311 IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
312 IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
313 IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
314 Style.PenaltyReturnTypeOnItsOwnLine);
315 IO.mapOptional("PointerAlignment", Style.PointerAlignment);
316 IO.mapOptional("ReflowComments", Style.ReflowComments);
317 IO.mapOptional("SortIncludes", Style.SortIncludes);
318 IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
319 IO.mapOptional("SpaceBeforeAssignmentOperators",
320 Style.SpaceBeforeAssignmentOperators);
321 IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
322 IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
323 IO.mapOptional("SpacesBeforeTrailingComments",
324 Style.SpacesBeforeTrailingComments);
325 IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
326 IO.mapOptional("SpacesInContainerLiterals",
327 Style.SpacesInContainerLiterals);
328 IO.mapOptional("SpacesInCStyleCastParentheses",
329 Style.SpacesInCStyleCastParentheses);
330 IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
331 IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
332 IO.mapOptional("Standard", Style.Standard);
333 IO.mapOptional("TabWidth", Style.TabWidth);
334 IO.mapOptional("UseTab", Style.UseTab);
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);
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);
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) {
370 static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
372 if (Index >= Seq.size()) {
373 assert(Index == Seq.size());
374 FormatStyle Template;
375 if (Seq.size() > 0 && Seq[0].Language == FormatStyle::LK_None) {
378 Template = *((const FormatStyle *)IO.getContext());
379 Template.Language = FormatStyle::LK_None;
381 Seq.resize(Index + 1, Template);
392 const std::error_category &getParseCategory() {
393 static ParseErrorCategory C;
396 std::error_code make_error_code(ParseError e) {
397 return std::error_code(static_cast<int>(e), getParseCategory());
400 const char *ParseErrorCategory::name() const LLVM_NOEXCEPT {
401 return "clang-format.parse_error";
404 std::string ParseErrorCategory::message(int EV) const {
405 switch (static_cast<ParseError>(EV)) {
406 case ParseError::Success:
408 case ParseError::Error:
409 return "Invalid argument";
410 case ParseError::Unsuitable:
413 llvm_unreachable("unexpected parse error");
416 static FormatStyle expandPresets(const FormatStyle &Style) {
417 if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
419 FormatStyle Expanded = Style;
420 Expanded.BraceWrapping = {false, false, false, false, false, false,
421 false, false, false, false, false};
422 switch (Style.BreakBeforeBraces) {
423 case FormatStyle::BS_Linux:
424 Expanded.BraceWrapping.AfterClass = true;
425 Expanded.BraceWrapping.AfterFunction = true;
426 Expanded.BraceWrapping.AfterNamespace = true;
428 case FormatStyle::BS_Mozilla:
429 Expanded.BraceWrapping.AfterClass = true;
430 Expanded.BraceWrapping.AfterEnum = true;
431 Expanded.BraceWrapping.AfterFunction = true;
432 Expanded.BraceWrapping.AfterStruct = true;
433 Expanded.BraceWrapping.AfterUnion = true;
435 case FormatStyle::BS_Stroustrup:
436 Expanded.BraceWrapping.AfterFunction = true;
437 Expanded.BraceWrapping.BeforeCatch = true;
438 Expanded.BraceWrapping.BeforeElse = true;
440 case FormatStyle::BS_Allman:
441 Expanded.BraceWrapping.AfterClass = true;
442 Expanded.BraceWrapping.AfterControlStatement = true;
443 Expanded.BraceWrapping.AfterEnum = true;
444 Expanded.BraceWrapping.AfterFunction = true;
445 Expanded.BraceWrapping.AfterNamespace = true;
446 Expanded.BraceWrapping.AfterObjCDeclaration = true;
447 Expanded.BraceWrapping.AfterStruct = true;
448 Expanded.BraceWrapping.BeforeCatch = true;
449 Expanded.BraceWrapping.BeforeElse = true;
451 case FormatStyle::BS_GNU:
452 Expanded.BraceWrapping = {true, true, true, true, true, true,
453 true, true, true, true, true};
455 case FormatStyle::BS_WebKit:
456 Expanded.BraceWrapping.AfterFunction = true;
464 FormatStyle getLLVMStyle() {
465 FormatStyle LLVMStyle;
466 LLVMStyle.Language = FormatStyle::LK_Cpp;
467 LLVMStyle.AccessModifierOffset = -2;
468 LLVMStyle.AlignEscapedNewlinesLeft = false;
469 LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
470 LLVMStyle.AlignOperands = true;
471 LLVMStyle.AlignTrailingComments = true;
472 LLVMStyle.AlignConsecutiveAssignments = false;
473 LLVMStyle.AlignConsecutiveDeclarations = false;
474 LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
475 LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
476 LLVMStyle.AllowShortBlocksOnASingleLine = false;
477 LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
478 LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
479 LLVMStyle.AllowShortLoopsOnASingleLine = false;
480 LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
481 LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
482 LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
483 LLVMStyle.AlwaysBreakTemplateDeclarations = false;
484 LLVMStyle.BinPackParameters = true;
485 LLVMStyle.BinPackArguments = true;
486 LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
487 LLVMStyle.BreakBeforeTernaryOperators = true;
488 LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
489 LLVMStyle.BraceWrapping = {false, false, false, false, false, false,
490 false, false, false, false, false};
491 LLVMStyle.BreakConstructorInitializersBeforeComma = false;
492 LLVMStyle.BreakAfterJavaFieldAnnotations = false;
493 LLVMStyle.ColumnLimit = 80;
494 LLVMStyle.CommentPragmas = "^ IWYU pragma:";
495 LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
496 LLVMStyle.ConstructorInitializerIndentWidth = 4;
497 LLVMStyle.ContinuationIndentWidth = 4;
498 LLVMStyle.Cpp11BracedListStyle = true;
499 LLVMStyle.DerivePointerAlignment = false;
500 LLVMStyle.ExperimentalAutoDetectBinPacking = false;
501 LLVMStyle.ForEachMacros.push_back("foreach");
502 LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
503 LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
504 LLVMStyle.IncludeCategories = {{"^\"(llvm|llvm-c|clang|clang-c)/", 2},
505 {"^(<|\"(gtest|isl|json)/)", 3},
507 LLVMStyle.IndentCaseLabels = false;
508 LLVMStyle.IndentWrappedFunctionNames = false;
509 LLVMStyle.IndentWidth = 2;
510 LLVMStyle.TabWidth = 8;
511 LLVMStyle.MaxEmptyLinesToKeep = 1;
512 LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
513 LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
514 LLVMStyle.ObjCBlockIndentWidth = 2;
515 LLVMStyle.ObjCSpaceAfterProperty = false;
516 LLVMStyle.ObjCSpaceBeforeProtocolList = true;
517 LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
518 LLVMStyle.SpacesBeforeTrailingComments = 1;
519 LLVMStyle.Standard = FormatStyle::LS_Cpp11;
520 LLVMStyle.UseTab = FormatStyle::UT_Never;
521 LLVMStyle.ReflowComments = true;
522 LLVMStyle.SpacesInParentheses = false;
523 LLVMStyle.SpacesInSquareBrackets = false;
524 LLVMStyle.SpaceInEmptyParentheses = false;
525 LLVMStyle.SpacesInContainerLiterals = true;
526 LLVMStyle.SpacesInCStyleCastParentheses = false;
527 LLVMStyle.SpaceAfterCStyleCast = false;
528 LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
529 LLVMStyle.SpaceBeforeAssignmentOperators = true;
530 LLVMStyle.SpacesInAngles = false;
532 LLVMStyle.PenaltyBreakComment = 300;
533 LLVMStyle.PenaltyBreakFirstLessLess = 120;
534 LLVMStyle.PenaltyBreakString = 1000;
535 LLVMStyle.PenaltyExcessCharacter = 1000000;
536 LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
537 LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
539 LLVMStyle.DisableFormat = false;
540 LLVMStyle.SortIncludes = true;
545 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
546 FormatStyle GoogleStyle = getLLVMStyle();
547 GoogleStyle.Language = Language;
549 GoogleStyle.AccessModifierOffset = -1;
550 GoogleStyle.AlignEscapedNewlinesLeft = true;
551 GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
552 GoogleStyle.AllowShortLoopsOnASingleLine = true;
553 GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
554 GoogleStyle.AlwaysBreakTemplateDeclarations = true;
555 GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
556 GoogleStyle.DerivePointerAlignment = true;
557 GoogleStyle.IncludeCategories = {{"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
558 GoogleStyle.IndentCaseLabels = true;
559 GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
560 GoogleStyle.ObjCSpaceAfterProperty = false;
561 GoogleStyle.ObjCSpaceBeforeProtocolList = false;
562 GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
563 GoogleStyle.SpacesBeforeTrailingComments = 2;
564 GoogleStyle.Standard = FormatStyle::LS_Auto;
566 GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
567 GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
569 if (Language == FormatStyle::LK_Java) {
570 GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
571 GoogleStyle.AlignOperands = false;
572 GoogleStyle.AlignTrailingComments = false;
573 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
574 GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
575 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
576 GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
577 GoogleStyle.ColumnLimit = 100;
578 GoogleStyle.SpaceAfterCStyleCast = true;
579 GoogleStyle.SpacesBeforeTrailingComments = 1;
580 } else if (Language == FormatStyle::LK_JavaScript) {
581 GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
582 GoogleStyle.AlignOperands = false;
583 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
584 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
585 GoogleStyle.BreakBeforeTernaryOperators = false;
586 GoogleStyle.CommentPragmas = "@(export|visibility) {";
587 GoogleStyle.MaxEmptyLinesToKeep = 3;
588 GoogleStyle.SpacesInContainerLiterals = false;
589 } else if (Language == FormatStyle::LK_Proto) {
590 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
591 GoogleStyle.SpacesInContainerLiterals = false;
597 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
598 FormatStyle ChromiumStyle = getGoogleStyle(Language);
599 if (Language == FormatStyle::LK_Java) {
600 ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
601 ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
602 ChromiumStyle.ContinuationIndentWidth = 8;
603 ChromiumStyle.IndentWidth = 4;
605 ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
606 ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
607 ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
608 ChromiumStyle.AllowShortLoopsOnASingleLine = false;
609 ChromiumStyle.BinPackParameters = false;
610 ChromiumStyle.DerivePointerAlignment = false;
612 ChromiumStyle.SortIncludes = false;
613 return ChromiumStyle;
616 FormatStyle getMozillaStyle() {
617 FormatStyle MozillaStyle = getLLVMStyle();
618 MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
619 MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
620 MozillaStyle.AlwaysBreakAfterReturnType =
621 FormatStyle::RTBS_TopLevelDefinitions;
622 MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
623 FormatStyle::DRTBS_TopLevel;
624 MozillaStyle.AlwaysBreakTemplateDeclarations = true;
625 MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
626 MozillaStyle.BreakConstructorInitializersBeforeComma = true;
627 MozillaStyle.ConstructorInitializerIndentWidth = 2;
628 MozillaStyle.ContinuationIndentWidth = 2;
629 MozillaStyle.Cpp11BracedListStyle = false;
630 MozillaStyle.IndentCaseLabels = true;
631 MozillaStyle.ObjCSpaceAfterProperty = true;
632 MozillaStyle.ObjCSpaceBeforeProtocolList = false;
633 MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
634 MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
638 FormatStyle getWebKitStyle() {
639 FormatStyle Style = getLLVMStyle();
640 Style.AccessModifierOffset = -4;
641 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
642 Style.AlignOperands = false;
643 Style.AlignTrailingComments = false;
644 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
645 Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
646 Style.BreakConstructorInitializersBeforeComma = true;
647 Style.Cpp11BracedListStyle = false;
648 Style.ColumnLimit = 0;
649 Style.IndentWidth = 4;
650 Style.NamespaceIndentation = FormatStyle::NI_Inner;
651 Style.ObjCBlockIndentWidth = 4;
652 Style.ObjCSpaceAfterProperty = true;
653 Style.PointerAlignment = FormatStyle::PAS_Left;
654 Style.Standard = FormatStyle::LS_Cpp03;
658 FormatStyle getGNUStyle() {
659 FormatStyle Style = getLLVMStyle();
660 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
661 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
662 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
663 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
664 Style.BreakBeforeTernaryOperators = true;
665 Style.Cpp11BracedListStyle = false;
666 Style.ColumnLimit = 79;
667 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
668 Style.Standard = FormatStyle::LS_Cpp03;
672 FormatStyle getNoStyle() {
673 FormatStyle NoStyle = getLLVMStyle();
674 NoStyle.DisableFormat = true;
675 NoStyle.SortIncludes = false;
679 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
680 FormatStyle *Style) {
681 if (Name.equals_lower("llvm")) {
682 *Style = getLLVMStyle();
683 } else if (Name.equals_lower("chromium")) {
684 *Style = getChromiumStyle(Language);
685 } else if (Name.equals_lower("mozilla")) {
686 *Style = getMozillaStyle();
687 } else if (Name.equals_lower("google")) {
688 *Style = getGoogleStyle(Language);
689 } else if (Name.equals_lower("webkit")) {
690 *Style = getWebKitStyle();
691 } else if (Name.equals_lower("gnu")) {
692 *Style = getGNUStyle();
693 } else if (Name.equals_lower("none")) {
694 *Style = getNoStyle();
699 Style->Language = Language;
703 std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
705 FormatStyle::LanguageKind Language = Style->Language;
706 assert(Language != FormatStyle::LK_None);
707 if (Text.trim().empty())
708 return make_error_code(ParseError::Error);
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
716 Input.setContext(Style);
719 return Input.error();
721 for (unsigned i = 0; i < Styles.size(); ++i) {
722 // Ensures that only the first configuration can skip the Language option.
723 if (Styles[i].Language == FormatStyle::LK_None && i != 0)
724 return make_error_code(ParseError::Error);
725 // Ensure that each language is configured at most once.
726 for (unsigned j = 0; j < i; ++j) {
727 if (Styles[i].Language == Styles[j].Language) {
729 << "Duplicate languages in the config file on positions " << j
730 << " and " << i << "\n");
731 return make_error_code(ParseError::Error);
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) {
742 Style->Language = Language;
743 return make_error_code(ParseError::Success);
746 return make_error_code(ParseError::Unsuitable);
749 std::string configurationAsText(const FormatStyle &Style) {
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
755 FormatStyle NonConstStyle = expandPresets(Style);
756 Output << NonConstStyle;
762 class FormatTokenLexer {
764 FormatTokenLexer(SourceManager &SourceMgr, FileID ID, FormatStyle &Style,
765 encoding::Encoding Encoding)
766 : FormatTok(nullptr), IsFirstToken(true), GreaterStashed(false),
767 LessStashed(false), Column(0), TrailingWhitespace(0),
768 SourceMgr(SourceMgr), ID(ID), Style(Style),
769 IdentTable(getFormattingLangOpts(Style)), Keywords(IdentTable),
770 Encoding(Encoding), FirstInLineIndex(0), FormattingDisabled(false),
771 MacroBlockBeginRegex(Style.MacroBlockBegin),
772 MacroBlockEndRegex(Style.MacroBlockEnd) {
773 Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
774 getFormattingLangOpts(Style)));
775 Lex->SetKeepWhitespaceMode(true);
777 for (const std::string &ForEachMacro : Style.ForEachMacros)
778 ForEachMacros.push_back(&IdentTable.get(ForEachMacro));
779 std::sort(ForEachMacros.begin(), ForEachMacros.end());
782 ArrayRef<FormatToken *> lex() {
783 assert(Tokens.empty());
784 assert(FirstInLineIndex == 0);
786 Tokens.push_back(getNextToken());
787 if (Style.Language == FormatStyle::LK_JavaScript)
788 tryParseJSRegexLiteral();
789 tryMergePreviousTokens();
790 if (Tokens.back()->NewlinesBefore > 0 || Tokens.back()->IsMultiline)
791 FirstInLineIndex = Tokens.size() - 1;
792 } while (Tokens.back()->Tok.isNot(tok::eof));
796 const AdditionalKeywords &getKeywords() { return Keywords; }
799 void tryMergePreviousTokens() {
800 if (tryMerge_TMacro())
802 if (tryMergeConflictMarkers())
804 if (tryMergeLessLess())
807 if (Style.Language == FormatStyle::LK_JavaScript) {
808 if (tryMergeTemplateString())
811 static const tok::TokenKind JSIdentity[] = {tok::equalequal, tok::equal};
812 static const tok::TokenKind JSNotIdentity[] = {tok::exclaimequal,
814 static const tok::TokenKind JSShiftEqual[] = {tok::greater, tok::greater,
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))
820 if (tryMergeTokens(JSNotIdentity, TT_BinaryOperator))
822 if (tryMergeTokens(JSShiftEqual, TT_BinaryOperator))
824 if (tryMergeTokens(JSRightArrow, TT_JsFatArrow))
829 bool tryMergeLessLess() {
830 // Merge X,less,less,Y into X,lessless,Y unless X or Y is less.
831 if (Tokens.size() < 3)
834 bool FourthTokenIsLess = false;
835 if (Tokens.size() > 3)
836 FourthTokenIsLess = (Tokens.end() - 4)[0]->is(tok::less);
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)
843 // Only merge if there currently is no whitespace between the two "<".
844 if (First[1]->WhitespaceRange.getBegin() !=
845 First[1]->WhitespaceRange.getEnd())
848 First[0]->Tok.setKind(tok::lessless);
849 First[0]->TokenText = "<<";
850 First[0]->ColumnWidth += 1;
851 Tokens.erase(Tokens.end() - 2);
855 bool tryMergeTokens(ArrayRef<tok::TokenKind> Kinds, TokenType NewType) {
856 if (Tokens.size() < Kinds.size())
859 SmallVectorImpl<FormatToken *>::const_iterator First =
860 Tokens.end() - Kinds.size();
861 if (!First[0]->is(Kinds[0]))
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())
869 AddLength += First[i]->TokenText.size();
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;
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,
891 Tok->isBinaryOperator();
894 bool canPrecedeRegexLiteral(FormatToken *Prev) {
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
902 if (Prev->isOneOf(tok::plusplus, tok::minusminus))
903 return (Tokens.size() < 3 || precedesOperand(Tokens[Tokens.size() - 3]));
905 // The previous token must introduce an operand location where regex
906 // literals can occur.
907 if (!precedesOperand(Prev))
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))
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)) {
932 if (!canPrecedeRegexLiteral(Prev))
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.
947 // Skip the escaped character.
951 InCharacterClass = true;
954 InCharacterClass = false;
957 if (!InCharacterClass)
958 HaveClosingSlash = true;
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();
969 resetLexer(SourceMgr.getFileOffset(Lex->getSourceLocation(Offset)));
972 bool tryMergeTemplateString() {
973 if (Tokens.size() < 2)
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
980 if (!EndBacktick->isOneOf(tok::comment, tok::string_literal,
981 tok::char_constant, tok::unknown))
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)
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++) {
995 if (I[0]->IsMultiline)
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))
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;
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);
1028 Tokens.back()->TokenText =
1029 StringRef(Tokens.back()->TokenText.data(),
1030 EndOffset - Tokens.back()->TokenText.data());
1032 unsigned EndOriginalColumn = EndBacktick->OriginalColumn;
1033 if (EndOriginalColumn == 0) {
1034 SourceLocation Loc = EndBacktick->Tok.getLocation();
1035 EndOriginalColumn = SourceMgr.getSpellingColumnNumber(Loc);
1037 // If the ` is further down within the token (e.g. in a comment).
1038 EndOriginalColumn += CommentBacktickPos;
1041 // ColumnWidth is from backtick to last token in line.
1042 // LastLineColumnWidth is 0 to backtick.
1043 // x = `some content
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;
1051 // Token simply spans from start to end, +1 for the ` itself.
1052 Tokens.back()->ColumnWidth =
1053 EndOriginalColumn - Tokens.back()->OriginalColumn + 1;
1060 bool tryMerge_TMacro() {
1061 if (Tokens.size() < 4)
1063 FormatToken *Last = Tokens.back();
1064 if (!Last->is(tok::r_paren))
1067 FormatToken *String = Tokens[Tokens.size() - 2];
1068 if (!String->is(tok::string_literal) || String->IsMultiline)
1071 if (!Tokens[Tokens.size() - 3]->is(tok::l_paren))
1074 FormatToken *Macro = Tokens[Tokens.size() - 4];
1075 if (Macro->TokenText != "_T")
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;
1093 Tokens.back() = String;
1097 bool tryMergeConflictMarkers() {
1098 if (Tokens.back()->NewlinesBefore == 0 && Tokens.back()->isNot(tok::eof))
1101 // Conflict lines look like:
1102 // <marker> <text from the vcs>
1104 // >>>>>>> /file/in/file/system at revision 1234
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.
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) {
1124 auto FirstSpace = Buffer.find_first_of(" \n", LineOffset);
1125 StringRef LineStart;
1126 if (FirstSpace == StringRef::npos) {
1127 LineStart = Buffer.substr(LineOffset);
1129 LineStart = Buffer.substr(LineOffset, FirstSpace - LineOffset);
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;
1142 if (Type != TT_Unknown) {
1143 FormatToken *Next = Tokens.back();
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
1149 Tokens.back()->Type = Type;
1150 Tokens.back()->Tok.setKind(tok::kw___unknown_anytype);
1152 Tokens.push_back(Next);
1159 FormatToken *getStashedToken() {
1160 // Create a synthesized second '>' or '<' token.
1161 Token Tok = FormatTok->Tok;
1162 StringRef TokenText = FormatTok->TokenText;
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;
1178 FormatToken *getNextToken() {
1179 if (GreaterStashed) {
1180 GreaterStashed = false;
1181 return getStashedToken();
1184 LessStashed = false;
1185 return getStashedToken();
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;
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')
1203 // See whether there is an odd number of '\' before this.
1205 for (; pos >= 0; --pos, ++count)
1206 if (Text[pos] != '\\')
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) {
1215 ++FormatTok->NewlinesBefore;
1216 FormatTok->HasUnescapedNewline = !EscapesNewline(i - 1);
1217 FormatTok->LastNewlineOffset = WhitespaceLength + i + 1;
1221 FormatTok->LastNewlineOffset = WhitespaceLength + i + 1;
1232 Column += Style.TabWidth - Column % Style.TabWidth;
1235 if (i + 1 == e || (Text[i + 1] != '\r' && Text[i + 1] != '\n'))
1236 FormatTok->Type = TT_ImplicitStringLiteral;
1239 FormatTok->Type = TT_ImplicitStringLiteral;
1242 if (FormatTok->Type == TT_ImplicitStringLiteral)
1246 if (FormatTok->is(TT_ImplicitStringLiteral))
1248 WhitespaceLength += FormatTok->Tok.getLength();
1250 readRawToken(*FormatTok);
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;
1263 FormatTok->TokenText = FormatTok->TokenText.substr(2);
1266 FormatTok->WhitespaceRange = SourceRange(
1267 WhitespaceStart, WhitespaceStart.getLocWithOffset(WhitespaceLength));
1269 FormatTok->OriginalColumn = Column;
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);
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);
1302 // Now FormatTok is the next non-whitespace token.
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;
1313 FormatTok->IsMultiline = true;
1314 // FIXME: ColumnWidth actually depends on the start column, we need to
1315 // take this into account when the token is moved.
1316 FormatTok->ColumnWidth = encoding::columnWidthWithTabs(
1317 Text.substr(0, FirstNewlinePos), Column, Style.TabWidth, Encoding);
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,
1324 Column = FormatTok->LastLineColumnWidth;
1327 if (Style.Language == FormatStyle::LK_Cpp) {
1328 if (!(Tokens.size() > 0 && Tokens.back()->Tok.getIdentifierInfo() &&
1329 Tokens.back()->Tok.getIdentifierInfo()->getPPKeywordID() ==
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;
1346 FormatToken *FormatTok;
1348 bool GreaterStashed, LessStashed;
1350 unsigned TrailingWhitespace;
1351 std::unique_ptr<Lexer> Lex;
1352 SourceManager &SourceMgr;
1355 IdentifierTable IdentTable;
1356 AdditionalKeywords Keywords;
1357 encoding::Encoding Encoding;
1358 llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
1359 // Index (in 'Tokens') of the last token that starts a new line.
1360 unsigned FirstInLineIndex;
1361 SmallVector<FormatToken *, 16> Tokens;
1362 SmallVector<IdentifierInfo *, 8> ForEachMacros;
1364 bool FormattingDisabled;
1366 llvm::Regex MacroBlockBeginRegex;
1367 llvm::Regex MacroBlockEndRegex;
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
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);
1385 if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format on" ||
1386 Tok.TokenText == "/* clang-format on */")) {
1387 FormattingDisabled = false;
1390 Tok.Finalized = FormattingDisabled;
1392 if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format off" ||
1393 Tok.TokenText == "/* clang-format off */")) {
1394 FormattingDisabled = true;
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;
1408 static StringRef getLanguageName(FormatStyle::LanguageKind Language) {
1410 case FormatStyle::LK_Cpp:
1412 case FormatStyle::LK_Java:
1414 case FormatStyle::LK_JavaScript:
1415 return "JavaScript";
1416 case FormatStyle::LK_Proto:
1423 class Formatter : public UnwrappedLineConsumer {
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"
1436 DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language)
1440 tooling::Replacements format(bool *IncompleteFormat) {
1441 tooling::Replacements Result;
1442 FormatTokenLexer Tokens(SourceMgr, ID, Style, Encoding);
1444 UnwrappedLineParser Parser(Style, Tokens.getKeywords(), Tokens.lex(),
1447 assert(UnwrappedLines.rbegin()->empty());
1448 for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE;
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]));
1455 tooling::Replacements RunResult =
1456 format(AnnotatedLines, Tokens, IncompleteFormat);
1458 llvm::dbgs() << "Replacements for run " << Run << ":\n";
1459 for (tooling::Replacements::iterator I = RunResult.begin(),
1460 E = RunResult.end();
1462 llvm::dbgs() << I->toString() << "\n";
1465 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1466 delete AnnotatedLines[i];
1468 Result.insert(RunResult.begin(), RunResult.end());
1469 Whitespaces.reset();
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]);
1481 deriveLocalStyle(AnnotatedLines);
1482 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1483 Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
1485 computeAffectedLines(AnnotatedLines.begin(), AnnotatedLines.end());
1487 Annotator.setCommentLineLevels(AnnotatedLines);
1488 ContinuationIndenter Indenter(Style, Tokens.getKeywords(), SourceMgr,
1489 Whitespaces, Encoding,
1490 BinPackInconclusiveFunctions);
1491 UnwrappedLineFormatter(&Indenter, &Whitespaces, Style, Tokens.getKeywords(),
1493 .format(AnnotatedLines);
1494 return Whitespaces.generateReplacements();
1498 // Determines which lines are affected by the SourceRanges given as input.
1499 // Returns \c true if at least one line between I and E or one of their
1500 // children is affected.
1501 bool computeAffectedLines(SmallVectorImpl<AnnotatedLine *>::iterator I,
1502 SmallVectorImpl<AnnotatedLine *>::iterator E) {
1503 bool SomeLineAffected = false;
1504 const AnnotatedLine *PreviousLine = nullptr;
1506 AnnotatedLine *Line = *I;
1507 Line->LeadingEmptyLinesAffected = affectsLeadingEmptyLines(*Line->First);
1509 // If a line is part of a preprocessor directive, it needs to be formatted
1510 // if any token within the directive is affected.
1511 if (Line->InPPDirective) {
1512 FormatToken *Last = Line->Last;
1513 SmallVectorImpl<AnnotatedLine *>::iterator PPEnd = I + 1;
1514 while (PPEnd != E && !(*PPEnd)->First->HasUnescapedNewline) {
1515 Last = (*PPEnd)->Last;
1519 if (affectsTokenRange(*Line->First, *Last,
1520 /*IncludeLeadingNewlines=*/false)) {
1521 SomeLineAffected = true;
1522 markAllAsAffected(I, PPEnd);
1528 if (nonPPLineAffected(Line, PreviousLine))
1529 SomeLineAffected = true;
1531 PreviousLine = Line;
1534 return SomeLineAffected;
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;
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;
1553 // Stores whether the first child line of any of this line's tokens is
1555 bool SomeFirstChildAffected = false;
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;
1562 // Determine whether the first child of 'Tok' was affected.
1563 if (!Tok->Children.empty() && Tok->Children.front()->Affected)
1564 SomeFirstChildAffected = true;
1566 IncludeLeadingNewlines = Tok->Children.empty();
1569 // Was this line moved, i.e. has it previously been on the same line as an
1571 bool LineMoved = PreviousLine && PreviousLine->Affected &&
1572 Line->First->NewlinesBefore == 0;
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);
1579 if (SomeTokenAffected || SomeFirstChildAffected || LineMoved ||
1580 IsContinuedComment) {
1581 Line->Affected = true;
1582 SomeLineAffected = true;
1584 return SomeLineAffected;
1587 // Marks all lines between I and E as well as all their children as affected.
1588 void markAllAsAffected(SmallVectorImpl<AnnotatedLine *>::iterator I,
1589 SmallVectorImpl<AnnotatedLine *>::iterator E) {
1591 (*I)->Affected = true;
1592 markAllAsAffected((*I)->Children.begin(), (*I)->Children.end());
1597 // Returns true if the range from 'First' to 'Last' intersects with one of the
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);
1610 // Returns true if one of the input ranges intersect the leading empty lines
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);
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(),
1624 if (!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(), I->getBegin()) &&
1625 !SourceMgr.isBeforeInTranslationUnit(I->getEnd(), Range.getBegin()))
1631 static bool inputUsesCRLF(StringRef Text) {
1632 return Text.count('\r') * 2 > Text.count('\n');
1636 hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
1637 for (const AnnotatedLine* Line : Lines) {
1638 if (hasCpp03IncompatibleFormat(Line->Children))
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))
1644 if (Tok->is(TT_TemplateCloser) &&
1645 Tok->Previous->is(TT_TemplateCloser))
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))
1661 Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
1662 bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
1663 Tok->Next->WhitespaceRange.getEnd();
1664 if (SpaceBefore && !SpaceAfter)
1666 if (!SpaceBefore && SpaceAfter)
1670 return AlignmentDiff;
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)
1680 FormatToken *Tok = AnnotatedLines[i]->First->Next;
1682 if (Tok->PackingKind == PPK_BinPacked)
1683 HasBinPackedFunction = true;
1684 if (Tok->PackingKind == PPK_OnePerLine)
1685 HasOnePerLineFunction = true;
1690 if (Style.DerivePointerAlignment)
1691 Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
1692 ? FormatStyle::PAS_Left
1693 : FormatStyle::PAS_Right;
1694 if (Style.Standard == FormatStyle::LS_Auto)
1695 Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
1696 ? FormatStyle::LS_Cpp11
1697 : FormatStyle::LS_Cpp03;
1698 BinPackInconclusiveFunctions =
1699 HasBinPackedFunction || !HasOnePerLineFunction;
1702 void consumeUnwrappedLine(const UnwrappedLine &TheLine) override {
1703 assert(!UnwrappedLines.empty());
1704 UnwrappedLines.back().push_back(TheLine);
1707 void finishRun() override {
1708 UnwrappedLines.push_back(SmallVector<UnwrappedLine, 16>());
1713 SourceManager &SourceMgr;
1714 WhitespaceManager Whitespaces;
1715 SmallVector<CharSourceRange, 8> Ranges;
1716 SmallVector<SmallVector<UnwrappedLine, 16>, 2> UnwrappedLines;
1718 encoding::Encoding Encoding;
1719 bool BinPackInconclusiveFunctions;
1722 struct IncludeDirective {
1729 } // end anonymous namespace
1731 // Determines whether 'Ranges' intersects with ('Start', 'End').
1732 static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
1734 for (auto Range : Ranges) {
1735 if (Range.getOffset() < End &&
1736 Range.getOffset() + Range.getLength() > Start)
1742 // Sorts a block of includes given by 'Includes' alphabetically adding the
1743 // necessary replacement to 'Replaces'. 'Includes' must be in strict source
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()))
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);
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) {
1773 bool CursorMoved = false;
1774 for (unsigned Index : Indices) {
1775 if (!result.empty())
1777 result += Includes[Index].Text;
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;
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);
1795 Replaces.insert(tooling::Replacement(FileName, Includes.front().Offset,
1796 result.size(), result));
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)
1807 unsigned SearchFrom = 0;
1808 llvm::Regex IncludeRegex(
1809 R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))");
1810 SmallVector<StringRef, 4> Matches;
1811 SmallVector<IncludeDirective, 16> IncludesInBlock;
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).
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;
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);
1833 bool FormattingOff = false;
1836 auto Pos = Code.find('\n', SearchFrom);
1838 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
1840 StringRef Trimmed = Line.trim();
1841 if (Trimmed == "// clang-format off")
1842 FormattingOff = true;
1843 else if (Trimmed == "// clang-format on")
1844 FormattingOff = false;
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;
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)) {
1862 MainIncludeFound = true;
1865 IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
1866 } else if (!IncludesInBlock.empty()) {
1867 sortIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
1869 IncludesInBlock.clear();
1870 FirstIncludeBlock = false;
1874 if (Pos == StringRef::npos || Pos + 1 == Code.size())
1876 SearchFrom = Pos + 1;
1878 if (!IncludesInBlock.empty())
1879 sortIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
1883 tooling::Replacements reformat(const FormatStyle &Style,
1884 SourceManager &SourceMgr, FileID ID,
1885 ArrayRef<CharSourceRange> Ranges,
1886 bool *IncompleteFormat) {
1887 FormatStyle Expanded = expandPresets(Style);
1888 if (Expanded.DisableFormat)
1889 return tooling::Replacements();
1890 Formatter formatter(Expanded, SourceMgr, ID, Ranges);
1891 return formatter.format(IncompleteFormat);
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();
1900 IntrusiveRefCntPtr<vfs::InMemoryFileSystem> InMemoryFileSystem(
1901 new vfs::InMemoryFileSystem);
1902 FileManager Files(FileSystemOptions(), InMemoryFileSystem);
1903 DiagnosticsEngine Diagnostics(
1904 IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
1905 new DiagnosticOptions);
1906 SourceManager SourceMgr(Diagnostics, Files);
1907 InMemoryFileSystem->addFile(
1908 FileName, 0, llvm::MemoryBuffer::getMemBuffer(
1909 Code, FileName, /*RequiresNullTerminator=*/false));
1910 FileID ID = SourceMgr.createFileID(Files.getFile(FileName), SourceLocation(),
1911 clang::SrcMgr::C_User);
1912 SourceLocation StartOfFile = SourceMgr.getLocForStartOfFile(ID);
1913 std::vector<CharSourceRange> CharRanges;
1914 for (const tooling::Range &Range : Ranges) {
1915 SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
1916 SourceLocation End = Start.getLocWithOffset(Range.getLength());
1917 CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
1919 return reformat(Style, SourceMgr, ID, CharRanges, IncompleteFormat);
1922 LangOptions getFormattingLangOpts(const FormatStyle &Style) {
1923 LangOptions LangOpts;
1924 LangOpts.CPlusPlus = 1;
1925 LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
1926 LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
1927 LangOpts.LineComment = 1;
1928 bool AlternativeOperators = Style.Language == FormatStyle::LK_Cpp;
1929 LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
1933 LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
1934 LangOpts.DeclSpecKeyword = 1; // To get __declspec.
1938 const char *StyleOptionHelpDescription =
1939 "Coding style, currently supports:\n"
1940 " LLVM, Google, Chromium, Mozilla, WebKit.\n"
1941 "Use -style=file to load style configuration from\n"
1942 ".clang-format file located in one of the parent\n"
1943 "directories of the source file (or current\n"
1944 "directory for stdin).\n"
1945 "Use -style=\"{key: value, ...}\" to set specific\n"
1946 "parameters, e.g.:\n"
1947 " -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
1949 static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
1950 if (FileName.endswith(".java"))
1951 return FormatStyle::LK_Java;
1952 if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
1953 return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
1954 if (FileName.endswith_lower(".proto") ||
1955 FileName.endswith_lower(".protodevel"))
1956 return FormatStyle::LK_Proto;
1957 if (FileName.endswith_lower(".td"))
1958 return FormatStyle::LK_TableGen;
1959 return FormatStyle::LK_Cpp;
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";
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";
1981 if (!StyleName.equals_lower("file")) {
1982 if (!getPredefinedStyle(StyleName, Style.Language, &Style))
1983 llvm::errs() << "Invalid value for -style, using " << FallbackStyle
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))
1996 SmallString<128> ConfigFile(Directory);
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
2003 llvm::sys::fs::is_regular_file(Twine(ConfigFile), 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);
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";
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);
2028 llvm::errs() << "Error reading " << ConfigFile << ": " << ec.message()
2032 DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n");
2036 if (!UnsuitableConfigFiles.empty()) {
2037 llvm::errs() << "Configuration file(s) do(es) not support "
2038 << getLanguageName(Style.Language) << ": "
2039 << UnsuitableConfigFiles << "\n";
2044 } // namespace format
2045 } // namespace clang