33 #include "llvm/ADT/STLExtras.h" 34 #include "llvm/ADT/StringRef.h" 35 #include "llvm/Support/Allocator.h" 36 #include "llvm/Support/Debug.h" 37 #include "llvm/Support/Path.h" 38 #include "llvm/Support/Regex.h" 39 #include "llvm/Support/VirtualFileSystem.h" 40 #include "llvm/Support/YAMLTraits.h" 45 #include <unordered_map> 47 #define DEBUG_TYPE "format-formatter" 51 LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::RawStringFormat)
55 template <>
struct ScalarEnumerationTraits<
FormatStyle::LanguageKind> {
57 IO.enumCase(Value,
"Cpp", FormatStyle::LK_Cpp);
58 IO.enumCase(Value,
"Java", FormatStyle::LK_Java);
59 IO.enumCase(Value,
"JavaScript", FormatStyle::LK_JavaScript);
60 IO.enumCase(Value,
"ObjC", FormatStyle::LK_ObjC);
61 IO.enumCase(Value,
"Proto", FormatStyle::LK_Proto);
62 IO.enumCase(Value,
"TableGen", FormatStyle::LK_TableGen);
63 IO.enumCase(Value,
"TextProto", FormatStyle::LK_TextProto);
64 IO.enumCase(Value,
"CSharp", FormatStyle::LK_CSharp);
68 template <>
struct ScalarEnumerationTraits<
FormatStyle::LanguageStandard> {
70 IO.enumCase(Value,
"Cpp03", FormatStyle::LS_Cpp03);
71 IO.enumCase(Value,
"C++03", FormatStyle::LS_Cpp03);
72 IO.enumCase(Value,
"Cpp11", FormatStyle::LS_Cpp11);
73 IO.enumCase(Value,
"C++11", FormatStyle::LS_Cpp11);
74 IO.enumCase(Value,
"Auto", FormatStyle::LS_Auto);
78 template <>
struct ScalarEnumerationTraits<
FormatStyle::UseTabStyle> {
80 IO.enumCase(Value,
"Never", FormatStyle::UT_Never);
81 IO.enumCase(Value,
"false", FormatStyle::UT_Never);
82 IO.enumCase(Value,
"Always", FormatStyle::UT_Always);
83 IO.enumCase(Value,
"true", FormatStyle::UT_Always);
84 IO.enumCase(Value,
"ForIndentation", FormatStyle::UT_ForIndentation);
85 IO.enumCase(Value,
"ForContinuationAndIndentation",
86 FormatStyle::UT_ForContinuationAndIndentation);
90 template <>
struct ScalarEnumerationTraits<
FormatStyle::JavaScriptQuoteStyle> {
92 IO.enumCase(Value,
"Leave", FormatStyle::JSQS_Leave);
93 IO.enumCase(Value,
"Single", FormatStyle::JSQS_Single);
94 IO.enumCase(Value,
"Double", FormatStyle::JSQS_Double);
98 template <>
struct ScalarEnumerationTraits<
FormatStyle::ShortFunctionStyle> {
100 IO.enumCase(Value,
"None", FormatStyle::SFS_None);
101 IO.enumCase(Value,
"false", FormatStyle::SFS_None);
102 IO.enumCase(Value,
"All", FormatStyle::SFS_All);
103 IO.enumCase(Value,
"true", FormatStyle::SFS_All);
104 IO.enumCase(Value,
"Inline", FormatStyle::SFS_Inline);
105 IO.enumCase(Value,
"InlineOnly", FormatStyle::SFS_InlineOnly);
106 IO.enumCase(Value,
"Empty", FormatStyle::SFS_Empty);
110 template <>
struct ScalarEnumerationTraits<
FormatStyle::ShortIfStyle> {
112 IO.enumCase(Value,
"Never", FormatStyle::SIS_Never);
113 IO.enumCase(Value,
"Always", FormatStyle::SIS_Always);
114 IO.enumCase(Value,
"WithoutElse", FormatStyle::SIS_WithoutElse);
117 IO.enumCase(Value,
"false", FormatStyle::SIS_Never);
118 IO.enumCase(Value,
"true", FormatStyle::SIS_WithoutElse);
122 template <>
struct ScalarEnumerationTraits<
FormatStyle::ShortLambdaStyle> {
124 IO.enumCase(Value,
"None", FormatStyle::SLS_None);
125 IO.enumCase(Value,
"false", FormatStyle::SLS_None);
126 IO.enumCase(Value,
"Empty", FormatStyle::SLS_Empty);
127 IO.enumCase(Value,
"Inline", FormatStyle::SLS_Inline);
128 IO.enumCase(Value,
"All", FormatStyle::SLS_All);
129 IO.enumCase(Value,
"true", FormatStyle::SLS_All);
133 template <>
struct ScalarEnumerationTraits<
FormatStyle::BinPackStyle> {
135 IO.enumCase(Value,
"Auto", FormatStyle::BPS_Auto);
136 IO.enumCase(Value,
"Always", FormatStyle::BPS_Always);
137 IO.enumCase(Value,
"Never", FormatStyle::BPS_Never);
141 template <>
struct ScalarEnumerationTraits<
FormatStyle::BinaryOperatorStyle> {
143 IO.enumCase(Value,
"All", FormatStyle::BOS_All);
144 IO.enumCase(Value,
"true", FormatStyle::BOS_All);
145 IO.enumCase(Value,
"None", FormatStyle::BOS_None);
146 IO.enumCase(Value,
"false", FormatStyle::BOS_None);
147 IO.enumCase(Value,
"NonAssignment", FormatStyle::BOS_NonAssignment);
151 template <>
struct ScalarEnumerationTraits<
FormatStyle::BraceBreakingStyle> {
153 IO.enumCase(Value,
"Attach", FormatStyle::BS_Attach);
154 IO.enumCase(Value,
"Linux", FormatStyle::BS_Linux);
155 IO.enumCase(Value,
"Mozilla", FormatStyle::BS_Mozilla);
156 IO.enumCase(Value,
"Stroustrup", FormatStyle::BS_Stroustrup);
157 IO.enumCase(Value,
"Allman", FormatStyle::BS_Allman);
158 IO.enumCase(Value,
"GNU", FormatStyle::BS_GNU);
159 IO.enumCase(Value,
"WebKit", FormatStyle::BS_WebKit);
160 IO.enumCase(Value,
"Custom", FormatStyle::BS_Custom);
165 struct ScalarEnumerationTraits<
FormatStyle::BreakConstructorInitializersStyle> {
168 IO.enumCase(Value,
"BeforeColon", FormatStyle::BCIS_BeforeColon);
169 IO.enumCase(Value,
"BeforeComma", FormatStyle::BCIS_BeforeComma);
170 IO.enumCase(Value,
"AfterColon", FormatStyle::BCIS_AfterColon);
175 struct ScalarEnumerationTraits<
FormatStyle::BreakInheritanceListStyle> {
177 FormatStyle::BreakInheritanceListStyle &
Value) {
178 IO.enumCase(Value,
"BeforeColon", FormatStyle::BILS_BeforeColon);
179 IO.enumCase(Value,
"BeforeComma", FormatStyle::BILS_BeforeComma);
180 IO.enumCase(Value,
"AfterColon", FormatStyle::BILS_AfterColon);
185 struct ScalarEnumerationTraits<
FormatStyle::PPDirectiveIndentStyle> {
187 IO.enumCase(Value,
"None", FormatStyle::PPDIS_None);
188 IO.enumCase(Value,
"AfterHash", FormatStyle::PPDIS_AfterHash);
189 IO.enumCase(Value,
"BeforeHash", FormatStyle::PPDIS_BeforeHash);
194 struct ScalarEnumerationTraits<
FormatStyle::ReturnTypeBreakingStyle> {
196 IO.enumCase(Value,
"None", FormatStyle::RTBS_None);
197 IO.enumCase(Value,
"All", FormatStyle::RTBS_All);
198 IO.enumCase(Value,
"TopLevel", FormatStyle::RTBS_TopLevel);
199 IO.enumCase(Value,
"TopLevelDefinitions",
200 FormatStyle::RTBS_TopLevelDefinitions);
201 IO.enumCase(Value,
"AllDefinitions", FormatStyle::RTBS_AllDefinitions);
206 struct ScalarEnumerationTraits<
FormatStyle::BreakTemplateDeclarationsStyle> {
208 FormatStyle::BreakTemplateDeclarationsStyle &
Value) {
209 IO.enumCase(Value,
"No", FormatStyle::BTDS_No);
210 IO.enumCase(Value,
"MultiLine", FormatStyle::BTDS_MultiLine);
211 IO.enumCase(Value,
"Yes", FormatStyle::BTDS_Yes);
214 IO.enumCase(Value,
"false", FormatStyle::BTDS_MultiLine);
215 IO.enumCase(Value,
"true", FormatStyle::BTDS_Yes);
220 struct ScalarEnumerationTraits<
FormatStyle::DefinitionReturnTypeBreakingStyle> {
223 IO.enumCase(Value,
"None", FormatStyle::DRTBS_None);
224 IO.enumCase(Value,
"All", FormatStyle::DRTBS_All);
225 IO.enumCase(Value,
"TopLevel", FormatStyle::DRTBS_TopLevel);
228 IO.enumCase(Value,
"false", FormatStyle::DRTBS_None);
229 IO.enumCase(Value,
"true", FormatStyle::DRTBS_All);
234 struct ScalarEnumerationTraits<
FormatStyle::NamespaceIndentationKind> {
236 FormatStyle::NamespaceIndentationKind &
Value) {
237 IO.enumCase(Value,
"None", FormatStyle::NI_None);
238 IO.enumCase(Value,
"Inner", FormatStyle::NI_Inner);
239 IO.enumCase(Value,
"All", FormatStyle::NI_All);
243 template <>
struct ScalarEnumerationTraits<
FormatStyle::BracketAlignmentStyle> {
245 IO.enumCase(Value,
"Align", FormatStyle::BAS_Align);
246 IO.enumCase(Value,
"DontAlign", FormatStyle::BAS_DontAlign);
247 IO.enumCase(Value,
"AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
250 IO.enumCase(Value,
"true", FormatStyle::BAS_Align);
251 IO.enumCase(Value,
"false", FormatStyle::BAS_DontAlign);
256 struct ScalarEnumerationTraits<
FormatStyle::EscapedNewlineAlignmentStyle> {
258 FormatStyle::EscapedNewlineAlignmentStyle &
Value) {
259 IO.enumCase(Value,
"DontAlign", FormatStyle::ENAS_DontAlign);
260 IO.enumCase(Value,
"Left", FormatStyle::ENAS_Left);
261 IO.enumCase(Value,
"Right", FormatStyle::ENAS_Right);
264 IO.enumCase(Value,
"true", FormatStyle::ENAS_Left);
265 IO.enumCase(Value,
"false", FormatStyle::ENAS_Right);
269 template <>
struct ScalarEnumerationTraits<
FormatStyle::PointerAlignmentStyle> {
271 IO.enumCase(Value,
"Middle", FormatStyle::PAS_Middle);
272 IO.enumCase(Value,
"Left", FormatStyle::PAS_Left);
273 IO.enumCase(Value,
"Right", FormatStyle::PAS_Right);
276 IO.enumCase(Value,
"true", FormatStyle::PAS_Left);
277 IO.enumCase(Value,
"false", FormatStyle::PAS_Right);
282 struct ScalarEnumerationTraits<
FormatStyle::SpaceBeforeParensOptions> {
284 FormatStyle::SpaceBeforeParensOptions &
Value) {
285 IO.enumCase(Value,
"Never", FormatStyle::SBPO_Never);
286 IO.enumCase(Value,
"ControlStatements",
287 FormatStyle::SBPO_ControlStatements);
288 IO.enumCase(Value,
"NonEmptyParentheses",
289 FormatStyle::SBPO_NonEmptyParentheses);
290 IO.enumCase(Value,
"Always", FormatStyle::SBPO_Always);
293 IO.enumCase(Value,
"false", FormatStyle::SBPO_Never);
294 IO.enumCase(Value,
"true", FormatStyle::SBPO_ControlStatements);
301 IO.mapOptional(
"Language", Style.Language);
303 if (IO.outputting()) {
304 StringRef StylesArray[] = {
"LLVM",
"Google",
"Chromium",
"Mozilla",
305 "WebKit",
"GNU",
"Microsoft"};
307 for (
size_t i = 0, e = Styles.size();
i < e; ++
i) {
308 StringRef StyleName(Styles[
i]);
311 Style == PredefinedStyle) {
312 IO.mapOptional(
"# BasedOnStyle", StyleName);
317 StringRef BasedOnStyle;
318 IO.mapOptional(
"BasedOnStyle", BasedOnStyle);
319 if (!BasedOnStyle.empty()) {
320 FormatStyle::LanguageKind OldLanguage = Style.Language;
321 FormatStyle::LanguageKind Language =
324 IO.setError(Twine(
"Unknown value for BasedOnStyle: ", BasedOnStyle));
327 Style.Language = OldLanguage;
332 if (!IO.outputting()) {
334 IO.mapOptional(
"DerivePointerBinding", Style.DerivePointerAlignment);
335 IO.mapOptional(
"IndentFunctionDeclarationAfterType",
336 Style.IndentWrappedFunctionNames);
337 IO.mapOptional(
"PointerBindsToType", Style.PointerAlignment);
338 IO.mapOptional(
"SpaceAfterControlStatementKeyword",
339 Style.SpaceBeforeParens);
345 IO.mapOptional(
"AlignConsecutiveAssignments",
347 IO.mapOptional(
"AlignConsecutiveDeclarations",
352 IO.mapOptional(
"AllowAllArgumentsOnNextLine",
354 IO.mapOptional(
"AllowAllConstructorInitializersOnNextLine",
355 Style.AllowAllConstructorInitializersOnNextLine);
356 IO.mapOptional(
"AllowAllParametersOfDeclarationOnNextLine",
357 Style.AllowAllParametersOfDeclarationOnNextLine);
358 IO.mapOptional(
"AllowShortBlocksOnASingleLine",
359 Style.AllowShortBlocksOnASingleLine);
360 IO.mapOptional(
"AllowShortCaseLabelsOnASingleLine",
361 Style.AllowShortCaseLabelsOnASingleLine);
362 IO.mapOptional(
"AllowShortFunctionsOnASingleLine",
363 Style.AllowShortFunctionsOnASingleLine);
364 IO.mapOptional(
"AllowShortLambdasOnASingleLine",
365 Style.AllowShortLambdasOnASingleLine);
366 IO.mapOptional(
"AllowShortIfStatementsOnASingleLine",
367 Style.AllowShortIfStatementsOnASingleLine);
368 IO.mapOptional(
"AllowShortLoopsOnASingleLine",
369 Style.AllowShortLoopsOnASingleLine);
370 IO.mapOptional(
"AlwaysBreakAfterDefinitionReturnType",
371 Style.AlwaysBreakAfterDefinitionReturnType);
372 IO.mapOptional(
"AlwaysBreakAfterReturnType",
373 Style.AlwaysBreakAfterReturnType);
378 if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
379 Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
380 if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
381 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
382 else if (Style.AlwaysBreakAfterDefinitionReturnType ==
383 FormatStyle::DRTBS_TopLevel)
384 Style.AlwaysBreakAfterReturnType =
385 FormatStyle::RTBS_TopLevelDefinitions;
388 IO.mapOptional(
"AlwaysBreakBeforeMultilineStrings",
389 Style.AlwaysBreakBeforeMultilineStrings);
390 IO.mapOptional(
"AlwaysBreakTemplateDeclarations",
391 Style.AlwaysBreakTemplateDeclarations);
392 IO.mapOptional(
"BinPackArguments", Style.BinPackArguments);
393 IO.mapOptional(
"BinPackParameters", Style.BinPackParameters);
394 IO.mapOptional(
"BraceWrapping", Style.BraceWrapping);
395 IO.mapOptional(
"BreakBeforeBinaryOperators",
396 Style.BreakBeforeBinaryOperators);
397 IO.mapOptional(
"BreakBeforeBraces", Style.BreakBeforeBraces);
399 bool BreakBeforeInheritanceComma =
false;
400 IO.mapOptional(
"BreakBeforeInheritanceComma", BreakBeforeInheritanceComma);
401 IO.mapOptional(
"BreakInheritanceList", Style.BreakInheritanceList);
405 if (BreakBeforeInheritanceComma &&
406 Style.BreakInheritanceList == FormatStyle::BILS_BeforeColon)
407 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
409 IO.mapOptional(
"BreakBeforeTernaryOperators",
410 Style.BreakBeforeTernaryOperators);
412 bool BreakConstructorInitializersBeforeComma =
false;
413 IO.mapOptional(
"BreakConstructorInitializersBeforeComma",
414 BreakConstructorInitializersBeforeComma);
415 IO.mapOptional(
"BreakConstructorInitializers",
416 Style.BreakConstructorInitializers);
420 if (BreakConstructorInitializersBeforeComma &&
421 Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeColon)
422 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
424 IO.mapOptional(
"BreakAfterJavaFieldAnnotations",
425 Style.BreakAfterJavaFieldAnnotations);
426 IO.mapOptional(
"BreakStringLiterals", Style.BreakStringLiterals);
427 IO.mapOptional(
"ColumnLimit", Style.ColumnLimit);
428 IO.mapOptional(
"CommentPragmas", Style.CommentPragmas);
429 IO.mapOptional(
"CompactNamespaces", Style.CompactNamespaces);
430 IO.mapOptional(
"ConstructorInitializerAllOnOneLineOrOnePerLine",
431 Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
432 IO.mapOptional(
"ConstructorInitializerIndentWidth",
433 Style.ConstructorInitializerIndentWidth);
434 IO.mapOptional(
"ContinuationIndentWidth", Style.ContinuationIndentWidth);
435 IO.mapOptional(
"Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
436 IO.mapOptional(
"DerivePointerAlignment", Style.DerivePointerAlignment);
437 IO.mapOptional(
"DisableFormat", Style.DisableFormat);
438 IO.mapOptional(
"ExperimentalAutoDetectBinPacking",
439 Style.ExperimentalAutoDetectBinPacking);
440 IO.mapOptional(
"FixNamespaceComments", Style.FixNamespaceComments);
441 IO.mapOptional(
"ForEachMacros", Style.ForEachMacros);
442 IO.mapOptional(
"IncludeBlocks", Style.IncludeStyle.IncludeBlocks);
443 IO.mapOptional(
"IncludeCategories", Style.IncludeStyle.IncludeCategories);
444 IO.mapOptional(
"IncludeIsMainRegex", Style.IncludeStyle.IncludeIsMainRegex);
445 IO.mapOptional(
"IndentCaseLabels", Style.IndentCaseLabels);
446 IO.mapOptional(
"IndentPPDirectives", Style.IndentPPDirectives);
447 IO.mapOptional(
"IndentWidth", Style.IndentWidth);
448 IO.mapOptional(
"IndentWrappedFunctionNames",
449 Style.IndentWrappedFunctionNames);
450 IO.mapOptional(
"JavaImportGroups", Style.JavaImportGroups);
451 IO.mapOptional(
"JavaScriptQuotes", Style.JavaScriptQuotes);
452 IO.mapOptional(
"JavaScriptWrapImports", Style.JavaScriptWrapImports);
453 IO.mapOptional(
"KeepEmptyLinesAtTheStartOfBlocks",
454 Style.KeepEmptyLinesAtTheStartOfBlocks);
455 IO.mapOptional(
"MacroBlockBegin", Style.MacroBlockBegin);
456 IO.mapOptional(
"MacroBlockEnd", Style.MacroBlockEnd);
457 IO.mapOptional(
"MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
458 IO.mapOptional(
"NamespaceIndentation", Style.NamespaceIndentation);
459 IO.mapOptional(
"NamespaceMacros", Style.NamespaceMacros);
460 IO.mapOptional(
"ObjCBinPackProtocolList", Style.ObjCBinPackProtocolList);
461 IO.mapOptional(
"ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
462 IO.mapOptional(
"ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
463 IO.mapOptional(
"ObjCSpaceBeforeProtocolList",
464 Style.ObjCSpaceBeforeProtocolList);
465 IO.mapOptional(
"PenaltyBreakAssignment", Style.PenaltyBreakAssignment);
466 IO.mapOptional(
"PenaltyBreakBeforeFirstCallParameter",
467 Style.PenaltyBreakBeforeFirstCallParameter);
468 IO.mapOptional(
"PenaltyBreakComment", Style.PenaltyBreakComment);
469 IO.mapOptional(
"PenaltyBreakFirstLessLess",
470 Style.PenaltyBreakFirstLessLess);
471 IO.mapOptional(
"PenaltyBreakString", Style.PenaltyBreakString);
472 IO.mapOptional(
"PenaltyBreakTemplateDeclaration",
473 Style.PenaltyBreakTemplateDeclaration);
474 IO.mapOptional(
"PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
475 IO.mapOptional(
"PenaltyReturnTypeOnItsOwnLine",
476 Style.PenaltyReturnTypeOnItsOwnLine);
477 IO.mapOptional(
"PointerAlignment", Style.PointerAlignment);
478 IO.mapOptional(
"RawStringFormats", Style.RawStringFormats);
479 IO.mapOptional(
"ReflowComments", Style.ReflowComments);
480 IO.mapOptional(
"SortIncludes", Style.SortIncludes);
481 IO.mapOptional(
"SortUsingDeclarations", Style.SortUsingDeclarations);
482 IO.mapOptional(
"SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
483 IO.mapOptional(
"SpaceAfterLogicalNot", Style.SpaceAfterLogicalNot);
484 IO.mapOptional(
"SpaceAfterTemplateKeyword",
485 Style.SpaceAfterTemplateKeyword);
486 IO.mapOptional(
"SpaceBeforeAssignmentOperators",
487 Style.SpaceBeforeAssignmentOperators);
488 IO.mapOptional(
"SpaceBeforeCpp11BracedList",
489 Style.SpaceBeforeCpp11BracedList);
490 IO.mapOptional(
"SpaceBeforeCtorInitializerColon",
491 Style.SpaceBeforeCtorInitializerColon);
492 IO.mapOptional(
"SpaceBeforeInheritanceColon",
493 Style.SpaceBeforeInheritanceColon);
494 IO.mapOptional(
"SpaceBeforeParens", Style.SpaceBeforeParens);
495 IO.mapOptional(
"SpaceBeforeRangeBasedForLoopColon",
496 Style.SpaceBeforeRangeBasedForLoopColon);
497 IO.mapOptional(
"SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
498 IO.mapOptional(
"SpacesBeforeTrailingComments",
499 Style.SpacesBeforeTrailingComments);
500 IO.mapOptional(
"SpacesInAngles", Style.SpacesInAngles);
501 IO.mapOptional(
"SpacesInContainerLiterals",
502 Style.SpacesInContainerLiterals);
503 IO.mapOptional(
"SpacesInCStyleCastParentheses",
504 Style.SpacesInCStyleCastParentheses);
505 IO.mapOptional(
"SpacesInParentheses", Style.SpacesInParentheses);
506 IO.mapOptional(
"SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
507 IO.mapOptional(
"Standard", Style.Standard);
508 IO.mapOptional(
"StatementMacros", Style.StatementMacros);
509 IO.mapOptional(
"TabWidth", Style.TabWidth);
510 IO.mapOptional(
"TypenameMacros", Style.TypenameMacros);
511 IO.mapOptional(
"UseTab", Style.UseTab);
515 template <>
struct MappingTraits<
FormatStyle::BraceWrappingFlags> {
516 static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
517 IO.mapOptional(
"AfterCaseLabel", Wrapping.AfterCaseLabel);
518 IO.mapOptional(
"AfterClass", Wrapping.AfterClass);
519 IO.mapOptional(
"AfterControlStatement", Wrapping.AfterControlStatement);
520 IO.mapOptional(
"AfterEnum", Wrapping.AfterEnum);
521 IO.mapOptional(
"AfterFunction", Wrapping.AfterFunction);
522 IO.mapOptional(
"AfterNamespace", Wrapping.AfterNamespace);
523 IO.mapOptional(
"AfterObjCDeclaration", Wrapping.AfterObjCDeclaration);
524 IO.mapOptional(
"AfterStruct", Wrapping.AfterStruct);
525 IO.mapOptional(
"AfterUnion", Wrapping.AfterUnion);
526 IO.mapOptional(
"AfterExternBlock", Wrapping.AfterExternBlock);
527 IO.mapOptional(
"BeforeCatch", Wrapping.BeforeCatch);
528 IO.mapOptional(
"BeforeElse", Wrapping.BeforeElse);
529 IO.mapOptional(
"IndentBraces", Wrapping.IndentBraces);
530 IO.mapOptional(
"SplitEmptyFunction", Wrapping.SplitEmptyFunction);
531 IO.mapOptional(
"SplitEmptyRecord", Wrapping.SplitEmptyRecord);
532 IO.mapOptional(
"SplitEmptyNamespace", Wrapping.SplitEmptyNamespace);
537 static void mapping(IO &IO, FormatStyle::RawStringFormat &Format) {
538 IO.mapOptional(
"Language", Format.Language);
539 IO.mapOptional(
"Delimiters", Format.Delimiters);
540 IO.mapOptional(
"EnclosingFunctions", Format.EnclosingFunctions);
541 IO.mapOptional(
"CanonicalDelimiter", Format.CanonicalDelimiter);
542 IO.mapOptional(
"BasedOnStyle", Format.BasedOnStyle);
551 template <>
struct DocumentListTraits<
std::vector<FormatStyle>> {
552 static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
557 if (Index >= Seq.size()) {
558 assert(Index == Seq.size());
560 if (!Seq.empty() && Seq[0].Language == FormatStyle::LK_None) {
563 Template = *((
const FormatStyle *)IO.getContext());
564 Template.Language = FormatStyle::LK_None;
566 Seq.resize(Index + 1, Template);
586 return llvm::make_error<llvm::StringError>(Message,
587 llvm::inconvertibleErrorCode());
591 return "clang-format.parse_error";
594 std::string ParseErrorCategory::message(
int EV)
const {
595 switch (static_cast<ParseError>(EV)) {
596 case ParseError::Success:
599 return "Invalid argument";
600 case ParseError::Unsuitable:
603 llvm_unreachable(
"unexpected parse error");
607 if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
610 Expanded.BraceWrapping = {
false,
false,
false,
false,
false,
false,
611 false,
false,
false,
false,
false,
612 false,
false,
true,
true,
true};
613 switch (Style.BreakBeforeBraces) {
614 case FormatStyle::BS_Linux:
615 Expanded.BraceWrapping.AfterClass =
true;
616 Expanded.BraceWrapping.AfterFunction =
true;
617 Expanded.BraceWrapping.AfterNamespace =
true;
619 case FormatStyle::BS_Mozilla:
620 Expanded.BraceWrapping.AfterClass =
true;
621 Expanded.BraceWrapping.AfterEnum =
true;
622 Expanded.BraceWrapping.AfterFunction =
true;
623 Expanded.BraceWrapping.AfterStruct =
true;
624 Expanded.BraceWrapping.AfterUnion =
true;
625 Expanded.BraceWrapping.AfterExternBlock =
true;
626 Expanded.BraceWrapping.SplitEmptyFunction =
true;
627 Expanded.BraceWrapping.SplitEmptyRecord =
false;
629 case FormatStyle::BS_Stroustrup:
630 Expanded.BraceWrapping.AfterFunction =
true;
631 Expanded.BraceWrapping.BeforeCatch =
true;
632 Expanded.BraceWrapping.BeforeElse =
true;
634 case FormatStyle::BS_Allman:
635 Expanded.BraceWrapping.AfterCaseLabel =
true;
636 Expanded.BraceWrapping.AfterClass =
true;
637 Expanded.BraceWrapping.AfterControlStatement =
true;
638 Expanded.BraceWrapping.AfterEnum =
true;
639 Expanded.BraceWrapping.AfterFunction =
true;
640 Expanded.BraceWrapping.AfterNamespace =
true;
641 Expanded.BraceWrapping.AfterObjCDeclaration =
true;
642 Expanded.BraceWrapping.AfterStruct =
true;
643 Expanded.BraceWrapping.AfterExternBlock =
true;
644 Expanded.BraceWrapping.BeforeCatch =
true;
645 Expanded.BraceWrapping.BeforeElse =
true;
647 case FormatStyle::BS_GNU:
648 Expanded.BraceWrapping = {
true,
true,
true,
true,
true,
true,
true,
true,
649 true,
true,
true,
true,
true,
true,
true,
true};
651 case FormatStyle::BS_WebKit:
652 Expanded.BraceWrapping.AfterFunction =
true;
662 LLVMStyle.Language = Language;
672 LLVMStyle.AllowAllConstructorInitializersOnNextLine =
true;
673 LLVMStyle.AllowAllParametersOfDeclarationOnNextLine =
true;
674 LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
675 LLVMStyle.AllowShortBlocksOnASingleLine =
false;
676 LLVMStyle.AllowShortCaseLabelsOnASingleLine =
false;
677 LLVMStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
678 LLVMStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
679 LLVMStyle.AllowShortLoopsOnASingleLine =
false;
680 LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
681 LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
682 LLVMStyle.AlwaysBreakBeforeMultilineStrings =
false;
683 LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
684 LLVMStyle.BinPackArguments =
true;
685 LLVMStyle.BinPackParameters =
true;
686 LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
687 LLVMStyle.BreakBeforeTernaryOperators =
true;
688 LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
689 LLVMStyle.BraceWrapping = {
false,
false,
false,
false,
false,
false,
690 false,
false,
false,
false,
false,
691 false,
false,
true,
true,
true};
692 LLVMStyle.BreakAfterJavaFieldAnnotations =
false;
693 LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
694 LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
695 LLVMStyle.BreakStringLiterals =
true;
696 LLVMStyle.ColumnLimit = 80;
697 LLVMStyle.CommentPragmas =
"^ IWYU pragma:";
698 LLVMStyle.CompactNamespaces =
false;
699 LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine =
false;
700 LLVMStyle.ConstructorInitializerIndentWidth = 4;
701 LLVMStyle.ContinuationIndentWidth = 4;
702 LLVMStyle.Cpp11BracedListStyle =
true;
703 LLVMStyle.DerivePointerAlignment =
false;
704 LLVMStyle.ExperimentalAutoDetectBinPacking =
false;
705 LLVMStyle.FixNamespaceComments =
true;
706 LLVMStyle.ForEachMacros.push_back(
"foreach");
707 LLVMStyle.ForEachMacros.push_back(
"Q_FOREACH");
708 LLVMStyle.ForEachMacros.push_back(
"BOOST_FOREACH");
709 LLVMStyle.IncludeStyle.IncludeCategories = {
710 {
"^\"(llvm|llvm-c|clang|clang-c)/", 2},
711 {
"^(<|\"(gtest|gmock|isl|json)/)", 3},
713 LLVMStyle.IncludeStyle.IncludeIsMainRegex =
"(Test)?$";
714 LLVMStyle.IncludeStyle.IncludeBlocks = tooling::IncludeStyle::IBS_Preserve;
715 LLVMStyle.IndentCaseLabels =
false;
716 LLVMStyle.IndentPPDirectives = FormatStyle::PPDIS_None;
717 LLVMStyle.IndentWrappedFunctionNames =
false;
718 LLVMStyle.IndentWidth = 2;
719 LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
720 LLVMStyle.JavaScriptWrapImports =
true;
721 LLVMStyle.TabWidth = 8;
722 LLVMStyle.MaxEmptyLinesToKeep = 1;
723 LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks =
true;
724 LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
725 LLVMStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
726 LLVMStyle.ObjCBlockIndentWidth = 2;
727 LLVMStyle.ObjCSpaceAfterProperty =
false;
728 LLVMStyle.ObjCSpaceBeforeProtocolList =
true;
729 LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
730 LLVMStyle.SpacesBeforeTrailingComments = 1;
731 LLVMStyle.Standard = FormatStyle::LS_Cpp11;
732 LLVMStyle.UseTab = FormatStyle::UT_Never;
733 LLVMStyle.ReflowComments =
true;
734 LLVMStyle.SpacesInParentheses =
false;
735 LLVMStyle.SpacesInSquareBrackets =
false;
736 LLVMStyle.SpaceInEmptyParentheses =
false;
737 LLVMStyle.SpacesInContainerLiterals =
true;
738 LLVMStyle.SpacesInCStyleCastParentheses =
false;
739 LLVMStyle.SpaceAfterCStyleCast =
false;
740 LLVMStyle.SpaceAfterLogicalNot =
false;
741 LLVMStyle.SpaceAfterTemplateKeyword =
true;
742 LLVMStyle.SpaceBeforeCtorInitializerColon =
true;
743 LLVMStyle.SpaceBeforeInheritanceColon =
true;
744 LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
745 LLVMStyle.SpaceBeforeRangeBasedForLoopColon =
true;
746 LLVMStyle.SpaceBeforeAssignmentOperators =
true;
747 LLVMStyle.SpaceBeforeCpp11BracedList =
false;
748 LLVMStyle.SpacesInAngles =
false;
751 LLVMStyle.PenaltyBreakComment = 300;
752 LLVMStyle.PenaltyBreakFirstLessLess = 120;
753 LLVMStyle.PenaltyBreakString = 1000;
754 LLVMStyle.PenaltyExcessCharacter = 1000000;
755 LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
756 LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
759 LLVMStyle.DisableFormat =
false;
760 LLVMStyle.SortIncludes =
true;
761 LLVMStyle.SortUsingDeclarations =
true;
762 LLVMStyle.StatementMacros.push_back(
"Q_UNUSED");
763 LLVMStyle.StatementMacros.push_back(
"QT_REQUIRE_VERSION");
766 if (Language == FormatStyle::LK_TableGen) {
767 LLVMStyle.SpacesInContainerLiterals =
false;
774 if (Language == FormatStyle::LK_TextProto) {
776 GoogleStyle.Language = FormatStyle::LK_TextProto;
785 GoogleStyle.AllowShortIfStatementsOnASingleLine =
786 FormatStyle::SIS_WithoutElse;
787 GoogleStyle.AllowShortLoopsOnASingleLine =
true;
788 GoogleStyle.AlwaysBreakBeforeMultilineStrings =
true;
789 GoogleStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
790 GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine =
true;
791 GoogleStyle.DerivePointerAlignment =
true;
792 GoogleStyle.IncludeStyle.IncludeCategories = {
793 {
"^<ext/.*\\.h>", 2}, {
"^<.*\\.h>", 1}, {
"^<.*", 2}, {
".*", 3}};
794 GoogleStyle.IncludeStyle.IncludeIsMainRegex =
"([-_](test|unittest))?$";
795 GoogleStyle.IncludeStyle.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup;
796 GoogleStyle.IndentCaseLabels =
true;
797 GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks =
false;
798 GoogleStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Never;
799 GoogleStyle.ObjCSpaceAfterProperty =
false;
800 GoogleStyle.ObjCSpaceBeforeProtocolList =
true;
801 GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
802 GoogleStyle.RawStringFormats = {
821 FormatStyle::LK_TextProto,
833 "PARSE_PARTIAL_TEXT_PROTO",
837 "ParseTextProtoOrDie",
843 GoogleStyle.SpacesBeforeTrailingComments = 2;
844 GoogleStyle.Standard = FormatStyle::LS_Auto;
846 GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
847 GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
849 if (Language == FormatStyle::LK_Java) {
853 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
854 GoogleStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
855 GoogleStyle.AlwaysBreakBeforeMultilineStrings =
false;
856 GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
857 GoogleStyle.ColumnLimit = 100;
858 GoogleStyle.SpaceAfterCStyleCast =
true;
859 GoogleStyle.SpacesBeforeTrailingComments = 1;
860 }
else if (Language == FormatStyle::LK_JavaScript) {
863 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
864 GoogleStyle.AlwaysBreakBeforeMultilineStrings =
false;
865 GoogleStyle.BreakBeforeTernaryOperators =
false;
868 GoogleStyle.CommentPragmas =
"(taze:|^/[ \t]*<|@see)";
869 GoogleStyle.MaxEmptyLinesToKeep = 3;
870 GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
871 GoogleStyle.SpacesInContainerLiterals =
false;
872 GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
873 GoogleStyle.JavaScriptWrapImports =
false;
874 }
else if (Language == FormatStyle::LK_Proto) {
875 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
876 GoogleStyle.AlwaysBreakBeforeMultilineStrings =
false;
877 GoogleStyle.SpacesInContainerLiterals =
false;
878 GoogleStyle.Cpp11BracedListStyle =
false;
884 GoogleStyle.BreakStringLiterals =
false;
885 }
else if (Language == FormatStyle::LK_ObjC) {
886 GoogleStyle.AlwaysBreakBeforeMultilineStrings =
false;
887 GoogleStyle.ColumnLimit = 100;
891 GoogleStyle.IncludeStyle.IncludeBlocks =
892 tooling::IncludeStyle::IBS_Preserve;
900 if (Language == FormatStyle::LK_Java) {
901 ChromiumStyle.AllowShortIfStatementsOnASingleLine =
902 FormatStyle::SIS_WithoutElse;
903 ChromiumStyle.BreakAfterJavaFieldAnnotations =
true;
904 ChromiumStyle.ContinuationIndentWidth = 8;
905 ChromiumStyle.IndentWidth = 4;
908 ChromiumStyle.JavaImportGroups = {
915 "com.google.android.apps.chrome",
920 ChromiumStyle.SortIncludes =
true;
921 }
else if (Language == FormatStyle::LK_JavaScript) {
922 ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
923 ChromiumStyle.AllowShortLoopsOnASingleLine =
false;
925 ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine =
false;
926 ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
927 ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
928 ChromiumStyle.AllowShortLoopsOnASingleLine =
false;
929 ChromiumStyle.BinPackParameters =
false;
930 ChromiumStyle.DerivePointerAlignment =
false;
931 if (Language == FormatStyle::LK_ObjC)
932 ChromiumStyle.ColumnLimit = 80;
934 return ChromiumStyle;
939 MozillaStyle.AllowAllParametersOfDeclarationOnNextLine =
false;
940 MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
941 MozillaStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
942 MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
943 FormatStyle::DRTBS_TopLevel;
944 MozillaStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
945 MozillaStyle.BinPackParameters =
false;
946 MozillaStyle.BinPackArguments =
false;
947 MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
948 MozillaStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
949 MozillaStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
950 MozillaStyle.ConstructorInitializerIndentWidth = 2;
951 MozillaStyle.ContinuationIndentWidth = 2;
952 MozillaStyle.Cpp11BracedListStyle =
false;
953 MozillaStyle.FixNamespaceComments =
false;
954 MozillaStyle.IndentCaseLabels =
true;
955 MozillaStyle.ObjCSpaceAfterProperty =
true;
956 MozillaStyle.ObjCSpaceBeforeProtocolList =
false;
957 MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
958 MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
959 MozillaStyle.SpaceAfterTemplateKeyword =
false;
969 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
970 Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
971 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
972 Style.Cpp11BracedListStyle =
false;
973 Style.ColumnLimit = 0;
974 Style.FixNamespaceComments =
false;
975 Style.IndentWidth = 4;
976 Style.NamespaceIndentation = FormatStyle::NI_Inner;
977 Style.ObjCBlockIndentWidth = 4;
978 Style.ObjCSpaceAfterProperty =
true;
979 Style.PointerAlignment = FormatStyle::PAS_Left;
980 Style.SpaceBeforeCpp11BracedList =
true;
986 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
987 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
988 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
989 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
990 Style.BreakBeforeTernaryOperators =
true;
991 Style.Cpp11BracedListStyle =
false;
992 Style.ColumnLimit = 79;
993 Style.FixNamespaceComments =
false;
994 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
995 Style.Standard = FormatStyle::LS_Cpp03;
1001 Style.ColumnLimit = 120;
1003 Style.IndentWidth = 4;
1004 Style.UseTab = FormatStyle::UT_Never;
1005 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1006 Style.BraceWrapping.AfterClass =
true;
1007 Style.BraceWrapping.AfterControlStatement =
true;
1008 Style.BraceWrapping.AfterEnum =
true;
1009 Style.BraceWrapping.AfterFunction =
true;
1010 Style.BraceWrapping.AfterNamespace =
true;
1011 Style.BraceWrapping.AfterObjCDeclaration =
true;
1012 Style.BraceWrapping.AfterStruct =
true;
1013 Style.BraceWrapping.AfterExternBlock =
true;
1014 Style.BraceWrapping.BeforeCatch =
true;
1015 Style.BraceWrapping.BeforeElse =
true;
1016 Style.PenaltyReturnTypeOnItsOwnLine = 1000;
1017 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
1018 Style.AllowShortBlocksOnASingleLine =
false;
1019 Style.AllowShortCaseLabelsOnASingleLine =
false;
1020 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
1021 Style.AllowShortLoopsOnASingleLine =
false;
1027 NoStyle.DisableFormat =
true;
1028 NoStyle.SortIncludes =
false;
1029 NoStyle.SortUsingDeclarations =
false;
1035 if (Name.equals_lower(
"llvm")) {
1037 }
else if (Name.equals_lower(
"chromium")) {
1039 }
else if (Name.equals_lower(
"mozilla")) {
1041 }
else if (Name.equals_lower(
"google")) {
1043 }
else if (Name.equals_lower(
"webkit")) {
1045 }
else if (Name.equals_lower(
"gnu")) {
1047 }
else if (Name.equals_lower(
"microsoft")) {
1049 }
else if (Name.equals_lower(
"none")) {
1055 Style->Language = Language;
1061 FormatStyle::LanguageKind Language = Style->Language;
1062 assert(Language != FormatStyle::LK_None);
1063 if (Text.trim().empty())
1065 Style->StyleSet.Clear();
1066 std::vector<FormatStyle> Styles;
1067 llvm::yaml::Input Input(Text);
1072 Input.setContext(Style);
1075 return Input.error();
1077 for (
unsigned i = 0;
i < Styles.size(); ++
i) {
1079 if (Styles[
i].Language == FormatStyle::LK_None &&
i != 0)
1082 for (
unsigned j = 0; j <
i; ++j) {
1083 if (Styles[i].Language == Styles[j].Language) {
1084 LLVM_DEBUG(llvm::dbgs()
1085 <<
"Duplicate languages in the config file on positions " 1086 << j <<
" and " << i <<
"\n");
1094 FormatStyle::FormatStyleSet StyleSet;
1095 bool LanguageFound =
false;
1096 for (
int i = Styles.size() - 1;
i >= 0; --
i) {
1097 if (Styles[
i].Language != FormatStyle::LK_None)
1098 StyleSet.Add(Styles[
i]);
1099 if (Styles[i].Language == Language)
1100 LanguageFound =
true;
1102 if (!LanguageFound) {
1103 if (Styles.empty() || Styles[0].Language != FormatStyle::LK_None)
1106 DefaultStyle.Language = Language;
1107 StyleSet.Add(std::move(DefaultStyle));
1109 *Style = *StyleSet.Get(Language);
1115 llvm::raw_string_ostream Stream(Text);
1116 llvm::yaml::Output Output(Stream);
1120 Output << NonConstStyle;
1121 return Stream.str();
1125 FormatStyle::FormatStyleSet::Get(FormatStyle::LanguageKind Language)
const {
1128 auto It = Styles->find(Language);
1129 if (It == Styles->end())
1132 Style.StyleSet = *
this;
1137 assert(Style.Language != LK_None &&
1138 "Cannot add a style for LK_None to a StyleSet");
1140 !Style.StyleSet.Styles &&
1141 "Cannot add a style associated with an existing StyleSet to a StyleSet");
1143 Styles = std::make_shared<MapType>();
1144 (*Styles)[Style.Language] = std::move(Style);
1147 void FormatStyle::FormatStyleSet::Clear() { Styles.reset(); }
1150 FormatStyle::GetLanguageStyle(FormatStyle::LanguageKind Language)
const {
1151 return StyleSet.Get(Language);
1161 std::pair<tooling::Replacements, unsigned>
1165 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
1167 requoteJSStringLiteral(AnnotatedLines, Result);
1177 requoteJSStringLiteral(
Line->Children, Result);
1178 if (!
Line->Affected)
1181 FormatTok = FormatTok->Next) {
1182 StringRef Input = FormatTok->TokenText;
1183 if (FormatTok->Finalized || !FormatTok->isStringLiteral() ||
1186 (Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
1187 !Input.startswith(
"\"")) ||
1188 (Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
1189 !Input.startswith(
"\'")))
1193 bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
1196 StringRef ReplacementText) {
1206 Replace(Start, 1, IsSingle ?
"'" :
"\"");
1207 Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
1208 IsSingle ?
"'" :
"\"");
1211 bool Escaped =
false;
1212 for (
size_t i = 1;
i < Input.size() - 1;
i++) {
1215 if (!Escaped && i + 1 < Input.size() &&
1216 ((IsSingle && Input[i + 1] ==
'"') ||
1217 (!IsSingle && Input[i + 1] ==
'\''))) {
1227 if (!Escaped && IsSingle == (Input[i] ==
'\'')) {
1249 std::pair<tooling::Replacements, unsigned>
1254 deriveLocalStyle(AnnotatedLines);
1255 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
1256 for (
unsigned i = 0, e = AnnotatedLines.size();
i != e; ++
i) {
1266 BinPackInconclusiveFunctions);
1271 .format(AnnotatedLines,
false,
1277 for (
const auto &R : Whitespaces.generateReplacements())
1279 return std::make_pair(Result, 0);
1280 return std::make_pair(Result, Penalty);
1284 static bool inputUsesCRLF(StringRef
Text) {
1285 return Text.count(
'\r') * 2 > Text.count(
'\n');
1291 if (hasCpp03IncompatibleFormat(
Line->Children))
1297 if (
Tok->
is(TT_TemplateCloser) &&
1307 int AlignmentDiff = 0;
1309 AlignmentDiff += countVariableAlignments(
Line->Children);
1311 if (!
Tok->
is(TT_PointerOrReference))
1317 if (SpaceBefore && !SpaceAfter)
1319 if (!SpaceBefore && SpaceAfter)
1323 return AlignmentDiff;
1328 bool HasBinPackedFunction =
false;
1329 bool HasOnePerLineFunction =
false;
1330 for (
unsigned i = 0, e = AnnotatedLines.size();
i != e; ++
i) {
1331 if (!AnnotatedLines[
i]->
First->Next)
1336 HasBinPackedFunction =
true;
1338 HasOnePerLineFunction =
true;
1343 if (Style.DerivePointerAlignment)
1344 Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
1345 ? FormatStyle::PAS_Left
1346 : FormatStyle::PAS_Right;
1347 if (Style.Standard == FormatStyle::LS_Auto)
1348 Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
1349 ? FormatStyle::LS_Cpp11
1350 : FormatStyle::LS_Cpp03;
1351 BinPackInconclusiveFunctions =
1352 HasBinPackedFunction || !HasOnePerLineFunction;
1355 bool BinPackInconclusiveFunctions;
1368 std::pair<tooling::Replacements, unsigned>
1379 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
1381 checkEmptyNamespace(AnnotatedLines);
1383 for (
auto &
Line : AnnotatedLines) {
1384 if (
Line->Affected) {
1385 cleanupRight(
Line->First, tok::comma, tok::comma);
1386 cleanupRight(
Line->First, TT_CtorInitializerColon, tok::comma);
1387 cleanupRight(
Line->First, tok::l_paren, tok::comma);
1388 cleanupLeft(
Line->First, tok::comma, tok::r_paren);
1389 cleanupLeft(
Line->First, TT_CtorInitializerComma, tok::l_brace);
1390 cleanupLeft(
Line->First, TT_CtorInitializerColon, tok::l_brace);
1391 cleanupLeft(
Line->First, TT_CtorInitializerColon, tok::equal);
1395 return {generateFixes(), 0};
1409 std::set<unsigned> DeletedLines;
1410 for (
unsigned i = 0, e = AnnotatedLines.size();
i != e; ++
i) {
1411 auto &Line = *AnnotatedLines[
i];
1413 checkEmptyNamespace(AnnotatedLines,
i,
i, DeletedLines);
1417 for (
auto Line : DeletedLines) {
1431 unsigned CurrentLine,
unsigned &
NewLine,
1432 std::set<unsigned> &DeletedLines) {
1433 unsigned InitLine = CurrentLine,
End = AnnotatedLines.size();
1434 if (Style.BraceWrapping.AfterNamespace) {
1438 if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
1439 NewLine = CurrentLine;
1442 }
else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
1445 while (++CurrentLine < End) {
1446 if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
1449 if (AnnotatedLines[CurrentLine]->startsWithNamespace()) {
1450 if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
1457 if (containsOnlyComments(*AnnotatedLines[CurrentLine]))
1462 NewLine = CurrentLine;
1466 NewLine = CurrentLine;
1467 if (CurrentLine >= End)
1471 if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
1472 AnnotatedLines[InitLine]->First->Tok.getLocation(),
1473 AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
1476 for (
unsigned i = InitLine;
i <= CurrentLine; ++
i) {
1477 DeletedLines.insert(
i);
1487 template <
typename LeftKind,
typename RightKind>
1488 void cleanupPair(
FormatToken *Start, LeftKind LK, RightKind RK,
1492 if (!Res->is(tok::comment) &&
1493 DeletedTokens.find(Res) == DeletedTokens.end())
1497 for (
auto *Left = Start; Left;) {
1498 auto *Right = NextNotDeleted(*Left);
1501 if (Left->is(LK) && Right->is(RK)) {
1502 deleteToken(DeleteLeft ? Left : Right);
1514 template <
typename LeftKind,
typename RightKind>
1515 void cleanupLeft(
FormatToken *Start, LeftKind LK, RightKind RK) {
1516 cleanupPair(Start, LK, RK,
true);
1519 template <
typename LeftKind,
typename RightKind>
1520 void cleanupRight(
FormatToken *Start, LeftKind LK, RightKind RK) {
1521 cleanupPair(Start, LK, RK,
false);
1527 DeletedTokens.insert(Tok);
1532 std::vector<FormatToken *> Tokens;
1533 std::copy(DeletedTokens.begin(), DeletedTokens.end(),
1534 std::back_inserter(Tokens));
1540 while (Idx < Tokens.size()) {
1541 unsigned St = Idx,
End = Idx;
1542 while ((End + 1) < Tokens.size() &&
1543 Tokens[
End]->Next == Tokens[End + 1]) {
1546 auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
1554 assert(
false &&
"Fixes must not conflict!");
1565 struct FormatTokenLess {
1576 std::set<FormatToken *, FormatTokenLess> DeletedTokens;
1579 class ObjCHeaderStyleGuesser :
public TokenAnalyzer {
1581 ObjCHeaderStyleGuesser(
const Environment &Env,
const FormatStyle &Style)
1582 : TokenAnalyzer(Env, Style), IsObjC(
false) {}
1584 std::pair<tooling::Replacements, unsigned>
1585 analyze(TokenAnnotator &Annotator,
1586 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1587 FormatTokenLexer &Tokens)
override {
1588 assert(Style.Language == FormatStyle::LK_Cpp);
1589 IsObjC = guessIsObjC(Env.getSourceManager(), AnnotatedLines,
1590 Tokens.getKeywords());
1591 tooling::Replacements Result;
1595 bool isObjC() {
return IsObjC; }
1599 guessIsObjC(
const SourceManager &SourceManager,
1600 const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1601 const AdditionalKeywords &Keywords) {
1603 static constexpr llvm::StringLiteral FoundationIdentifiers[] = {
1618 "NSAffineTransform",
1620 "NSAttributedString",
1637 "NSInvocationOperation",
1641 "NSMutableAttributedString",
1642 "NSMutableCharacterSet",
1644 "NSMutableDictionary",
1645 "NSMutableIndexSet",
1646 "NSMutableOrderedSet",
1650 "NSNumberFormatter",
1654 "NSOperationQueuePriority",
1658 "NSQualityOfService",
1661 "NSRegularExpression",
1676 for (
auto Line : AnnotatedLines) {
1677 for (
const FormatToken *FormatTok =
Line->First; FormatTok;
1678 FormatTok = FormatTok->Next) {
1679 if ((FormatTok->Previous && FormatTok->Previous->is(tok::at) &&
1680 (FormatTok->Tok.getObjCKeywordID() != tok::objc_not_keyword ||
1681 FormatTok->isOneOf(tok::numeric_constant, tok::l_square,
1683 (FormatTok->Tok.isAnyIdentifier() &&
1684 std::binary_search(std::begin(FoundationIdentifiers),
1685 std::end(FoundationIdentifiers),
1686 FormatTok->TokenText)) ||
1687 FormatTok->is(TT_ObjCStringLiteral) ||
1688 FormatTok->isOneOf(Keywords.kw_NS_ENUM, Keywords.kw_NS_OPTIONS,
1689 TT_ObjCBlockLBrace, TT_ObjCBlockLParen,
1690 TT_ObjCDecl, TT_ObjCForIn, TT_ObjCMethodExpr,
1691 TT_ObjCMethodSpecifier, TT_ObjCProperty)) {
1692 LLVM_DEBUG(llvm::dbgs()
1693 <<
"Detected ObjC at location " 1694 << FormatTok->Tok.getLocation().printToString(
1696 <<
" token: " << FormatTok->TokenText <<
" token type: " 1700 if (guessIsObjC(SourceManager,
Line->Children, Keywords))
1710 struct IncludeDirective {
1717 struct JavaImportDirective {
1730 for (
auto Range : Ranges) {
1731 if (Range.getOffset() < End &&
1732 Range.getOffset() + Range.getLength() > Start)
1745 static std::pair<unsigned, unsigned>
1749 unsigned OffsetToEOL = 0;
1750 for (
int i = 0, e = Includes.size();
i != e; ++
i) {
1751 unsigned Start = Includes[Indices[
i]].Offset;
1752 unsigned End = Start + Includes[Indices[
i]].Text.size();
1753 if (!(Cursor >= Start && Cursor < End))
1755 CursorIndex = Indices[
i];
1756 OffsetToEOL = End -
Cursor;
1759 while (--
i >= 0 && Includes[CursorIndex].
Text == Includes[Indices[
i]].
Text)
1763 return std::make_pair(CursorIndex, OffsetToEOL);
1778 unsigned IncludesBeginOffset = Includes.front().Offset;
1779 unsigned IncludesEndOffset =
1780 Includes.back().Offset + Includes.back().Text.size();
1781 unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
1782 if (!
affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
1785 for (
unsigned i = 0, e = Includes.size();
i != e; ++
i)
1786 Indices.push_back(
i);
1787 llvm::stable_sort(Indices, [&](
unsigned LHSI,
unsigned RHSI) {
1789 std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
1793 unsigned CursorIndex;
1795 unsigned CursorToEOLOffset;
1797 std::tie(CursorIndex, CursorToEOLOffset) =
1801 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1802 [&](
unsigned LHSI,
unsigned RHSI) {
1803 return Includes[LHSI].Text == Includes[RHSI].Text;
1807 int CurrentCategory = Includes.front().Category;
1815 if (Indices.size() == Includes.size() &&
1816 std::is_sorted(Indices.begin(), Indices.end()) &&
1817 Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Preserve)
1821 for (
unsigned Index : Indices) {
1822 if (!result.empty()) {
1824 if (Style.IncludeStyle.IncludeBlocks ==
1825 tooling::IncludeStyle::IBS_Regroup &&
1826 CurrentCategory != Includes[Index].Category)
1829 result += Includes[Index].Text;
1830 if (Cursor && CursorIndex == Index)
1831 *Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
1832 CurrentCategory = Includes[Index].Category;
1837 if (result == Code.substr(IncludesBeginOffset, IncludesBlockSize))
1841 FileName, Includes.front().Offset, IncludesBlockSize,
result));
1852 const char CppIncludeRegexPattern[] =
1853 R
"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))"; 1863 unsigned SearchFrom = 0;
1864 llvm::Regex IncludeRegex(CppIncludeRegexPattern);
1876 bool FirstIncludeBlock =
true;
1877 bool MainIncludeFound =
false;
1878 bool FormattingOff =
false;
1881 auto Pos = Code.find(
'\n', SearchFrom);
1883 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
1885 StringRef Trimmed = Line.trim();
1886 if (Trimmed ==
"// clang-format off" || Trimmed ==
"/* clang-format off */")
1887 FormattingOff =
true;
1888 else if (Trimmed ==
"// clang-format on" ||
1889 Trimmed ==
"/* clang-format on */")
1890 FormattingOff =
false;
1892 const bool EmptyLineSkipped =
1894 (Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Merge ||
1895 Style.IncludeStyle.IncludeBlocks ==
1896 tooling::IncludeStyle::IBS_Regroup);
1898 if (!FormattingOff && !Line.endswith(
"\\")) {
1899 if (IncludeRegex.match(Line, &Matches)) {
1900 StringRef IncludeName = Matches[2];
1903 !MainIncludeFound && FirstIncludeBlock);
1905 MainIncludeFound =
true;
1906 IncludesInBlock.push_back({IncludeName,
Line, Prev, Category});
1907 }
else if (!IncludesInBlock.empty() && !EmptyLineSkipped) {
1910 IncludesInBlock.clear();
1911 FirstIncludeBlock =
false;
1915 if (Pos == StringRef::npos || Pos + 1 == Code.size())
1917 SearchFrom = Pos + 1;
1919 if (!IncludesInBlock.empty()) {
1920 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Code, Replaces,
1929 StringRef ImportIdentifier) {
1930 unsigned LongestMatchIndex =
UINT_MAX;
1931 unsigned LongestMatchLength = 0;
1932 for (
unsigned I = 0; I < Style.JavaImportGroups.size(); I++) {
1933 std::string GroupPrefix = Style.JavaImportGroups[I];
1934 if (ImportIdentifier.startswith(GroupPrefix) &&
1935 GroupPrefix.length() > LongestMatchLength) {
1936 LongestMatchIndex = I;
1937 LongestMatchLength = GroupPrefix.length();
1940 return LongestMatchIndex;
1952 unsigned ImportsBeginOffset = Imports.front().Offset;
1953 unsigned ImportsEndOffset =
1954 Imports.back().Offset + Imports.back().Text.size();
1955 unsigned ImportsBlockSize = ImportsEndOffset - ImportsBeginOffset;
1956 if (!
affectsRange(Ranges, ImportsBeginOffset, ImportsEndOffset))
1960 for (
unsigned i = 0, e = Imports.size();
i != e; ++
i) {
1961 Indices.push_back(
i);
1962 JavaImportGroups.push_back(
1965 llvm::sort(Indices, [&](
unsigned LHSI,
unsigned RHSI) {
1967 return std::make_tuple(!Imports[LHSI].
IsStatic, JavaImportGroups[LHSI],
1969 std::make_tuple(!Imports[RHSI].IsStatic, JavaImportGroups[RHSI],
1970 Imports[RHSI].Identifier);
1974 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1975 [&](
unsigned LHSI,
unsigned RHSI) {
1976 return Imports[LHSI].Text == Imports[RHSI].Text;
1980 bool CurrentIsStatic = Imports[Indices.front()].IsStatic;
1981 unsigned CurrentImportGroup = JavaImportGroups[Indices.front()];
1984 for (
unsigned Index : Indices) {
1985 if (!result.empty()) {
1987 if (CurrentIsStatic != Imports[Index].
IsStatic ||
1988 CurrentImportGroup != JavaImportGroups[Index])
1992 result += CommentLine;
1995 result += Imports[Index].Text;
1996 CurrentIsStatic = Imports[Index].IsStatic;
1997 CurrentImportGroup = JavaImportGroups[Index];
2002 if (result == Code.substr(Imports.front().Offset, ImportsBlockSize))
2006 ImportsBlockSize,
result));
2017 const char JavaImportRegexPattern[] =
2018 "^[\t ]*import[\t ]+(static[\t ]*)?([^\t ]*)[\t ]*;";
2027 unsigned SearchFrom = 0;
2028 llvm::Regex ImportRegex(JavaImportRegexPattern);
2033 bool FormattingOff =
false;
2036 auto Pos = Code.find(
'\n', SearchFrom);
2038 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
2040 StringRef Trimmed = Line.trim();
2041 if (Trimmed ==
"// clang-format off")
2042 FormattingOff =
true;
2043 else if (Trimmed ==
"// clang-format on")
2044 FormattingOff =
false;
2046 if (ImportRegex.match(Line, &Matches)) {
2047 if (FormattingOff) {
2052 StringRef Static = Matches[1];
2055 if (Static.contains(
"static")) {
2058 ImportsInBlock.push_back(
2060 AssociatedCommentLines.clear();
2061 }
else if (Trimmed.size() > 0 && !ImportsInBlock.empty()) {
2063 AssociatedCommentLines.push_back(Line);
2066 if (Pos == StringRef::npos || Pos + 1 == Code.size())
2068 SearchFrom = Pos + 1;
2070 if (!ImportsInBlock.empty())
2071 sortJavaImports(Style, ImportsInBlock, Ranges, FileName, Code, Replaces);
2079 return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
2082 bool isLikelyXml(StringRef Code) {
return Code.ltrim().startswith(
"<"); }
2086 StringRef FileName,
unsigned *
Cursor) {
2088 if (!Style.SortIncludes)
2092 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
2095 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
2097 if (Style.Language == FormatStyle::LanguageKind::LK_Java)
2103 template <
typename T>
2108 if (Replaces.
empty())
2113 return NewCode.takeError();
2115 StringRef FileName = Replaces.
begin()->getFilePath();
2118 ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
2120 return Replaces.
merge(FormatReplaces);
2129 std::vector<tooling::Range> Ranges,
2133 auto SortedReplaces =
2135 if (!SortedReplaces)
2136 return SortedReplaces.takeError();
2141 std::vector<tooling::Range> Ranges,
2143 return reformat(Style, Code, Ranges, FileName);
2152 llvm::Regex(CppIncludeRegexPattern)
2168 std::set<llvm::StringRef> HeadersToDelete;
2170 for (
const auto &R : Replaces) {
2171 if (isHeaderInsertion(R)) {
2174 llvm::consumeError(HeaderInsertions.
add(R));
2175 }
else if (isHeaderDeletion(R)) {
2176 HeadersToDelete.insert(R.getReplacementText());
2177 }
else if (R.getOffset() ==
UINT_MAX) {
2178 llvm::errs() <<
"Insertions other than header #include insertion are " 2180 << R.getReplacementText() <<
"\n";
2182 llvm::consumeError(Result.
add(R));
2185 if (HeaderInsertions.
empty() && HeadersToDelete.empty())
2188 StringRef FileName = Replaces.begin()->getFilePath();
2191 for (
const auto &Header : HeadersToDelete) {
2193 Includes.
remove(Header.trim(
"\"<>"), Header.startswith(
"<"));
2194 for (
const auto &R : Replaces) {
2195 auto Err = Result.
add(R);
2198 llvm::errs() <<
"Failed to add header deletion replacement for " 2205 llvm::Regex IncludeRegex = llvm::Regex(CppIncludeRegexPattern);
2207 for (
const auto &R : HeaderInsertions) {
2208 auto IncludeDirective = R.getReplacementText();
2209 bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
2210 assert(Matched &&
"Header insertion replacement must have replacement text " 2213 auto IncludeName = Matches[2];
2215 Includes.
insert(IncludeName.trim(
"\"<>"), IncludeName.startswith(
"<"));
2217 auto Err = Result.
add(*Replace);
2219 llvm::consumeError(std::move(Err));
2220 unsigned NewOffset =
2239 std::vector<tooling::Range> Ranges,
2241 return cleanup(Style, Code, Ranges, FileName);
2245 fixCppIncludeInsertions(Code, Replaces, Style);
2249 namespace internal {
2250 std::pair<tooling::Replacements, unsigned>
2253 unsigned NextStartColumn,
unsigned LastStartColumn, StringRef FileName,
2256 if (Expanded.DisableFormat)
2260 if (Expanded.Language == FormatStyle::LK_JavaScript &&
isMpegTS(Code))
2263 typedef std::function<std::pair<tooling::Replacements, unsigned>(
2268 if (Style.Language == FormatStyle::LK_Cpp) {
2269 if (Style.FixNamespaceComments)
2274 if (Style.SortUsingDeclarations)
2280 if (Style.Language == FormatStyle::LK_JavaScript &&
2281 Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
2283 return JavaScriptRequoter(Env, Expanded).process();
2287 return Formatter(Env, Expanded, Status).process();
2291 llvm::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
2292 NextStartColumn, LastStartColumn);
2295 unsigned Penalty = 0;
2296 for (
size_t I = 0, E = Passes.size(); I < E; ++I) {
2297 std::pair<tooling::Replacements, unsigned> PassFixes = Passes[I](*Env);
2299 CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first);
2301 Fixes = Fixes.
merge(PassFixes.first);
2302 Penalty += PassFixes.second;
2304 CurrentCode = std::move(*NewCode);
2305 Env = llvm::make_unique<Environment>(
2306 *CurrentCode, FileName,
2308 FirstStartColumn, NextStartColumn, LastStartColumn);
2313 return {Fixes, Penalty};
2324 0, FileName, Status)
2330 StringRef FileName) {
2332 if (Style.Language != FormatStyle::LK_Cpp)
2334 return Cleaner(
Environment(Code, FileName, Ranges), Style).process().first;
2339 StringRef FileName,
bool *IncompleteFormat) {
2341 auto Result =
reformat(Style, Code, Ranges, FileName, &Status);
2343 *IncompleteFormat =
true;
2350 StringRef FileName) {
2359 StringRef FileName) {
2367 LangOpts.CPlusPlus = 1;
2368 LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2369 LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2370 LangOpts.CPlusPlus17 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2371 LangOpts.CPlusPlus2a = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2372 LangOpts.LineComment = 1;
2373 bool AlternativeOperators = Style.isCpp();
2374 LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
2377 LangOpts.MicrosoftExt = 1;
2378 LangOpts.DeclSpecKeyword = 1;
2383 "Coding style, currently supports:\n" 2384 " LLVM, Google, Chromium, Mozilla, WebKit.\n" 2385 "Use -style=file to load style configuration from\n" 2386 ".clang-format file located in one of the parent\n" 2387 "directories of the source file (or current\n" 2388 "directory for stdin).\n" 2389 "Use -style=\"{key: value, ...}\" to set specific\n" 2390 "parameters, e.g.:\n" 2391 " -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
2394 if (FileName.endswith(
".java"))
2395 return FormatStyle::LK_Java;
2396 if (FileName.endswith_lower(
".js") || FileName.endswith_lower(
".ts"))
2397 return FormatStyle::LK_JavaScript;
2398 if (FileName.endswith(
".m") || FileName.endswith(
".mm"))
2399 return FormatStyle::LK_ObjC;
2400 if (FileName.endswith_lower(
".proto") ||
2401 FileName.endswith_lower(
".protodevel"))
2402 return FormatStyle::LK_Proto;
2403 if (FileName.endswith_lower(
".textpb") ||
2404 FileName.endswith_lower(
".pb.txt") ||
2405 FileName.endswith_lower(
".textproto") ||
2406 FileName.endswith_lower(
".asciipb"))
2407 return FormatStyle::LK_TextProto;
2408 if (FileName.endswith_lower(
".td"))
2409 return FormatStyle::LK_TableGen;
2410 if (FileName.endswith_lower(
".cs"))
2411 return FormatStyle::LK_CSharp;
2412 return FormatStyle::LK_Cpp;
2417 if (GuessedLanguage == FormatStyle::LK_Cpp) {
2418 auto Extension = llvm::sys::path::extension(FileName);
2421 if (Extension.empty() || Extension ==
".h") {
2422 auto NonEmptyFileName = FileName.empty() ?
"guess.h" : FileName;
2426 if (Guesser.isObjC())
2427 return FormatStyle::LK_ObjC;
2430 return GuessedLanguage;
2438 StringRef FallbackStyleName,
2440 llvm::vfs::FileSystem *FS) {
2442 FS = llvm::vfs::getRealFileSystem().get();
2450 if (StyleName.startswith(
"{")) {
2457 if (!StyleName.equals_lower(
"file")) {
2466 if (std::error_code EC = FS->makeAbsolute(Path))
2469 for (StringRef Directory = Path; !Directory.empty();
2470 Directory = llvm::sys::path::parent_path(Directory)) {
2472 auto Status = FS->status(Directory);
2474 Status->getType() != llvm::sys::fs::file_type::directory_file) {
2480 llvm::sys::path::append(ConfigFile,
".clang-format");
2481 LLVM_DEBUG(llvm::dbgs() <<
"Trying " << ConfigFile <<
"...\n");
2483 Status = FS->status(ConfigFile.str());
2484 bool FoundConfigFile =
2485 Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
2486 if (!FoundConfigFile) {
2488 ConfigFile = Directory;
2489 llvm::sys::path::append(ConfigFile,
"_clang-format");
2490 LLVM_DEBUG(llvm::dbgs() <<
"Trying " << ConfigFile <<
"...\n");
2491 Status = FS->status(ConfigFile.str());
2492 FoundConfigFile = Status && (Status->getType() ==
2493 llvm::sys::fs::file_type::regular_file);
2496 if (FoundConfigFile) {
2497 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
Text =
2498 FS->getBufferForFile(ConfigFile.str());
2499 if (std::error_code EC = Text.getError())
2501 if (std::error_code ec =
2503 if (ec == ParseError::Unsuitable) {
2504 if (!UnsuitableConfigFiles.empty())
2505 UnsuitableConfigFiles.append(
", ");
2506 UnsuitableConfigFiles.append(ConfigFile);
2512 LLVM_DEBUG(llvm::dbgs()
2513 <<
"Using configuration file " << ConfigFile <<
"\n");
2517 if (!UnsuitableConfigFiles.empty())
2520 UnsuitableConfigFiles);
2521 return FallbackStyle;
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be placed into a PointerUnion...
Defines the SourceManager interface.
AffectedRangeManager class manages affected ranges in the code.
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const
Return a StringRef to the source buffer data for the specified FileID.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file implements a token annotator, i.e.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Defines the Diagnostic-related interfaces.
WhitespaceManager class manages whitespace around tokens and their replacements.
const AnnotatedLine * Line
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
SourceLocation getEnd() const
Encodes a location in the source.
This file contains the declaration of the UnwrappedLineParser, which turns a stream of tokens into Un...
Dataflow Directional Tag Classes.
This file implements a sorter for JavaScript ES6 imports.
This file declares an abstract TokenAnalyzer, and associated helper classes.
This file implements an indenter that manages the indentation of continuations.
This file declares UsingDeclarationsSorter, a TokenAnalyzer that sorts consecutive using declarations...
SourceLocation getBegin() const
This class handles loading and caching of source files into memory.
bool isObjC(ID Id)
isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
SourceLocation getEndLoc() const