blob: 4a67cdeedf35692e59186e9e149e0a574731ecf3 [file] [log] [blame]
Daniel Jasperf7935112012-12-03 18:12:45 +00001//===--- Format.cpp - Format C++ code -------------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9///
10/// \file
Adrian Prantl9fc8faf2018-05-09 01:00:01 +000011/// This file implements functions declared in Format.h. This will be
Daniel Jasperf7935112012-12-03 18:12:45 +000012/// split into separate files as we go.
13///
Daniel Jasperf7935112012-12-03 18:12:45 +000014//===----------------------------------------------------------------------===//
15
Daniel Jasper85c472d2015-09-29 07:53:08 +000016#include "clang/Format/Format.h"
Eric Liu4cfb88a2016-04-25 15:09:22 +000017#include "AffectedRangeManager.h"
Daniel Jasperde0328a2013-08-16 11:20:30 +000018#include "ContinuationIndenter.h"
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +000019#include "FormatInternal.h"
Martin Probstc4a0dd42016-05-20 11:24:24 +000020#include "FormatTokenLexer.h"
Krasimir Georgiev7cb267a2017-02-27 13:28:36 +000021#include "NamespaceEndCommentsFixer.h"
Martin Probstc4a0dd42016-05-20 11:24:24 +000022#include "SortJavaScriptImports.h"
23#include "TokenAnalyzer.h"
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000024#include "TokenAnnotator.h"
Daniel Jasper0df50932014-12-10 19:00:42 +000025#include "UnwrappedLineFormatter.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000026#include "UnwrappedLineParser.h"
Krasimir Georgievb03877a2017-06-21 12:03:12 +000027#include "UsingDeclarationsSorter.h"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +000028#include "WhitespaceManager.h"
Daniel Jasperec04c0d2013-05-16 10:40:07 +000029#include "clang/Basic/Diagnostic.h"
Benjamin Kramerf3ca26982014-05-10 16:31:55 +000030#include "clang/Basic/DiagnosticOptions.h"
Chandler Carruth44eb4f62013-01-02 10:28:36 +000031#include "clang/Basic/SourceManager.h"
Marianne Mailhot-Sarrasin4988fa12016-04-14 14:47:37 +000032#include "clang/Basic/VirtualFileSystem.h"
Daniel Jasperf7935112012-12-03 18:12:45 +000033#include "clang/Lex/Lexer.h"
Eric Liu44564ac2018-06-04 09:04:12 +000034#include "clang/Tooling/Inclusions/HeaderIncludes.h"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +000035#include "llvm/ADT/STLExtras.h"
Ben Hamiltone2e3e672018-01-17 17:33:08 +000036#include "llvm/ADT/StringRef.h"
Manuel Klimek2ef908e2013-02-13 10:46:36 +000037#include "llvm/Support/Allocator.h"
Manuel Klimek24998102013-01-16 14:55:28 +000038#include "llvm/Support/Debug.h"
Edwin Vaned544aa72013-09-30 13:31:48 +000039#include "llvm/Support/Path.h"
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +000040#include "llvm/Support/Regex.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000041#include "llvm/Support/YAMLTraits.h"
Martin Probst081f1762016-06-01 15:19:53 +000042#include <algorithm>
Eric Liu4cfb88a2016-04-25 15:09:22 +000043#include <memory>
Eric Liubf4c41c2018-05-04 17:55:13 +000044#include <mutex>
Daniel Jasper8b529712012-12-04 13:02:32 +000045#include <string>
Eric Liubf4c41c2018-05-04 17:55:13 +000046#include <unordered_map>
Daniel Jasper8b529712012-12-04 13:02:32 +000047
Chandler Carruth10346662014-04-22 03:17:02 +000048#define DEBUG_TYPE "format-formatter"
49
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +000050using clang::format::FormatStyle;
51
NAKAMURA Takumi057a9422017-11-01 04:43:22 +000052LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::RawStringFormat)
Daniel Jaspere1e43192014-04-01 12:55:11 +000053
Alexander Kornienkod6538332013-05-07 15:32:14 +000054namespace llvm {
55namespace yaml {
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +000056template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
57 static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
58 IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
Daniel Jasperc58c70e2014-09-15 11:21:46 +000059 IO.enumCase(Value, "Java", FormatStyle::LK_Java);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +000060 IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
Daniel Jasper03a04fe2016-12-12 12:42:29 +000061 IO.enumCase(Value, "ObjC", FormatStyle::LK_ObjC);
Daniel Jasper7052ce62014-01-19 09:04:08 +000062 IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
Daniel Jasper498f5582015-12-25 08:53:31 +000063 IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
Krasimir Georgiev26b144c2017-07-03 15:05:14 +000064 IO.enumCase(Value, "TextProto", FormatStyle::LK_TextProto);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +000065 }
66};
67
68template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> {
69 static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
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);
75 }
76};
77
78template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
79 static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
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);
Marianne Mailhot-Sarrasin51fe2792016-04-14 14:52:26 +000085 IO.enumCase(Value, "ForContinuationAndIndentation",
86 FormatStyle::UT_ForContinuationAndIndentation);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +000087 }
88};
89
Daniel Jasperabd1f572016-03-02 22:44:03 +000090template <> struct ScalarEnumerationTraits<FormatStyle::JavaScriptQuoteStyle> {
91 static void enumeration(IO &IO, FormatStyle::JavaScriptQuoteStyle &Value) {
92 IO.enumCase(Value, "Leave", FormatStyle::JSQS_Leave);
93 IO.enumCase(Value, "Single", FormatStyle::JSQS_Single);
94 IO.enumCase(Value, "Double", FormatStyle::JSQS_Double);
95 }
96};
97
Daniel Jasperd74cf402014-04-08 12:46:38 +000098template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
99 static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
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);
Francois Ferrandd3f0e3d2017-06-21 13:56:02 +0000105 IO.enumCase(Value, "InlineOnly", FormatStyle::SFS_InlineOnly);
Daniel Jasper9e709352014-11-26 10:43:58 +0000106 IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
Daniel Jasperd74cf402014-04-08 12:46:38 +0000107 }
108};
109
Ben Hamilton4dc658c2018-02-02 20:15:14 +0000110template <> struct ScalarEnumerationTraits<FormatStyle::BinPackStyle> {
111 static void enumeration(IO &IO, FormatStyle::BinPackStyle &Value) {
112 IO.enumCase(Value, "Auto", FormatStyle::BPS_Auto);
113 IO.enumCase(Value, "Always", FormatStyle::BPS_Always);
114 IO.enumCase(Value, "Never", FormatStyle::BPS_Never);
115 }
116};
117
Daniel Jasperac043c92014-09-15 11:11:00 +0000118template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
119 static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
120 IO.enumCase(Value, "All", FormatStyle::BOS_All);
121 IO.enumCase(Value, "true", FormatStyle::BOS_All);
122 IO.enumCase(Value, "None", FormatStyle::BOS_None);
123 IO.enumCase(Value, "false", FormatStyle::BOS_None);
124 IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
125 }
126};
127
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000128template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
129 static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
130 IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
131 IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +0000132 IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000133 IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
134 IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000135 IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
Roman Kashitsyn291f64f2015-08-10 13:43:19 +0000136 IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000137 IO.enumCase(Value, "Custom", FormatStyle::BS_Custom);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000138 }
139};
140
Manuel Klimek89628f62017-09-20 09:51:03 +0000141template <>
142struct ScalarEnumerationTraits<FormatStyle::BreakConstructorInitializersStyle> {
143 static void
144 enumeration(IO &IO, FormatStyle::BreakConstructorInitializersStyle &Value) {
Francois Ferranda6b6d512017-05-24 11:36:58 +0000145 IO.enumCase(Value, "BeforeColon", FormatStyle::BCIS_BeforeColon);
146 IO.enumCase(Value, "BeforeComma", FormatStyle::BCIS_BeforeComma);
147 IO.enumCase(Value, "AfterColon", FormatStyle::BCIS_AfterColon);
148 }
149};
150
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000151template <>
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000152struct ScalarEnumerationTraits<FormatStyle::BreakInheritanceListStyle> {
153 static void
154 enumeration(IO &IO, FormatStyle::BreakInheritanceListStyle &Value) {
155 IO.enumCase(Value, "BeforeColon", FormatStyle::BILS_BeforeColon);
156 IO.enumCase(Value, "BeforeComma", FormatStyle::BILS_BeforeComma);
157 IO.enumCase(Value, "AfterColon", FormatStyle::BILS_AfterColon);
158 }
159};
160
161template <>
Krasimir Georgievad47c902017-08-30 14:34:57 +0000162struct ScalarEnumerationTraits<FormatStyle::PPDirectiveIndentStyle> {
163 static void enumeration(IO &IO, FormatStyle::PPDirectiveIndentStyle &Value) {
164 IO.enumCase(Value, "None", FormatStyle::PPDIS_None);
165 IO.enumCase(Value, "AfterHash", FormatStyle::PPDIS_AfterHash);
166 }
167};
168
169template <>
Zachary Turner448592e2015-12-18 22:20:15 +0000170struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
171 static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
172 IO.enumCase(Value, "None", FormatStyle::RTBS_None);
173 IO.enumCase(Value, "All", FormatStyle::RTBS_All);
174 IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
175 IO.enumCase(Value, "TopLevelDefinitions",
176 FormatStyle::RTBS_TopLevelDefinitions);
177 IO.enumCase(Value, "AllDefinitions", FormatStyle::RTBS_AllDefinitions);
178 }
179};
180
181template <>
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000182struct ScalarEnumerationTraits<FormatStyle::BreakTemplateDeclarationsStyle> {
183 static void enumeration(IO &IO, FormatStyle::BreakTemplateDeclarationsStyle &Value) {
184 IO.enumCase(Value, "No", FormatStyle::BTDS_No);
185 IO.enumCase(Value, "MultiLine", FormatStyle::BTDS_MultiLine);
186 IO.enumCase(Value, "Yes", FormatStyle::BTDS_Yes);
187
188 // For backward compatibility.
189 IO.enumCase(Value, "false", FormatStyle::BTDS_MultiLine);
190 IO.enumCase(Value, "true", FormatStyle::BTDS_Yes);
191 }
192};
193
194template <>
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000195struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
196 static void
197 enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) {
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +0000198 IO.enumCase(Value, "None", FormatStyle::DRTBS_None);
199 IO.enumCase(Value, "All", FormatStyle::DRTBS_All);
200 IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel);
201
202 // For backward compatibility.
203 IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
204 IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
205 }
206};
207
Alexander Kornienkod6538332013-05-07 15:32:14 +0000208template <>
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000209struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000210 static void enumeration(IO &IO,
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000211 FormatStyle::NamespaceIndentationKind &Value) {
212 IO.enumCase(Value, "None", FormatStyle::NI_None);
213 IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
214 IO.enumCase(Value, "All", FormatStyle::NI_All);
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000215 }
216};
217
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000218template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
219 static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
220 IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
221 IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign);
222 IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
223
224 // For backward compatibility.
225 IO.enumCase(Value, "true", FormatStyle::BAS_Align);
226 IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
227 }
228};
229
Manuel Klimek89628f62017-09-20 09:51:03 +0000230template <>
231struct ScalarEnumerationTraits<FormatStyle::EscapedNewlineAlignmentStyle> {
232 static void enumeration(IO &IO,
233 FormatStyle::EscapedNewlineAlignmentStyle &Value) {
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000234 IO.enumCase(Value, "DontAlign", FormatStyle::ENAS_DontAlign);
235 IO.enumCase(Value, "Left", FormatStyle::ENAS_Left);
236 IO.enumCase(Value, "Right", FormatStyle::ENAS_Right);
237
238 // For backward compatibility.
239 IO.enumCase(Value, "true", FormatStyle::ENAS_Left);
240 IO.enumCase(Value, "false", FormatStyle::ENAS_Right);
241 }
242};
243
Jacques Pienaarfc275112015-02-18 23:48:37 +0000244template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
245 static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
Daniel Jasper553d4872014-06-17 12:40:34 +0000246 IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
247 IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
248 IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
249
Alp Toker958027b2014-07-14 19:42:55 +0000250 // For backward compatibility.
Daniel Jasper553d4872014-06-17 12:40:34 +0000251 IO.enumCase(Value, "true", FormatStyle::PAS_Left);
252 IO.enumCase(Value, "false", FormatStyle::PAS_Right);
253 }
254};
255
256template <>
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000257struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
Manuel Klimeka8eb9142013-05-13 12:51:40 +0000258 static void enumeration(IO &IO,
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000259 FormatStyle::SpaceBeforeParensOptions &Value) {
260 IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +0000261 IO.enumCase(Value, "ControlStatements",
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000262 FormatStyle::SBPO_ControlStatements);
263 IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +0000264
265 // For backward compatibility.
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000266 IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
267 IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +0000268 }
269};
270
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000271template <> struct MappingTraits<FormatStyle> {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000272 static void mapping(IO &IO, FormatStyle &Style) {
273 // When reading, read the language first, we need it for getPredefinedStyle.
274 IO.mapOptional("Language", Style.Language);
275
Alexander Kornienko49149672013-05-10 11:56:10 +0000276 if (IO.outputting()) {
Jacques Pienaarfc275112015-02-18 23:48:37 +0000277 StringRef StylesArray[] = {"LLVM", "Google", "Chromium",
278 "Mozilla", "WebKit", "GNU"};
Alexander Kornienko49149672013-05-10 11:56:10 +0000279 ArrayRef<StringRef> Styles(StylesArray);
280 for (size_t i = 0, e = Styles.size(); i < e; ++i) {
281 StringRef StyleName(Styles[i]);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000282 FormatStyle PredefinedStyle;
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000283 if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
Alexander Kornienko006b5c82013-05-19 00:53:30 +0000284 Style == PredefinedStyle) {
Alexander Kornienko49149672013-05-10 11:56:10 +0000285 IO.mapOptional("# BasedOnStyle", StyleName);
286 break;
287 }
288 }
289 } else {
Alexander Kornienkod6538332013-05-07 15:32:14 +0000290 StringRef BasedOnStyle;
291 IO.mapOptional("BasedOnStyle", BasedOnStyle);
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000292 if (!BasedOnStyle.empty()) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000293 FormatStyle::LanguageKind OldLanguage = Style.Language;
294 FormatStyle::LanguageKind Language =
295 ((FormatStyle *)IO.getContext())->Language;
296 if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
Alexander Kornienko006b5c82013-05-19 00:53:30 +0000297 IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
298 return;
299 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000300 Style.Language = OldLanguage;
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000301 }
Alexander Kornienkod6538332013-05-07 15:32:14 +0000302 }
303
Birunthan Mohanathas50a6f912015-06-28 14:52:34 +0000304 // For backward compatibility.
305 if (!IO.outputting()) {
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000306 IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlines);
Birunthan Mohanathas50a6f912015-06-28 14:52:34 +0000307 IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
308 IO.mapOptional("IndentFunctionDeclarationAfterType",
309 Style.IndentWrappedFunctionNames);
310 IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
311 IO.mapOptional("SpaceAfterControlStatementKeyword",
312 Style.SpaceBeforeParens);
313 }
314
Alexander Kornienkod6538332013-05-07 15:32:14 +0000315 IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +0000316 IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000317 IO.mapOptional("AlignConsecutiveAssignments",
318 Style.AlignConsecutiveAssignments);
Daniel Jaspere12597c2015-10-01 10:06:54 +0000319 IO.mapOptional("AlignConsecutiveDeclarations",
320 Style.AlignConsecutiveDeclarations);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000321 IO.mapOptional("AlignEscapedNewlines", Style.AlignEscapedNewlines);
Daniel Jasper3219e432014-12-02 13:24:51 +0000322 IO.mapOptional("AlignOperands", Style.AlignOperands);
Daniel Jasper552f4a72013-07-31 23:55:15 +0000323 IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000324 IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
325 Style.AllowAllParametersOfDeclarationOnNextLine);
Daniel Jasper17605d32014-05-14 09:33:35 +0000326 IO.mapOptional("AllowShortBlocksOnASingleLine",
327 Style.AllowShortBlocksOnASingleLine);
Daniel Jasperb87899b2014-09-10 13:11:45 +0000328 IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
329 Style.AllowShortCaseLabelsOnASingleLine);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000330 IO.mapOptional("AllowShortFunctionsOnASingleLine",
331 Style.AllowShortFunctionsOnASingleLine);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000332 IO.mapOptional("AllowShortIfStatementsOnASingleLine",
333 Style.AllowShortIfStatementsOnASingleLine);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000334 IO.mapOptional("AllowShortLoopsOnASingleLine",
335 Style.AllowShortLoopsOnASingleLine);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +0000336 IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
337 Style.AlwaysBreakAfterDefinitionReturnType);
Zachary Turner448592e2015-12-18 22:20:15 +0000338 IO.mapOptional("AlwaysBreakAfterReturnType",
339 Style.AlwaysBreakAfterReturnType);
340 // If AlwaysBreakAfterDefinitionReturnType was specified but
341 // AlwaysBreakAfterReturnType was not, initialize the latter from the
342 // former for backwards compatibility.
343 if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
344 Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
345 if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
346 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
347 else if (Style.AlwaysBreakAfterDefinitionReturnType ==
348 FormatStyle::DRTBS_TopLevel)
349 Style.AlwaysBreakAfterReturnType =
350 FormatStyle::RTBS_TopLevelDefinitions;
351 }
352
Alexander Kornienko58611712013-07-04 12:02:44 +0000353 IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
354 Style.AlwaysBreakBeforeMultilineStrings);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000355 IO.mapOptional("AlwaysBreakTemplateDeclarations",
356 Style.AlwaysBreakTemplateDeclarations);
357 IO.mapOptional("BinPackArguments", Style.BinPackArguments);
358 IO.mapOptional("BinPackParameters", Style.BinPackParameters);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000359 IO.mapOptional("BraceWrapping", Style.BraceWrapping);
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000360 IO.mapOptional("BreakBeforeBinaryOperators",
361 Style.BreakBeforeBinaryOperators);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000362 IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000363
364 bool BreakBeforeInheritanceComma = false;
Francois Ferrande56a8292017-06-14 12:29:47 +0000365 IO.mapOptional("BreakBeforeInheritanceComma",
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000366 BreakBeforeInheritanceComma);
367 IO.mapOptional("BreakInheritanceList",
368 Style.BreakInheritanceList);
369 // If BreakBeforeInheritanceComma was specified but
370 // BreakInheritance was not, initialize the latter from the
371 // former for backwards compatibility.
372 if (BreakBeforeInheritanceComma &&
373 Style.BreakInheritanceList == FormatStyle::BILS_BeforeColon)
374 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
375
Daniel Jasper165b29e2013-11-08 00:57:11 +0000376 IO.mapOptional("BreakBeforeTernaryOperators",
377 Style.BreakBeforeTernaryOperators);
Francois Ferranda6b6d512017-05-24 11:36:58 +0000378
379 bool BreakConstructorInitializersBeforeComma = false;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000380 IO.mapOptional("BreakConstructorInitializersBeforeComma",
Francois Ferranda6b6d512017-05-24 11:36:58 +0000381 BreakConstructorInitializersBeforeComma);
382 IO.mapOptional("BreakConstructorInitializers",
383 Style.BreakConstructorInitializers);
384 // If BreakConstructorInitializersBeforeComma was specified but
385 // BreakConstructorInitializers was not, initialize the latter from the
386 // former for backwards compatibility.
387 if (BreakConstructorInitializersBeforeComma &&
388 Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeColon)
389 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
390
Daniel Jaspere1a7b762016-02-01 11:21:02 +0000391 IO.mapOptional("BreakAfterJavaFieldAnnotations",
392 Style.BreakAfterJavaFieldAnnotations);
393 IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000394 IO.mapOptional("ColumnLimit", Style.ColumnLimit);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000395 IO.mapOptional("CommentPragmas", Style.CommentPragmas);
Francois Ferrande56a8292017-06-14 12:29:47 +0000396 IO.mapOptional("CompactNamespaces", Style.CompactNamespaces);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000397 IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
398 Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
Daniel Jasper50d634b2014-10-28 16:53:38 +0000399 IO.mapOptional("ConstructorInitializerIndentWidth",
400 Style.ConstructorInitializerIndentWidth);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000401 IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
402 IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
Daniel Jasper553d4872014-06-17 12:40:34 +0000403 IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000404 IO.mapOptional("DisableFormat", Style.DisableFormat);
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000405 IO.mapOptional("ExperimentalAutoDetectBinPacking",
406 Style.ExperimentalAutoDetectBinPacking);
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000407 IO.mapOptional("FixNamespaceComments", Style.FixNamespaceComments);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000408 IO.mapOptional("ForEachMacros", Style.ForEachMacros);
Eric Liu9d92c022018-05-14 19:51:33 +0000409 IO.mapOptional("IncludeBlocks", Style.IncludeStyle.IncludeBlocks);
410 IO.mapOptional("IncludeCategories", Style.IncludeStyle.IncludeCategories);
411 IO.mapOptional("IncludeIsMainRegex", Style.IncludeStyle.IncludeIsMainRegex);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000412 IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
Krasimir Georgievad47c902017-08-30 14:34:57 +0000413 IO.mapOptional("IndentPPDirectives", Style.IndentPPDirectives);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000414 IO.mapOptional("IndentWidth", Style.IndentWidth);
415 IO.mapOptional("IndentWrappedFunctionNames",
416 Style.IndentWrappedFunctionNames);
Martin Probst0cd74ee2016-06-13 16:39:50 +0000417 IO.mapOptional("JavaScriptQuotes", Style.JavaScriptQuotes);
418 IO.mapOptional("JavaScriptWrapImports", Style.JavaScriptWrapImports);
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000419 IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
420 Style.KeepEmptyLinesAtTheStartOfBlocks);
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000421 IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
422 IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000423 IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
Daniel Jasper65ee3472013-07-31 23:16:02 +0000424 IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
Ben Hamilton4dc658c2018-02-02 20:15:14 +0000425 IO.mapOptional("ObjCBinPackProtocolList", Style.ObjCBinPackProtocolList);
Daniel Jasper50d634b2014-10-28 16:53:38 +0000426 IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
Daniel Jaspere9beea22014-01-28 15:20:33 +0000427 IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000428 IO.mapOptional("ObjCSpaceBeforeProtocolList",
429 Style.ObjCSpaceBeforeProtocolList);
Manuel Klimek89628f62017-09-20 09:51:03 +0000430 IO.mapOptional("PenaltyBreakAssignment", Style.PenaltyBreakAssignment);
Daniel Jasper33b909c2013-10-25 14:29:37 +0000431 IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
432 Style.PenaltyBreakBeforeFirstCallParameter);
Alexander Kornienkodd7ece52013-06-07 16:02:52 +0000433 IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000434 IO.mapOptional("PenaltyBreakFirstLessLess",
435 Style.PenaltyBreakFirstLessLess);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000436 IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000437 IO.mapOptional("PenaltyBreakTemplateDeclaration",
438 Style.PenaltyBreakTemplateDeclaration);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000439 IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
440 IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
441 Style.PenaltyReturnTypeOnItsOwnLine);
Daniel Jasper553d4872014-06-17 12:40:34 +0000442 IO.mapOptional("PointerAlignment", Style.PointerAlignment);
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +0000443 IO.mapOptional("RawStringFormats", Style.RawStringFormats);
Daniel Jaspera0a50392015-12-01 13:28:53 +0000444 IO.mapOptional("ReflowComments", Style.ReflowComments);
445 IO.mapOptional("SortIncludes", Style.SortIncludes);
Krasimir Georgievac16a202017-06-23 11:46:03 +0000446 IO.mapOptional("SortUsingDeclarations", Style.SortUsingDeclarations);
Daniel Jasperdb986eb2014-09-03 07:37:29 +0000447 IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
Manuel Klimek89628f62017-09-20 09:51:03 +0000448 IO.mapOptional("SpaceAfterTemplateKeyword",
449 Style.SpaceAfterTemplateKeyword);
Daniel Jasperd94bff32013-09-25 15:15:02 +0000450 IO.mapOptional("SpaceBeforeAssignmentOperators",
451 Style.SpaceBeforeAssignmentOperators);
Hans Wennborgbfc34062018-06-14 08:01:09 +0000452 IO.mapOptional("SpaceBeforeCpp11BracedList",
453 Style.SpaceBeforeCpp11BracedList);
Francois Ferrand2a9ea782018-03-01 10:09:13 +0000454 IO.mapOptional("SpaceBeforeCtorInitializerColon",
455 Style.SpaceBeforeCtorInitializerColon);
456 IO.mapOptional("SpaceBeforeInheritanceColon",
457 Style.SpaceBeforeInheritanceColon);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000458 IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
Francois Ferrand2a9ea782018-03-01 10:09:13 +0000459 IO.mapOptional("SpaceBeforeRangeBasedForLoopColon",
460 Style.SpaceBeforeRangeBasedForLoopColon);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000461 IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
462 IO.mapOptional("SpacesBeforeTrailingComments",
463 Style.SpacesBeforeTrailingComments);
464 IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
465 IO.mapOptional("SpacesInContainerLiterals",
466 Style.SpacesInContainerLiterals);
467 IO.mapOptional("SpacesInCStyleCastParentheses",
468 Style.SpacesInCStyleCastParentheses);
469 IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
470 IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
471 IO.mapOptional("Standard", Style.Standard);
472 IO.mapOptional("TabWidth", Style.TabWidth);
473 IO.mapOptional("UseTab", Style.UseTab);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000474 }
475};
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000476
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000477template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
478 static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
479 IO.mapOptional("AfterClass", Wrapping.AfterClass);
480 IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
481 IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
482 IO.mapOptional("AfterFunction", Wrapping.AfterFunction);
483 IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace);
484 IO.mapOptional("AfterObjCDeclaration", Wrapping.AfterObjCDeclaration);
485 IO.mapOptional("AfterStruct", Wrapping.AfterStruct);
486 IO.mapOptional("AfterUnion", Wrapping.AfterUnion);
Krasimir Georgievd6ce9372017-09-15 11:23:50 +0000487 IO.mapOptional("AfterExternBlock", Wrapping.AfterExternBlock);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000488 IO.mapOptional("BeforeCatch", Wrapping.BeforeCatch);
489 IO.mapOptional("BeforeElse", Wrapping.BeforeElse);
490 IO.mapOptional("IndentBraces", Wrapping.IndentBraces);
Francois Ferrandad722562017-06-30 20:25:55 +0000491 IO.mapOptional("SplitEmptyFunction", Wrapping.SplitEmptyFunction);
492 IO.mapOptional("SplitEmptyRecord", Wrapping.SplitEmptyRecord);
493 IO.mapOptional("SplitEmptyNamespace", Wrapping.SplitEmptyNamespace);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000494 }
495};
496
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +0000497template <> struct MappingTraits<FormatStyle::RawStringFormat> {
498 static void mapping(IO &IO, FormatStyle::RawStringFormat &Format) {
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +0000499 IO.mapOptional("Language", Format.Language);
Krasimir Georgiev4527f132018-01-17 12:24:59 +0000500 IO.mapOptional("Delimiters", Format.Delimiters);
Krasimir Georgiev2537e222018-01-17 16:17:26 +0000501 IO.mapOptional("EnclosingFunctions", Format.EnclosingFunctions);
Krasimir Georgiev412ed092018-01-19 16:18:47 +0000502 IO.mapOptional("CanonicalDelimiter", Format.CanonicalDelimiter);
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +0000503 IO.mapOptional("BasedOnStyle", Format.BasedOnStyle);
504 }
505};
506
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000507// Allows to read vector<FormatStyle> while keeping default values.
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000508// IO.getContext() should contain a pointer to the FormatStyle structure, that
509// will be used to get default values for missing keys.
510// If the first element has no Language specified, it will be treated as the
511// default one for the following elements.
Jacques Pienaarfc275112015-02-18 23:48:37 +0000512template <> struct DocumentListTraits<std::vector<FormatStyle>> {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000513 static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
514 return Seq.size();
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000515 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000516 static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000517 size_t Index) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000518 if (Index >= Seq.size()) {
519 assert(Index == Seq.size());
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000520 FormatStyle Template;
Krasimir Georgiev1696bb62017-11-09 15:12:17 +0000521 if (!Seq.empty() && Seq[0].Language == FormatStyle::LK_None) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000522 Template = Seq[0];
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000523 } else {
Daniel Jasperb05a81d2014-05-09 13:11:16 +0000524 Template = *((const FormatStyle *)IO.getContext());
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000525 Template.Language = FormatStyle::LK_None;
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000526 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000527 Seq.resize(Index + 1, Template);
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000528 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000529 return Seq[Index];
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000530 }
531};
Daniel Jasperd89ae9d2015-09-23 08:30:47 +0000532} // namespace yaml
533} // namespace llvm
Alexander Kornienkod6538332013-05-07 15:32:14 +0000534
Daniel Jasperf7935112012-12-03 18:12:45 +0000535namespace clang {
536namespace format {
537
Rafael Espindola6d0d89b2014-06-12 03:31:26 +0000538const std::error_category &getParseCategory() {
Benjamin Kramerf76861c2018-03-20 21:52:19 +0000539 static const ParseErrorCategory C{};
Rafael Espindolad0136702014-06-12 02:50:04 +0000540 return C;
541}
542std::error_code make_error_code(ParseError e) {
Rafael Espindola6d0d89b2014-06-12 03:31:26 +0000543 return std::error_code(static_cast<int>(e), getParseCategory());
Rafael Espindolad0136702014-06-12 02:50:04 +0000544}
545
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +0000546inline llvm::Error make_string_error(const llvm::Twine &Message) {
547 return llvm::make_error<llvm::StringError>(Message,
548 llvm::inconvertibleErrorCode());
549}
550
Reid Kleckner6432d452016-10-19 23:39:55 +0000551const char *ParseErrorCategory::name() const noexcept {
Rafael Espindolad0136702014-06-12 02:50:04 +0000552 return "clang-format.parse_error";
553}
554
555std::string ParseErrorCategory::message(int EV) const {
556 switch (static_cast<ParseError>(EV)) {
557 case ParseError::Success:
558 return "Success";
559 case ParseError::Error:
560 return "Invalid argument";
561 case ParseError::Unsuitable:
562 return "Unsuitable";
563 }
Saleem Abdulrasoolfbfbaf62014-06-12 19:33:26 +0000564 llvm_unreachable("unexpected parse error");
Rafael Espindolad0136702014-06-12 02:50:04 +0000565}
566
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000567static FormatStyle expandPresets(const FormatStyle &Style) {
Daniel Jasper55bbe662015-10-07 04:06:10 +0000568 if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
569 return Style;
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000570 FormatStyle Expanded = Style;
Manuel Klimek89628f62017-09-20 09:51:03 +0000571 Expanded.BraceWrapping = {false, false, false, false, false,
572 false, false, false, false, false,
573 false, false, true, true, true};
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000574 switch (Style.BreakBeforeBraces) {
575 case FormatStyle::BS_Linux:
576 Expanded.BraceWrapping.AfterClass = true;
577 Expanded.BraceWrapping.AfterFunction = true;
578 Expanded.BraceWrapping.AfterNamespace = true;
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000579 break;
580 case FormatStyle::BS_Mozilla:
581 Expanded.BraceWrapping.AfterClass = true;
582 Expanded.BraceWrapping.AfterEnum = true;
583 Expanded.BraceWrapping.AfterFunction = true;
584 Expanded.BraceWrapping.AfterStruct = true;
585 Expanded.BraceWrapping.AfterUnion = true;
Krasimir Georgievd6ce9372017-09-15 11:23:50 +0000586 Expanded.BraceWrapping.AfterExternBlock = true;
Sylvestre Ledru82c9a0e2017-09-13 20:03:29 +0000587 Expanded.BraceWrapping.SplitEmptyFunction = true;
Francois Ferrandad722562017-06-30 20:25:55 +0000588 Expanded.BraceWrapping.SplitEmptyRecord = false;
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000589 break;
590 case FormatStyle::BS_Stroustrup:
591 Expanded.BraceWrapping.AfterFunction = true;
592 Expanded.BraceWrapping.BeforeCatch = true;
593 Expanded.BraceWrapping.BeforeElse = true;
594 break;
595 case FormatStyle::BS_Allman:
596 Expanded.BraceWrapping.AfterClass = true;
597 Expanded.BraceWrapping.AfterControlStatement = true;
598 Expanded.BraceWrapping.AfterEnum = true;
599 Expanded.BraceWrapping.AfterFunction = true;
600 Expanded.BraceWrapping.AfterNamespace = true;
601 Expanded.BraceWrapping.AfterObjCDeclaration = true;
602 Expanded.BraceWrapping.AfterStruct = true;
Krasimir Georgievd6ce9372017-09-15 11:23:50 +0000603 Expanded.BraceWrapping.AfterExternBlock = true;
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000604 Expanded.BraceWrapping.BeforeCatch = true;
605 Expanded.BraceWrapping.BeforeElse = true;
606 break;
607 case FormatStyle::BS_GNU:
Manuel Klimek89628f62017-09-20 09:51:03 +0000608 Expanded.BraceWrapping = {true, true, true, true, true, true, true, true,
609 true, true, true, true, true, true, true};
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000610 break;
611 case FormatStyle::BS_WebKit:
612 Expanded.BraceWrapping.AfterFunction = true;
613 break;
614 default:
615 break;
616 }
617 return Expanded;
618}
619
Daniel Jasperf7935112012-12-03 18:12:45 +0000620FormatStyle getLLVMStyle() {
621 FormatStyle LLVMStyle;
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000622 LLVMStyle.Language = FormatStyle::LK_Cpp;
Daniel Jasperf7935112012-12-03 18:12:45 +0000623 LLVMStyle.AccessModifierOffset = -2;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000624 LLVMStyle.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000625 LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
Daniel Jasper3219e432014-12-02 13:24:51 +0000626 LLVMStyle.AlignOperands = true;
Daniel Jasper552f4a72013-07-31 23:55:15 +0000627 LLVMStyle.AlignTrailingComments = true;
Daniel Jaspera44991332015-04-29 13:06:49 +0000628 LLVMStyle.AlignConsecutiveAssignments = false;
Daniel Jaspere12597c2015-10-01 10:06:54 +0000629 LLVMStyle.AlignConsecutiveDeclarations = false;
Daniel Jasperf7db4332013-01-29 16:03:49 +0000630 LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
Daniel Jasperd74cf402014-04-08 12:46:38 +0000631 LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jasper17605d32014-05-14 09:33:35 +0000632 LLVMStyle.AllowShortBlocksOnASingleLine = false;
Daniel Jasperb87899b2014-09-10 13:11:45 +0000633 LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000634 LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
Daniel Jasper3a685df2013-05-16 12:12:21 +0000635 LLVMStyle.AllowShortLoopsOnASingleLine = false;
Zachary Turner448592e2015-12-18 22:20:15 +0000636 LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +0000637 LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
Alexander Kornienko58611712013-07-04 12:02:44 +0000638 LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000639 LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
Daniel Jasper18210d72014-10-09 09:52:05 +0000640 LLVMStyle.BinPackArguments = true;
Francois Ferrande56a8292017-06-14 12:29:47 +0000641 LLVMStyle.BinPackParameters = true;
Daniel Jasperac043c92014-09-15 11:11:00 +0000642 LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
Daniel Jasper165b29e2013-11-08 00:57:11 +0000643 LLVMStyle.BreakBeforeTernaryOperators = true;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000644 LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
Manuel Klimek89628f62017-09-20 09:51:03 +0000645 LLVMStyle.BraceWrapping = {false, false, false, false, false,
646 false, false, false, false, false,
647 false, false, true, true, true};
Nico Weber2cd92f12015-10-15 16:03:01 +0000648 LLVMStyle.BreakAfterJavaFieldAnnotations = false;
Francois Ferranda6b6d512017-05-24 11:36:58 +0000649 LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000650 LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
Daniel Jaspere1a7b762016-02-01 11:21:02 +0000651 LLVMStyle.BreakStringLiterals = true;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000652 LLVMStyle.ColumnLimit = 80;
Daniel Jaspere1e43192014-04-01 12:55:11 +0000653 LLVMStyle.CommentPragmas = "^ IWYU pragma:";
Francois Ferrande56a8292017-06-14 12:29:47 +0000654 LLVMStyle.CompactNamespaces = false;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000655 LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
Daniel Jaspercdaffa42013-08-13 10:58:30 +0000656 LLVMStyle.ConstructorInitializerIndentWidth = 4;
Daniel Jaspere1e43192014-04-01 12:55:11 +0000657 LLVMStyle.ContinuationIndentWidth = 4;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000658 LLVMStyle.Cpp11BracedListStyle = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000659 LLVMStyle.DerivePointerAlignment = false;
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000660 LLVMStyle.ExperimentalAutoDetectBinPacking = false;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000661 LLVMStyle.FixNamespaceComments = true;
Daniel Jaspere1e43192014-04-01 12:55:11 +0000662 LLVMStyle.ForEachMacros.push_back("foreach");
663 LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
664 LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
Eric Liu9d92c022018-05-14 19:51:33 +0000665 LLVMStyle.IncludeStyle.IncludeCategories = {
666 {"^\"(llvm|llvm-c|clang|clang-c)/", 2},
667 {"^(<|\"(gtest|gmock|isl|json)/)", 3},
668 {".*", 1}};
669 LLVMStyle.IncludeStyle.IncludeIsMainRegex = "(Test)?$";
670 LLVMStyle.IncludeStyle.IncludeBlocks = tooling::IncludeStyle::IBS_Preserve;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000671 LLVMStyle.IndentCaseLabels = false;
Krasimir Georgievad47c902017-08-30 14:34:57 +0000672 LLVMStyle.IndentPPDirectives = FormatStyle::PPDIS_None;
Daniel Jasperc75e1ef2014-07-09 08:42:42 +0000673 LLVMStyle.IndentWrappedFunctionNames = false;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000674 LLVMStyle.IndentWidth = 2;
Martin Probstfb2342d2016-06-13 17:50:10 +0000675 LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
676 LLVMStyle.JavaScriptWrapImports = true;
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +0000677 LLVMStyle.TabWidth = 8;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000678 LLVMStyle.MaxEmptyLinesToKeep = 1;
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000679 LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
Daniel Jasper65ee3472013-07-31 23:16:02 +0000680 LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
Ben Hamilton4dc658c2018-02-02 20:15:14 +0000681 LLVMStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
Daniel Jasper50d634b2014-10-28 16:53:38 +0000682 LLVMStyle.ObjCBlockIndentWidth = 2;
Daniel Jaspere9beea22014-01-28 15:20:33 +0000683 LLVMStyle.ObjCSpaceAfterProperty = false;
Nico Webera6087752013-01-10 20:12:55 +0000684 LLVMStyle.ObjCSpaceBeforeProtocolList = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000685 LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000686 LLVMStyle.SpacesBeforeTrailingComments = 1;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000687 LLVMStyle.Standard = FormatStyle::LS_Cpp11;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +0000688 LLVMStyle.UseTab = FormatStyle::UT_Never;
Daniel Jaspera0a50392015-12-01 13:28:53 +0000689 LLVMStyle.ReflowComments = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +0000690 LLVMStyle.SpacesInParentheses = false;
Daniel Jasperad981f82014-08-26 11:41:14 +0000691 LLVMStyle.SpacesInSquareBrackets = false;
Daniel Jasperb55acad2013-08-20 12:36:34 +0000692 LLVMStyle.SpaceInEmptyParentheses = false;
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000693 LLVMStyle.SpacesInContainerLiterals = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +0000694 LLVMStyle.SpacesInCStyleCastParentheses = false;
Daniel Jasperdb986eb2014-09-03 07:37:29 +0000695 LLVMStyle.SpaceAfterCStyleCast = false;
Sylvestre Ledru83bbd572016-08-09 14:24:40 +0000696 LLVMStyle.SpaceAfterTemplateKeyword = true;
Francois Ferrand2a9ea782018-03-01 10:09:13 +0000697 LLVMStyle.SpaceBeforeCtorInitializerColon = true;
698 LLVMStyle.SpaceBeforeInheritanceColon = true;
Alexander Kornienkofdca83d2013-12-10 10:18:34 +0000699 LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
Francois Ferrand2a9ea782018-03-01 10:09:13 +0000700 LLVMStyle.SpaceBeforeRangeBasedForLoopColon = true;
Daniel Jasperd94bff32013-09-25 15:15:02 +0000701 LLVMStyle.SpaceBeforeAssignmentOperators = true;
Hans Wennborgbfc34062018-06-14 08:01:09 +0000702 LLVMStyle.SpaceBeforeCpp11BracedList = false;
Daniel Jasperdd978ae2013-10-29 14:52:02 +0000703 LLVMStyle.SpacesInAngles = false;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000704
Francois Ferrand9976efa2017-05-22 08:28:17 +0000705 LLVMStyle.PenaltyBreakAssignment = prec::Assignment;
Daniel Jasper19a541e2013-12-19 16:45:34 +0000706 LLVMStyle.PenaltyBreakComment = 300;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000707 LLVMStyle.PenaltyBreakFirstLessLess = 120;
708 LLVMStyle.PenaltyBreakString = 1000;
709 LLVMStyle.PenaltyExcessCharacter = 1000000;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000710 LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
Daniel Jasper33b909c2013-10-25 14:29:37 +0000711 LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000712 LLVMStyle.PenaltyBreakTemplateDeclaration = prec::Relational;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000713
Daniel Jasperc64b09a2014-05-22 15:12:22 +0000714 LLVMStyle.DisableFormat = false;
Daniel Jasperda446772015-11-16 12:38:56 +0000715 LLVMStyle.SortIncludes = true;
Krasimir Georgievac16a202017-06-23 11:46:03 +0000716 LLVMStyle.SortUsingDeclarations = true;
Daniel Jasperc64b09a2014-05-22 15:12:22 +0000717
Daniel Jasperf7935112012-12-03 18:12:45 +0000718 return LLVMStyle;
719}
720
Nico Weber514ecc82014-02-02 20:50:45 +0000721FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
Krasimir Georgiev26b144c2017-07-03 15:05:14 +0000722 if (Language == FormatStyle::LK_TextProto) {
723 FormatStyle GoogleStyle = getGoogleStyle(FormatStyle::LK_Proto);
724 GoogleStyle.Language = FormatStyle::LK_TextProto;
Krasimir Georgieveda222e2018-01-24 11:18:39 +0000725
Krasimir Georgiev26b144c2017-07-03 15:05:14 +0000726 return GoogleStyle;
727 }
728
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000729 FormatStyle GoogleStyle = getLLVMStyle();
Nico Weber514ecc82014-02-02 20:50:45 +0000730 GoogleStyle.Language = Language;
731
Daniel Jasperf7935112012-12-03 18:12:45 +0000732 GoogleStyle.AccessModifierOffset = -1;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000733 GoogleStyle.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Daniel Jasper085a2ed2013-04-24 13:46:00 +0000734 GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
Daniel Jasper5bd0b9e2013-05-23 18:05:18 +0000735 GoogleStyle.AllowShortLoopsOnASingleLine = true;
Alexander Kornienko58611712013-07-04 12:02:44 +0000736 GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000737 GoogleStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000738 GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000739 GoogleStyle.DerivePointerAlignment = true;
Eric Liu9d92c022018-05-14 19:51:33 +0000740 GoogleStyle.IncludeStyle.IncludeCategories = {
Krasimir Georgieva84e7872017-09-26 14:58:29 +0000741 {"^<ext/.*\\.h>", 2}, {"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
Eric Liu9d92c022018-05-14 19:51:33 +0000742 GoogleStyle.IncludeStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000743 GoogleStyle.IndentCaseLabels = true;
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000744 GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
Ben Hamilton3a47fdd2018-02-08 01:49:10 +0000745 GoogleStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Never;
Daniel Jaspere9beea22014-01-28 15:20:33 +0000746 GoogleStyle.ObjCSpaceAfterProperty = false;
Ben Hamiltonf84f1182018-01-18 18:37:16 +0000747 GoogleStyle.ObjCSpaceBeforeProtocolList = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000748 GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
Krasimir Georgiev5559cc32018-04-25 14:56:19 +0000749 GoogleStyle.RawStringFormats = {
Krasimir Georgiev4527f132018-01-17 12:24:59 +0000750 {
Krasimir Georgiev5559cc32018-04-25 14:56:19 +0000751 FormatStyle::LK_Cpp,
752 /*Delimiters=*/
753 {
754 "cc",
755 "CC",
756 "cpp",
757 "Cpp",
758 "CPP",
759 "c++",
760 "C++",
761 },
762 /*EnclosingFunctionNames=*/
763 {},
764 /*CanonicalDelimiter=*/"",
765 /*BasedOnStyle=*/"google",
Krasimir Georgiev4527f132018-01-17 12:24:59 +0000766 },
Krasimir Georgiev5559cc32018-04-25 14:56:19 +0000767 {
768 FormatStyle::LK_TextProto,
769 /*Delimiters=*/
770 {
771 "pb",
772 "PB",
773 "proto",
774 "PROTO",
775 },
776 /*EnclosingFunctionNames=*/
Krasimir Georgiev42948e32018-06-26 12:00:14 +0000777 {
Krasimir Georgiev42948e32018-06-26 12:00:14 +0000778 "EqualsProto",
Krasimir Georgiev61f46f22018-06-29 14:25:25 +0000779 "EquivToProto",
Krasimir Georgievce0b8d62018-08-01 12:35:23 +0000780 "PARSE_PARTIAL_TEXT_PROTO",
Krasimir Georgiev61f46f22018-06-29 14:25:25 +0000781 "PARSE_TEST_PROTO",
782 "PARSE_TEXT_PROTO",
783 "ParseTextOrDie",
Krasimir Georgievce0b8d62018-08-01 12:35:23 +0000784 "ParseTextProtoOrDie",
Krasimir Georgiev42948e32018-06-26 12:00:14 +0000785 },
Krasimir Georgiev5559cc32018-04-25 14:56:19 +0000786 /*CanonicalDelimiter=*/"",
787 /*BasedOnStyle=*/"google",
788 },
789 };
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000790 GoogleStyle.SpacesBeforeTrailingComments = 2;
791 GoogleStyle.Standard = FormatStyle::LS_Auto;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000792
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000793 GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
Daniel Jasper33b909c2013-10-25 14:29:37 +0000794 GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000795
Daniel Jasperc58c70e2014-09-15 11:21:46 +0000796 if (Language == FormatStyle::LK_Java) {
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000797 GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +0000798 GoogleStyle.AlignOperands = false;
Daniel Jasperfd4ed182015-01-04 20:40:45 +0000799 GoogleStyle.AlignTrailingComments = false;
Daniel Jasper9e709352014-11-26 10:43:58 +0000800 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
Daniel Jasperfd4ed182015-01-04 20:40:45 +0000801 GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
Daniel Jasper1cd3c712015-01-14 12:24:59 +0000802 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
Daniel Jasperc58c70e2014-09-15 11:21:46 +0000803 GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
804 GoogleStyle.ColumnLimit = 100;
805 GoogleStyle.SpaceAfterCStyleCast = true;
Daniel Jasper61d81972014-11-14 08:22:46 +0000806 GoogleStyle.SpacesBeforeTrailingComments = 1;
Daniel Jasperc58c70e2014-09-15 11:21:46 +0000807 } else if (Language == FormatStyle::LK_JavaScript) {
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000808 GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000809 GoogleStyle.AlignOperands = false;
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000810 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000811 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
Daniel Jaspere551bb72014-11-05 17:22:31 +0000812 GoogleStyle.BreakBeforeTernaryOperators = false;
Krasimir Georgiev6a5c95b2018-07-30 08:45:45 +0000813 // taze:, triple slash directives (`/// <...`), @see, which is commonly
814 // followed by overlong URLs.
815 GoogleStyle.CommentPragmas = "(taze:|^/[ \t]*<|@see)";
Daniel Jasper8f83a902014-05-09 10:28:58 +0000816 GoogleStyle.MaxEmptyLinesToKeep = 3;
Martin Probstece8c0c2016-06-13 16:41:28 +0000817 GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
Nico Weber514ecc82014-02-02 20:50:45 +0000818 GoogleStyle.SpacesInContainerLiterals = false;
Daniel Jasperabd1f572016-03-02 22:44:03 +0000819 GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
Martin Probst0cd74ee2016-06-13 16:39:50 +0000820 GoogleStyle.JavaScriptWrapImports = false;
Nico Weber514ecc82014-02-02 20:50:45 +0000821 } else if (Language == FormatStyle::LK_Proto) {
Daniel Jasper67e65212018-08-15 19:07:55 +0000822 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
Daniel Jasper9c95dfe2018-03-12 10:32:18 +0000823 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
Daniel Jasper783bac62014-04-15 09:54:30 +0000824 GoogleStyle.SpacesInContainerLiterals = false;
Krasimir Georgievc2091802018-01-31 10:14:10 +0000825 GoogleStyle.Cpp11BracedListStyle = false;
Krasimir Georgiev374e6de2018-02-08 10:47:12 +0000826 // This affects protocol buffer options specifications and text protos.
827 // Text protos are currently mostly formatted inside C++ raw string literals
828 // and often the current breaking behavior of string literals is not
829 // beneficial there. Investigate turning this on once proper string reflow
830 // has been implemented.
831 GoogleStyle.BreakStringLiterals = false;
Daniel Jasper03a04fe2016-12-12 12:42:29 +0000832 } else if (Language == FormatStyle::LK_ObjC) {
Ben Hamilton1ab722e2018-06-14 17:30:10 +0000833 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
Daniel Jasper03a04fe2016-12-12 12:42:29 +0000834 GoogleStyle.ColumnLimit = 100;
Nico Weber514ecc82014-02-02 20:50:45 +0000835 }
836
Daniel Jasperf7935112012-12-03 18:12:45 +0000837 return GoogleStyle;
838}
839
Nico Weber514ecc82014-02-02 20:50:45 +0000840FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
841 FormatStyle ChromiumStyle = getGoogleStyle(Language);
Nico Weber450425c2014-11-26 16:43:18 +0000842 if (Language == FormatStyle::LK_Java) {
Daniel Jasperfd4ed182015-01-04 20:40:45 +0000843 ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
Nico Weber2cd92f12015-10-15 16:03:01 +0000844 ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
Nico Weber450425c2014-11-26 16:43:18 +0000845 ChromiumStyle.ContinuationIndentWidth = 8;
Nico Weber2cd92f12015-10-15 16:03:01 +0000846 ChromiumStyle.IndentWidth = 4;
Nico Weberea649692017-01-04 02:33:36 +0000847 } else if (Language == FormatStyle::LK_JavaScript) {
848 ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
849 ChromiumStyle.AllowShortLoopsOnASingleLine = false;
Nico Weber450425c2014-11-26 16:43:18 +0000850 } else {
851 ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
852 ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
853 ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
854 ChromiumStyle.AllowShortLoopsOnASingleLine = false;
855 ChromiumStyle.BinPackParameters = false;
856 ChromiumStyle.DerivePointerAlignment = false;
Nico Weber9e2bc302017-01-31 18:42:05 +0000857 if (Language == FormatStyle::LK_ObjC)
858 ChromiumStyle.ColumnLimit = 80;
Nico Weber450425c2014-11-26 16:43:18 +0000859 }
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000860 return ChromiumStyle;
861}
862
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000863FormatStyle getMozillaStyle() {
864 FormatStyle MozillaStyle = getLLVMStyle();
865 MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
Birunthan Mohanathasa0810022015-06-29 15:18:58 +0000866 MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Manuel Klimek89628f62017-09-20 09:51:03 +0000867 MozillaStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +0000868 MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
869 FormatStyle::DRTBS_TopLevel;
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000870 MozillaStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
Sylvestre Ledrudcb038d2016-12-14 16:09:29 +0000871 MozillaStyle.BinPackParameters = false;
872 MozillaStyle.BinPackArguments = false;
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +0000873 MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
Francois Ferranda6b6d512017-05-24 11:36:58 +0000874 MozillaStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000875 MozillaStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
Birunthan Mohanathasa0810022015-06-29 15:18:58 +0000876 MozillaStyle.ConstructorInitializerIndentWidth = 2;
877 MozillaStyle.ContinuationIndentWidth = 2;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000878 MozillaStyle.Cpp11BracedListStyle = false;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000879 MozillaStyle.FixNamespaceComments = false;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000880 MozillaStyle.IndentCaseLabels = true;
Daniel Jaspere9beea22014-01-28 15:20:33 +0000881 MozillaStyle.ObjCSpaceAfterProperty = true;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000882 MozillaStyle.ObjCSpaceBeforeProtocolList = false;
883 MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
Daniel Jasper553d4872014-06-17 12:40:34 +0000884 MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
Sylvestre Ledru83bbd572016-08-09 14:24:40 +0000885 MozillaStyle.SpaceAfterTemplateKeyword = false;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000886 return MozillaStyle;
887}
888
Daniel Jasperffefb3d2013-07-24 13:10:59 +0000889FormatStyle getWebKitStyle() {
890 FormatStyle Style = getLLVMStyle();
Daniel Jasper65ee3472013-07-31 23:16:02 +0000891 Style.AccessModifierOffset = -4;
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000892 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +0000893 Style.AlignOperands = false;
Daniel Jasper552f4a72013-07-31 23:55:15 +0000894 Style.AlignTrailingComments = false;
Daniel Jasperac043c92014-09-15 11:11:00 +0000895 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Roman Kashitsyn291f64f2015-08-10 13:43:19 +0000896 Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
Francois Ferranda6b6d512017-05-24 11:36:58 +0000897 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000898 Style.Cpp11BracedListStyle = false;
Daniel Jasper65ee3472013-07-31 23:16:02 +0000899 Style.ColumnLimit = 0;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000900 Style.FixNamespaceComments = false;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000901 Style.IndentWidth = 4;
Daniel Jasper65ee3472013-07-31 23:16:02 +0000902 Style.NamespaceIndentation = FormatStyle::NI_Inner;
Daniel Jasper50d634b2014-10-28 16:53:38 +0000903 Style.ObjCBlockIndentWidth = 4;
Daniel Jaspere9beea22014-01-28 15:20:33 +0000904 Style.ObjCSpaceAfterProperty = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000905 Style.PointerAlignment = FormatStyle::PAS_Left;
Hans Wennborgbfc34062018-06-14 08:01:09 +0000906 Style.SpaceBeforeCpp11BracedList = true;
Daniel Jasperffefb3d2013-07-24 13:10:59 +0000907 return Style;
908}
909
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000910FormatStyle getGNUStyle() {
911 FormatStyle Style = getLLVMStyle();
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +0000912 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
Zachary Turner448592e2015-12-18 22:20:15 +0000913 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
Daniel Jasperac043c92014-09-15 11:11:00 +0000914 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000915 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000916 Style.BreakBeforeTernaryOperators = true;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000917 Style.Cpp11BracedListStyle = false;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000918 Style.ColumnLimit = 79;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000919 Style.FixNamespaceComments = false;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000920 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000921 Style.Standard = FormatStyle::LS_Cpp03;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000922 return Style;
923}
924
Daniel Jasperc64b09a2014-05-22 15:12:22 +0000925FormatStyle getNoStyle() {
926 FormatStyle NoStyle = getLLVMStyle();
927 NoStyle.DisableFormat = true;
Daniel Jasperda446772015-11-16 12:38:56 +0000928 NoStyle.SortIncludes = false;
Krasimir Georgievac16a202017-06-23 11:46:03 +0000929 NoStyle.SortUsingDeclarations = false;
Daniel Jasperc64b09a2014-05-22 15:12:22 +0000930 return NoStyle;
931}
932
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000933bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
934 FormatStyle *Style) {
935 if (Name.equals_lower("llvm")) {
Alexander Kornienko006b5c82013-05-19 00:53:30 +0000936 *Style = getLLVMStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000937 } else if (Name.equals_lower("chromium")) {
Nico Weber514ecc82014-02-02 20:50:45 +0000938 *Style = getChromiumStyle(Language);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000939 } else if (Name.equals_lower("mozilla")) {
Alexander Kornienko006b5c82013-05-19 00:53:30 +0000940 *Style = getMozillaStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000941 } else if (Name.equals_lower("google")) {
Nico Weber514ecc82014-02-02 20:50:45 +0000942 *Style = getGoogleStyle(Language);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000943 } else if (Name.equals_lower("webkit")) {
Daniel Jasperffefb3d2013-07-24 13:10:59 +0000944 *Style = getWebKitStyle();
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000945 } else if (Name.equals_lower("gnu")) {
946 *Style = getGNUStyle();
Daniel Jasperc64b09a2014-05-22 15:12:22 +0000947 } else if (Name.equals_lower("none")) {
948 *Style = getNoStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000949 } else {
Alexander Kornienko006b5c82013-05-19 00:53:30 +0000950 return false;
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000951 }
Alexander Kornienkod6538332013-05-07 15:32:14 +0000952
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000953 Style->Language = Language;
Alexander Kornienko006b5c82013-05-19 00:53:30 +0000954 return true;
Alexander Kornienkod6538332013-05-07 15:32:14 +0000955}
956
Rafael Espindolac0809172014-06-12 14:02:15 +0000957std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000958 assert(Style);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000959 FormatStyle::LanguageKind Language = Style->Language;
960 assert(Language != FormatStyle::LK_None);
Alexander Kornienko06e00332013-05-20 15:18:01 +0000961 if (Text.trim().empty())
Rafael Espindolad0136702014-06-12 02:50:04 +0000962 return make_error_code(ParseError::Error);
Krasimir Georgiev54076fe2018-01-15 12:06:16 +0000963 Style->StyleSet.Clear();
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000964 std::vector<FormatStyle> Styles;
Alexander Kornienkod6538332013-05-07 15:32:14 +0000965 llvm::yaml::Input Input(Text);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000966 // DocumentListTraits<vector<FormatStyle>> uses the context to get default
967 // values for the fields, keys for which are missing from the configuration.
968 // Mapping also uses the context to get the language to find the correct
969 // base style.
970 Input.setContext(Style);
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000971 Input >> Styles;
972 if (Input.error())
973 return Input.error();
974
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000975 for (unsigned i = 0; i < Styles.size(); ++i) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000976 // Ensures that only the first configuration can skip the Language option.
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000977 if (Styles[i].Language == FormatStyle::LK_None && i != 0)
Rafael Espindolad0136702014-06-12 02:50:04 +0000978 return make_error_code(ParseError::Error);
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000979 // Ensure that each language is configured at most once.
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000980 for (unsigned j = 0; j < i; ++j) {
981 if (Styles[i].Language == Styles[j].Language) {
Nicola Zaghen3538b392018-05-15 13:30:56 +0000982 LLVM_DEBUG(llvm::dbgs()
983 << "Duplicate languages in the config file on positions "
984 << j << " and " << i << "\n");
Rafael Espindolad0136702014-06-12 02:50:04 +0000985 return make_error_code(ParseError::Error);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000986 }
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000987 }
988 }
989 // Look for a suitable configuration starting from the end, so we can
990 // find the configuration for the specific language first, and the default
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000991 // configuration (which can only be at slot 0) after it.
Krasimir Georgiev54076fe2018-01-15 12:06:16 +0000992 FormatStyle::FormatStyleSet StyleSet;
993 bool LanguageFound = false;
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000994 for (int i = Styles.size() - 1; i >= 0; --i) {
Krasimir Georgiev54076fe2018-01-15 12:06:16 +0000995 if (Styles[i].Language != FormatStyle::LK_None)
996 StyleSet.Add(Styles[i]);
997 if (Styles[i].Language == Language)
998 LanguageFound = true;
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000999 }
Krasimir Georgiev54076fe2018-01-15 12:06:16 +00001000 if (!LanguageFound) {
1001 if (Styles.empty() || Styles[0].Language != FormatStyle::LK_None)
1002 return make_error_code(ParseError::Unsuitable);
1003 FormatStyle DefaultStyle = Styles[0];
1004 DefaultStyle.Language = Language;
1005 StyleSet.Add(std::move(DefaultStyle));
1006 }
1007 *Style = *StyleSet.Get(Language);
1008 return make_error_code(ParseError::Success);
Alexander Kornienkod6538332013-05-07 15:32:14 +00001009}
1010
1011std::string configurationAsText(const FormatStyle &Style) {
1012 std::string Text;
1013 llvm::raw_string_ostream Stream(Text);
1014 llvm::yaml::Output Output(Stream);
1015 // We use the same mapping method for input and output, so we need a non-const
1016 // reference here.
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001017 FormatStyle NonConstStyle = expandPresets(Style);
Alexander Kornienkod6538332013-05-07 15:32:14 +00001018 Output << NonConstStyle;
Alexander Kornienko9a38ec22013-05-13 12:56:35 +00001019 return Stream.str();
Alexander Kornienkod6538332013-05-07 15:32:14 +00001020}
1021
Krasimir Georgiev54076fe2018-01-15 12:06:16 +00001022llvm::Optional<FormatStyle>
1023FormatStyle::FormatStyleSet::Get(FormatStyle::LanguageKind Language) const {
1024 if (!Styles)
1025 return None;
1026 auto It = Styles->find(Language);
1027 if (It == Styles->end())
1028 return None;
1029 FormatStyle Style = It->second;
1030 Style.StyleSet = *this;
1031 return Style;
1032}
1033
1034void FormatStyle::FormatStyleSet::Add(FormatStyle Style) {
1035 assert(Style.Language != LK_None &&
1036 "Cannot add a style for LK_None to a StyleSet");
1037 assert(
1038 !Style.StyleSet.Styles &&
1039 "Cannot add a style associated with an existing StyleSet to a StyleSet");
1040 if (!Styles)
1041 Styles = std::make_shared<MapType>();
1042 (*Styles)[Style.Language] = std::move(Style);
1043}
1044
1045void FormatStyle::FormatStyleSet::Clear() {
1046 Styles.reset();
1047}
1048
1049llvm::Optional<FormatStyle>
1050FormatStyle::GetLanguageStyle(FormatStyle::LanguageKind Language) const {
1051 return StyleSet.Get(Language);
1052}
1053
Craig Topperaf35e852013-06-30 22:29:28 +00001054namespace {
1055
Daniel Jasper496c1992016-09-07 22:48:53 +00001056class JavaScriptRequoter : public TokenAnalyzer {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001057public:
Daniel Jasper496c1992016-09-07 22:48:53 +00001058 JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
1059 : TokenAnalyzer(Env, Style) {}
Eric Liu4cfb88a2016-04-25 15:09:22 +00001060
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001061 std::pair<tooling::Replacements, unsigned>
Eric Liu4cfb88a2016-04-25 15:09:22 +00001062 analyze(TokenAnnotator &Annotator,
1063 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
Martin Probsta9855af2016-09-02 14:29:48 +00001064 FormatTokenLexer &Tokens) override {
Manuel Klimek0dddcf72018-04-23 09:34:26 +00001065 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
Daniel Jasper496c1992016-09-07 22:48:53 +00001066 tooling::Replacements Result;
1067 requoteJSStringLiteral(AnnotatedLines, Result);
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001068 return {Result, 0};
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001069 }
1070
1071private:
Daniel Jasper496c1992016-09-07 22:48:53 +00001072 // Replaces double/single-quoted string literal as appropriate, re-escaping
1073 // the contents in the process.
Daniel Jasper97439922016-03-17 13:03:41 +00001074 void requoteJSStringLiteral(SmallVectorImpl<AnnotatedLine *> &Lines,
Eric Liu4cfb88a2016-04-25 15:09:22 +00001075 tooling::Replacements &Result) {
Daniel Jasper97439922016-03-17 13:03:41 +00001076 for (AnnotatedLine *Line : Lines) {
1077 requoteJSStringLiteral(Line->Children, Result);
1078 if (!Line->Affected)
1079 continue;
1080 for (FormatToken *FormatTok = Line->First; FormatTok;
1081 FormatTok = FormatTok->Next) {
1082 StringRef Input = FormatTok->TokenText;
Martin Probsta1669792016-05-12 11:20:32 +00001083 if (FormatTok->Finalized || !FormatTok->isStringLiteral() ||
Daniel Jasper97439922016-03-17 13:03:41 +00001084 // NB: testing for not starting with a double quote to avoid
Daniel Jasper496c1992016-09-07 22:48:53 +00001085 // breaking `template strings`.
Eric Liu635423e2016-04-28 07:52:03 +00001086 (Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
Daniel Jasper97439922016-03-17 13:03:41 +00001087 !Input.startswith("\"")) ||
Eric Liu635423e2016-04-28 07:52:03 +00001088 (Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
Daniel Jasper97439922016-03-17 13:03:41 +00001089 !Input.startswith("\'")))
1090 continue;
1091
1092 // Change start and end quote.
Eric Liu635423e2016-04-28 07:52:03 +00001093 bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
Daniel Jasper97439922016-03-17 13:03:41 +00001094 SourceLocation Start = FormatTok->Tok.getLocation();
1095 auto Replace = [&](SourceLocation Start, unsigned Length,
1096 StringRef ReplacementText) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001097 auto Err = Result.add(tooling::Replacement(
1098 Env.getSourceManager(), Start, Length, ReplacementText));
1099 // FIXME: handle error. For now, print error message and skip the
1100 // replacement for release version.
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001101 if (Err) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001102 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001103 assert(false);
1104 }
Daniel Jasper97439922016-03-17 13:03:41 +00001105 };
1106 Replace(Start, 1, IsSingle ? "'" : "\"");
1107 Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
1108 IsSingle ? "'" : "\"");
1109
1110 // Escape internal quotes.
Daniel Jasper97439922016-03-17 13:03:41 +00001111 bool Escaped = false;
1112 for (size_t i = 1; i < Input.size() - 1; i++) {
1113 switch (Input[i]) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001114 case '\\':
1115 if (!Escaped && i + 1 < Input.size() &&
1116 ((IsSingle && Input[i + 1] == '"') ||
1117 (!IsSingle && Input[i + 1] == '\''))) {
1118 // Remove this \, it's escaping a " or ' that no longer needs
1119 // escaping
Eric Liu4cfb88a2016-04-25 15:09:22 +00001120 Replace(Start.getLocWithOffset(i), 1, "");
1121 continue;
1122 }
1123 Escaped = !Escaped;
1124 break;
1125 case '\"':
1126 case '\'':
1127 if (!Escaped && IsSingle == (Input[i] == '\'')) {
1128 // Escape the quote.
1129 Replace(Start.getLocWithOffset(i), 0, "\\");
Eric Liu4cfb88a2016-04-25 15:09:22 +00001130 }
1131 Escaped = false;
1132 break;
1133 default:
1134 Escaped = false;
1135 break;
Daniel Jasper97439922016-03-17 13:03:41 +00001136 }
1137 }
Daniel Jasper97439922016-03-17 13:03:41 +00001138 }
1139 }
1140 }
Daniel Jasper496c1992016-09-07 22:48:53 +00001141};
1142
1143class Formatter : public TokenAnalyzer {
1144public:
1145 Formatter(const Environment &Env, const FormatStyle &Style,
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00001146 FormattingAttemptStatus *Status)
1147 : TokenAnalyzer(Env, Style), Status(Status) {}
Daniel Jasper496c1992016-09-07 22:48:53 +00001148
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001149 std::pair<tooling::Replacements, unsigned>
Daniel Jasper496c1992016-09-07 22:48:53 +00001150 analyze(TokenAnnotator &Annotator,
1151 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1152 FormatTokenLexer &Tokens) override {
1153 tooling::Replacements Result;
1154 deriveLocalStyle(AnnotatedLines);
Manuel Klimek0dddcf72018-04-23 09:34:26 +00001155 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
Daniel Jasper496c1992016-09-07 22:48:53 +00001156 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1157 Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
1158 }
1159 Annotator.setCommentLineLevels(AnnotatedLines);
1160
1161 WhitespaceManager Whitespaces(
1162 Env.getSourceManager(), Style,
1163 inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
1164 ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
1165 Env.getSourceManager(), Whitespaces, Encoding,
1166 BinPackInconclusiveFunctions);
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001167 unsigned Penalty =
1168 UnwrappedLineFormatter(&Indenter, &Whitespaces, Style,
1169 Tokens.getKeywords(), Env.getSourceManager(),
1170 Status)
1171 .format(AnnotatedLines, /*DryRun=*/false,
1172 /*AdditionalIndent=*/0,
1173 /*FixBadIndentation=*/false,
1174 /*FirstStartColumn=*/Env.getFirstStartColumn(),
1175 /*NextStartColumn=*/Env.getNextStartColumn(),
1176 /*LastStartColumn=*/Env.getLastStartColumn());
Daniel Jasper496c1992016-09-07 22:48:53 +00001177 for (const auto &R : Whitespaces.generateReplacements())
1178 if (Result.add(R))
Krasimir Georgieve56e9a42017-10-30 14:30:14 +00001179 return std::make_pair(Result, 0);
1180 return std::make_pair(Result, Penalty);
Daniel Jasper496c1992016-09-07 22:48:53 +00001181 }
1182
1183private:
Alexander Kornienko9e649af2013-09-11 12:25:57 +00001184 static bool inputUsesCRLF(StringRef Text) {
1185 return Text.count('\r') * 2 > Text.count('\n');
1186 }
1187
Daniel Jasper352f0df2015-07-18 16:35:30 +00001188 bool
1189 hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001190 for (const AnnotatedLine *Line : Lines) {
Daniel Jasper352f0df2015-07-18 16:35:30 +00001191 if (hasCpp03IncompatibleFormat(Line->Children))
1192 return true;
1193 for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
1194 if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
1195 if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
1196 return true;
1197 if (Tok->is(TT_TemplateCloser) &&
1198 Tok->Previous->is(TT_TemplateCloser))
1199 return true;
1200 }
1201 }
1202 }
1203 return false;
1204 }
1205
1206 int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
1207 int AlignmentDiff = 0;
Eric Liu4cfb88a2016-04-25 15:09:22 +00001208 for (const AnnotatedLine *Line : Lines) {
Daniel Jasper352f0df2015-07-18 16:35:30 +00001209 AlignmentDiff += countVariableAlignments(Line->Children);
1210 for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
1211 if (!Tok->is(TT_PointerOrReference))
1212 continue;
1213 bool SpaceBefore =
1214 Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
1215 bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
1216 Tok->Next->WhitespaceRange.getEnd();
1217 if (SpaceBefore && !SpaceAfter)
1218 ++AlignmentDiff;
1219 if (!SpaceBefore && SpaceAfter)
1220 --AlignmentDiff;
1221 }
1222 }
1223 return AlignmentDiff;
1224 }
1225
Manuel Klimek71814b42013-10-11 21:25:45 +00001226 void
1227 deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
Daniel Jasperb10cbc42013-07-10 14:02:49 +00001228 bool HasBinPackedFunction = false;
1229 bool HasOnePerLineFunction = false;
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001230 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001231 if (!AnnotatedLines[i]->First->Next)
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001232 continue;
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001233 FormatToken *Tok = AnnotatedLines[i]->First->Next;
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001234 while (Tok->Next) {
Daniel Jasperb10cbc42013-07-10 14:02:49 +00001235 if (Tok->PackingKind == PPK_BinPacked)
1236 HasBinPackedFunction = true;
1237 if (Tok->PackingKind == PPK_OnePerLine)
1238 HasOnePerLineFunction = true;
1239
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001240 Tok = Tok->Next;
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001241 }
1242 }
Eric Liu635423e2016-04-28 07:52:03 +00001243 if (Style.DerivePointerAlignment)
1244 Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
1245 ? FormatStyle::PAS_Left
1246 : FormatStyle::PAS_Right;
1247 if (Style.Standard == FormatStyle::LS_Auto)
1248 Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
1249 ? FormatStyle::LS_Cpp11
1250 : FormatStyle::LS_Cpp03;
Daniel Jasperb10cbc42013-07-10 14:02:49 +00001251 BinPackInconclusiveFunctions =
1252 HasBinPackedFunction || !HasOnePerLineFunction;
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001253 }
1254
Daniel Jasperb10cbc42013-07-10 14:02:49 +00001255 bool BinPackInconclusiveFunctions;
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00001256 FormattingAttemptStatus *Status;
Eric Liu4cfb88a2016-04-25 15:09:22 +00001257};
1258
1259// This class clean up the erroneous/redundant code around the given ranges in
1260// file.
1261class Cleaner : public TokenAnalyzer {
1262public:
Eric Liu635423e2016-04-28 07:52:03 +00001263 Cleaner(const Environment &Env, const FormatStyle &Style)
1264 : TokenAnalyzer(Env, Style),
Eric Liu4cfb88a2016-04-25 15:09:22 +00001265 DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
1266
1267 // FIXME: eliminate unused parameters.
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001268 std::pair<tooling::Replacements, unsigned>
Eric Liu4cfb88a2016-04-25 15:09:22 +00001269 analyze(TokenAnnotator &Annotator,
1270 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
Martin Probsta9855af2016-09-02 14:29:48 +00001271 FormatTokenLexer &Tokens) override {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001272 // FIXME: in the current implementation the granularity of affected range
1273 // is an annotated line. However, this is not sufficient. Furthermore,
1274 // redundant code introduced by replacements does not necessarily
1275 // intercept with ranges of replacements that result in the redundancy.
1276 // To determine if some redundant code is actually introduced by
1277 // replacements(e.g. deletions), we need to come up with a more
1278 // sophisticated way of computing affected ranges.
Manuel Klimek0dddcf72018-04-23 09:34:26 +00001279 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
Eric Liu4cfb88a2016-04-25 15:09:22 +00001280
1281 checkEmptyNamespace(AnnotatedLines);
1282
Eric Liuce5e4bc2016-05-18 08:02:56 +00001283 for (auto &Line : AnnotatedLines) {
1284 if (Line->Affected) {
1285 cleanupRight(Line->First, tok::comma, tok::comma);
1286 cleanupRight(Line->First, TT_CtorInitializerColon, tok::comma);
Eric Liu2574d152016-09-13 15:02:43 +00001287 cleanupRight(Line->First, tok::l_paren, tok::comma);
1288 cleanupLeft(Line->First, tok::comma, tok::r_paren);
Eric Liuce5e4bc2016-05-18 08:02:56 +00001289 cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
1290 cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
Malcolm Parsons5d8cdb82016-10-20 14:58:45 +00001291 cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
Eric Liuce5e4bc2016-05-18 08:02:56 +00001292 }
1293 }
1294
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001295 return {generateFixes(), 0};
Eric Liu4cfb88a2016-04-25 15:09:22 +00001296 }
1297
1298private:
1299 bool containsOnlyComments(const AnnotatedLine &Line) {
1300 for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
1301 if (Tok->isNot(tok::comment))
1302 return false;
1303 }
1304 return true;
1305 }
1306
1307 // Iterate through all lines and remove any empty (nested) namespaces.
1308 void checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
Eric Liu7956c402016-10-05 15:49:01 +00001309 std::set<unsigned> DeletedLines;
Eric Liu4cfb88a2016-04-25 15:09:22 +00001310 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1311 auto &Line = *AnnotatedLines[i];
1312 if (Line.startsWith(tok::kw_namespace) ||
1313 Line.startsWith(tok::kw_inline, tok::kw_namespace)) {
Eric Liu7956c402016-10-05 15:49:01 +00001314 checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
Eric Liu4cfb88a2016-04-25 15:09:22 +00001315 }
1316 }
1317
1318 for (auto Line : DeletedLines) {
1319 FormatToken *Tok = AnnotatedLines[Line]->First;
1320 while (Tok) {
1321 deleteToken(Tok);
1322 Tok = Tok->Next;
1323 }
1324 }
1325 }
1326
1327 // The function checks if the namespace, which starts from \p CurrentLine, and
1328 // its nested namespaces are empty and delete them if they are empty. It also
1329 // sets \p NewLine to the last line checked.
1330 // Returns true if the current namespace is empty.
1331 bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
Eric Liu7956c402016-10-05 15:49:01 +00001332 unsigned CurrentLine, unsigned &NewLine,
1333 std::set<unsigned> &DeletedLines) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001334 unsigned InitLine = CurrentLine, End = AnnotatedLines.size();
Eric Liu635423e2016-04-28 07:52:03 +00001335 if (Style.BraceWrapping.AfterNamespace) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001336 // If the left brace is in a new line, we should consume it first so that
1337 // it does not make the namespace non-empty.
1338 // FIXME: error handling if there is no left brace.
1339 if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
1340 NewLine = CurrentLine;
1341 return false;
1342 }
1343 } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
1344 return false;
1345 }
1346 while (++CurrentLine < End) {
1347 if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
1348 break;
1349
1350 if (AnnotatedLines[CurrentLine]->startsWith(tok::kw_namespace) ||
1351 AnnotatedLines[CurrentLine]->startsWith(tok::kw_inline,
1352 tok::kw_namespace)) {
Eric Liu7956c402016-10-05 15:49:01 +00001353 if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
1354 DeletedLines))
Eric Liu4cfb88a2016-04-25 15:09:22 +00001355 return false;
1356 CurrentLine = NewLine;
1357 continue;
1358 }
1359
1360 if (containsOnlyComments(*AnnotatedLines[CurrentLine]))
1361 continue;
1362
1363 // If there is anything other than comments or nested namespaces in the
1364 // current namespace, the namespace cannot be empty.
1365 NewLine = CurrentLine;
1366 return false;
1367 }
1368
1369 NewLine = CurrentLine;
1370 if (CurrentLine >= End)
1371 return false;
1372
1373 // Check if the empty namespace is actually affected by changed ranges.
1374 if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
1375 AnnotatedLines[InitLine]->First->Tok.getLocation(),
1376 AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
1377 return false;
1378
1379 for (unsigned i = InitLine; i <= CurrentLine; ++i) {
1380 DeletedLines.insert(i);
1381 }
1382
1383 return true;
1384 }
1385
Eric Liuce5e4bc2016-05-18 08:02:56 +00001386 // Checks pairs {start, start->next},..., {end->previous, end} and deletes one
1387 // of the token in the pair if the left token has \p LK token kind and the
1388 // right token has \p RK token kind. If \p DeleteLeft is true, the left token
1389 // is deleted on match; otherwise, the right token is deleted.
1390 template <typename LeftKind, typename RightKind>
1391 void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
1392 bool DeleteLeft) {
1393 auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
1394 for (auto *Res = Tok.Next; Res; Res = Res->Next)
1395 if (!Res->is(tok::comment) &&
1396 DeletedTokens.find(Res) == DeletedTokens.end())
1397 return Res;
1398 return nullptr;
1399 };
1400 for (auto *Left = Start; Left;) {
1401 auto *Right = NextNotDeleted(*Left);
1402 if (!Right)
1403 break;
1404 if (Left->is(LK) && Right->is(RK)) {
1405 deleteToken(DeleteLeft ? Left : Right);
Eric Liu01426ff2016-09-09 17:50:49 +00001406 for (auto *Tok = Left->Next; Tok && Tok != Right; Tok = Tok->Next)
1407 deleteToken(Tok);
Eric Liuce5e4bc2016-05-18 08:02:56 +00001408 // If the right token is deleted, we should keep the left token
1409 // unchanged and pair it with the new right token.
1410 if (!DeleteLeft)
1411 continue;
1412 }
1413 Left = Right;
1414 }
1415 }
1416
1417 template <typename LeftKind, typename RightKind>
1418 void cleanupLeft(FormatToken *Start, LeftKind LK, RightKind RK) {
1419 cleanupPair(Start, LK, RK, /*DeleteLeft=*/true);
1420 }
1421
1422 template <typename LeftKind, typename RightKind>
1423 void cleanupRight(FormatToken *Start, LeftKind LK, RightKind RK) {
1424 cleanupPair(Start, LK, RK, /*DeleteLeft=*/false);
1425 }
1426
Eric Liu4cfb88a2016-04-25 15:09:22 +00001427 // Delete the given token.
1428 inline void deleteToken(FormatToken *Tok) {
1429 if (Tok)
1430 DeletedTokens.insert(Tok);
1431 }
1432
1433 tooling::Replacements generateFixes() {
1434 tooling::Replacements Fixes;
1435 std::vector<FormatToken *> Tokens;
1436 std::copy(DeletedTokens.begin(), DeletedTokens.end(),
1437 std::back_inserter(Tokens));
1438
1439 // Merge multiple continuous token deletions into one big deletion so that
1440 // the number of replacements can be reduced. This makes computing affected
1441 // ranges more efficient when we run reformat on the changed code.
1442 unsigned Idx = 0;
1443 while (Idx < Tokens.size()) {
1444 unsigned St = Idx, End = Idx;
1445 while ((End + 1) < Tokens.size() &&
1446 Tokens[End]->Next == Tokens[End + 1]) {
1447 End++;
1448 }
1449 auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
1450 Tokens[End]->Tok.getEndLoc());
Eric Liu40ef2fb2016-08-01 10:16:37 +00001451 auto Err =
1452 Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
1453 // FIXME: better error handling. for now just print error message and skip
1454 // for the release version.
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001455 if (Err) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001456 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001457 assert(false && "Fixes must not conflict!");
1458 }
Eric Liu4cfb88a2016-04-25 15:09:22 +00001459 Idx = End + 1;
1460 }
1461
1462 return Fixes;
1463 }
1464
1465 // Class for less-than inequality comparason for the set `RedundantTokens`.
1466 // We store tokens in the order they appear in the translation unit so that
1467 // we do not need to sort them in `generateFixes()`.
1468 struct FormatTokenLess {
Eric Liu635423e2016-04-28 07:52:03 +00001469 FormatTokenLess(const SourceManager &SM) : SM(SM) {}
Eric Liu4cfb88a2016-04-25 15:09:22 +00001470
Eric Liu2874ac32016-05-18 08:14:49 +00001471 bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001472 return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
1473 RHS->Tok.getLocation());
1474 }
Eric Liu635423e2016-04-28 07:52:03 +00001475 const SourceManager &SM;
Eric Liu4cfb88a2016-04-25 15:09:22 +00001476 };
1477
1478 // Tokens to be deleted.
1479 std::set<FormatToken *, FormatTokenLess> DeletedTokens;
Daniel Jasperf7935112012-12-03 18:12:45 +00001480};
1481
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001482class ObjCHeaderStyleGuesser : public TokenAnalyzer {
1483public:
1484 ObjCHeaderStyleGuesser(const Environment &Env, const FormatStyle &Style)
1485 : TokenAnalyzer(Env, Style), IsObjC(false) {}
1486
1487 std::pair<tooling::Replacements, unsigned>
1488 analyze(TokenAnnotator &Annotator,
1489 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1490 FormatTokenLexer &Tokens) override {
1491 assert(Style.Language == FormatStyle::LK_Cpp);
1492 IsObjC = guessIsObjC(AnnotatedLines, Tokens.getKeywords());
1493 tooling::Replacements Result;
1494 return {Result, 0};
1495 }
1496
1497 bool isObjC() { return IsObjC; }
1498
1499private:
1500 static bool guessIsObjC(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1501 const AdditionalKeywords &Keywords) {
Krasimir Georgiev8e216782018-01-17 20:01:02 +00001502 // Keep this array sorted, since we are binary searching over it.
1503 static constexpr llvm::StringLiteral FoundationIdentifiers[] = {
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001504 "CGFloat",
Ben Hamilton19c782d2018-03-22 03:25:22 +00001505 "CGPoint",
1506 "CGPointMake",
1507 "CGPointZero",
1508 "CGRect",
1509 "CGRectEdge",
1510 "CGRectInfinite",
1511 "CGRectMake",
1512 "CGRectNull",
1513 "CGRectZero",
1514 "CGSize",
1515 "CGSizeMake",
1516 "CGVector",
1517 "CGVectorMake",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001518 "NSAffineTransform",
1519 "NSArray",
1520 "NSAttributedString",
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001521 "NSBlockOperation",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001522 "NSBundle",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001523 "NSCache",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001524 "NSCalendar",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001525 "NSCharacterSet",
1526 "NSCountedSet",
1527 "NSData",
1528 "NSDataDetector",
1529 "NSDecimal",
1530 "NSDecimalNumber",
1531 "NSDictionary",
1532 "NSEdgeInsets",
1533 "NSHashTable",
1534 "NSIndexPath",
1535 "NSIndexSet",
1536 "NSInteger",
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001537 "NSInvocationOperation",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001538 "NSLocale",
1539 "NSMapTable",
1540 "NSMutableArray",
1541 "NSMutableAttributedString",
1542 "NSMutableCharacterSet",
1543 "NSMutableData",
1544 "NSMutableDictionary",
1545 "NSMutableIndexSet",
1546 "NSMutableOrderedSet",
1547 "NSMutableSet",
1548 "NSMutableString",
1549 "NSNumber",
1550 "NSNumberFormatter",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001551 "NSObject",
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001552 "NSOperation",
1553 "NSOperationQueue",
1554 "NSOperationQueuePriority",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001555 "NSOrderedSet",
1556 "NSPoint",
1557 "NSPointerArray",
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001558 "NSQualityOfService",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001559 "NSRange",
1560 "NSRect",
1561 "NSRegularExpression",
1562 "NSSet",
1563 "NSSize",
1564 "NSString",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001565 "NSTimeZone",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001566 "NSUInteger",
1567 "NSURL",
1568 "NSURLComponents",
1569 "NSURLQueryItem",
1570 "NSUUID",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001571 "NSValue",
Ben Hamilton19c782d2018-03-22 03:25:22 +00001572 "UIImage",
1573 "UIView",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001574 };
1575
Ben Hamiltonea7a27b2018-03-27 15:01:21 +00001576 for (auto Line : AnnotatedLines) {
1577 for (const FormatToken *FormatTok = Line->First; FormatTok;
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001578 FormatTok = FormatTok->Next) {
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001579 if ((FormatTok->Previous && FormatTok->Previous->is(tok::at) &&
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001580 (FormatTok->Tok.getObjCKeywordID() != tok::objc_not_keyword ||
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001581 FormatTok->isOneOf(tok::numeric_constant, tok::l_square,
1582 tok::l_brace))) ||
1583 (FormatTok->Tok.isAnyIdentifier() &&
Krasimir Georgiev8e216782018-01-17 20:01:02 +00001584 std::binary_search(std::begin(FoundationIdentifiers),
1585 std::end(FoundationIdentifiers),
1586 FormatTok->TokenText)) ||
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001587 FormatTok->is(TT_ObjCStringLiteral) ||
1588 FormatTok->isOneOf(Keywords.kw_NS_ENUM, Keywords.kw_NS_OPTIONS,
1589 TT_ObjCBlockLBrace, TT_ObjCBlockLParen,
1590 TT_ObjCDecl, TT_ObjCForIn, TT_ObjCMethodExpr,
1591 TT_ObjCMethodSpecifier, TT_ObjCProperty)) {
1592 return true;
1593 }
Ben Hamiltonea7a27b2018-03-27 15:01:21 +00001594 if (guessIsObjC(Line->Children, Keywords))
Ben Hamilton6432afe2018-03-22 17:37:19 +00001595 return true;
1596 }
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001597 }
1598 return false;
1599 }
1600
1601 bool IsObjC;
1602};
1603
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001604struct IncludeDirective {
1605 StringRef Filename;
1606 StringRef Text;
1607 unsigned Offset;
Daniel Jasperd2629dc2015-12-16 10:10:16 +00001608 int Category;
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001609};
1610
Craig Topperaf35e852013-06-30 22:29:28 +00001611} // end anonymous namespace
1612
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001613// Determines whether 'Ranges' intersects with ('Start', 'End').
1614static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
1615 unsigned End) {
1616 for (auto Range : Ranges) {
1617 if (Range.getOffset() < End &&
1618 Range.getOffset() + Range.getLength() > Start)
1619 return true;
1620 }
1621 return false;
1622}
1623
Eric Liua992afe2016-08-10 09:32:23 +00001624// Returns a pair (Index, OffsetToEOL) describing the position of the cursor
1625// before sorting/deduplicating. Index is the index of the include under the
1626// cursor in the original set of includes. If this include has duplicates, it is
1627// the index of the first of the duplicates as the others are going to be
1628// removed. OffsetToEOL describes the cursor's position relative to the end of
1629// its current line.
1630// If `Cursor` is not on any #include, `Index` will be UINT_MAX.
1631static std::pair<unsigned, unsigned>
1632FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
1633 const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
1634 unsigned CursorIndex = UINT_MAX;
1635 unsigned OffsetToEOL = 0;
1636 for (int i = 0, e = Includes.size(); i != e; ++i) {
1637 unsigned Start = Includes[Indices[i]].Offset;
1638 unsigned End = Start + Includes[Indices[i]].Text.size();
1639 if (!(Cursor >= Start && Cursor < End))
1640 continue;
1641 CursorIndex = Indices[i];
1642 OffsetToEOL = End - Cursor;
1643 // Put the cursor on the only remaining #include among the duplicate
1644 // #includes.
1645 while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
1646 CursorIndex = i;
1647 break;
1648 }
1649 return std::make_pair(CursorIndex, OffsetToEOL);
1650}
1651
1652// Sorts and deduplicate a block of includes given by 'Includes' alphabetically
1653// adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
1654// source order.
1655// #include directives with the same text will be deduplicated, and only the
1656// first #include in the duplicate #includes remains. If the `Cursor` is
1657// provided and put on a deleted #include, it will be moved to the remaining
1658// #include in the duplicate #includes.
Martin Probstc4a0dd42016-05-20 11:24:24 +00001659static void sortCppIncludes(const FormatStyle &Style,
Eric Liua992afe2016-08-10 09:32:23 +00001660 const SmallVectorImpl<IncludeDirective> &Includes,
1661 ArrayRef<tooling::Range> Ranges, StringRef FileName,
1662 tooling::Replacements &Replaces, unsigned *Cursor) {
1663 unsigned IncludesBeginOffset = Includes.front().Offset;
Daniel Jasperd6a00782016-08-30 21:33:41 +00001664 unsigned IncludesEndOffset =
1665 Includes.back().Offset + Includes.back().Text.size();
1666 unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
1667 if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001668 return;
1669 SmallVector<unsigned, 16> Indices;
1670 for (unsigned i = 0, e = Includes.size(); i != e; ++i)
1671 Indices.push_back(i);
Daniel Jasper94a96fc2016-03-03 17:34:14 +00001672 std::stable_sort(
1673 Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
1674 return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
1675 std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
1676 });
Eric Liua992afe2016-08-10 09:32:23 +00001677 // The index of the include on which the cursor will be put after
1678 // sorting/deduplicating.
1679 unsigned CursorIndex;
1680 // The offset from cursor to the end of line.
1681 unsigned CursorToEOLOffset;
1682 if (Cursor)
1683 std::tie(CursorIndex, CursorToEOLOffset) =
1684 FindCursorIndex(Includes, Indices, *Cursor);
1685
1686 // Deduplicate #includes.
1687 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1688 [&](unsigned LHSI, unsigned RHSI) {
1689 return Includes[LHSI].Text == Includes[RHSI].Text;
1690 }),
1691 Indices.end());
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001692
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001693 int CurrentCategory = Includes.front().Category;
1694
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001695 // If the #includes are out of order, we generate a single replacement fixing
1696 // the entire block. Otherwise, no replacement is generated.
Eric Liua992afe2016-08-10 09:32:23 +00001697 if (Indices.size() == Includes.size() &&
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001698 std::is_sorted(Indices.begin(), Indices.end()) &&
Eric Liu9d92c022018-05-14 19:51:33 +00001699 Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Preserve)
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001700 return;
1701
Daniel Jasperb68aabf2015-11-23 08:36:35 +00001702 std::string result;
Daniel Jasperb68aabf2015-11-23 08:36:35 +00001703 for (unsigned Index : Indices) {
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001704 if (!result.empty()) {
Daniel Jasperb68aabf2015-11-23 08:36:35 +00001705 result += "\n";
Eric Liu9d92c022018-05-14 19:51:33 +00001706 if (Style.IncludeStyle.IncludeBlocks ==
1707 tooling::IncludeStyle::IBS_Regroup &&
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001708 CurrentCategory != Includes[Index].Category)
1709 result += "\n";
1710 }
Daniel Jasperb68aabf2015-11-23 08:36:35 +00001711 result += Includes[Index].Text;
Eric Liua992afe2016-08-10 09:32:23 +00001712 if (Cursor && CursorIndex == Index)
1713 *Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001714 CurrentCategory = Includes[Index].Category;
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001715 }
1716
Eric Liu40ef2fb2016-08-01 10:16:37 +00001717 auto Err = Replaces.add(tooling::Replacement(
Eric Liua992afe2016-08-10 09:32:23 +00001718 FileName, Includes.front().Offset, IncludesBlockSize, result));
Eric Liu40ef2fb2016-08-01 10:16:37 +00001719 // FIXME: better error handling. For now, just skip the replacement for the
1720 // release version.
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001721 if (Err) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001722 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001723 assert(false);
1724 }
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001725}
1726
Eric Liu659afd52016-05-31 13:34:20 +00001727namespace {
1728
Eric Liu659afd52016-05-31 13:34:20 +00001729const char IncludeRegexPattern[] =
1730 R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
1731
1732} // anonymous namespace
1733
Martin Probstc4a0dd42016-05-20 11:24:24 +00001734tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
1735 ArrayRef<tooling::Range> Ranges,
1736 StringRef FileName,
1737 tooling::Replacements &Replaces,
1738 unsigned *Cursor) {
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001739 unsigned Prev = 0;
1740 unsigned SearchFrom = 0;
Eric Liu659afd52016-05-31 13:34:20 +00001741 llvm::Regex IncludeRegex(IncludeRegexPattern);
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001742 SmallVector<StringRef, 4> Matches;
1743 SmallVector<IncludeDirective, 16> IncludesInBlock;
Daniel Jasper85c472d2015-09-29 07:53:08 +00001744
1745 // In compiled files, consider the first #include to be the main #include of
1746 // the file if it is not a system #include. This ensures that the header
1747 // doesn't have hidden dependencies
1748 // (http://llvm.org/docs/CodingStandards.html#include-style).
1749 //
1750 // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
1751 // cases where the first #include is unlikely to be the main header.
Eric Liu7129e632018-05-14 20:17:53 +00001752 tooling::IncludeCategoryManager Categories(Style.IncludeStyle, FileName);
Daniel Jasper32d75fa2015-12-21 13:40:49 +00001753 bool FirstIncludeBlock = true;
Daniel Jaspera252f5d2015-12-21 17:28:24 +00001754 bool MainIncludeFound = false;
Daniel Jasper9b8c7c72015-11-21 09:17:08 +00001755 bool FormattingOff = false;
1756
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001757 for (;;) {
1758 auto Pos = Code.find('\n', SearchFrom);
1759 StringRef Line =
1760 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
Daniel Jasper9b8c7c72015-11-21 09:17:08 +00001761
1762 StringRef Trimmed = Line.trim();
1763 if (Trimmed == "// clang-format off")
1764 FormattingOff = true;
1765 else if (Trimmed == "// clang-format on")
1766 FormattingOff = false;
1767
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001768 const bool EmptyLineSkipped =
Eric Liu9d92c022018-05-14 19:51:33 +00001769 Trimmed.empty() &&
1770 (Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Merge ||
1771 Style.IncludeStyle.IncludeBlocks ==
1772 tooling::IncludeStyle::IBS_Regroup);
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001773
Daniel Jasper9b8c7c72015-11-21 09:17:08 +00001774 if (!FormattingOff && !Line.endswith("\\")) {
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001775 if (IncludeRegex.match(Line, &Matches)) {
Nico Weberff063702015-10-21 17:13:45 +00001776 StringRef IncludeName = Matches[2];
Eric Liu659afd52016-05-31 13:34:20 +00001777 int Category = Categories.getIncludePriority(
1778 IncludeName,
1779 /*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
1780 if (Category == 0)
1781 MainIncludeFound = true;
Nico Weberff063702015-10-21 17:13:45 +00001782 IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001783 } else if (!IncludesInBlock.empty() && !EmptyLineSkipped) {
Martin Probstc4a0dd42016-05-20 11:24:24 +00001784 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
1785 Cursor);
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001786 IncludesInBlock.clear();
Daniel Jasper32d75fa2015-12-21 13:40:49 +00001787 FirstIncludeBlock = false;
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001788 }
1789 Prev = Pos + 1;
1790 }
1791 if (Pos == StringRef::npos || Pos + 1 == Code.size())
1792 break;
1793 SearchFrom = Pos + 1;
1794 }
1795 if (!IncludesInBlock.empty())
Martin Probstc4a0dd42016-05-20 11:24:24 +00001796 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
1797 return Replaces;
1798}
1799
Martin Probstfa37b182017-01-27 09:09:11 +00001800bool isMpegTS(StringRef Code) {
1801 // MPEG transport streams use the ".ts" file extension. clang-format should
1802 // not attempt to format those. MPEG TS' frame format starts with 0x47 every
1803 // 189 bytes - detect that and return.
1804 return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
1805}
1806
Manuel Klimek89628f62017-09-20 09:51:03 +00001807bool isLikelyXml(StringRef Code) { return Code.ltrim().startswith("<"); }
Krasimir Georgieva2e7d0d2017-08-29 13:51:38 +00001808
Martin Probstc4a0dd42016-05-20 11:24:24 +00001809tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
1810 ArrayRef<tooling::Range> Ranges,
1811 StringRef FileName, unsigned *Cursor) {
1812 tooling::Replacements Replaces;
1813 if (!Style.SortIncludes)
1814 return Replaces;
Krasimir Georgiev86873032017-08-29 13:57:31 +00001815 if (isLikelyXml(Code))
1816 return Replaces;
1817 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
1818 isMpegTS(Code))
Martin Probstfa37b182017-01-27 09:09:11 +00001819 return Replaces;
Martin Probstc4a0dd42016-05-20 11:24:24 +00001820 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
1821 return sortJavaScriptImports(Style, Code, Ranges, FileName);
1822 sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001823 return Replaces;
1824}
1825
Eric Liu4cfb88a2016-04-25 15:09:22 +00001826template <typename T>
Eric Liu4f8d9942016-07-11 13:53:12 +00001827static llvm::Expected<tooling::Replacements>
Eric Liu4cfb88a2016-04-25 15:09:22 +00001828processReplacements(T ProcessFunc, StringRef Code,
1829 const tooling::Replacements &Replaces,
1830 const FormatStyle &Style) {
Manuel Klimekb12e5a52016-03-01 12:37:30 +00001831 if (Replaces.empty())
1832 return tooling::Replacements();
1833
Eric Liu4f8d9942016-07-11 13:53:12 +00001834 auto NewCode = applyAllReplacements(Code, Replaces);
1835 if (!NewCode)
1836 return NewCode.takeError();
Eric Liu40ef2fb2016-08-01 10:16:37 +00001837 std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
Manuel Klimekb12e5a52016-03-01 12:37:30 +00001838 StringRef FileName = Replaces.begin()->getFilePath();
Eric Liu4cfb88a2016-04-25 15:09:22 +00001839
Manuel Klimekb12e5a52016-03-01 12:37:30 +00001840 tooling::Replacements FormatReplaces =
Eric Liu4f8d9942016-07-11 13:53:12 +00001841 ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
Manuel Klimekb12e5a52016-03-01 12:37:30 +00001842
Eric Liu40ef2fb2016-08-01 10:16:37 +00001843 return Replaces.merge(FormatReplaces);
Manuel Klimekb12e5a52016-03-01 12:37:30 +00001844}
1845
Eric Liu4f8d9942016-07-11 13:53:12 +00001846llvm::Expected<tooling::Replacements>
1847formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
1848 const FormatStyle &Style) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001849 // We need to use lambda function here since there are two versions of
Eric Liubaf58c22016-05-18 13:43:48 +00001850 // `sortIncludes`.
1851 auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
1852 std::vector<tooling::Range> Ranges,
1853 StringRef FileName) -> tooling::Replacements {
1854 return sortIncludes(Style, Code, Ranges, FileName);
1855 };
Eric Liu4f8d9942016-07-11 13:53:12 +00001856 auto SortedReplaces =
Eric Liubaf58c22016-05-18 13:43:48 +00001857 processReplacements(SortIncludes, Code, Replaces, Style);
Eric Liu4f8d9942016-07-11 13:53:12 +00001858 if (!SortedReplaces)
1859 return SortedReplaces.takeError();
Eric Liubaf58c22016-05-18 13:43:48 +00001860
1861 // We need to use lambda function here since there are two versions of
Eric Liu4cfb88a2016-04-25 15:09:22 +00001862 // `reformat`.
1863 auto Reformat = [](const FormatStyle &Style, StringRef Code,
1864 std::vector<tooling::Range> Ranges,
1865 StringRef FileName) -> tooling::Replacements {
1866 return reformat(Style, Code, Ranges, FileName);
1867 };
Eric Liu4f8d9942016-07-11 13:53:12 +00001868 return processReplacements(Reformat, Code, *SortedReplaces, Style);
Eric Liu4cfb88a2016-04-25 15:09:22 +00001869}
1870
Eric Liu659afd52016-05-31 13:34:20 +00001871namespace {
1872
1873inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
Eric Liuc0d3a802016-09-23 15:10:56 +00001874 return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
Eric Liu659afd52016-05-31 13:34:20 +00001875 llvm::Regex(IncludeRegexPattern).match(Replace.getReplacementText());
1876}
1877
Eric Liuc0d3a802016-09-23 15:10:56 +00001878inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
1879 return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
1880}
1881
Eric Liu659afd52016-05-31 13:34:20 +00001882// FIXME: insert empty lines between newly created blocks.
1883tooling::Replacements
1884fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
1885 const FormatStyle &Style) {
Daniel Jasper1dbc2102017-03-31 13:30:24 +00001886 if (!Style.isCpp())
Eric Liu659afd52016-05-31 13:34:20 +00001887 return Replaces;
1888
1889 tooling::Replacements HeaderInsertions;
Eric Liuc0d3a802016-09-23 15:10:56 +00001890 std::set<llvm::StringRef> HeadersToDelete;
Eric Liu40ef2fb2016-08-01 10:16:37 +00001891 tooling::Replacements Result;
Eric Liu659afd52016-05-31 13:34:20 +00001892 for (const auto &R : Replaces) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001893 if (isHeaderInsertion(R)) {
1894 // Replacements from \p Replaces must be conflict-free already, so we can
1895 // simply consume the error.
1896 llvm::consumeError(HeaderInsertions.add(R));
Eric Liuc0d3a802016-09-23 15:10:56 +00001897 } else if (isHeaderDeletion(R)) {
1898 HeadersToDelete.insert(R.getReplacementText());
Eric Liu40ef2fb2016-08-01 10:16:37 +00001899 } else if (R.getOffset() == UINT_MAX) {
Eric Liu659afd52016-05-31 13:34:20 +00001900 llvm::errs() << "Insertions other than header #include insertion are "
1901 "not supported! "
1902 << R.getReplacementText() << "\n";
Eric Liu40ef2fb2016-08-01 10:16:37 +00001903 } else {
1904 llvm::consumeError(Result.add(R));
1905 }
Eric Liu659afd52016-05-31 13:34:20 +00001906 }
Eric Liuc0d3a802016-09-23 15:10:56 +00001907 if (HeaderInsertions.empty() && HeadersToDelete.empty())
Eric Liu659afd52016-05-31 13:34:20 +00001908 return Replaces;
Eric Liu659afd52016-05-31 13:34:20 +00001909
Eric Liu659afd52016-05-31 13:34:20 +00001910
1911 StringRef FileName = Replaces.begin()->getFilePath();
Eric Liu7129e632018-05-14 20:17:53 +00001912 tooling::HeaderIncludes Includes(FileName, Code, Style.IncludeStyle);
Eric Liu659afd52016-05-31 13:34:20 +00001913
Eric Liubf4c41c2018-05-04 17:55:13 +00001914 for (const auto &Header : HeadersToDelete) {
1915 tooling::Replacements Replaces =
Eric Liu7129e632018-05-14 20:17:53 +00001916 Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
Eric Liubf4c41c2018-05-04 17:55:13 +00001917 for (const auto &R : Replaces) {
1918 auto Err = Result.add(R);
1919 if (Err) {
1920 // Ignore the deletion on conflict.
1921 llvm::errs() << "Failed to add header deletion replacement for "
1922 << Header << ": " << llvm::toString(std::move(Err))
1923 << "\n";
Eric Liuc0d3a802016-09-23 15:10:56 +00001924 }
Eric Liu659afd52016-05-31 13:34:20 +00001925 }
Eric Liu659afd52016-05-31 13:34:20 +00001926 }
1927
Eric Liubf4c41c2018-05-04 17:55:13 +00001928 llvm::Regex IncludeRegex = llvm::Regex(IncludeRegexPattern);
1929 llvm::SmallVector<StringRef, 4> Matches;
Eric Liu659afd52016-05-31 13:34:20 +00001930 for (const auto &R : HeaderInsertions) {
1931 auto IncludeDirective = R.getReplacementText();
1932 bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
1933 assert(Matched && "Header insertion replacement must have replacement text "
1934 "'#include ...'");
Benjamin Kramer1cb7ee12016-05-31 14:14:42 +00001935 (void)Matched;
Eric Liu659afd52016-05-31 13:34:20 +00001936 auto IncludeName = Matches[2];
Eric Liubf4c41c2018-05-04 17:55:13 +00001937 auto Replace =
Eric Liu7129e632018-05-14 20:17:53 +00001938 Includes.insert(IncludeName.trim("\"<>"), IncludeName.startswith("<"));
Eric Liubf4c41c2018-05-04 17:55:13 +00001939 if (Replace) {
1940 auto Err = Result.add(*Replace);
1941 if (Err) {
1942 llvm::consumeError(std::move(Err));
1943 unsigned NewOffset = Result.getShiftedCodePosition(Replace->getOffset());
1944 auto Shifted = tooling::Replacement(FileName, NewOffset, 0,
1945 Replace->getReplacementText());
1946 Result = Result.merge(tooling::Replacements(Shifted));
1947 }
Eric Liu40ef2fb2016-08-01 10:16:37 +00001948 }
Eric Liu659afd52016-05-31 13:34:20 +00001949 }
1950 return Result;
1951}
1952
1953} // anonymous namespace
1954
Eric Liu4f8d9942016-07-11 13:53:12 +00001955llvm::Expected<tooling::Replacements>
Eric Liu4cfb88a2016-04-25 15:09:22 +00001956cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
1957 const FormatStyle &Style) {
1958 // We need to use lambda function here since there are two versions of
1959 // `cleanup`.
1960 auto Cleanup = [](const FormatStyle &Style, StringRef Code,
1961 std::vector<tooling::Range> Ranges,
1962 StringRef FileName) -> tooling::Replacements {
1963 return cleanup(Style, Code, Ranges, FileName);
1964 };
Eric Liu659afd52016-05-31 13:34:20 +00001965 // Make header insertion replacements insert new headers into correct blocks.
1966 tooling::Replacements NewReplaces =
1967 fixCppIncludeInsertions(Code, Replaces, Style);
1968 return processReplacements(Cleanup, Code, NewReplaces, Style);
Eric Liu4cfb88a2016-04-25 15:09:22 +00001969}
1970
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001971namespace internal {
1972std::pair<tooling::Replacements, unsigned>
1973reformat(const FormatStyle &Style, StringRef Code,
1974 ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
1975 unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
1976 FormattingAttemptStatus *Status) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001977 FormatStyle Expanded = expandPresets(Style);
1978 if (Expanded.DisableFormat)
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001979 return {tooling::Replacements(), 0};
Krasimir Georgiev86873032017-08-29 13:57:31 +00001980 if (isLikelyXml(Code))
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001981 return {tooling::Replacements(), 0};
Krasimir Georgiev86873032017-08-29 13:57:31 +00001982 if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001983 return {tooling::Replacements(), 0};
Daniel Jasper496c1992016-09-07 22:48:53 +00001984
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001985 typedef std::function<std::pair<tooling::Replacements, unsigned>(
1986 const Environment &)>
Krasimir Georgievac16a202017-06-23 11:46:03 +00001987 AnalyzerPass;
1988 SmallVector<AnalyzerPass, 4> Passes;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00001989
Krasimir Georgievac16a202017-06-23 11:46:03 +00001990 if (Style.Language == FormatStyle::LK_Cpp) {
1991 if (Style.FixNamespaceComments)
1992 Passes.emplace_back([&](const Environment &Env) {
1993 return NamespaceEndCommentsFixer(Env, Expanded).process();
1994 });
1995
1996 if (Style.SortUsingDeclarations)
1997 Passes.emplace_back([&](const Environment &Env) {
1998 return UsingDeclarationsSorter(Env, Expanded).process();
1999 });
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002000 }
2001
2002 if (Style.Language == FormatStyle::LK_JavaScript &&
Krasimir Georgievac16a202017-06-23 11:46:03 +00002003 Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
2004 Passes.emplace_back([&](const Environment &Env) {
2005 return JavaScriptRequoter(Env, Expanded).process();
2006 });
2007
2008 Passes.emplace_back([&](const Environment &Env) {
2009 return Formatter(Env, Expanded, Status).process();
2010 });
2011
Eric Liu2e538082018-05-09 21:35:52 +00002012 auto Env =
2013 llvm::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
2014 NextStartColumn, LastStartColumn);
Krasimir Georgievac16a202017-06-23 11:46:03 +00002015 llvm::Optional<std::string> CurrentCode = None;
2016 tooling::Replacements Fixes;
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002017 unsigned Penalty = 0;
Krasimir Georgievac16a202017-06-23 11:46:03 +00002018 for (size_t I = 0, E = Passes.size(); I < E; ++I) {
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002019 std::pair<tooling::Replacements, unsigned> PassFixes = Passes[I](*Env);
Krasimir Georgievac16a202017-06-23 11:46:03 +00002020 auto NewCode = applyAllReplacements(
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002021 CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first);
Krasimir Georgievac16a202017-06-23 11:46:03 +00002022 if (NewCode) {
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002023 Fixes = Fixes.merge(PassFixes.first);
2024 Penalty += PassFixes.second;
Krasimir Georgievac16a202017-06-23 11:46:03 +00002025 if (I + 1 < E) {
2026 CurrentCode = std::move(*NewCode);
Eric Liu2e538082018-05-09 21:35:52 +00002027 Env = llvm::make_unique<Environment>(
Krasimir Georgievac16a202017-06-23 11:46:03 +00002028 *CurrentCode, FileName,
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002029 tooling::calculateRangesAfterReplacements(Fixes, Ranges),
2030 FirstStartColumn, NextStartColumn, LastStartColumn);
Krasimir Georgievac16a202017-06-23 11:46:03 +00002031 }
2032 }
Daniel Jasper496c1992016-09-07 22:48:53 +00002033 }
2034
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002035 return {Fixes, Penalty};
2036}
2037} // namespace internal
2038
2039tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2040 ArrayRef<tooling::Range> Ranges,
2041 StringRef FileName,
2042 FormattingAttemptStatus *Status) {
2043 return internal::reformat(Style, Code, Ranges,
2044 /*FirstStartColumn=*/0,
2045 /*NextStartColumn=*/0,
2046 /*LastStartColumn=*/0, FileName, Status)
2047 .first;
Eric Liu4cfb88a2016-04-25 15:09:22 +00002048}
2049
Eric Liu4cfb88a2016-04-25 15:09:22 +00002050tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
2051 ArrayRef<tooling::Range> Ranges,
2052 StringRef FileName) {
Martin Probst816a9662017-05-29 08:41:11 +00002053 // cleanups only apply to C++ (they mostly concern ctor commas etc.)
2054 if (Style.Language != FormatStyle::LK_Cpp)
2055 return tooling::Replacements();
Eric Liu2e538082018-05-09 21:35:52 +00002056 return Cleaner(Environment(Code, FileName, Ranges), Style).process().first;
Daniel Jasperec04c0d2013-05-16 10:40:07 +00002057}
2058
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00002059tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2060 ArrayRef<tooling::Range> Ranges,
2061 StringRef FileName, bool *IncompleteFormat) {
2062 FormattingAttemptStatus Status;
2063 auto Result = reformat(Style, Code, Ranges, FileName, &Status);
2064 if (!Status.FormatComplete)
2065 *IncompleteFormat = true;
2066 return Result;
2067}
2068
Krasimir Georgiev7cb267a2017-02-27 13:28:36 +00002069tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
2070 StringRef Code,
2071 ArrayRef<tooling::Range> Ranges,
2072 StringRef FileName) {
Eric Liu2e538082018-05-09 21:35:52 +00002073 return NamespaceEndCommentsFixer(Environment(Code, FileName, Ranges), Style)
2074 .process()
2075 .first;
Krasimir Georgiev7cb267a2017-02-27 13:28:36 +00002076}
2077
Krasimir Georgievb03877a2017-06-21 12:03:12 +00002078tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
2079 StringRef Code,
2080 ArrayRef<tooling::Range> Ranges,
2081 StringRef FileName) {
Eric Liu2e538082018-05-09 21:35:52 +00002082 return UsingDeclarationsSorter(Environment(Code, FileName, Ranges), Style)
2083 .process()
2084 .first;
Krasimir Georgievb03877a2017-06-21 12:03:12 +00002085}
2086
Daniel Jasper4db69bd2014-09-04 18:23:42 +00002087LangOptions getFormattingLangOpts(const FormatStyle &Style) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00002088 LangOptions LangOpts;
2089 LangOpts.CPlusPlus = 1;
Daniel Jasper4db69bd2014-09-04 18:23:42 +00002090 LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2091 LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
Aaron Ballmanc351fba2017-12-04 20:27:34 +00002092 LangOpts.CPlusPlus17 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
Richard Smithc70f1d62017-12-14 15:16:18 +00002093 LangOpts.CPlusPlus2a = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
Daniel Jasper55213652013-03-22 10:01:29 +00002094 LangOpts.LineComment = 1;
Daniel Jasper1dbc2102017-03-31 13:30:24 +00002095 bool AlternativeOperators = Style.isCpp();
Daniel Jasper30a24062014-11-14 09:02:28 +00002096 LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
Daniel Jasperc1fa2812013-01-10 13:08:12 +00002097 LangOpts.Bool = 1;
2098 LangOpts.ObjC1 = 1;
2099 LangOpts.ObjC2 = 1;
Eric Liu4cfb88a2016-04-25 15:09:22 +00002100 LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
Saleem Abdulrasoold170c4b2015-10-04 17:51:05 +00002101 LangOpts.DeclSpecKeyword = 1; // To get __declspec.
Daniel Jasperc1fa2812013-01-10 13:08:12 +00002102 return LangOpts;
2103}
2104
Edwin Vaned544aa72013-09-30 13:31:48 +00002105const char *StyleOptionHelpDescription =
2106 "Coding style, currently supports:\n"
2107 " LLVM, Google, Chromium, Mozilla, WebKit.\n"
2108 "Use -style=file to load style configuration from\n"
2109 ".clang-format file located in one of the parent\n"
2110 "directories of the source file (or current\n"
2111 "directory for stdin).\n"
2112 "Use -style=\"{key: value, ...}\" to set specific\n"
2113 "parameters, e.g.:\n"
2114 " -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
2115
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002116static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
Daniel Jasper498f5582015-12-25 08:53:31 +00002117 if (FileName.endswith(".java"))
Daniel Jasperc58c70e2014-09-15 11:21:46 +00002118 return FormatStyle::LK_Java;
Daniel Jasper498f5582015-12-25 08:53:31 +00002119 if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
2120 return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
Daniel Jasper03a04fe2016-12-12 12:42:29 +00002121 if (FileName.endswith(".m") || FileName.endswith(".mm"))
2122 return FormatStyle::LK_ObjC;
Daniel Jasper498f5582015-12-25 08:53:31 +00002123 if (FileName.endswith_lower(".proto") ||
2124 FileName.endswith_lower(".protodevel"))
Daniel Jasper7052ce62014-01-19 09:04:08 +00002125 return FormatStyle::LK_Proto;
Krasimir Georgiev66496652017-11-17 15:10:49 +00002126 if (FileName.endswith_lower(".textpb") ||
2127 FileName.endswith_lower(".pb.txt") ||
2128 FileName.endswith_lower(".textproto") ||
2129 FileName.endswith_lower(".asciipb"))
2130 return FormatStyle::LK_TextProto;
Daniel Jasper498f5582015-12-25 08:53:31 +00002131 if (FileName.endswith_lower(".td"))
2132 return FormatStyle::LK_TableGen;
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002133 return FormatStyle::LK_Cpp;
Alexander Kornienkocabdd732013-11-29 15:19:43 +00002134}
2135
Ben Hamilton3b345c32018-02-21 15:54:31 +00002136FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
Ben Hamilton6e066352018-02-27 15:56:40 +00002137 const auto GuessedLanguage = getLanguageByFileName(FileName);
2138 if (GuessedLanguage == FormatStyle::LK_Cpp) {
Ben Hamilton07e58362018-02-21 21:27:27 +00002139 auto Extension = llvm::sys::path::extension(FileName);
Ben Hamilton3b345c32018-02-21 15:54:31 +00002140 // If there's no file extension (or it's .h), we need to check the contents
2141 // of the code to see if it contains Objective-C.
Ben Hamilton07e58362018-02-21 21:27:27 +00002142 if (Extension.empty() || Extension == ".h") {
2143 auto NonEmptyFileName = FileName.empty() ? "guess.h" : FileName;
Eric Liu2e538082018-05-09 21:35:52 +00002144 Environment Env(Code, NonEmptyFileName, /*Ranges=*/{});
2145 ObjCHeaderStyleGuesser Guesser(Env, getLLVMStyle());
Ben Hamilton3b345c32018-02-21 15:54:31 +00002146 Guesser.process();
Ben Hamilton6e066352018-02-27 15:56:40 +00002147 if (Guesser.isObjC())
2148 return FormatStyle::LK_ObjC;
Ben Hamilton3b345c32018-02-21 15:54:31 +00002149 }
2150 }
Ben Hamilton6e066352018-02-27 15:56:40 +00002151 return GuessedLanguage;
Ben Hamilton3b345c32018-02-21 15:54:31 +00002152}
2153
Eric Liub4adc912018-06-25 16:29:19 +00002154const char *DefaultFormatStyle = "file";
2155
2156const char *DefaultFallbackStyle = "LLVM";
2157
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002158llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
Antonio Maiorano7eb75072017-01-20 01:22:42 +00002159 StringRef FallbackStyleName,
2160 StringRef Code, vfs::FileSystem *FS) {
Eric Liu547d8792016-03-24 13:22:42 +00002161 if (!FS) {
2162 FS = vfs::getRealFileSystem().get();
2163 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002164 FormatStyle Style = getLLVMStyle();
Ben Hamilton3b345c32018-02-21 15:54:31 +00002165 Style.Language = guessLanguage(FileName, Code);
Daniel Jasper03a04fe2016-12-12 12:42:29 +00002166
Antonio Maiorano7eb75072017-01-20 01:22:42 +00002167 FormatStyle FallbackStyle = getNoStyle();
2168 if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
2169 return make_string_error("Invalid fallback style \"" + FallbackStyleName);
Edwin Vaned544aa72013-09-30 13:31:48 +00002170
2171 if (StyleName.startswith("{")) {
2172 // Parse YAML/JSON style from the command line.
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002173 if (std::error_code ec = parseConfiguration(StyleName, &Style))
2174 return make_string_error("Error parsing -style: " + ec.message());
Edwin Vaned544aa72013-09-30 13:31:48 +00002175 return Style;
2176 }
2177
2178 if (!StyleName.equals_lower("file")) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002179 if (!getPredefinedStyle(StyleName, Style.Language, &Style))
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002180 return make_string_error("Invalid value for -style");
Edwin Vaned544aa72013-09-30 13:31:48 +00002181 return Style;
2182 }
2183
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002184 // Look for .clang-format/_clang-format file in the file's parent directories.
Alexander Kornienkocabdd732013-11-29 15:19:43 +00002185 SmallString<128> UnsuitableConfigFiles;
Edwin Vaned544aa72013-09-30 13:31:48 +00002186 SmallString<128> Path(FileName);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002187 if (std::error_code EC = FS->makeAbsolute(Path))
2188 return make_string_error(EC.message());
Antonio Maiorano34c03762016-12-22 05:10:07 +00002189
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00002190 for (StringRef Directory = Path; !Directory.empty();
Edwin Vaned544aa72013-09-30 13:31:48 +00002191 Directory = llvm::sys::path::parent_path(Directory)) {
Eric Liu547d8792016-03-24 13:22:42 +00002192
2193 auto Status = FS->status(Directory);
2194 if (!Status ||
2195 Status->getType() != llvm::sys::fs::file_type::directory_file) {
Edwin Vaned544aa72013-09-30 13:31:48 +00002196 continue;
Eric Liu547d8792016-03-24 13:22:42 +00002197 }
2198
Edwin Vaned544aa72013-09-30 13:31:48 +00002199 SmallString<128> ConfigFile(Directory);
2200
2201 llvm::sys::path::append(ConfigFile, ".clang-format");
Nicola Zaghen3538b392018-05-15 13:30:56 +00002202 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
Eric Liud4758322016-03-24 13:22:37 +00002203
Eric Liu547d8792016-03-24 13:22:42 +00002204 Status = FS->status(ConfigFile.str());
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002205 bool FoundConfigFile =
Eric Liu547d8792016-03-24 13:22:42 +00002206 Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002207 if (!FoundConfigFile) {
Edwin Vaned544aa72013-09-30 13:31:48 +00002208 // Try _clang-format too, since dotfiles are not commonly used on Windows.
2209 ConfigFile = Directory;
2210 llvm::sys::path::append(ConfigFile, "_clang-format");
Nicola Zaghen3538b392018-05-15 13:30:56 +00002211 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
Eric Liu547d8792016-03-24 13:22:42 +00002212 Status = FS->status(ConfigFile.str());
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002213 FoundConfigFile = Status && (Status->getType() ==
2214 llvm::sys::fs::file_type::regular_file);
Edwin Vaned544aa72013-09-30 13:31:48 +00002215 }
2216
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002217 if (FoundConfigFile) {
Rafael Espindola2d2b4202014-07-06 17:43:24 +00002218 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
Eric Liu547d8792016-03-24 13:22:42 +00002219 FS->getBufferForFile(ConfigFile.str());
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002220 if (std::error_code EC = Text.getError())
2221 return make_string_error(EC.message());
Rafael Espindola2d2b4202014-07-06 17:43:24 +00002222 if (std::error_code ec =
2223 parseConfiguration(Text.get()->getBuffer(), &Style)) {
Rafael Espindolad0136702014-06-12 02:50:04 +00002224 if (ec == ParseError::Unsuitable) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +00002225 if (!UnsuitableConfigFiles.empty())
2226 UnsuitableConfigFiles.append(", ");
2227 UnsuitableConfigFiles.append(ConfigFile);
Alexander Kornienkobc4ae442013-12-02 15:21:38 +00002228 continue;
Alexander Kornienkocabdd732013-11-29 15:19:43 +00002229 }
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002230 return make_string_error("Error reading " + ConfigFile + ": " +
2231 ec.message());
Edwin Vaned544aa72013-09-30 13:31:48 +00002232 }
Nicola Zaghen3538b392018-05-15 13:30:56 +00002233 LLVM_DEBUG(llvm::dbgs()
2234 << "Using configuration file " << ConfigFile << "\n");
Edwin Vaned544aa72013-09-30 13:31:48 +00002235 return Style;
2236 }
2237 }
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002238 if (!UnsuitableConfigFiles.empty())
2239 return make_string_error("Configuration file(s) do(es) not support " +
2240 getLanguageName(Style.Language) + ": " +
2241 UnsuitableConfigFiles);
Antonio Maiorano7eb75072017-01-20 01:22:42 +00002242 return FallbackStyle;
Edwin Vaned544aa72013-09-30 13:31:48 +00002243}
2244
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002245} // namespace format
2246} // namespace clang