blob: 39651ab74d6706e63248d909e4f2777789717b66 [file] [log] [blame]
Daniel Jasperf7935112012-12-03 18:12:45 +00001//===--- Format.cpp - Format C++ code -------------------------------------===//
2//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Daniel Jasperf7935112012-12-03 18:12:45 +00006//
7//===----------------------------------------------------------------------===//
8///
9/// \file
Adrian Prantl9fc8faf2018-05-09 01:00:01 +000010/// This file implements functions declared in Format.h. This will be
Daniel Jasperf7935112012-12-03 18:12:45 +000011/// split into separate files as we go.
12///
Daniel Jasperf7935112012-12-03 18:12:45 +000013//===----------------------------------------------------------------------===//
14
Daniel Jasper85c472d2015-09-29 07:53:08 +000015#include "clang/Format/Format.h"
Eric Liu4cfb88a2016-04-25 15:09:22 +000016#include "AffectedRangeManager.h"
Daniel Jasperde0328a2013-08-16 11:20:30 +000017#include "ContinuationIndenter.h"
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +000018#include "FormatInternal.h"
Martin Probstc4a0dd42016-05-20 11:24:24 +000019#include "FormatTokenLexer.h"
Krasimir Georgiev7cb267a2017-02-27 13:28:36 +000020#include "NamespaceEndCommentsFixer.h"
Martin Probstc4a0dd42016-05-20 11:24:24 +000021#include "SortJavaScriptImports.h"
22#include "TokenAnalyzer.h"
Daniel Jasper7a6d09b2013-01-29 21:01:14 +000023#include "TokenAnnotator.h"
Daniel Jasper0df50932014-12-10 19:00:42 +000024#include "UnwrappedLineFormatter.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000025#include "UnwrappedLineParser.h"
Krasimir Georgievb03877a2017-06-21 12:03:12 +000026#include "UsingDeclarationsSorter.h"
Alexander Kornienkocb45bc12013-04-15 14:28:00 +000027#include "WhitespaceManager.h"
Daniel Jasperec04c0d2013-05-16 10:40:07 +000028#include "clang/Basic/Diagnostic.h"
Benjamin Kramerf3ca26982014-05-10 16:31:55 +000029#include "clang/Basic/DiagnosticOptions.h"
Chandler Carruth44eb4f62013-01-02 10:28:36 +000030#include "clang/Basic/SourceManager.h"
Daniel Jasperf7935112012-12-03 18:12:45 +000031#include "clang/Lex/Lexer.h"
Eric Liu44564ac2018-06-04 09:04:12 +000032#include "clang/Tooling/Inclusions/HeaderIncludes.h"
Alexander Kornienkoffd6d042013-03-27 11:52:18 +000033#include "llvm/ADT/STLExtras.h"
Ben Hamiltone2e3e672018-01-17 17:33:08 +000034#include "llvm/ADT/StringRef.h"
Manuel Klimek2ef908e2013-02-13 10:46:36 +000035#include "llvm/Support/Allocator.h"
Manuel Klimek24998102013-01-16 14:55:28 +000036#include "llvm/Support/Debug.h"
Edwin Vaned544aa72013-09-30 13:31:48 +000037#include "llvm/Support/Path.h"
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +000038#include "llvm/Support/Regex.h"
Jonas Devliegherefc514902018-10-10 13:27:25 +000039#include "llvm/Support/VirtualFileSystem.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000040#include "llvm/Support/YAMLTraits.h"
Martin Probst081f1762016-06-01 15:19:53 +000041#include <algorithm>
Eric Liu4cfb88a2016-04-25 15:09:22 +000042#include <memory>
Eric Liubf4c41c2018-05-04 17:55:13 +000043#include <mutex>
Daniel Jasper8b529712012-12-04 13:02:32 +000044#include <string>
Eric Liubf4c41c2018-05-04 17:55:13 +000045#include <unordered_map>
Daniel Jasper8b529712012-12-04 13:02:32 +000046
Chandler Carruth10346662014-04-22 03:17:02 +000047#define DEBUG_TYPE "format-formatter"
48
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +000049using clang::format::FormatStyle;
50
NAKAMURA Takumi057a9422017-11-01 04:43:22 +000051LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::RawStringFormat)
Daniel Jaspere1e43192014-04-01 12:55:11 +000052
Alexander Kornienkod6538332013-05-07 15:32:14 +000053namespace llvm {
54namespace yaml {
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +000055template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
56 static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
57 IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
Daniel Jasperc58c70e2014-09-15 11:21:46 +000058 IO.enumCase(Value, "Java", FormatStyle::LK_Java);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +000059 IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
Daniel Jasper03a04fe2016-12-12 12:42:29 +000060 IO.enumCase(Value, "ObjC", FormatStyle::LK_ObjC);
Daniel Jasper7052ce62014-01-19 09:04:08 +000061 IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
Daniel Jasper498f5582015-12-25 08:53:31 +000062 IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
Krasimir Georgiev26b144c2017-07-03 15:05:14 +000063 IO.enumCase(Value, "TextProto", FormatStyle::LK_TextProto);
Paul Hoadcbb726d2019-03-21 13:09:22 +000064 IO.enumCase(Value, "CSharp", FormatStyle::LK_CSharp);
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
Paul Hoad15000a12019-03-13 08:26:39 +0000110template <> struct ScalarEnumerationTraits<FormatStyle::ShortIfStyle> {
111 static void enumeration(IO &IO, FormatStyle::ShortIfStyle &Value) {
112 IO.enumCase(Value, "Never", FormatStyle::SIS_Never);
113 IO.enumCase(Value, "Always", FormatStyle::SIS_Always);
114 IO.enumCase(Value, "WithoutElse", FormatStyle::SIS_WithoutElse);
115
116 // For backward compatibility.
117 IO.enumCase(Value, "false", FormatStyle::SIS_Never);
118 IO.enumCase(Value, "true", FormatStyle::SIS_WithoutElse);
119 }
120};
121
Ronald Wamplera83e2db2019-03-26 20:18:14 +0000122template <> struct ScalarEnumerationTraits<FormatStyle::ShortLambdaStyle> {
123 static void enumeration(IO &IO, FormatStyle::ShortLambdaStyle &Value) {
124 IO.enumCase(Value, "None", FormatStyle::SLS_None);
125 IO.enumCase(Value, "false", FormatStyle::SLS_None);
126 IO.enumCase(Value, "Empty", FormatStyle::SLS_Empty);
127 IO.enumCase(Value, "Inline", FormatStyle::SLS_Inline);
128 IO.enumCase(Value, "All", FormatStyle::SLS_All);
129 IO.enumCase(Value, "true", FormatStyle::SLS_All);
130 }
131};
132
Ben Hamilton4dc658c2018-02-02 20:15:14 +0000133template <> struct ScalarEnumerationTraits<FormatStyle::BinPackStyle> {
134 static void enumeration(IO &IO, FormatStyle::BinPackStyle &Value) {
135 IO.enumCase(Value, "Auto", FormatStyle::BPS_Auto);
136 IO.enumCase(Value, "Always", FormatStyle::BPS_Always);
137 IO.enumCase(Value, "Never", FormatStyle::BPS_Never);
138 }
139};
140
Daniel Jasperac043c92014-09-15 11:11:00 +0000141template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
142 static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
143 IO.enumCase(Value, "All", FormatStyle::BOS_All);
144 IO.enumCase(Value, "true", FormatStyle::BOS_All);
145 IO.enumCase(Value, "None", FormatStyle::BOS_None);
146 IO.enumCase(Value, "false", FormatStyle::BOS_None);
147 IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
148 }
149};
150
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000151template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
152 static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
153 IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
154 IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +0000155 IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000156 IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
157 IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000158 IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
Roman Kashitsyn291f64f2015-08-10 13:43:19 +0000159 IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000160 IO.enumCase(Value, "Custom", FormatStyle::BS_Custom);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000161 }
162};
163
Manuel Klimek89628f62017-09-20 09:51:03 +0000164template <>
165struct ScalarEnumerationTraits<FormatStyle::BreakConstructorInitializersStyle> {
166 static void
167 enumeration(IO &IO, FormatStyle::BreakConstructorInitializersStyle &Value) {
Francois Ferranda6b6d512017-05-24 11:36:58 +0000168 IO.enumCase(Value, "BeforeColon", FormatStyle::BCIS_BeforeColon);
169 IO.enumCase(Value, "BeforeComma", FormatStyle::BCIS_BeforeComma);
170 IO.enumCase(Value, "AfterColon", FormatStyle::BCIS_AfterColon);
171 }
172};
173
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000174template <>
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000175struct ScalarEnumerationTraits<FormatStyle::BreakInheritanceListStyle> {
Paul Hoad5bcf99b2019-03-01 09:09:54 +0000176 static void enumeration(IO &IO,
177 FormatStyle::BreakInheritanceListStyle &Value) {
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000178 IO.enumCase(Value, "BeforeColon", FormatStyle::BILS_BeforeColon);
179 IO.enumCase(Value, "BeforeComma", FormatStyle::BILS_BeforeComma);
180 IO.enumCase(Value, "AfterColon", FormatStyle::BILS_AfterColon);
181 }
182};
183
184template <>
Krasimir Georgievad47c902017-08-30 14:34:57 +0000185struct ScalarEnumerationTraits<FormatStyle::PPDirectiveIndentStyle> {
186 static void enumeration(IO &IO, FormatStyle::PPDirectiveIndentStyle &Value) {
187 IO.enumCase(Value, "None", FormatStyle::PPDIS_None);
188 IO.enumCase(Value, "AfterHash", FormatStyle::PPDIS_AfterHash);
Paul Hoad701a0d72019-03-20 20:49:43 +0000189 IO.enumCase(Value, "BeforeHash", FormatStyle::PPDIS_BeforeHash);
Krasimir Georgievad47c902017-08-30 14:34:57 +0000190 }
191};
192
193template <>
Zachary Turner448592e2015-12-18 22:20:15 +0000194struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
195 static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
196 IO.enumCase(Value, "None", FormatStyle::RTBS_None);
197 IO.enumCase(Value, "All", FormatStyle::RTBS_All);
198 IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
199 IO.enumCase(Value, "TopLevelDefinitions",
200 FormatStyle::RTBS_TopLevelDefinitions);
201 IO.enumCase(Value, "AllDefinitions", FormatStyle::RTBS_AllDefinitions);
202 }
203};
204
205template <>
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000206struct ScalarEnumerationTraits<FormatStyle::BreakTemplateDeclarationsStyle> {
Paul Hoad5bcf99b2019-03-01 09:09:54 +0000207 static void enumeration(IO &IO,
208 FormatStyle::BreakTemplateDeclarationsStyle &Value) {
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000209 IO.enumCase(Value, "No", FormatStyle::BTDS_No);
210 IO.enumCase(Value, "MultiLine", FormatStyle::BTDS_MultiLine);
211 IO.enumCase(Value, "Yes", FormatStyle::BTDS_Yes);
212
213 // For backward compatibility.
214 IO.enumCase(Value, "false", FormatStyle::BTDS_MultiLine);
215 IO.enumCase(Value, "true", FormatStyle::BTDS_Yes);
216 }
217};
218
219template <>
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000220struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
221 static void
222 enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) {
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +0000223 IO.enumCase(Value, "None", FormatStyle::DRTBS_None);
224 IO.enumCase(Value, "All", FormatStyle::DRTBS_All);
225 IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel);
226
227 // For backward compatibility.
228 IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
229 IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
230 }
231};
232
Alexander Kornienkod6538332013-05-07 15:32:14 +0000233template <>
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000234struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000235 static void enumeration(IO &IO,
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000236 FormatStyle::NamespaceIndentationKind &Value) {
237 IO.enumCase(Value, "None", FormatStyle::NI_None);
238 IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
239 IO.enumCase(Value, "All", FormatStyle::NI_All);
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000240 }
241};
242
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000243template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
244 static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
245 IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
246 IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign);
247 IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
248
249 // For backward compatibility.
250 IO.enumCase(Value, "true", FormatStyle::BAS_Align);
251 IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
252 }
253};
254
Manuel Klimek89628f62017-09-20 09:51:03 +0000255template <>
256struct ScalarEnumerationTraits<FormatStyle::EscapedNewlineAlignmentStyle> {
257 static void enumeration(IO &IO,
258 FormatStyle::EscapedNewlineAlignmentStyle &Value) {
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000259 IO.enumCase(Value, "DontAlign", FormatStyle::ENAS_DontAlign);
260 IO.enumCase(Value, "Left", FormatStyle::ENAS_Left);
261 IO.enumCase(Value, "Right", FormatStyle::ENAS_Right);
262
263 // For backward compatibility.
264 IO.enumCase(Value, "true", FormatStyle::ENAS_Left);
265 IO.enumCase(Value, "false", FormatStyle::ENAS_Right);
266 }
267};
268
Jacques Pienaarfc275112015-02-18 23:48:37 +0000269template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
270 static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
Daniel Jasper553d4872014-06-17 12:40:34 +0000271 IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
272 IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
273 IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
274
Alp Toker958027b2014-07-14 19:42:55 +0000275 // For backward compatibility.
Daniel Jasper553d4872014-06-17 12:40:34 +0000276 IO.enumCase(Value, "true", FormatStyle::PAS_Left);
277 IO.enumCase(Value, "false", FormatStyle::PAS_Right);
278 }
279};
280
281template <>
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000282struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
Manuel Klimeka8eb9142013-05-13 12:51:40 +0000283 static void enumeration(IO &IO,
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000284 FormatStyle::SpaceBeforeParensOptions &Value) {
285 IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +0000286 IO.enumCase(Value, "ControlStatements",
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000287 FormatStyle::SBPO_ControlStatements);
288 IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +0000289
290 // For backward compatibility.
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000291 IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
292 IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
Alexander Kornienkofdca83d2013-12-10 10:18:34 +0000293 }
294};
295
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000296template <> struct MappingTraits<FormatStyle> {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000297 static void mapping(IO &IO, FormatStyle &Style) {
298 // When reading, read the language first, we need it for getPredefinedStyle.
299 IO.mapOptional("Language", Style.Language);
300
Alexander Kornienko49149672013-05-10 11:56:10 +0000301 if (IO.outputting()) {
Paul Hoadcbb726d2019-03-21 13:09:22 +0000302 StringRef StylesArray[] = {"LLVM", "Google", "Chromium", "Mozilla",
303 "WebKit", "GNU", "Microsoft"};
Alexander Kornienko49149672013-05-10 11:56:10 +0000304 ArrayRef<StringRef> Styles(StylesArray);
305 for (size_t i = 0, e = Styles.size(); i < e; ++i) {
306 StringRef StyleName(Styles[i]);
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000307 FormatStyle PredefinedStyle;
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000308 if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
Alexander Kornienko006b5c82013-05-19 00:53:30 +0000309 Style == PredefinedStyle) {
Alexander Kornienko49149672013-05-10 11:56:10 +0000310 IO.mapOptional("# BasedOnStyle", StyleName);
311 break;
312 }
313 }
314 } else {
Alexander Kornienkod6538332013-05-07 15:32:14 +0000315 StringRef BasedOnStyle;
316 IO.mapOptional("BasedOnStyle", BasedOnStyle);
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000317 if (!BasedOnStyle.empty()) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000318 FormatStyle::LanguageKind OldLanguage = Style.Language;
319 FormatStyle::LanguageKind Language =
320 ((FormatStyle *)IO.getContext())->Language;
321 if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
Alexander Kornienko006b5c82013-05-19 00:53:30 +0000322 IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
323 return;
324 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000325 Style.Language = OldLanguage;
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000326 }
Alexander Kornienkod6538332013-05-07 15:32:14 +0000327 }
328
Birunthan Mohanathas50a6f912015-06-28 14:52:34 +0000329 // For backward compatibility.
330 if (!IO.outputting()) {
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000331 IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlines);
Birunthan Mohanathas50a6f912015-06-28 14:52:34 +0000332 IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
333 IO.mapOptional("IndentFunctionDeclarationAfterType",
334 Style.IndentWrappedFunctionNames);
335 IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
336 IO.mapOptional("SpaceAfterControlStatementKeyword",
337 Style.SpaceBeforeParens);
338 }
339
Alexander Kornienkod6538332013-05-07 15:32:14 +0000340 IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
Daniel Jasper3aa9a6a2014-11-18 23:55:27 +0000341 IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000342 IO.mapOptional("AlignConsecutiveAssignments",
343 Style.AlignConsecutiveAssignments);
Daniel Jaspere12597c2015-10-01 10:06:54 +0000344 IO.mapOptional("AlignConsecutiveDeclarations",
345 Style.AlignConsecutiveDeclarations);
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000346 IO.mapOptional("AlignEscapedNewlines", Style.AlignEscapedNewlines);
Daniel Jasper3219e432014-12-02 13:24:51 +0000347 IO.mapOptional("AlignOperands", Style.AlignOperands);
Daniel Jasper552f4a72013-07-31 23:55:15 +0000348 IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
Paul Hoadc6deae42019-03-23 14:37:58 +0000349 IO.mapOptional("AllowAllArgumentsOnNextLine",
350 Style.AllowAllArgumentsOnNextLine);
351 IO.mapOptional("AllowAllConstructorInitializersOnNextLine",
352 Style.AllowAllConstructorInitializersOnNextLine);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000353 IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
354 Style.AllowAllParametersOfDeclarationOnNextLine);
Daniel Jasper17605d32014-05-14 09:33:35 +0000355 IO.mapOptional("AllowShortBlocksOnASingleLine",
356 Style.AllowShortBlocksOnASingleLine);
Daniel Jasperb87899b2014-09-10 13:11:45 +0000357 IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
358 Style.AllowShortCaseLabelsOnASingleLine);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000359 IO.mapOptional("AllowShortFunctionsOnASingleLine",
360 Style.AllowShortFunctionsOnASingleLine);
Ronald Wamplera83e2db2019-03-26 20:18:14 +0000361 IO.mapOptional("AllowShortLambdasOnASingleLine",
362 Style.AllowShortLambdasOnASingleLine);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000363 IO.mapOptional("AllowShortIfStatementsOnASingleLine",
364 Style.AllowShortIfStatementsOnASingleLine);
Daniel Jasper3a685df2013-05-16 12:12:21 +0000365 IO.mapOptional("AllowShortLoopsOnASingleLine",
366 Style.AllowShortLoopsOnASingleLine);
Daniel Jasperca4ea1c2014-08-05 12:16:31 +0000367 IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
368 Style.AlwaysBreakAfterDefinitionReturnType);
Zachary Turner448592e2015-12-18 22:20:15 +0000369 IO.mapOptional("AlwaysBreakAfterReturnType",
370 Style.AlwaysBreakAfterReturnType);
Paul Hoadc6deae42019-03-23 14:37:58 +0000371
Zachary Turner448592e2015-12-18 22:20:15 +0000372 // If AlwaysBreakAfterDefinitionReturnType was specified but
373 // AlwaysBreakAfterReturnType was not, initialize the latter from the
374 // former for backwards compatibility.
375 if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
376 Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
377 if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
378 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
379 else if (Style.AlwaysBreakAfterDefinitionReturnType ==
380 FormatStyle::DRTBS_TopLevel)
381 Style.AlwaysBreakAfterReturnType =
382 FormatStyle::RTBS_TopLevelDefinitions;
383 }
384
Alexander Kornienko58611712013-07-04 12:02:44 +0000385 IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
386 Style.AlwaysBreakBeforeMultilineStrings);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000387 IO.mapOptional("AlwaysBreakTemplateDeclarations",
388 Style.AlwaysBreakTemplateDeclarations);
389 IO.mapOptional("BinPackArguments", Style.BinPackArguments);
390 IO.mapOptional("BinPackParameters", Style.BinPackParameters);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000391 IO.mapOptional("BraceWrapping", Style.BraceWrapping);
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000392 IO.mapOptional("BreakBeforeBinaryOperators",
393 Style.BreakBeforeBinaryOperators);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000394 IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000395
396 bool BreakBeforeInheritanceComma = false;
Paul Hoad5bcf99b2019-03-01 09:09:54 +0000397 IO.mapOptional("BreakBeforeInheritanceComma", BreakBeforeInheritanceComma);
398 IO.mapOptional("BreakInheritanceList", Style.BreakInheritanceList);
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000399 // If BreakBeforeInheritanceComma was specified but
400 // BreakInheritance was not, initialize the latter from the
401 // former for backwards compatibility.
402 if (BreakBeforeInheritanceComma &&
403 Style.BreakInheritanceList == FormatStyle::BILS_BeforeColon)
404 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
405
Daniel Jasper165b29e2013-11-08 00:57:11 +0000406 IO.mapOptional("BreakBeforeTernaryOperators",
407 Style.BreakBeforeTernaryOperators);
Francois Ferranda6b6d512017-05-24 11:36:58 +0000408
409 bool BreakConstructorInitializersBeforeComma = false;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000410 IO.mapOptional("BreakConstructorInitializersBeforeComma",
Francois Ferranda6b6d512017-05-24 11:36:58 +0000411 BreakConstructorInitializersBeforeComma);
412 IO.mapOptional("BreakConstructorInitializers",
413 Style.BreakConstructorInitializers);
414 // If BreakConstructorInitializersBeforeComma was specified but
415 // BreakConstructorInitializers was not, initialize the latter from the
416 // former for backwards compatibility.
417 if (BreakConstructorInitializersBeforeComma &&
418 Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeColon)
419 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
420
Daniel Jaspere1a7b762016-02-01 11:21:02 +0000421 IO.mapOptional("BreakAfterJavaFieldAnnotations",
422 Style.BreakAfterJavaFieldAnnotations);
423 IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000424 IO.mapOptional("ColumnLimit", Style.ColumnLimit);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000425 IO.mapOptional("CommentPragmas", Style.CommentPragmas);
Francois Ferrande56a8292017-06-14 12:29:47 +0000426 IO.mapOptional("CompactNamespaces", Style.CompactNamespaces);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000427 IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
428 Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
Daniel Jasper50d634b2014-10-28 16:53:38 +0000429 IO.mapOptional("ConstructorInitializerIndentWidth",
430 Style.ConstructorInitializerIndentWidth);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000431 IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
432 IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
Daniel Jasper553d4872014-06-17 12:40:34 +0000433 IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000434 IO.mapOptional("DisableFormat", Style.DisableFormat);
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000435 IO.mapOptional("ExperimentalAutoDetectBinPacking",
436 Style.ExperimentalAutoDetectBinPacking);
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000437 IO.mapOptional("FixNamespaceComments", Style.FixNamespaceComments);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000438 IO.mapOptional("ForEachMacros", Style.ForEachMacros);
Eric Liu9d92c022018-05-14 19:51:33 +0000439 IO.mapOptional("IncludeBlocks", Style.IncludeStyle.IncludeBlocks);
440 IO.mapOptional("IncludeCategories", Style.IncludeStyle.IncludeCategories);
441 IO.mapOptional("IncludeIsMainRegex", Style.IncludeStyle.IncludeIsMainRegex);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000442 IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
Krasimir Georgievad47c902017-08-30 14:34:57 +0000443 IO.mapOptional("IndentPPDirectives", Style.IndentPPDirectives);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000444 IO.mapOptional("IndentWidth", Style.IndentWidth);
445 IO.mapOptional("IndentWrappedFunctionNames",
446 Style.IndentWrappedFunctionNames);
Krasimir Georgiev7e91b032018-10-05 17:19:26 +0000447 IO.mapOptional("JavaImportGroups", Style.JavaImportGroups);
Martin Probst0cd74ee2016-06-13 16:39:50 +0000448 IO.mapOptional("JavaScriptQuotes", Style.JavaScriptQuotes);
449 IO.mapOptional("JavaScriptWrapImports", Style.JavaScriptWrapImports);
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000450 IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
451 Style.KeepEmptyLinesAtTheStartOfBlocks);
Birunthan Mohanathasb001a0b2015-07-03 17:25:16 +0000452 IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
453 IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000454 IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
Daniel Jasper65ee3472013-07-31 23:16:02 +0000455 IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
Ben Hamilton4dc658c2018-02-02 20:15:14 +0000456 IO.mapOptional("ObjCBinPackProtocolList", Style.ObjCBinPackProtocolList);
Daniel Jasper50d634b2014-10-28 16:53:38 +0000457 IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
Daniel Jaspere9beea22014-01-28 15:20:33 +0000458 IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000459 IO.mapOptional("ObjCSpaceBeforeProtocolList",
460 Style.ObjCSpaceBeforeProtocolList);
Manuel Klimek89628f62017-09-20 09:51:03 +0000461 IO.mapOptional("PenaltyBreakAssignment", Style.PenaltyBreakAssignment);
Daniel Jasper33b909c2013-10-25 14:29:37 +0000462 IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
463 Style.PenaltyBreakBeforeFirstCallParameter);
Alexander Kornienkodd7ece52013-06-07 16:02:52 +0000464 IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000465 IO.mapOptional("PenaltyBreakFirstLessLess",
466 Style.PenaltyBreakFirstLessLess);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000467 IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000468 IO.mapOptional("PenaltyBreakTemplateDeclaration",
469 Style.PenaltyBreakTemplateDeclaration);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000470 IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
471 IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
472 Style.PenaltyReturnTypeOnItsOwnLine);
Daniel Jasper553d4872014-06-17 12:40:34 +0000473 IO.mapOptional("PointerAlignment", Style.PointerAlignment);
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +0000474 IO.mapOptional("RawStringFormats", Style.RawStringFormats);
Daniel Jaspera0a50392015-12-01 13:28:53 +0000475 IO.mapOptional("ReflowComments", Style.ReflowComments);
476 IO.mapOptional("SortIncludes", Style.SortIncludes);
Krasimir Georgievac16a202017-06-23 11:46:03 +0000477 IO.mapOptional("SortUsingDeclarations", Style.SortUsingDeclarations);
Daniel Jasperdb986eb2014-09-03 07:37:29 +0000478 IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
Manuel Klimek89628f62017-09-20 09:51:03 +0000479 IO.mapOptional("SpaceAfterTemplateKeyword",
480 Style.SpaceAfterTemplateKeyword);
Daniel Jasperd94bff32013-09-25 15:15:02 +0000481 IO.mapOptional("SpaceBeforeAssignmentOperators",
482 Style.SpaceBeforeAssignmentOperators);
Hans Wennborgbfc34062018-06-14 08:01:09 +0000483 IO.mapOptional("SpaceBeforeCpp11BracedList",
484 Style.SpaceBeforeCpp11BracedList);
Francois Ferrand2a9ea782018-03-01 10:09:13 +0000485 IO.mapOptional("SpaceBeforeCtorInitializerColon",
486 Style.SpaceBeforeCtorInitializerColon);
487 IO.mapOptional("SpaceBeforeInheritanceColon",
488 Style.SpaceBeforeInheritanceColon);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000489 IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
Francois Ferrand2a9ea782018-03-01 10:09:13 +0000490 IO.mapOptional("SpaceBeforeRangeBasedForLoopColon",
491 Style.SpaceBeforeRangeBasedForLoopColon);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000492 IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
493 IO.mapOptional("SpacesBeforeTrailingComments",
494 Style.SpacesBeforeTrailingComments);
495 IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
496 IO.mapOptional("SpacesInContainerLiterals",
497 Style.SpacesInContainerLiterals);
498 IO.mapOptional("SpacesInCStyleCastParentheses",
499 Style.SpacesInCStyleCastParentheses);
500 IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
501 IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
502 IO.mapOptional("Standard", Style.Standard);
Francois Ferrand6f40e212018-10-02 16:37:51 +0000503 IO.mapOptional("StatementMacros", Style.StatementMacros);
Birunthan Mohanathas35cfbd72015-06-28 14:51:17 +0000504 IO.mapOptional("TabWidth", Style.TabWidth);
505 IO.mapOptional("UseTab", Style.UseTab);
Alexander Kornienkod6538332013-05-07 15:32:14 +0000506 }
507};
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000508
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000509template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
510 static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
511 IO.mapOptional("AfterClass", Wrapping.AfterClass);
512 IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
513 IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
514 IO.mapOptional("AfterFunction", Wrapping.AfterFunction);
515 IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace);
516 IO.mapOptional("AfterObjCDeclaration", Wrapping.AfterObjCDeclaration);
517 IO.mapOptional("AfterStruct", Wrapping.AfterStruct);
518 IO.mapOptional("AfterUnion", Wrapping.AfterUnion);
Krasimir Georgievd6ce9372017-09-15 11:23:50 +0000519 IO.mapOptional("AfterExternBlock", Wrapping.AfterExternBlock);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000520 IO.mapOptional("BeforeCatch", Wrapping.BeforeCatch);
521 IO.mapOptional("BeforeElse", Wrapping.BeforeElse);
522 IO.mapOptional("IndentBraces", Wrapping.IndentBraces);
Francois Ferrandad722562017-06-30 20:25:55 +0000523 IO.mapOptional("SplitEmptyFunction", Wrapping.SplitEmptyFunction);
524 IO.mapOptional("SplitEmptyRecord", Wrapping.SplitEmptyRecord);
525 IO.mapOptional("SplitEmptyNamespace", Wrapping.SplitEmptyNamespace);
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000526 }
527};
528
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +0000529template <> struct MappingTraits<FormatStyle::RawStringFormat> {
530 static void mapping(IO &IO, FormatStyle::RawStringFormat &Format) {
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +0000531 IO.mapOptional("Language", Format.Language);
Krasimir Georgiev4527f132018-01-17 12:24:59 +0000532 IO.mapOptional("Delimiters", Format.Delimiters);
Krasimir Georgiev2537e222018-01-17 16:17:26 +0000533 IO.mapOptional("EnclosingFunctions", Format.EnclosingFunctions);
Krasimir Georgiev412ed092018-01-19 16:18:47 +0000534 IO.mapOptional("CanonicalDelimiter", Format.CanonicalDelimiter);
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +0000535 IO.mapOptional("BasedOnStyle", Format.BasedOnStyle);
536 }
537};
538
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000539// Allows to read vector<FormatStyle> while keeping default values.
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000540// IO.getContext() should contain a pointer to the FormatStyle structure, that
541// will be used to get default values for missing keys.
542// If the first element has no Language specified, it will be treated as the
543// default one for the following elements.
Jacques Pienaarfc275112015-02-18 23:48:37 +0000544template <> struct DocumentListTraits<std::vector<FormatStyle>> {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000545 static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
546 return Seq.size();
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000547 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000548 static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000549 size_t Index) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000550 if (Index >= Seq.size()) {
551 assert(Index == Seq.size());
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000552 FormatStyle Template;
Krasimir Georgiev1696bb62017-11-09 15:12:17 +0000553 if (!Seq.empty() && Seq[0].Language == FormatStyle::LK_None) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000554 Template = Seq[0];
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000555 } else {
Daniel Jasperb05a81d2014-05-09 13:11:16 +0000556 Template = *((const FormatStyle *)IO.getContext());
Alexander Kornienko6d2c88e2013-12-10 10:30:34 +0000557 Template.Language = FormatStyle::LK_None;
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000558 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000559 Seq.resize(Index + 1, Template);
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000560 }
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000561 return Seq[Index];
Alexander Kornienkocabdd732013-11-29 15:19:43 +0000562 }
563};
Daniel Jasperd89ae9d2015-09-23 08:30:47 +0000564} // namespace yaml
565} // namespace llvm
Alexander Kornienkod6538332013-05-07 15:32:14 +0000566
Daniel Jasperf7935112012-12-03 18:12:45 +0000567namespace clang {
568namespace format {
569
Rafael Espindola6d0d89b2014-06-12 03:31:26 +0000570const std::error_category &getParseCategory() {
Benjamin Kramerf76861c2018-03-20 21:52:19 +0000571 static const ParseErrorCategory C{};
Rafael Espindolad0136702014-06-12 02:50:04 +0000572 return C;
573}
574std::error_code make_error_code(ParseError e) {
Rafael Espindola6d0d89b2014-06-12 03:31:26 +0000575 return std::error_code(static_cast<int>(e), getParseCategory());
Rafael Espindolad0136702014-06-12 02:50:04 +0000576}
577
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +0000578inline llvm::Error make_string_error(const llvm::Twine &Message) {
579 return llvm::make_error<llvm::StringError>(Message,
580 llvm::inconvertibleErrorCode());
581}
582
Reid Kleckner6432d452016-10-19 23:39:55 +0000583const char *ParseErrorCategory::name() const noexcept {
Rafael Espindolad0136702014-06-12 02:50:04 +0000584 return "clang-format.parse_error";
585}
586
587std::string ParseErrorCategory::message(int EV) const {
588 switch (static_cast<ParseError>(EV)) {
589 case ParseError::Success:
590 return "Success";
591 case ParseError::Error:
592 return "Invalid argument";
593 case ParseError::Unsuitable:
594 return "Unsuitable";
595 }
Saleem Abdulrasoolfbfbaf62014-06-12 19:33:26 +0000596 llvm_unreachable("unexpected parse error");
Rafael Espindolad0136702014-06-12 02:50:04 +0000597}
598
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000599static FormatStyle expandPresets(const FormatStyle &Style) {
Daniel Jasper55bbe662015-10-07 04:06:10 +0000600 if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
601 return Style;
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000602 FormatStyle Expanded = Style;
Manuel Klimek89628f62017-09-20 09:51:03 +0000603 Expanded.BraceWrapping = {false, false, false, false, false,
604 false, false, false, false, false,
605 false, false, true, true, true};
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000606 switch (Style.BreakBeforeBraces) {
607 case FormatStyle::BS_Linux:
608 Expanded.BraceWrapping.AfterClass = true;
609 Expanded.BraceWrapping.AfterFunction = true;
610 Expanded.BraceWrapping.AfterNamespace = true;
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000611 break;
612 case FormatStyle::BS_Mozilla:
613 Expanded.BraceWrapping.AfterClass = true;
614 Expanded.BraceWrapping.AfterEnum = true;
615 Expanded.BraceWrapping.AfterFunction = true;
616 Expanded.BraceWrapping.AfterStruct = true;
617 Expanded.BraceWrapping.AfterUnion = true;
Krasimir Georgievd6ce9372017-09-15 11:23:50 +0000618 Expanded.BraceWrapping.AfterExternBlock = true;
Sylvestre Ledru82c9a0e2017-09-13 20:03:29 +0000619 Expanded.BraceWrapping.SplitEmptyFunction = true;
Francois Ferrandad722562017-06-30 20:25:55 +0000620 Expanded.BraceWrapping.SplitEmptyRecord = false;
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000621 break;
622 case FormatStyle::BS_Stroustrup:
623 Expanded.BraceWrapping.AfterFunction = true;
624 Expanded.BraceWrapping.BeforeCatch = true;
625 Expanded.BraceWrapping.BeforeElse = true;
626 break;
627 case FormatStyle::BS_Allman:
628 Expanded.BraceWrapping.AfterClass = true;
629 Expanded.BraceWrapping.AfterControlStatement = true;
630 Expanded.BraceWrapping.AfterEnum = true;
631 Expanded.BraceWrapping.AfterFunction = true;
632 Expanded.BraceWrapping.AfterNamespace = true;
633 Expanded.BraceWrapping.AfterObjCDeclaration = true;
634 Expanded.BraceWrapping.AfterStruct = true;
Krasimir Georgievd6ce9372017-09-15 11:23:50 +0000635 Expanded.BraceWrapping.AfterExternBlock = true;
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000636 Expanded.BraceWrapping.BeforeCatch = true;
637 Expanded.BraceWrapping.BeforeElse = true;
638 break;
639 case FormatStyle::BS_GNU:
Manuel Klimek89628f62017-09-20 09:51:03 +0000640 Expanded.BraceWrapping = {true, true, true, true, true, true, true, true,
641 true, true, true, true, true, true, true};
Daniel Jasperc1bc38e2015-09-29 14:57:55 +0000642 break;
643 case FormatStyle::BS_WebKit:
644 Expanded.BraceWrapping.AfterFunction = true;
645 break;
646 default:
647 break;
648 }
649 return Expanded;
650}
651
Jordan Rupprecht8bd97e72019-02-28 19:16:45 +0000652FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
Daniel Jasperf7935112012-12-03 18:12:45 +0000653 FormatStyle LLVMStyle;
Jordan Rupprecht8bd97e72019-02-28 19:16:45 +0000654 LLVMStyle.Language = Language;
Daniel Jasperf7935112012-12-03 18:12:45 +0000655 LLVMStyle.AccessModifierOffset = -2;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000656 LLVMStyle.AlignEscapedNewlines = FormatStyle::ENAS_Right;
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000657 LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
Daniel Jasper3219e432014-12-02 13:24:51 +0000658 LLVMStyle.AlignOperands = true;
Daniel Jasper552f4a72013-07-31 23:55:15 +0000659 LLVMStyle.AlignTrailingComments = true;
Daniel Jaspera44991332015-04-29 13:06:49 +0000660 LLVMStyle.AlignConsecutiveAssignments = false;
Daniel Jaspere12597c2015-10-01 10:06:54 +0000661 LLVMStyle.AlignConsecutiveDeclarations = false;
Paul Hoadc6deae42019-03-23 14:37:58 +0000662 LLVMStyle.AllowAllArgumentsOnNextLine = true;
663 LLVMStyle.AllowAllConstructorInitializersOnNextLine = true;
Daniel Jasperf7db4332013-01-29 16:03:49 +0000664 LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
Daniel Jasperd74cf402014-04-08 12:46:38 +0000665 LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jasper17605d32014-05-14 09:33:35 +0000666 LLVMStyle.AllowShortBlocksOnASingleLine = false;
Daniel Jasperb87899b2014-09-10 13:11:45 +0000667 LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
Paul Hoad15000a12019-03-13 08:26:39 +0000668 LLVMStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
Ronald Wamplera83e2db2019-03-26 20:18:14 +0000669 LLVMStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
Daniel Jasper3a685df2013-05-16 12:12:21 +0000670 LLVMStyle.AllowShortLoopsOnASingleLine = false;
Zachary Turner448592e2015-12-18 22:20:15 +0000671 LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +0000672 LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
Alexander Kornienko58611712013-07-04 12:02:44 +0000673 LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000674 LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
Daniel Jasper18210d72014-10-09 09:52:05 +0000675 LLVMStyle.BinPackArguments = true;
Francois Ferrande56a8292017-06-14 12:29:47 +0000676 LLVMStyle.BinPackParameters = true;
Daniel Jasperac043c92014-09-15 11:11:00 +0000677 LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
Daniel Jasper165b29e2013-11-08 00:57:11 +0000678 LLVMStyle.BreakBeforeTernaryOperators = true;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000679 LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
Manuel Klimek89628f62017-09-20 09:51:03 +0000680 LLVMStyle.BraceWrapping = {false, false, false, false, false,
681 false, false, false, false, false,
682 false, false, true, true, true};
Nico Weber2cd92f12015-10-15 16:03:01 +0000683 LLVMStyle.BreakAfterJavaFieldAnnotations = false;
Francois Ferranda6b6d512017-05-24 11:36:58 +0000684 LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000685 LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
Daniel Jaspere1a7b762016-02-01 11:21:02 +0000686 LLVMStyle.BreakStringLiterals = true;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000687 LLVMStyle.ColumnLimit = 80;
Daniel Jaspere1e43192014-04-01 12:55:11 +0000688 LLVMStyle.CommentPragmas = "^ IWYU pragma:";
Francois Ferrande56a8292017-06-14 12:29:47 +0000689 LLVMStyle.CompactNamespaces = false;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000690 LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
Daniel Jaspercdaffa42013-08-13 10:58:30 +0000691 LLVMStyle.ConstructorInitializerIndentWidth = 4;
Daniel Jaspere1e43192014-04-01 12:55:11 +0000692 LLVMStyle.ContinuationIndentWidth = 4;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000693 LLVMStyle.Cpp11BracedListStyle = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000694 LLVMStyle.DerivePointerAlignment = false;
Daniel Jasperb10cbc42013-07-10 14:02:49 +0000695 LLVMStyle.ExperimentalAutoDetectBinPacking = false;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000696 LLVMStyle.FixNamespaceComments = true;
Daniel Jaspere1e43192014-04-01 12:55:11 +0000697 LLVMStyle.ForEachMacros.push_back("foreach");
698 LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
699 LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
Eric Liu9d92c022018-05-14 19:51:33 +0000700 LLVMStyle.IncludeStyle.IncludeCategories = {
701 {"^\"(llvm|llvm-c|clang|clang-c)/", 2},
702 {"^(<|\"(gtest|gmock|isl|json)/)", 3},
703 {".*", 1}};
704 LLVMStyle.IncludeStyle.IncludeIsMainRegex = "(Test)?$";
705 LLVMStyle.IncludeStyle.IncludeBlocks = tooling::IncludeStyle::IBS_Preserve;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000706 LLVMStyle.IndentCaseLabels = false;
Krasimir Georgievad47c902017-08-30 14:34:57 +0000707 LLVMStyle.IndentPPDirectives = FormatStyle::PPDIS_None;
Daniel Jasperc75e1ef2014-07-09 08:42:42 +0000708 LLVMStyle.IndentWrappedFunctionNames = false;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000709 LLVMStyle.IndentWidth = 2;
Martin Probstfb2342d2016-06-13 17:50:10 +0000710 LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
711 LLVMStyle.JavaScriptWrapImports = true;
Alexander Kornienkoebb43ca2013-09-05 14:08:34 +0000712 LLVMStyle.TabWidth = 8;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000713 LLVMStyle.MaxEmptyLinesToKeep = 1;
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000714 LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
Daniel Jasper65ee3472013-07-31 23:16:02 +0000715 LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
Ben Hamilton4dc658c2018-02-02 20:15:14 +0000716 LLVMStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
Daniel Jasper50d634b2014-10-28 16:53:38 +0000717 LLVMStyle.ObjCBlockIndentWidth = 2;
Daniel Jaspere9beea22014-01-28 15:20:33 +0000718 LLVMStyle.ObjCSpaceAfterProperty = false;
Nico Webera6087752013-01-10 20:12:55 +0000719 LLVMStyle.ObjCSpaceBeforeProtocolList = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000720 LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000721 LLVMStyle.SpacesBeforeTrailingComments = 1;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000722 LLVMStyle.Standard = FormatStyle::LS_Cpp11;
Alexander Kornienko3c3d09c2013-09-27 16:14:22 +0000723 LLVMStyle.UseTab = FormatStyle::UT_Never;
Daniel Jaspera0a50392015-12-01 13:28:53 +0000724 LLVMStyle.ReflowComments = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +0000725 LLVMStyle.SpacesInParentheses = false;
Daniel Jasperad981f82014-08-26 11:41:14 +0000726 LLVMStyle.SpacesInSquareBrackets = false;
Daniel Jasperb55acad2013-08-20 12:36:34 +0000727 LLVMStyle.SpaceInEmptyParentheses = false;
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000728 LLVMStyle.SpacesInContainerLiterals = true;
Daniel Jasperb55acad2013-08-20 12:36:34 +0000729 LLVMStyle.SpacesInCStyleCastParentheses = false;
Daniel Jasperdb986eb2014-09-03 07:37:29 +0000730 LLVMStyle.SpaceAfterCStyleCast = false;
Sylvestre Ledru83bbd572016-08-09 14:24:40 +0000731 LLVMStyle.SpaceAfterTemplateKeyword = true;
Francois Ferrand2a9ea782018-03-01 10:09:13 +0000732 LLVMStyle.SpaceBeforeCtorInitializerColon = true;
733 LLVMStyle.SpaceBeforeInheritanceColon = true;
Alexander Kornienkofdca83d2013-12-10 10:18:34 +0000734 LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
Francois Ferrand2a9ea782018-03-01 10:09:13 +0000735 LLVMStyle.SpaceBeforeRangeBasedForLoopColon = true;
Daniel Jasperd94bff32013-09-25 15:15:02 +0000736 LLVMStyle.SpaceBeforeAssignmentOperators = true;
Hans Wennborgbfc34062018-06-14 08:01:09 +0000737 LLVMStyle.SpaceBeforeCpp11BracedList = false;
Daniel Jasperdd978ae2013-10-29 14:52:02 +0000738 LLVMStyle.SpacesInAngles = false;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000739
Francois Ferrand9976efa2017-05-22 08:28:17 +0000740 LLVMStyle.PenaltyBreakAssignment = prec::Assignment;
Daniel Jasper19a541e2013-12-19 16:45:34 +0000741 LLVMStyle.PenaltyBreakComment = 300;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000742 LLVMStyle.PenaltyBreakFirstLessLess = 120;
743 LLVMStyle.PenaltyBreakString = 1000;
744 LLVMStyle.PenaltyExcessCharacter = 1000000;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000745 LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
Daniel Jasper33b909c2013-10-25 14:29:37 +0000746 LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000747 LLVMStyle.PenaltyBreakTemplateDeclaration = prec::Relational;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000748
Daniel Jasperc64b09a2014-05-22 15:12:22 +0000749 LLVMStyle.DisableFormat = false;
Daniel Jasperda446772015-11-16 12:38:56 +0000750 LLVMStyle.SortIncludes = true;
Krasimir Georgievac16a202017-06-23 11:46:03 +0000751 LLVMStyle.SortUsingDeclarations = true;
Francois Ferrand6f40e212018-10-02 16:37:51 +0000752 LLVMStyle.StatementMacros.push_back("Q_UNUSED");
753 LLVMStyle.StatementMacros.push_back("QT_REQUIRE_VERSION");
Daniel Jasperc64b09a2014-05-22 15:12:22 +0000754
Jordan Rupprecht7f514162019-03-01 00:12:18 +0000755 // Defaults that differ when not C++.
756 if (Language == FormatStyle::LK_TableGen) {
757 LLVMStyle.SpacesInContainerLiterals = false;
758 }
759
Daniel Jasperf7935112012-12-03 18:12:45 +0000760 return LLVMStyle;
761}
762
Nico Weber514ecc82014-02-02 20:50:45 +0000763FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
Krasimir Georgiev26b144c2017-07-03 15:05:14 +0000764 if (Language == FormatStyle::LK_TextProto) {
765 FormatStyle GoogleStyle = getGoogleStyle(FormatStyle::LK_Proto);
766 GoogleStyle.Language = FormatStyle::LK_TextProto;
Krasimir Georgieveda222e2018-01-24 11:18:39 +0000767
Krasimir Georgiev26b144c2017-07-03 15:05:14 +0000768 return GoogleStyle;
769 }
770
Jordan Rupprecht8bd97e72019-02-28 19:16:45 +0000771 FormatStyle GoogleStyle = getLLVMStyle(Language);
Nico Weber514ecc82014-02-02 20:50:45 +0000772
Daniel Jasperf7935112012-12-03 18:12:45 +0000773 GoogleStyle.AccessModifierOffset = -1;
Daniel Jasper7fdbb3f2017-05-08 15:08:00 +0000774 GoogleStyle.AlignEscapedNewlines = FormatStyle::ENAS_Left;
Paul Hoad15000a12019-03-13 08:26:39 +0000775 GoogleStyle.AllowShortIfStatementsOnASingleLine =
776 FormatStyle::SIS_WithoutElse;
Daniel Jasper5bd0b9e2013-05-23 18:05:18 +0000777 GoogleStyle.AllowShortLoopsOnASingleLine = true;
Alexander Kornienko58611712013-07-04 12:02:44 +0000778 GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000779 GoogleStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000780 GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000781 GoogleStyle.DerivePointerAlignment = true;
Eric Liu9d92c022018-05-14 19:51:33 +0000782 GoogleStyle.IncludeStyle.IncludeCategories = {
Krasimir Georgieva84e7872017-09-26 14:58:29 +0000783 {"^<ext/.*\\.h>", 2}, {"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
Eric Liu9d92c022018-05-14 19:51:33 +0000784 GoogleStyle.IncludeStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000785 GoogleStyle.IndentCaseLabels = true;
Daniel Jaspera26fc5c2014-03-21 13:43:14 +0000786 GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
Ben Hamilton3a47fdd2018-02-08 01:49:10 +0000787 GoogleStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Never;
Daniel Jaspere9beea22014-01-28 15:20:33 +0000788 GoogleStyle.ObjCSpaceAfterProperty = false;
Ben Hamiltonf84f1182018-01-18 18:37:16 +0000789 GoogleStyle.ObjCSpaceBeforeProtocolList = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000790 GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
Krasimir Georgiev5559cc32018-04-25 14:56:19 +0000791 GoogleStyle.RawStringFormats = {
Krasimir Georgiev4527f132018-01-17 12:24:59 +0000792 {
Krasimir Georgiev5559cc32018-04-25 14:56:19 +0000793 FormatStyle::LK_Cpp,
794 /*Delimiters=*/
795 {
796 "cc",
797 "CC",
798 "cpp",
799 "Cpp",
800 "CPP",
801 "c++",
802 "C++",
803 },
804 /*EnclosingFunctionNames=*/
805 {},
806 /*CanonicalDelimiter=*/"",
807 /*BasedOnStyle=*/"google",
Krasimir Georgiev4527f132018-01-17 12:24:59 +0000808 },
Krasimir Georgiev5559cc32018-04-25 14:56:19 +0000809 {
810 FormatStyle::LK_TextProto,
811 /*Delimiters=*/
812 {
813 "pb",
814 "PB",
815 "proto",
816 "PROTO",
817 },
818 /*EnclosingFunctionNames=*/
Krasimir Georgiev42948e32018-06-26 12:00:14 +0000819 {
Krasimir Georgiev42948e32018-06-26 12:00:14 +0000820 "EqualsProto",
Krasimir Georgiev61f46f22018-06-29 14:25:25 +0000821 "EquivToProto",
Krasimir Georgievce0b8d62018-08-01 12:35:23 +0000822 "PARSE_PARTIAL_TEXT_PROTO",
Krasimir Georgiev61f46f22018-06-29 14:25:25 +0000823 "PARSE_TEST_PROTO",
824 "PARSE_TEXT_PROTO",
825 "ParseTextOrDie",
Krasimir Georgievce0b8d62018-08-01 12:35:23 +0000826 "ParseTextProtoOrDie",
Krasimir Georgiev42948e32018-06-26 12:00:14 +0000827 },
Krasimir Georgiev5559cc32018-04-25 14:56:19 +0000828 /*CanonicalDelimiter=*/"",
829 /*BasedOnStyle=*/"google",
830 },
831 };
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000832 GoogleStyle.SpacesBeforeTrailingComments = 2;
833 GoogleStyle.Standard = FormatStyle::LS_Auto;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000834
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000835 GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
Daniel Jasper33b909c2013-10-25 14:29:37 +0000836 GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
Daniel Jasper4e9678f2013-07-11 20:41:21 +0000837
Daniel Jasperc58c70e2014-09-15 11:21:46 +0000838 if (Language == FormatStyle::LK_Java) {
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000839 GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +0000840 GoogleStyle.AlignOperands = false;
Daniel Jasperfd4ed182015-01-04 20:40:45 +0000841 GoogleStyle.AlignTrailingComments = false;
Daniel Jasper9e709352014-11-26 10:43:58 +0000842 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
Paul Hoad15000a12019-03-13 08:26:39 +0000843 GoogleStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
Daniel Jasper1cd3c712015-01-14 12:24:59 +0000844 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
Daniel Jasperc58c70e2014-09-15 11:21:46 +0000845 GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
846 GoogleStyle.ColumnLimit = 100;
847 GoogleStyle.SpaceAfterCStyleCast = true;
Daniel Jasper61d81972014-11-14 08:22:46 +0000848 GoogleStyle.SpacesBeforeTrailingComments = 1;
Daniel Jasperc58c70e2014-09-15 11:21:46 +0000849 } else if (Language == FormatStyle::LK_JavaScript) {
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000850 GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000851 GoogleStyle.AlignOperands = false;
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000852 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000853 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
Daniel Jaspere551bb72014-11-05 17:22:31 +0000854 GoogleStyle.BreakBeforeTernaryOperators = false;
Krasimir Georgiev6a5c95b2018-07-30 08:45:45 +0000855 // taze:, triple slash directives (`/// <...`), @see, which is commonly
856 // followed by overlong URLs.
857 GoogleStyle.CommentPragmas = "(taze:|^/[ \t]*<|@see)";
Daniel Jasper8f83a902014-05-09 10:28:58 +0000858 GoogleStyle.MaxEmptyLinesToKeep = 3;
Martin Probstece8c0c2016-06-13 16:41:28 +0000859 GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
Nico Weber514ecc82014-02-02 20:50:45 +0000860 GoogleStyle.SpacesInContainerLiterals = false;
Daniel Jasperabd1f572016-03-02 22:44:03 +0000861 GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
Martin Probst0cd74ee2016-06-13 16:39:50 +0000862 GoogleStyle.JavaScriptWrapImports = false;
Nico Weber514ecc82014-02-02 20:50:45 +0000863 } else if (Language == FormatStyle::LK_Proto) {
Daniel Jasper67e65212018-08-15 19:07:55 +0000864 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
Daniel Jasper9c95dfe2018-03-12 10:32:18 +0000865 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
Daniel Jasper783bac62014-04-15 09:54:30 +0000866 GoogleStyle.SpacesInContainerLiterals = false;
Krasimir Georgievc2091802018-01-31 10:14:10 +0000867 GoogleStyle.Cpp11BracedListStyle = false;
Krasimir Georgiev374e6de2018-02-08 10:47:12 +0000868 // This affects protocol buffer options specifications and text protos.
869 // Text protos are currently mostly formatted inside C++ raw string literals
870 // and often the current breaking behavior of string literals is not
871 // beneficial there. Investigate turning this on once proper string reflow
872 // has been implemented.
873 GoogleStyle.BreakStringLiterals = false;
Daniel Jasper03a04fe2016-12-12 12:42:29 +0000874 } else if (Language == FormatStyle::LK_ObjC) {
Ben Hamilton1ab722e2018-06-14 17:30:10 +0000875 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
Daniel Jasper03a04fe2016-12-12 12:42:29 +0000876 GoogleStyle.ColumnLimit = 100;
Nico Weber514ecc82014-02-02 20:50:45 +0000877 }
878
Daniel Jasperf7935112012-12-03 18:12:45 +0000879 return GoogleStyle;
880}
881
Nico Weber514ecc82014-02-02 20:50:45 +0000882FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
883 FormatStyle ChromiumStyle = getGoogleStyle(Language);
Nico Weber450425c2014-11-26 16:43:18 +0000884 if (Language == FormatStyle::LK_Java) {
Paul Hoad15000a12019-03-13 08:26:39 +0000885 ChromiumStyle.AllowShortIfStatementsOnASingleLine =
886 FormatStyle::SIS_WithoutElse;
Nico Weber2cd92f12015-10-15 16:03:01 +0000887 ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
Nico Weber450425c2014-11-26 16:43:18 +0000888 ChromiumStyle.ContinuationIndentWidth = 8;
Nico Weber2cd92f12015-10-15 16:03:01 +0000889 ChromiumStyle.IndentWidth = 4;
Krasimir Georgiev7e91b032018-10-05 17:19:26 +0000890 // See styleguide for import groups:
891 // https://chromium.googlesource.com/chromium/src/+/master/styleguide/java/java.md#Import-Order
892 ChromiumStyle.JavaImportGroups = {
Paul Hoad5bcf99b2019-03-01 09:09:54 +0000893 "android", "com", "dalvik",
894 "junit", "org", "com.google.android.apps.chrome",
895 "org.chromium", "java", "javax",
Krasimir Georgiev7e91b032018-10-05 17:19:26 +0000896 };
897 ChromiumStyle.SortIncludes = true;
Nico Weberea649692017-01-04 02:33:36 +0000898 } else if (Language == FormatStyle::LK_JavaScript) {
Paul Hoad15000a12019-03-13 08:26:39 +0000899 ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
Nico Weberea649692017-01-04 02:33:36 +0000900 ChromiumStyle.AllowShortLoopsOnASingleLine = false;
Nico Weber450425c2014-11-26 16:43:18 +0000901 } else {
902 ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
903 ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Paul Hoad15000a12019-03-13 08:26:39 +0000904 ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
Nico Weber450425c2014-11-26 16:43:18 +0000905 ChromiumStyle.AllowShortLoopsOnASingleLine = false;
906 ChromiumStyle.BinPackParameters = false;
907 ChromiumStyle.DerivePointerAlignment = false;
Nico Weber9e2bc302017-01-31 18:42:05 +0000908 if (Language == FormatStyle::LK_ObjC)
909 ChromiumStyle.ColumnLimit = 80;
Nico Weber450425c2014-11-26 16:43:18 +0000910 }
Daniel Jasper1b750ed2013-01-14 16:24:39 +0000911 return ChromiumStyle;
912}
913
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000914FormatStyle getMozillaStyle() {
915 FormatStyle MozillaStyle = getLLVMStyle();
916 MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
Birunthan Mohanathasa0810022015-06-29 15:18:58 +0000917 MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Manuel Klimek89628f62017-09-20 09:51:03 +0000918 MozillaStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +0000919 MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
920 FormatStyle::DRTBS_TopLevel;
Francois Ferrand58e6fe52018-05-16 08:25:03 +0000921 MozillaStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
Sylvestre Ledrudcb038d2016-12-14 16:09:29 +0000922 MozillaStyle.BinPackParameters = false;
923 MozillaStyle.BinPackArguments = false;
Birunthan Mohanathas305fa9c2015-07-12 03:13:54 +0000924 MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
Francois Ferranda6b6d512017-05-24 11:36:58 +0000925 MozillaStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
Francois Ferrand6bb103f2018-06-11 14:41:26 +0000926 MozillaStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
Birunthan Mohanathasa0810022015-06-29 15:18:58 +0000927 MozillaStyle.ConstructorInitializerIndentWidth = 2;
928 MozillaStyle.ContinuationIndentWidth = 2;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000929 MozillaStyle.Cpp11BracedListStyle = false;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000930 MozillaStyle.FixNamespaceComments = false;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000931 MozillaStyle.IndentCaseLabels = true;
Daniel Jaspere9beea22014-01-28 15:20:33 +0000932 MozillaStyle.ObjCSpaceAfterProperty = true;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000933 MozillaStyle.ObjCSpaceBeforeProtocolList = false;
934 MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
Daniel Jasper553d4872014-06-17 12:40:34 +0000935 MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
Sylvestre Ledru83bbd572016-08-09 14:24:40 +0000936 MozillaStyle.SpaceAfterTemplateKeyword = false;
Alexander Kornienkoc8602662013-05-06 14:11:27 +0000937 return MozillaStyle;
938}
939
Daniel Jasperffefb3d2013-07-24 13:10:59 +0000940FormatStyle getWebKitStyle() {
941 FormatStyle Style = getLLVMStyle();
Daniel Jasper65ee3472013-07-31 23:16:02 +0000942 Style.AccessModifierOffset = -4;
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000943 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
Daniel Jasper3219e432014-12-02 13:24:51 +0000944 Style.AlignOperands = false;
Daniel Jasper552f4a72013-07-31 23:55:15 +0000945 Style.AlignTrailingComments = false;
Daniel Jasperac043c92014-09-15 11:11:00 +0000946 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Roman Kashitsyn291f64f2015-08-10 13:43:19 +0000947 Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
Francois Ferranda6b6d512017-05-24 11:36:58 +0000948 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000949 Style.Cpp11BracedListStyle = false;
Daniel Jasper65ee3472013-07-31 23:16:02 +0000950 Style.ColumnLimit = 0;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000951 Style.FixNamespaceComments = false;
Daniel Jaspere33d4af2013-07-26 16:56:36 +0000952 Style.IndentWidth = 4;
Daniel Jasper65ee3472013-07-31 23:16:02 +0000953 Style.NamespaceIndentation = FormatStyle::NI_Inner;
Daniel Jasper50d634b2014-10-28 16:53:38 +0000954 Style.ObjCBlockIndentWidth = 4;
Daniel Jaspere9beea22014-01-28 15:20:33 +0000955 Style.ObjCSpaceAfterProperty = true;
Daniel Jasper553d4872014-06-17 12:40:34 +0000956 Style.PointerAlignment = FormatStyle::PAS_Left;
Hans Wennborgbfc34062018-06-14 08:01:09 +0000957 Style.SpaceBeforeCpp11BracedList = true;
Daniel Jasperffefb3d2013-07-24 13:10:59 +0000958 return Style;
959}
960
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000961FormatStyle getGNUStyle() {
962 FormatStyle Style = getLLVMStyle();
Birunthan Mohanathasa0388a82015-06-29 15:30:42 +0000963 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
Zachary Turner448592e2015-12-18 22:20:15 +0000964 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
Daniel Jasperac043c92014-09-15 11:11:00 +0000965 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
Alexander Kornienko3a33f022013-12-12 09:49:52 +0000966 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000967 Style.BreakBeforeTernaryOperators = true;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000968 Style.Cpp11BracedListStyle = false;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000969 Style.ColumnLimit = 79;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +0000970 Style.FixNamespaceComments = false;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000971 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
Chandler Carruthf8b72662014-03-02 12:37:31 +0000972 Style.Standard = FormatStyle::LS_Cpp03;
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +0000973 return Style;
974}
975
Paul Hoadcbb726d2019-03-21 13:09:22 +0000976FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language) {
977 FormatStyle Style = getLLVMStyle();
978 Style.ColumnLimit = 120;
979 Style.TabWidth = 4;
980 Style.IndentWidth = 4;
981 Style.UseTab = FormatStyle::UT_Never;
982 Style.BreakBeforeBraces = FormatStyle::BS_Custom;
983 Style.BraceWrapping.AfterClass = true;
984 Style.BraceWrapping.AfterControlStatement = true;
985 Style.BraceWrapping.AfterEnum = true;
986 Style.BraceWrapping.AfterFunction = true;
987 Style.BraceWrapping.AfterNamespace = true;
988 Style.BraceWrapping.AfterObjCDeclaration = true;
989 Style.BraceWrapping.AfterStruct = true;
990 Style.BraceWrapping.AfterExternBlock = true;
991 Style.BraceWrapping.BeforeCatch = true;
992 Style.BraceWrapping.BeforeElse = true;
993 Style.PenaltyReturnTypeOnItsOwnLine = 1000;
994 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
995 Style.AllowShortBlocksOnASingleLine = false;
996 Style.AllowShortCaseLabelsOnASingleLine = false;
997 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
998 Style.AllowShortLoopsOnASingleLine = false;
999 return Style;
1000}
1001
Daniel Jasperc64b09a2014-05-22 15:12:22 +00001002FormatStyle getNoStyle() {
1003 FormatStyle NoStyle = getLLVMStyle();
1004 NoStyle.DisableFormat = true;
Daniel Jasperda446772015-11-16 12:38:56 +00001005 NoStyle.SortIncludes = false;
Krasimir Georgievac16a202017-06-23 11:46:03 +00001006 NoStyle.SortUsingDeclarations = false;
Daniel Jasperc64b09a2014-05-22 15:12:22 +00001007 return NoStyle;
1008}
1009
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001010bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
1011 FormatStyle *Style) {
1012 if (Name.equals_lower("llvm")) {
Jordan Rupprecht55881d52019-03-13 21:13:01 +00001013 *Style = getLLVMStyle(Language);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001014 } else if (Name.equals_lower("chromium")) {
Nico Weber514ecc82014-02-02 20:50:45 +00001015 *Style = getChromiumStyle(Language);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001016 } else if (Name.equals_lower("mozilla")) {
Alexander Kornienko006b5c82013-05-19 00:53:30 +00001017 *Style = getMozillaStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001018 } else if (Name.equals_lower("google")) {
Nico Weber514ecc82014-02-02 20:50:45 +00001019 *Style = getGoogleStyle(Language);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001020 } else if (Name.equals_lower("webkit")) {
Daniel Jasperffefb3d2013-07-24 13:10:59 +00001021 *Style = getWebKitStyle();
Alexander Kornienkofe7a57f2013-12-10 15:42:15 +00001022 } else if (Name.equals_lower("gnu")) {
1023 *Style = getGNUStyle();
Paul Hoadcbb726d2019-03-21 13:09:22 +00001024 } else if (Name.equals_lower("microsoft")) {
1025 *Style = getMicrosoftStyle(Language);
Daniel Jasperc64b09a2014-05-22 15:12:22 +00001026 } else if (Name.equals_lower("none")) {
1027 *Style = getNoStyle();
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001028 } else {
Alexander Kornienko006b5c82013-05-19 00:53:30 +00001029 return false;
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001030 }
Alexander Kornienkod6538332013-05-07 15:32:14 +00001031
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001032 Style->Language = Language;
Alexander Kornienko006b5c82013-05-19 00:53:30 +00001033 return true;
Alexander Kornienkod6538332013-05-07 15:32:14 +00001034}
1035
Rafael Espindolac0809172014-06-12 14:02:15 +00001036std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +00001037 assert(Style);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001038 FormatStyle::LanguageKind Language = Style->Language;
1039 assert(Language != FormatStyle::LK_None);
Alexander Kornienko06e00332013-05-20 15:18:01 +00001040 if (Text.trim().empty())
Rafael Espindolad0136702014-06-12 02:50:04 +00001041 return make_error_code(ParseError::Error);
Krasimir Georgiev54076fe2018-01-15 12:06:16 +00001042 Style->StyleSet.Clear();
Alexander Kornienkocabdd732013-11-29 15:19:43 +00001043 std::vector<FormatStyle> Styles;
Alexander Kornienkod6538332013-05-07 15:32:14 +00001044 llvm::yaml::Input Input(Text);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001045 // DocumentListTraits<vector<FormatStyle>> uses the context to get default
1046 // values for the fields, keys for which are missing from the configuration.
1047 // Mapping also uses the context to get the language to find the correct
1048 // base style.
1049 Input.setContext(Style);
Alexander Kornienkocabdd732013-11-29 15:19:43 +00001050 Input >> Styles;
1051 if (Input.error())
1052 return Input.error();
1053
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001054 for (unsigned i = 0; i < Styles.size(); ++i) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +00001055 // Ensures that only the first configuration can skip the Language option.
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001056 if (Styles[i].Language == FormatStyle::LK_None && i != 0)
Rafael Espindolad0136702014-06-12 02:50:04 +00001057 return make_error_code(ParseError::Error);
Alexander Kornienkocabdd732013-11-29 15:19:43 +00001058 // Ensure that each language is configured at most once.
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001059 for (unsigned j = 0; j < i; ++j) {
1060 if (Styles[i].Language == Styles[j].Language) {
Nicola Zaghen3538b392018-05-15 13:30:56 +00001061 LLVM_DEBUG(llvm::dbgs()
1062 << "Duplicate languages in the config file on positions "
1063 << j << " and " << i << "\n");
Rafael Espindolad0136702014-06-12 02:50:04 +00001064 return make_error_code(ParseError::Error);
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001065 }
Alexander Kornienkocabdd732013-11-29 15:19:43 +00001066 }
1067 }
1068 // Look for a suitable configuration starting from the end, so we can
1069 // find the configuration for the specific language first, and the default
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001070 // configuration (which can only be at slot 0) after it.
Krasimir Georgiev54076fe2018-01-15 12:06:16 +00001071 FormatStyle::FormatStyleSet StyleSet;
1072 bool LanguageFound = false;
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00001073 for (int i = Styles.size() - 1; i >= 0; --i) {
Krasimir Georgiev54076fe2018-01-15 12:06:16 +00001074 if (Styles[i].Language != FormatStyle::LK_None)
1075 StyleSet.Add(Styles[i]);
1076 if (Styles[i].Language == Language)
1077 LanguageFound = true;
Alexander Kornienkocabdd732013-11-29 15:19:43 +00001078 }
Krasimir Georgiev54076fe2018-01-15 12:06:16 +00001079 if (!LanguageFound) {
1080 if (Styles.empty() || Styles[0].Language != FormatStyle::LK_None)
1081 return make_error_code(ParseError::Unsuitable);
1082 FormatStyle DefaultStyle = Styles[0];
1083 DefaultStyle.Language = Language;
1084 StyleSet.Add(std::move(DefaultStyle));
1085 }
1086 *Style = *StyleSet.Get(Language);
1087 return make_error_code(ParseError::Success);
Alexander Kornienkod6538332013-05-07 15:32:14 +00001088}
1089
1090std::string configurationAsText(const FormatStyle &Style) {
1091 std::string Text;
1092 llvm::raw_string_ostream Stream(Text);
1093 llvm::yaml::Output Output(Stream);
1094 // We use the same mapping method for input and output, so we need a non-const
1095 // reference here.
Daniel Jasperc1bc38e2015-09-29 14:57:55 +00001096 FormatStyle NonConstStyle = expandPresets(Style);
Alexander Kornienkod6538332013-05-07 15:32:14 +00001097 Output << NonConstStyle;
Alexander Kornienko9a38ec22013-05-13 12:56:35 +00001098 return Stream.str();
Alexander Kornienkod6538332013-05-07 15:32:14 +00001099}
1100
Krasimir Georgiev54076fe2018-01-15 12:06:16 +00001101llvm::Optional<FormatStyle>
1102FormatStyle::FormatStyleSet::Get(FormatStyle::LanguageKind Language) const {
1103 if (!Styles)
1104 return None;
1105 auto It = Styles->find(Language);
1106 if (It == Styles->end())
1107 return None;
1108 FormatStyle Style = It->second;
1109 Style.StyleSet = *this;
1110 return Style;
1111}
1112
1113void FormatStyle::FormatStyleSet::Add(FormatStyle Style) {
1114 assert(Style.Language != LK_None &&
1115 "Cannot add a style for LK_None to a StyleSet");
1116 assert(
1117 !Style.StyleSet.Styles &&
1118 "Cannot add a style associated with an existing StyleSet to a StyleSet");
1119 if (!Styles)
1120 Styles = std::make_shared<MapType>();
1121 (*Styles)[Style.Language] = std::move(Style);
1122}
1123
Paul Hoad5bcf99b2019-03-01 09:09:54 +00001124void FormatStyle::FormatStyleSet::Clear() { Styles.reset(); }
Krasimir Georgiev54076fe2018-01-15 12:06:16 +00001125
1126llvm::Optional<FormatStyle>
1127FormatStyle::GetLanguageStyle(FormatStyle::LanguageKind Language) const {
1128 return StyleSet.Get(Language);
1129}
1130
Craig Topperaf35e852013-06-30 22:29:28 +00001131namespace {
1132
Daniel Jasper496c1992016-09-07 22:48:53 +00001133class JavaScriptRequoter : public TokenAnalyzer {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001134public:
Daniel Jasper496c1992016-09-07 22:48:53 +00001135 JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
1136 : TokenAnalyzer(Env, Style) {}
Eric Liu4cfb88a2016-04-25 15:09:22 +00001137
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001138 std::pair<tooling::Replacements, unsigned>
Eric Liu4cfb88a2016-04-25 15:09:22 +00001139 analyze(TokenAnnotator &Annotator,
1140 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
Martin Probsta9855af2016-09-02 14:29:48 +00001141 FormatTokenLexer &Tokens) override {
Manuel Klimek0dddcf72018-04-23 09:34:26 +00001142 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
Daniel Jasper496c1992016-09-07 22:48:53 +00001143 tooling::Replacements Result;
1144 requoteJSStringLiteral(AnnotatedLines, Result);
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001145 return {Result, 0};
Alexander Kornienko62b85b92013-03-13 14:41:29 +00001146 }
1147
1148private:
Daniel Jasper496c1992016-09-07 22:48:53 +00001149 // Replaces double/single-quoted string literal as appropriate, re-escaping
1150 // the contents in the process.
Daniel Jasper97439922016-03-17 13:03:41 +00001151 void requoteJSStringLiteral(SmallVectorImpl<AnnotatedLine *> &Lines,
Eric Liu4cfb88a2016-04-25 15:09:22 +00001152 tooling::Replacements &Result) {
Daniel Jasper97439922016-03-17 13:03:41 +00001153 for (AnnotatedLine *Line : Lines) {
1154 requoteJSStringLiteral(Line->Children, Result);
1155 if (!Line->Affected)
1156 continue;
1157 for (FormatToken *FormatTok = Line->First; FormatTok;
1158 FormatTok = FormatTok->Next) {
1159 StringRef Input = FormatTok->TokenText;
Martin Probsta1669792016-05-12 11:20:32 +00001160 if (FormatTok->Finalized || !FormatTok->isStringLiteral() ||
Daniel Jasper97439922016-03-17 13:03:41 +00001161 // NB: testing for not starting with a double quote to avoid
Daniel Jasper496c1992016-09-07 22:48:53 +00001162 // breaking `template strings`.
Eric Liu635423e2016-04-28 07:52:03 +00001163 (Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
Daniel Jasper97439922016-03-17 13:03:41 +00001164 !Input.startswith("\"")) ||
Eric Liu635423e2016-04-28 07:52:03 +00001165 (Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
Daniel Jasper97439922016-03-17 13:03:41 +00001166 !Input.startswith("\'")))
1167 continue;
1168
1169 // Change start and end quote.
Eric Liu635423e2016-04-28 07:52:03 +00001170 bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
Daniel Jasper97439922016-03-17 13:03:41 +00001171 SourceLocation Start = FormatTok->Tok.getLocation();
1172 auto Replace = [&](SourceLocation Start, unsigned Length,
1173 StringRef ReplacementText) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001174 auto Err = Result.add(tooling::Replacement(
1175 Env.getSourceManager(), Start, Length, ReplacementText));
1176 // FIXME: handle error. For now, print error message and skip the
1177 // replacement for release version.
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001178 if (Err) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001179 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001180 assert(false);
1181 }
Daniel Jasper97439922016-03-17 13:03:41 +00001182 };
1183 Replace(Start, 1, IsSingle ? "'" : "\"");
1184 Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
1185 IsSingle ? "'" : "\"");
1186
1187 // Escape internal quotes.
Daniel Jasper97439922016-03-17 13:03:41 +00001188 bool Escaped = false;
1189 for (size_t i = 1; i < Input.size() - 1; i++) {
1190 switch (Input[i]) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001191 case '\\':
1192 if (!Escaped && i + 1 < Input.size() &&
1193 ((IsSingle && Input[i + 1] == '"') ||
1194 (!IsSingle && Input[i + 1] == '\''))) {
1195 // Remove this \, it's escaping a " or ' that no longer needs
1196 // escaping
Eric Liu4cfb88a2016-04-25 15:09:22 +00001197 Replace(Start.getLocWithOffset(i), 1, "");
1198 continue;
1199 }
1200 Escaped = !Escaped;
1201 break;
1202 case '\"':
1203 case '\'':
1204 if (!Escaped && IsSingle == (Input[i] == '\'')) {
1205 // Escape the quote.
1206 Replace(Start.getLocWithOffset(i), 0, "\\");
Eric Liu4cfb88a2016-04-25 15:09:22 +00001207 }
1208 Escaped = false;
1209 break;
1210 default:
1211 Escaped = false;
1212 break;
Daniel Jasper97439922016-03-17 13:03:41 +00001213 }
1214 }
Daniel Jasper97439922016-03-17 13:03:41 +00001215 }
1216 }
1217 }
Daniel Jasper496c1992016-09-07 22:48:53 +00001218};
1219
1220class Formatter : public TokenAnalyzer {
1221public:
1222 Formatter(const Environment &Env, const FormatStyle &Style,
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00001223 FormattingAttemptStatus *Status)
1224 : TokenAnalyzer(Env, Style), Status(Status) {}
Daniel Jasper496c1992016-09-07 22:48:53 +00001225
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001226 std::pair<tooling::Replacements, unsigned>
Daniel Jasper496c1992016-09-07 22:48:53 +00001227 analyze(TokenAnnotator &Annotator,
1228 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1229 FormatTokenLexer &Tokens) override {
1230 tooling::Replacements Result;
1231 deriveLocalStyle(AnnotatedLines);
Manuel Klimek0dddcf72018-04-23 09:34:26 +00001232 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
Daniel Jasper496c1992016-09-07 22:48:53 +00001233 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1234 Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
1235 }
1236 Annotator.setCommentLineLevels(AnnotatedLines);
1237
1238 WhitespaceManager Whitespaces(
1239 Env.getSourceManager(), Style,
1240 inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
1241 ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
1242 Env.getSourceManager(), Whitespaces, Encoding,
1243 BinPackInconclusiveFunctions);
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001244 unsigned Penalty =
1245 UnwrappedLineFormatter(&Indenter, &Whitespaces, Style,
1246 Tokens.getKeywords(), Env.getSourceManager(),
1247 Status)
1248 .format(AnnotatedLines, /*DryRun=*/false,
1249 /*AdditionalIndent=*/0,
1250 /*FixBadIndentation=*/false,
1251 /*FirstStartColumn=*/Env.getFirstStartColumn(),
1252 /*NextStartColumn=*/Env.getNextStartColumn(),
1253 /*LastStartColumn=*/Env.getLastStartColumn());
Daniel Jasper496c1992016-09-07 22:48:53 +00001254 for (const auto &R : Whitespaces.generateReplacements())
1255 if (Result.add(R))
Krasimir Georgieve56e9a42017-10-30 14:30:14 +00001256 return std::make_pair(Result, 0);
1257 return std::make_pair(Result, Penalty);
Daniel Jasper496c1992016-09-07 22:48:53 +00001258 }
1259
1260private:
Alexander Kornienko9e649af2013-09-11 12:25:57 +00001261 static bool inputUsesCRLF(StringRef Text) {
1262 return Text.count('\r') * 2 > Text.count('\n');
1263 }
1264
Daniel Jasper352f0df2015-07-18 16:35:30 +00001265 bool
1266 hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001267 for (const AnnotatedLine *Line : Lines) {
Daniel Jasper352f0df2015-07-18 16:35:30 +00001268 if (hasCpp03IncompatibleFormat(Line->Children))
1269 return true;
1270 for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
1271 if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
1272 if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
1273 return true;
1274 if (Tok->is(TT_TemplateCloser) &&
1275 Tok->Previous->is(TT_TemplateCloser))
1276 return true;
1277 }
1278 }
1279 }
1280 return false;
1281 }
1282
1283 int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
1284 int AlignmentDiff = 0;
Eric Liu4cfb88a2016-04-25 15:09:22 +00001285 for (const AnnotatedLine *Line : Lines) {
Daniel Jasper352f0df2015-07-18 16:35:30 +00001286 AlignmentDiff += countVariableAlignments(Line->Children);
1287 for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
1288 if (!Tok->is(TT_PointerOrReference))
1289 continue;
1290 bool SpaceBefore =
1291 Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
1292 bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
1293 Tok->Next->WhitespaceRange.getEnd();
1294 if (SpaceBefore && !SpaceAfter)
1295 ++AlignmentDiff;
1296 if (!SpaceBefore && SpaceAfter)
1297 --AlignmentDiff;
1298 }
1299 }
1300 return AlignmentDiff;
1301 }
1302
Manuel Klimek71814b42013-10-11 21:25:45 +00001303 void
1304 deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
Daniel Jasperb10cbc42013-07-10 14:02:49 +00001305 bool HasBinPackedFunction = false;
1306 bool HasOnePerLineFunction = false;
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001307 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001308 if (!AnnotatedLines[i]->First->Next)
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001309 continue;
Daniel Jasper9fe0e8d2013-09-05 09:29:45 +00001310 FormatToken *Tok = AnnotatedLines[i]->First->Next;
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001311 while (Tok->Next) {
Daniel Jasperb10cbc42013-07-10 14:02:49 +00001312 if (Tok->PackingKind == PPK_BinPacked)
1313 HasBinPackedFunction = true;
1314 if (Tok->PackingKind == PPK_OnePerLine)
1315 HasOnePerLineFunction = true;
1316
Manuel Klimek6e6310e2013-05-29 14:47:47 +00001317 Tok = Tok->Next;
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001318 }
1319 }
Eric Liu635423e2016-04-28 07:52:03 +00001320 if (Style.DerivePointerAlignment)
1321 Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
1322 ? FormatStyle::PAS_Left
1323 : FormatStyle::PAS_Right;
1324 if (Style.Standard == FormatStyle::LS_Auto)
1325 Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
1326 ? FormatStyle::LS_Cpp11
1327 : FormatStyle::LS_Cpp03;
Daniel Jasperb10cbc42013-07-10 14:02:49 +00001328 BinPackInconclusiveFunctions =
1329 HasBinPackedFunction || !HasOnePerLineFunction;
Daniel Jasper7fce3ab2013-02-06 14:22:40 +00001330 }
1331
Daniel Jasperb10cbc42013-07-10 14:02:49 +00001332 bool BinPackInconclusiveFunctions;
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00001333 FormattingAttemptStatus *Status;
Eric Liu4cfb88a2016-04-25 15:09:22 +00001334};
1335
1336// This class clean up the erroneous/redundant code around the given ranges in
1337// file.
1338class Cleaner : public TokenAnalyzer {
1339public:
Eric Liu635423e2016-04-28 07:52:03 +00001340 Cleaner(const Environment &Env, const FormatStyle &Style)
1341 : TokenAnalyzer(Env, Style),
Eric Liu4cfb88a2016-04-25 15:09:22 +00001342 DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
1343
1344 // FIXME: eliminate unused parameters.
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001345 std::pair<tooling::Replacements, unsigned>
Eric Liu4cfb88a2016-04-25 15:09:22 +00001346 analyze(TokenAnnotator &Annotator,
1347 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
Martin Probsta9855af2016-09-02 14:29:48 +00001348 FormatTokenLexer &Tokens) override {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001349 // FIXME: in the current implementation the granularity of affected range
1350 // is an annotated line. However, this is not sufficient. Furthermore,
1351 // redundant code introduced by replacements does not necessarily
1352 // intercept with ranges of replacements that result in the redundancy.
1353 // To determine if some redundant code is actually introduced by
1354 // replacements(e.g. deletions), we need to come up with a more
1355 // sophisticated way of computing affected ranges.
Manuel Klimek0dddcf72018-04-23 09:34:26 +00001356 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
Eric Liu4cfb88a2016-04-25 15:09:22 +00001357
1358 checkEmptyNamespace(AnnotatedLines);
1359
Eric Liuce5e4bc2016-05-18 08:02:56 +00001360 for (auto &Line : AnnotatedLines) {
1361 if (Line->Affected) {
1362 cleanupRight(Line->First, tok::comma, tok::comma);
1363 cleanupRight(Line->First, TT_CtorInitializerColon, tok::comma);
Eric Liu2574d152016-09-13 15:02:43 +00001364 cleanupRight(Line->First, tok::l_paren, tok::comma);
1365 cleanupLeft(Line->First, tok::comma, tok::r_paren);
Eric Liuce5e4bc2016-05-18 08:02:56 +00001366 cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
1367 cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
Malcolm Parsons5d8cdb82016-10-20 14:58:45 +00001368 cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
Eric Liuce5e4bc2016-05-18 08:02:56 +00001369 }
1370 }
1371
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00001372 return {generateFixes(), 0};
Eric Liu4cfb88a2016-04-25 15:09:22 +00001373 }
1374
1375private:
1376 bool containsOnlyComments(const AnnotatedLine &Line) {
1377 for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
1378 if (Tok->isNot(tok::comment))
1379 return false;
1380 }
1381 return true;
1382 }
1383
1384 // Iterate through all lines and remove any empty (nested) namespaces.
1385 void checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
Eric Liu7956c402016-10-05 15:49:01 +00001386 std::set<unsigned> DeletedLines;
Eric Liu4cfb88a2016-04-25 15:09:22 +00001387 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1388 auto &Line = *AnnotatedLines[i];
Sam McCall6f3778c2018-09-05 07:44:02 +00001389 if (Line.startsWithNamespace()) {
Eric Liu7956c402016-10-05 15:49:01 +00001390 checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
Eric Liu4cfb88a2016-04-25 15:09:22 +00001391 }
1392 }
1393
1394 for (auto Line : DeletedLines) {
1395 FormatToken *Tok = AnnotatedLines[Line]->First;
1396 while (Tok) {
1397 deleteToken(Tok);
1398 Tok = Tok->Next;
1399 }
1400 }
1401 }
1402
1403 // The function checks if the namespace, which starts from \p CurrentLine, and
1404 // its nested namespaces are empty and delete them if they are empty. It also
1405 // sets \p NewLine to the last line checked.
1406 // Returns true if the current namespace is empty.
1407 bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
Eric Liu7956c402016-10-05 15:49:01 +00001408 unsigned CurrentLine, unsigned &NewLine,
1409 std::set<unsigned> &DeletedLines) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001410 unsigned InitLine = CurrentLine, End = AnnotatedLines.size();
Eric Liu635423e2016-04-28 07:52:03 +00001411 if (Style.BraceWrapping.AfterNamespace) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001412 // If the left brace is in a new line, we should consume it first so that
1413 // it does not make the namespace non-empty.
1414 // FIXME: error handling if there is no left brace.
1415 if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
1416 NewLine = CurrentLine;
1417 return false;
1418 }
1419 } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
1420 return false;
1421 }
1422 while (++CurrentLine < End) {
1423 if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
1424 break;
1425
Sam McCall6f3778c2018-09-05 07:44:02 +00001426 if (AnnotatedLines[CurrentLine]->startsWithNamespace()) {
Eric Liu7956c402016-10-05 15:49:01 +00001427 if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
1428 DeletedLines))
Eric Liu4cfb88a2016-04-25 15:09:22 +00001429 return false;
1430 CurrentLine = NewLine;
1431 continue;
1432 }
1433
1434 if (containsOnlyComments(*AnnotatedLines[CurrentLine]))
1435 continue;
1436
1437 // If there is anything other than comments or nested namespaces in the
1438 // current namespace, the namespace cannot be empty.
1439 NewLine = CurrentLine;
1440 return false;
1441 }
1442
1443 NewLine = CurrentLine;
1444 if (CurrentLine >= End)
1445 return false;
1446
1447 // Check if the empty namespace is actually affected by changed ranges.
1448 if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
1449 AnnotatedLines[InitLine]->First->Tok.getLocation(),
1450 AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
1451 return false;
1452
1453 for (unsigned i = InitLine; i <= CurrentLine; ++i) {
1454 DeletedLines.insert(i);
1455 }
1456
1457 return true;
1458 }
1459
Eric Liuce5e4bc2016-05-18 08:02:56 +00001460 // Checks pairs {start, start->next},..., {end->previous, end} and deletes one
1461 // of the token in the pair if the left token has \p LK token kind and the
1462 // right token has \p RK token kind. If \p DeleteLeft is true, the left token
1463 // is deleted on match; otherwise, the right token is deleted.
1464 template <typename LeftKind, typename RightKind>
1465 void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
1466 bool DeleteLeft) {
1467 auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
1468 for (auto *Res = Tok.Next; Res; Res = Res->Next)
1469 if (!Res->is(tok::comment) &&
1470 DeletedTokens.find(Res) == DeletedTokens.end())
1471 return Res;
1472 return nullptr;
1473 };
1474 for (auto *Left = Start; Left;) {
1475 auto *Right = NextNotDeleted(*Left);
1476 if (!Right)
1477 break;
1478 if (Left->is(LK) && Right->is(RK)) {
1479 deleteToken(DeleteLeft ? Left : Right);
Eric Liu01426ff2016-09-09 17:50:49 +00001480 for (auto *Tok = Left->Next; Tok && Tok != Right; Tok = Tok->Next)
1481 deleteToken(Tok);
Eric Liuce5e4bc2016-05-18 08:02:56 +00001482 // If the right token is deleted, we should keep the left token
1483 // unchanged and pair it with the new right token.
1484 if (!DeleteLeft)
1485 continue;
1486 }
1487 Left = Right;
1488 }
1489 }
1490
1491 template <typename LeftKind, typename RightKind>
1492 void cleanupLeft(FormatToken *Start, LeftKind LK, RightKind RK) {
1493 cleanupPair(Start, LK, RK, /*DeleteLeft=*/true);
1494 }
1495
1496 template <typename LeftKind, typename RightKind>
1497 void cleanupRight(FormatToken *Start, LeftKind LK, RightKind RK) {
1498 cleanupPair(Start, LK, RK, /*DeleteLeft=*/false);
1499 }
1500
Eric Liu4cfb88a2016-04-25 15:09:22 +00001501 // Delete the given token.
1502 inline void deleteToken(FormatToken *Tok) {
1503 if (Tok)
1504 DeletedTokens.insert(Tok);
1505 }
1506
1507 tooling::Replacements generateFixes() {
1508 tooling::Replacements Fixes;
1509 std::vector<FormatToken *> Tokens;
1510 std::copy(DeletedTokens.begin(), DeletedTokens.end(),
1511 std::back_inserter(Tokens));
1512
1513 // Merge multiple continuous token deletions into one big deletion so that
1514 // the number of replacements can be reduced. This makes computing affected
1515 // ranges more efficient when we run reformat on the changed code.
1516 unsigned Idx = 0;
1517 while (Idx < Tokens.size()) {
1518 unsigned St = Idx, End = Idx;
1519 while ((End + 1) < Tokens.size() &&
1520 Tokens[End]->Next == Tokens[End + 1]) {
1521 End++;
1522 }
1523 auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
1524 Tokens[End]->Tok.getEndLoc());
Eric Liu40ef2fb2016-08-01 10:16:37 +00001525 auto Err =
1526 Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
1527 // FIXME: better error handling. for now just print error message and skip
1528 // for the release version.
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001529 if (Err) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001530 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001531 assert(false && "Fixes must not conflict!");
1532 }
Eric Liu4cfb88a2016-04-25 15:09:22 +00001533 Idx = End + 1;
1534 }
1535
1536 return Fixes;
1537 }
1538
1539 // Class for less-than inequality comparason for the set `RedundantTokens`.
1540 // We store tokens in the order they appear in the translation unit so that
1541 // we do not need to sort them in `generateFixes()`.
1542 struct FormatTokenLess {
Eric Liu635423e2016-04-28 07:52:03 +00001543 FormatTokenLess(const SourceManager &SM) : SM(SM) {}
Eric Liu4cfb88a2016-04-25 15:09:22 +00001544
Eric Liu2874ac32016-05-18 08:14:49 +00001545 bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
Eric Liu4cfb88a2016-04-25 15:09:22 +00001546 return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
1547 RHS->Tok.getLocation());
1548 }
Eric Liu635423e2016-04-28 07:52:03 +00001549 const SourceManager &SM;
Eric Liu4cfb88a2016-04-25 15:09:22 +00001550 };
1551
1552 // Tokens to be deleted.
1553 std::set<FormatToken *, FormatTokenLess> DeletedTokens;
Daniel Jasperf7935112012-12-03 18:12:45 +00001554};
1555
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001556class ObjCHeaderStyleGuesser : public TokenAnalyzer {
1557public:
1558 ObjCHeaderStyleGuesser(const Environment &Env, const FormatStyle &Style)
1559 : TokenAnalyzer(Env, Style), IsObjC(false) {}
1560
1561 std::pair<tooling::Replacements, unsigned>
1562 analyze(TokenAnnotator &Annotator,
1563 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1564 FormatTokenLexer &Tokens) override {
1565 assert(Style.Language == FormatStyle::LK_Cpp);
Ben Hamilton0675e872018-11-05 16:59:33 +00001566 IsObjC = guessIsObjC(Env.getSourceManager(), AnnotatedLines,
1567 Tokens.getKeywords());
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001568 tooling::Replacements Result;
1569 return {Result, 0};
1570 }
1571
1572 bool isObjC() { return IsObjC; }
1573
1574private:
Ben Hamilton0675e872018-11-05 16:59:33 +00001575 static bool
1576 guessIsObjC(const SourceManager &SourceManager,
1577 const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1578 const AdditionalKeywords &Keywords) {
Krasimir Georgiev8e216782018-01-17 20:01:02 +00001579 // Keep this array sorted, since we are binary searching over it.
1580 static constexpr llvm::StringLiteral FoundationIdentifiers[] = {
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001581 "CGFloat",
Ben Hamilton19c782d2018-03-22 03:25:22 +00001582 "CGPoint",
1583 "CGPointMake",
1584 "CGPointZero",
1585 "CGRect",
1586 "CGRectEdge",
1587 "CGRectInfinite",
1588 "CGRectMake",
1589 "CGRectNull",
1590 "CGRectZero",
1591 "CGSize",
1592 "CGSizeMake",
1593 "CGVector",
1594 "CGVectorMake",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001595 "NSAffineTransform",
1596 "NSArray",
1597 "NSAttributedString",
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001598 "NSBlockOperation",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001599 "NSBundle",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001600 "NSCache",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001601 "NSCalendar",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001602 "NSCharacterSet",
1603 "NSCountedSet",
1604 "NSData",
1605 "NSDataDetector",
1606 "NSDecimal",
1607 "NSDecimalNumber",
1608 "NSDictionary",
1609 "NSEdgeInsets",
1610 "NSHashTable",
1611 "NSIndexPath",
1612 "NSIndexSet",
1613 "NSInteger",
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001614 "NSInvocationOperation",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001615 "NSLocale",
1616 "NSMapTable",
1617 "NSMutableArray",
1618 "NSMutableAttributedString",
1619 "NSMutableCharacterSet",
1620 "NSMutableData",
1621 "NSMutableDictionary",
1622 "NSMutableIndexSet",
1623 "NSMutableOrderedSet",
1624 "NSMutableSet",
1625 "NSMutableString",
1626 "NSNumber",
1627 "NSNumberFormatter",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001628 "NSObject",
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001629 "NSOperation",
1630 "NSOperationQueue",
1631 "NSOperationQueuePriority",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001632 "NSOrderedSet",
1633 "NSPoint",
1634 "NSPointerArray",
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001635 "NSQualityOfService",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001636 "NSRange",
1637 "NSRect",
1638 "NSRegularExpression",
1639 "NSSet",
1640 "NSSize",
1641 "NSString",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001642 "NSTimeZone",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001643 "NSUInteger",
1644 "NSURL",
1645 "NSURLComponents",
1646 "NSURLQueryItem",
1647 "NSUUID",
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001648 "NSValue",
Ben Hamilton19c782d2018-03-22 03:25:22 +00001649 "UIImage",
1650 "UIView",
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001651 };
1652
Ben Hamiltonea7a27b2018-03-27 15:01:21 +00001653 for (auto Line : AnnotatedLines) {
1654 for (const FormatToken *FormatTok = Line->First; FormatTok;
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001655 FormatTok = FormatTok->Next) {
Jacek Olesiakce4f0af2018-02-15 08:47:56 +00001656 if ((FormatTok->Previous && FormatTok->Previous->is(tok::at) &&
Ben Hamiltonb1a79192018-04-12 15:11:53 +00001657 (FormatTok->Tok.getObjCKeywordID() != tok::objc_not_keyword ||
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001658 FormatTok->isOneOf(tok::numeric_constant, tok::l_square,
1659 tok::l_brace))) ||
1660 (FormatTok->Tok.isAnyIdentifier() &&
Krasimir Georgiev8e216782018-01-17 20:01:02 +00001661 std::binary_search(std::begin(FoundationIdentifiers),
1662 std::end(FoundationIdentifiers),
1663 FormatTok->TokenText)) ||
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001664 FormatTok->is(TT_ObjCStringLiteral) ||
1665 FormatTok->isOneOf(Keywords.kw_NS_ENUM, Keywords.kw_NS_OPTIONS,
1666 TT_ObjCBlockLBrace, TT_ObjCBlockLParen,
1667 TT_ObjCDecl, TT_ObjCForIn, TT_ObjCMethodExpr,
1668 TT_ObjCMethodSpecifier, TT_ObjCProperty)) {
Ben Hamilton0675e872018-11-05 16:59:33 +00001669 LLVM_DEBUG(llvm::dbgs()
1670 << "Detected ObjC at location "
1671 << FormatTok->Tok.getLocation().printToString(
1672 SourceManager)
1673 << " token: " << FormatTok->TokenText << " token type: "
1674 << getTokenTypeName(FormatTok->Type) << "\n");
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001675 return true;
1676 }
Ben Hamilton0675e872018-11-05 16:59:33 +00001677 if (guessIsObjC(SourceManager, Line->Children, Keywords))
Ben Hamilton6432afe2018-03-22 17:37:19 +00001678 return true;
1679 }
Ben Hamiltone2e3e672018-01-17 17:33:08 +00001680 }
1681 return false;
1682 }
1683
1684 bool IsObjC;
1685};
1686
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001687struct IncludeDirective {
1688 StringRef Filename;
1689 StringRef Text;
1690 unsigned Offset;
Daniel Jasperd2629dc2015-12-16 10:10:16 +00001691 int Category;
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001692};
1693
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00001694struct JavaImportDirective {
1695 StringRef Identifier;
1696 StringRef Text;
1697 unsigned Offset;
1698 std::vector<StringRef> AssociatedCommentLines;
1699 bool IsStatic;
1700};
1701
Craig Topperaf35e852013-06-30 22:29:28 +00001702} // end anonymous namespace
1703
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001704// Determines whether 'Ranges' intersects with ('Start', 'End').
1705static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
1706 unsigned End) {
1707 for (auto Range : Ranges) {
1708 if (Range.getOffset() < End &&
1709 Range.getOffset() + Range.getLength() > Start)
1710 return true;
1711 }
1712 return false;
1713}
1714
Eric Liua992afe2016-08-10 09:32:23 +00001715// Returns a pair (Index, OffsetToEOL) describing the position of the cursor
1716// before sorting/deduplicating. Index is the index of the include under the
1717// cursor in the original set of includes. If this include has duplicates, it is
1718// the index of the first of the duplicates as the others are going to be
1719// removed. OffsetToEOL describes the cursor's position relative to the end of
1720// its current line.
1721// If `Cursor` is not on any #include, `Index` will be UINT_MAX.
1722static std::pair<unsigned, unsigned>
1723FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
1724 const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
1725 unsigned CursorIndex = UINT_MAX;
1726 unsigned OffsetToEOL = 0;
1727 for (int i = 0, e = Includes.size(); i != e; ++i) {
1728 unsigned Start = Includes[Indices[i]].Offset;
1729 unsigned End = Start + Includes[Indices[i]].Text.size();
1730 if (!(Cursor >= Start && Cursor < End))
1731 continue;
1732 CursorIndex = Indices[i];
1733 OffsetToEOL = End - Cursor;
1734 // Put the cursor on the only remaining #include among the duplicate
1735 // #includes.
1736 while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
1737 CursorIndex = i;
1738 break;
1739 }
1740 return std::make_pair(CursorIndex, OffsetToEOL);
1741}
1742
1743// Sorts and deduplicate a block of includes given by 'Includes' alphabetically
1744// adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
1745// source order.
1746// #include directives with the same text will be deduplicated, and only the
1747// first #include in the duplicate #includes remains. If the `Cursor` is
1748// provided and put on a deleted #include, it will be moved to the remaining
1749// #include in the duplicate #includes.
Martin Probstc4a0dd42016-05-20 11:24:24 +00001750static void sortCppIncludes(const FormatStyle &Style,
Eric Liua992afe2016-08-10 09:32:23 +00001751 const SmallVectorImpl<IncludeDirective> &Includes,
1752 ArrayRef<tooling::Range> Ranges, StringRef FileName,
1753 tooling::Replacements &Replaces, unsigned *Cursor) {
1754 unsigned IncludesBeginOffset = Includes.front().Offset;
Daniel Jasperd6a00782016-08-30 21:33:41 +00001755 unsigned IncludesEndOffset =
1756 Includes.back().Offset + Includes.back().Text.size();
1757 unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
1758 if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001759 return;
1760 SmallVector<unsigned, 16> Indices;
1761 for (unsigned i = 0, e = Includes.size(); i != e; ++i)
1762 Indices.push_back(i);
Daniel Jasper94a96fc2016-03-03 17:34:14 +00001763 std::stable_sort(
1764 Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
1765 return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
1766 std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
1767 });
Eric Liua992afe2016-08-10 09:32:23 +00001768 // The index of the include on which the cursor will be put after
1769 // sorting/deduplicating.
1770 unsigned CursorIndex;
1771 // The offset from cursor to the end of line.
1772 unsigned CursorToEOLOffset;
1773 if (Cursor)
1774 std::tie(CursorIndex, CursorToEOLOffset) =
1775 FindCursorIndex(Includes, Indices, *Cursor);
1776
1777 // Deduplicate #includes.
1778 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1779 [&](unsigned LHSI, unsigned RHSI) {
1780 return Includes[LHSI].Text == Includes[RHSI].Text;
1781 }),
1782 Indices.end());
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001783
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001784 int CurrentCategory = Includes.front().Category;
1785
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001786 // If the #includes are out of order, we generate a single replacement fixing
1787 // the entire block. Otherwise, no replacement is generated.
Eric Liua992afe2016-08-10 09:32:23 +00001788 if (Indices.size() == Includes.size() &&
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001789 std::is_sorted(Indices.begin(), Indices.end()) &&
Eric Liu9d92c022018-05-14 19:51:33 +00001790 Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Preserve)
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001791 return;
1792
Daniel Jasperb68aabf2015-11-23 08:36:35 +00001793 std::string result;
Daniel Jasperb68aabf2015-11-23 08:36:35 +00001794 for (unsigned Index : Indices) {
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001795 if (!result.empty()) {
Daniel Jasperb68aabf2015-11-23 08:36:35 +00001796 result += "\n";
Eric Liu9d92c022018-05-14 19:51:33 +00001797 if (Style.IncludeStyle.IncludeBlocks ==
1798 tooling::IncludeStyle::IBS_Regroup &&
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001799 CurrentCategory != Includes[Index].Category)
1800 result += "\n";
1801 }
Daniel Jasperb68aabf2015-11-23 08:36:35 +00001802 result += Includes[Index].Text;
Eric Liua992afe2016-08-10 09:32:23 +00001803 if (Cursor && CursorIndex == Index)
1804 *Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001805 CurrentCategory = Includes[Index].Category;
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001806 }
1807
Eric Liu40ef2fb2016-08-01 10:16:37 +00001808 auto Err = Replaces.add(tooling::Replacement(
Eric Liua992afe2016-08-10 09:32:23 +00001809 FileName, Includes.front().Offset, IncludesBlockSize, result));
Eric Liu40ef2fb2016-08-01 10:16:37 +00001810 // FIXME: better error handling. For now, just skip the replacement for the
1811 // release version.
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001812 if (Err) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00001813 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
Piotr Padlewski1ec383c2016-12-23 11:40:44 +00001814 assert(false);
1815 }
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001816}
1817
Eric Liu659afd52016-05-31 13:34:20 +00001818namespace {
1819
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00001820const char CppIncludeRegexPattern[] =
Eric Liu659afd52016-05-31 13:34:20 +00001821 R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
1822
1823} // anonymous namespace
1824
Martin Probstc4a0dd42016-05-20 11:24:24 +00001825tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
1826 ArrayRef<tooling::Range> Ranges,
1827 StringRef FileName,
1828 tooling::Replacements &Replaces,
1829 unsigned *Cursor) {
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001830 unsigned Prev = 0;
1831 unsigned SearchFrom = 0;
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00001832 llvm::Regex IncludeRegex(CppIncludeRegexPattern);
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001833 SmallVector<StringRef, 4> Matches;
1834 SmallVector<IncludeDirective, 16> IncludesInBlock;
Daniel Jasper85c472d2015-09-29 07:53:08 +00001835
1836 // In compiled files, consider the first #include to be the main #include of
1837 // the file if it is not a system #include. This ensures that the header
1838 // doesn't have hidden dependencies
1839 // (http://llvm.org/docs/CodingStandards.html#include-style).
1840 //
1841 // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
1842 // cases where the first #include is unlikely to be the main header.
Eric Liu7129e632018-05-14 20:17:53 +00001843 tooling::IncludeCategoryManager Categories(Style.IncludeStyle, FileName);
Daniel Jasper32d75fa2015-12-21 13:40:49 +00001844 bool FirstIncludeBlock = true;
Daniel Jaspera252f5d2015-12-21 17:28:24 +00001845 bool MainIncludeFound = false;
Daniel Jasper9b8c7c72015-11-21 09:17:08 +00001846 bool FormattingOff = false;
1847
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001848 for (;;) {
1849 auto Pos = Code.find('\n', SearchFrom);
1850 StringRef Line =
1851 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
Daniel Jasper9b8c7c72015-11-21 09:17:08 +00001852
1853 StringRef Trimmed = Line.trim();
Paul Hoad9b468c02019-03-02 09:08:51 +00001854 if (Trimmed == "// clang-format off" || Trimmed == "/* clang-format off */")
Daniel Jasper9b8c7c72015-11-21 09:17:08 +00001855 FormattingOff = true;
Paul Hoad9b468c02019-03-02 09:08:51 +00001856 else if (Trimmed == "// clang-format on" ||
1857 Trimmed == "/* clang-format on */")
Daniel Jasper9b8c7c72015-11-21 09:17:08 +00001858 FormattingOff = false;
1859
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001860 const bool EmptyLineSkipped =
Eric Liu9d92c022018-05-14 19:51:33 +00001861 Trimmed.empty() &&
1862 (Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Merge ||
1863 Style.IncludeStyle.IncludeBlocks ==
1864 tooling::IncludeStyle::IBS_Regroup);
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001865
Daniel Jasper9b8c7c72015-11-21 09:17:08 +00001866 if (!FormattingOff && !Line.endswith("\\")) {
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001867 if (IncludeRegex.match(Line, &Matches)) {
Nico Weberff063702015-10-21 17:13:45 +00001868 StringRef IncludeName = Matches[2];
Eric Liu659afd52016-05-31 13:34:20 +00001869 int Category = Categories.getIncludePriority(
1870 IncludeName,
1871 /*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
1872 if (Category == 0)
1873 MainIncludeFound = true;
Nico Weberff063702015-10-21 17:13:45 +00001874 IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
Krasimir Georgiev4c2c9c32017-11-27 13:23:45 +00001875 } else if (!IncludesInBlock.empty() && !EmptyLineSkipped) {
Martin Probstc4a0dd42016-05-20 11:24:24 +00001876 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
1877 Cursor);
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001878 IncludesInBlock.clear();
Daniel Jasper32d75fa2015-12-21 13:40:49 +00001879 FirstIncludeBlock = false;
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00001880 }
1881 Prev = Pos + 1;
1882 }
1883 if (Pos == StringRef::npos || Pos + 1 == Code.size())
1884 break;
1885 SearchFrom = Pos + 1;
1886 }
1887 if (!IncludesInBlock.empty())
Martin Probstc4a0dd42016-05-20 11:24:24 +00001888 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
1889 return Replaces;
1890}
1891
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00001892// Returns group number to use as a first order sort on imports. Gives UINT_MAX
1893// if the import does not match any given groups.
1894static unsigned findJavaImportGroup(const FormatStyle &Style,
1895 StringRef ImportIdentifier) {
1896 unsigned LongestMatchIndex = UINT_MAX;
1897 unsigned LongestMatchLength = 0;
1898 for (unsigned I = 0; I < Style.JavaImportGroups.size(); I++) {
1899 std::string GroupPrefix = Style.JavaImportGroups[I];
1900 if (ImportIdentifier.startswith(GroupPrefix) &&
1901 GroupPrefix.length() > LongestMatchLength) {
1902 LongestMatchIndex = I;
1903 LongestMatchLength = GroupPrefix.length();
1904 }
1905 }
1906 return LongestMatchIndex;
1907}
1908
1909// Sorts and deduplicates a block of includes given by 'Imports' based on
1910// JavaImportGroups, then adding the necessary replacement to 'Replaces'.
1911// Import declarations with the same text will be deduplicated. Between each
1912// import group, a newline is inserted, and within each import group, a
1913// lexicographic sort based on ASCII value is performed.
1914static void sortJavaImports(const FormatStyle &Style,
1915 const SmallVectorImpl<JavaImportDirective> &Imports,
1916 ArrayRef<tooling::Range> Ranges, StringRef FileName,
Paul Hoad5bcf99b2019-03-01 09:09:54 +00001917 StringRef Code, tooling::Replacements &Replaces) {
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00001918 unsigned ImportsBeginOffset = Imports.front().Offset;
1919 unsigned ImportsEndOffset =
1920 Imports.back().Offset + Imports.back().Text.size();
1921 unsigned ImportsBlockSize = ImportsEndOffset - ImportsBeginOffset;
1922 if (!affectsRange(Ranges, ImportsBeginOffset, ImportsEndOffset))
1923 return;
1924 SmallVector<unsigned, 16> Indices;
1925 SmallVector<unsigned, 16> JavaImportGroups;
1926 for (unsigned i = 0, e = Imports.size(); i != e; ++i) {
1927 Indices.push_back(i);
1928 JavaImportGroups.push_back(
1929 findJavaImportGroup(Style, Imports[i].Identifier));
1930 }
Mandeep Singh Grangd36da8a2019-01-18 18:45:26 +00001931 llvm::sort(Indices, [&](unsigned LHSI, unsigned RHSI) {
Krasimir Georgiev777bb822019-02-20 11:44:21 +00001932 // Negating IsStatic to push static imports above non-static imports.
1933 return std::make_tuple(!Imports[LHSI].IsStatic, JavaImportGroups[LHSI],
1934 Imports[LHSI].Identifier) <
1935 std::make_tuple(!Imports[RHSI].IsStatic, JavaImportGroups[RHSI],
1936 Imports[RHSI].Identifier);
1937 });
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00001938
1939 // Deduplicate imports.
1940 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1941 [&](unsigned LHSI, unsigned RHSI) {
1942 return Imports[LHSI].Text == Imports[RHSI].Text;
1943 }),
1944 Indices.end());
1945
1946 bool CurrentIsStatic = Imports[Indices.front()].IsStatic;
1947 unsigned CurrentImportGroup = JavaImportGroups[Indices.front()];
1948
1949 std::string result;
1950 for (unsigned Index : Indices) {
1951 if (!result.empty()) {
1952 result += "\n";
1953 if (CurrentIsStatic != Imports[Index].IsStatic ||
1954 CurrentImportGroup != JavaImportGroups[Index])
1955 result += "\n";
1956 }
1957 for (StringRef CommentLine : Imports[Index].AssociatedCommentLines) {
1958 result += CommentLine;
1959 result += "\n";
1960 }
1961 result += Imports[Index].Text;
1962 CurrentIsStatic = Imports[Index].IsStatic;
1963 CurrentImportGroup = JavaImportGroups[Index];
1964 }
1965
Krasimir Georgiev777bb822019-02-20 11:44:21 +00001966 // If the imports are out of order, we generate a single replacement fixing
1967 // the entire block. Otherwise, no replacement is generated.
1968 if (result == Code.substr(Imports.front().Offset, ImportsBlockSize))
1969 return;
1970
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00001971 auto Err = Replaces.add(tooling::Replacement(FileName, Imports.front().Offset,
1972 ImportsBlockSize, result));
1973 // FIXME: better error handling. For now, just skip the replacement for the
1974 // release version.
1975 if (Err) {
1976 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1977 assert(false);
1978 }
1979}
1980
1981namespace {
1982
1983const char JavaImportRegexPattern[] =
1984 "^[\t ]*import[\t ]*(static[\t ]*)?([^\t ]*)[\t ]*;";
1985
1986} // anonymous namespace
1987
1988tooling::Replacements sortJavaImports(const FormatStyle &Style, StringRef Code,
1989 ArrayRef<tooling::Range> Ranges,
1990 StringRef FileName,
1991 tooling::Replacements &Replaces) {
1992 unsigned Prev = 0;
1993 unsigned SearchFrom = 0;
1994 llvm::Regex ImportRegex(JavaImportRegexPattern);
1995 SmallVector<StringRef, 4> Matches;
1996 SmallVector<JavaImportDirective, 16> ImportsInBlock;
1997 std::vector<StringRef> AssociatedCommentLines;
1998
1999 bool FormattingOff = false;
2000
2001 for (;;) {
2002 auto Pos = Code.find('\n', SearchFrom);
2003 StringRef Line =
2004 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
2005
2006 StringRef Trimmed = Line.trim();
2007 if (Trimmed == "// clang-format off")
2008 FormattingOff = true;
2009 else if (Trimmed == "// clang-format on")
2010 FormattingOff = false;
2011
2012 if (ImportRegex.match(Line, &Matches)) {
2013 if (FormattingOff) {
2014 // If at least one import line has formatting turned off, turn off
2015 // formatting entirely.
2016 return Replaces;
2017 }
2018 StringRef Static = Matches[1];
2019 StringRef Identifier = Matches[2];
2020 bool IsStatic = false;
2021 if (Static.contains("static")) {
2022 IsStatic = true;
2023 }
Paul Hoad5bcf99b2019-03-01 09:09:54 +00002024 ImportsInBlock.push_back(
2025 {Identifier, Line, Prev, AssociatedCommentLines, IsStatic});
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00002026 AssociatedCommentLines.clear();
2027 } else if (Trimmed.size() > 0 && !ImportsInBlock.empty()) {
2028 // Associating comments within the imports with the nearest import below
2029 AssociatedCommentLines.push_back(Line);
2030 }
2031 Prev = Pos + 1;
2032 if (Pos == StringRef::npos || Pos + 1 == Code.size())
2033 break;
2034 SearchFrom = Pos + 1;
2035 }
2036 if (!ImportsInBlock.empty())
Krasimir Georgiev777bb822019-02-20 11:44:21 +00002037 sortJavaImports(Style, ImportsInBlock, Ranges, FileName, Code, Replaces);
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00002038 return Replaces;
2039}
2040
Martin Probstfa37b182017-01-27 09:09:11 +00002041bool isMpegTS(StringRef Code) {
2042 // MPEG transport streams use the ".ts" file extension. clang-format should
2043 // not attempt to format those. MPEG TS' frame format starts with 0x47 every
2044 // 189 bytes - detect that and return.
2045 return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
2046}
2047
Manuel Klimek89628f62017-09-20 09:51:03 +00002048bool isLikelyXml(StringRef Code) { return Code.ltrim().startswith("<"); }
Krasimir Georgieva2e7d0d2017-08-29 13:51:38 +00002049
Martin Probstc4a0dd42016-05-20 11:24:24 +00002050tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
2051 ArrayRef<tooling::Range> Ranges,
2052 StringRef FileName, unsigned *Cursor) {
2053 tooling::Replacements Replaces;
2054 if (!Style.SortIncludes)
2055 return Replaces;
Krasimir Georgiev86873032017-08-29 13:57:31 +00002056 if (isLikelyXml(Code))
2057 return Replaces;
2058 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
2059 isMpegTS(Code))
Martin Probstfa37b182017-01-27 09:09:11 +00002060 return Replaces;
Martin Probstc4a0dd42016-05-20 11:24:24 +00002061 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
2062 return sortJavaScriptImports(Style, Code, Ranges, FileName);
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00002063 if (Style.Language == FormatStyle::LanguageKind::LK_Java)
2064 return sortJavaImports(Style, Code, Ranges, FileName, Replaces);
Martin Probstc4a0dd42016-05-20 11:24:24 +00002065 sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
Daniel Jasperd89ae9d2015-09-23 08:30:47 +00002066 return Replaces;
2067}
2068
Eric Liu4cfb88a2016-04-25 15:09:22 +00002069template <typename T>
Eric Liu4f8d9942016-07-11 13:53:12 +00002070static llvm::Expected<tooling::Replacements>
Eric Liu4cfb88a2016-04-25 15:09:22 +00002071processReplacements(T ProcessFunc, StringRef Code,
2072 const tooling::Replacements &Replaces,
2073 const FormatStyle &Style) {
Manuel Klimekb12e5a52016-03-01 12:37:30 +00002074 if (Replaces.empty())
2075 return tooling::Replacements();
2076
Eric Liu4f8d9942016-07-11 13:53:12 +00002077 auto NewCode = applyAllReplacements(Code, Replaces);
2078 if (!NewCode)
2079 return NewCode.takeError();
Eric Liu40ef2fb2016-08-01 10:16:37 +00002080 std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
Manuel Klimekb12e5a52016-03-01 12:37:30 +00002081 StringRef FileName = Replaces.begin()->getFilePath();
Eric Liu4cfb88a2016-04-25 15:09:22 +00002082
Manuel Klimekb12e5a52016-03-01 12:37:30 +00002083 tooling::Replacements FormatReplaces =
Eric Liu4f8d9942016-07-11 13:53:12 +00002084 ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
Manuel Klimekb12e5a52016-03-01 12:37:30 +00002085
Eric Liu40ef2fb2016-08-01 10:16:37 +00002086 return Replaces.merge(FormatReplaces);
Manuel Klimekb12e5a52016-03-01 12:37:30 +00002087}
2088
Eric Liu4f8d9942016-07-11 13:53:12 +00002089llvm::Expected<tooling::Replacements>
2090formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
2091 const FormatStyle &Style) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00002092 // We need to use lambda function here since there are two versions of
Eric Liubaf58c22016-05-18 13:43:48 +00002093 // `sortIncludes`.
2094 auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
2095 std::vector<tooling::Range> Ranges,
2096 StringRef FileName) -> tooling::Replacements {
2097 return sortIncludes(Style, Code, Ranges, FileName);
2098 };
Eric Liu4f8d9942016-07-11 13:53:12 +00002099 auto SortedReplaces =
Eric Liubaf58c22016-05-18 13:43:48 +00002100 processReplacements(SortIncludes, Code, Replaces, Style);
Eric Liu4f8d9942016-07-11 13:53:12 +00002101 if (!SortedReplaces)
2102 return SortedReplaces.takeError();
Eric Liubaf58c22016-05-18 13:43:48 +00002103
2104 // We need to use lambda function here since there are two versions of
Eric Liu4cfb88a2016-04-25 15:09:22 +00002105 // `reformat`.
2106 auto Reformat = [](const FormatStyle &Style, StringRef Code,
2107 std::vector<tooling::Range> Ranges,
2108 StringRef FileName) -> tooling::Replacements {
2109 return reformat(Style, Code, Ranges, FileName);
2110 };
Eric Liu4f8d9942016-07-11 13:53:12 +00002111 return processReplacements(Reformat, Code, *SortedReplaces, Style);
Eric Liu4cfb88a2016-04-25 15:09:22 +00002112}
2113
Eric Liu659afd52016-05-31 13:34:20 +00002114namespace {
2115
2116inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
Eric Liuc0d3a802016-09-23 15:10:56 +00002117 return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00002118 llvm::Regex(CppIncludeRegexPattern)
2119 .match(Replace.getReplacementText());
Eric Liu659afd52016-05-31 13:34:20 +00002120}
2121
Eric Liuc0d3a802016-09-23 15:10:56 +00002122inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
2123 return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
2124}
2125
Eric Liu659afd52016-05-31 13:34:20 +00002126// FIXME: insert empty lines between newly created blocks.
2127tooling::Replacements
2128fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
2129 const FormatStyle &Style) {
Daniel Jasper1dbc2102017-03-31 13:30:24 +00002130 if (!Style.isCpp())
Eric Liu659afd52016-05-31 13:34:20 +00002131 return Replaces;
2132
2133 tooling::Replacements HeaderInsertions;
Eric Liuc0d3a802016-09-23 15:10:56 +00002134 std::set<llvm::StringRef> HeadersToDelete;
Eric Liu40ef2fb2016-08-01 10:16:37 +00002135 tooling::Replacements Result;
Eric Liu659afd52016-05-31 13:34:20 +00002136 for (const auto &R : Replaces) {
Eric Liu40ef2fb2016-08-01 10:16:37 +00002137 if (isHeaderInsertion(R)) {
2138 // Replacements from \p Replaces must be conflict-free already, so we can
2139 // simply consume the error.
2140 llvm::consumeError(HeaderInsertions.add(R));
Eric Liuc0d3a802016-09-23 15:10:56 +00002141 } else if (isHeaderDeletion(R)) {
2142 HeadersToDelete.insert(R.getReplacementText());
Eric Liu40ef2fb2016-08-01 10:16:37 +00002143 } else if (R.getOffset() == UINT_MAX) {
Eric Liu659afd52016-05-31 13:34:20 +00002144 llvm::errs() << "Insertions other than header #include insertion are "
2145 "not supported! "
2146 << R.getReplacementText() << "\n";
Eric Liu40ef2fb2016-08-01 10:16:37 +00002147 } else {
2148 llvm::consumeError(Result.add(R));
2149 }
Eric Liu659afd52016-05-31 13:34:20 +00002150 }
Eric Liuc0d3a802016-09-23 15:10:56 +00002151 if (HeaderInsertions.empty() && HeadersToDelete.empty())
Eric Liu659afd52016-05-31 13:34:20 +00002152 return Replaces;
Eric Liu659afd52016-05-31 13:34:20 +00002153
Eric Liu659afd52016-05-31 13:34:20 +00002154 StringRef FileName = Replaces.begin()->getFilePath();
Eric Liu7129e632018-05-14 20:17:53 +00002155 tooling::HeaderIncludes Includes(FileName, Code, Style.IncludeStyle);
Eric Liu659afd52016-05-31 13:34:20 +00002156
Eric Liubf4c41c2018-05-04 17:55:13 +00002157 for (const auto &Header : HeadersToDelete) {
2158 tooling::Replacements Replaces =
Eric Liu7129e632018-05-14 20:17:53 +00002159 Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
Eric Liubf4c41c2018-05-04 17:55:13 +00002160 for (const auto &R : Replaces) {
2161 auto Err = Result.add(R);
2162 if (Err) {
2163 // Ignore the deletion on conflict.
2164 llvm::errs() << "Failed to add header deletion replacement for "
2165 << Header << ": " << llvm::toString(std::move(Err))
2166 << "\n";
Eric Liuc0d3a802016-09-23 15:10:56 +00002167 }
Eric Liu659afd52016-05-31 13:34:20 +00002168 }
Eric Liu659afd52016-05-31 13:34:20 +00002169 }
2170
Krasimir Georgiev7e91b032018-10-05 17:19:26 +00002171 llvm::Regex IncludeRegex = llvm::Regex(CppIncludeRegexPattern);
Eric Liubf4c41c2018-05-04 17:55:13 +00002172 llvm::SmallVector<StringRef, 4> Matches;
Eric Liu659afd52016-05-31 13:34:20 +00002173 for (const auto &R : HeaderInsertions) {
2174 auto IncludeDirective = R.getReplacementText();
2175 bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
2176 assert(Matched && "Header insertion replacement must have replacement text "
2177 "'#include ...'");
Benjamin Kramer1cb7ee12016-05-31 14:14:42 +00002178 (void)Matched;
Eric Liu659afd52016-05-31 13:34:20 +00002179 auto IncludeName = Matches[2];
Eric Liubf4c41c2018-05-04 17:55:13 +00002180 auto Replace =
Eric Liu7129e632018-05-14 20:17:53 +00002181 Includes.insert(IncludeName.trim("\"<>"), IncludeName.startswith("<"));
Eric Liubf4c41c2018-05-04 17:55:13 +00002182 if (Replace) {
2183 auto Err = Result.add(*Replace);
2184 if (Err) {
2185 llvm::consumeError(std::move(Err));
Paul Hoad5bcf99b2019-03-01 09:09:54 +00002186 unsigned NewOffset =
2187 Result.getShiftedCodePosition(Replace->getOffset());
Eric Liubf4c41c2018-05-04 17:55:13 +00002188 auto Shifted = tooling::Replacement(FileName, NewOffset, 0,
2189 Replace->getReplacementText());
2190 Result = Result.merge(tooling::Replacements(Shifted));
2191 }
Eric Liu40ef2fb2016-08-01 10:16:37 +00002192 }
Eric Liu659afd52016-05-31 13:34:20 +00002193 }
2194 return Result;
2195}
2196
2197} // anonymous namespace
2198
Eric Liu4f8d9942016-07-11 13:53:12 +00002199llvm::Expected<tooling::Replacements>
Eric Liu4cfb88a2016-04-25 15:09:22 +00002200cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
2201 const FormatStyle &Style) {
2202 // We need to use lambda function here since there are two versions of
2203 // `cleanup`.
2204 auto Cleanup = [](const FormatStyle &Style, StringRef Code,
2205 std::vector<tooling::Range> Ranges,
2206 StringRef FileName) -> tooling::Replacements {
2207 return cleanup(Style, Code, Ranges, FileName);
2208 };
Eric Liu659afd52016-05-31 13:34:20 +00002209 // Make header insertion replacements insert new headers into correct blocks.
2210 tooling::Replacements NewReplaces =
2211 fixCppIncludeInsertions(Code, Replaces, Style);
2212 return processReplacements(Cleanup, Code, NewReplaces, Style);
Eric Liu4cfb88a2016-04-25 15:09:22 +00002213}
2214
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002215namespace internal {
2216std::pair<tooling::Replacements, unsigned>
2217reformat(const FormatStyle &Style, StringRef Code,
2218 ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
2219 unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
2220 FormattingAttemptStatus *Status) {
Eric Liu4cfb88a2016-04-25 15:09:22 +00002221 FormatStyle Expanded = expandPresets(Style);
2222 if (Expanded.DisableFormat)
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002223 return {tooling::Replacements(), 0};
Krasimir Georgiev86873032017-08-29 13:57:31 +00002224 if (isLikelyXml(Code))
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002225 return {tooling::Replacements(), 0};
Krasimir Georgiev86873032017-08-29 13:57:31 +00002226 if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002227 return {tooling::Replacements(), 0};
Daniel Jasper496c1992016-09-07 22:48:53 +00002228
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002229 typedef std::function<std::pair<tooling::Replacements, unsigned>(
2230 const Environment &)>
Krasimir Georgievac16a202017-06-23 11:46:03 +00002231 AnalyzerPass;
2232 SmallVector<AnalyzerPass, 4> Passes;
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002233
Krasimir Georgievac16a202017-06-23 11:46:03 +00002234 if (Style.Language == FormatStyle::LK_Cpp) {
2235 if (Style.FixNamespaceComments)
2236 Passes.emplace_back([&](const Environment &Env) {
2237 return NamespaceEndCommentsFixer(Env, Expanded).process();
2238 });
2239
2240 if (Style.SortUsingDeclarations)
2241 Passes.emplace_back([&](const Environment &Env) {
2242 return UsingDeclarationsSorter(Env, Expanded).process();
2243 });
Krasimir Georgiev32eaa862017-03-01 15:35:39 +00002244 }
2245
2246 if (Style.Language == FormatStyle::LK_JavaScript &&
Krasimir Georgievac16a202017-06-23 11:46:03 +00002247 Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
2248 Passes.emplace_back([&](const Environment &Env) {
2249 return JavaScriptRequoter(Env, Expanded).process();
2250 });
2251
2252 Passes.emplace_back([&](const Environment &Env) {
2253 return Formatter(Env, Expanded, Status).process();
2254 });
2255
Eric Liu2e538082018-05-09 21:35:52 +00002256 auto Env =
2257 llvm::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
2258 NextStartColumn, LastStartColumn);
Krasimir Georgievac16a202017-06-23 11:46:03 +00002259 llvm::Optional<std::string> CurrentCode = None;
2260 tooling::Replacements Fixes;
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002261 unsigned Penalty = 0;
Krasimir Georgievac16a202017-06-23 11:46:03 +00002262 for (size_t I = 0, E = Passes.size(); I < E; ++I) {
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002263 std::pair<tooling::Replacements, unsigned> PassFixes = Passes[I](*Env);
Krasimir Georgievac16a202017-06-23 11:46:03 +00002264 auto NewCode = applyAllReplacements(
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002265 CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first);
Krasimir Georgievac16a202017-06-23 11:46:03 +00002266 if (NewCode) {
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002267 Fixes = Fixes.merge(PassFixes.first);
2268 Penalty += PassFixes.second;
Krasimir Georgievac16a202017-06-23 11:46:03 +00002269 if (I + 1 < E) {
2270 CurrentCode = std::move(*NewCode);
Eric Liu2e538082018-05-09 21:35:52 +00002271 Env = llvm::make_unique<Environment>(
Krasimir Georgievac16a202017-06-23 11:46:03 +00002272 *CurrentCode, FileName,
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002273 tooling::calculateRangesAfterReplacements(Fixes, Ranges),
2274 FirstStartColumn, NextStartColumn, LastStartColumn);
Krasimir Georgievac16a202017-06-23 11:46:03 +00002275 }
2276 }
Daniel Jasper496c1992016-09-07 22:48:53 +00002277 }
2278
Krasimir Georgiev9ad83fe2017-10-30 14:01:50 +00002279 return {Fixes, Penalty};
2280}
2281} // namespace internal
2282
2283tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2284 ArrayRef<tooling::Range> Ranges,
2285 StringRef FileName,
2286 FormattingAttemptStatus *Status) {
2287 return internal::reformat(Style, Code, Ranges,
2288 /*FirstStartColumn=*/0,
2289 /*NextStartColumn=*/0,
2290 /*LastStartColumn=*/0, FileName, Status)
2291 .first;
Eric Liu4cfb88a2016-04-25 15:09:22 +00002292}
2293
Eric Liu4cfb88a2016-04-25 15:09:22 +00002294tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
2295 ArrayRef<tooling::Range> Ranges,
2296 StringRef FileName) {
Martin Probst816a9662017-05-29 08:41:11 +00002297 // cleanups only apply to C++ (they mostly concern ctor commas etc.)
2298 if (Style.Language != FormatStyle::LK_Cpp)
2299 return tooling::Replacements();
Eric Liu2e538082018-05-09 21:35:52 +00002300 return Cleaner(Environment(Code, FileName, Ranges), Style).process().first;
Daniel Jasperec04c0d2013-05-16 10:40:07 +00002301}
2302
Krasimir Georgievbcda54b2017-04-21 14:35:20 +00002303tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2304 ArrayRef<tooling::Range> Ranges,
2305 StringRef FileName, bool *IncompleteFormat) {
2306 FormattingAttemptStatus Status;
2307 auto Result = reformat(Style, Code, Ranges, FileName, &Status);
2308 if (!Status.FormatComplete)
2309 *IncompleteFormat = true;
2310 return Result;
2311}
2312
Krasimir Georgiev7cb267a2017-02-27 13:28:36 +00002313tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
2314 StringRef Code,
2315 ArrayRef<tooling::Range> Ranges,
2316 StringRef FileName) {
Eric Liu2e538082018-05-09 21:35:52 +00002317 return NamespaceEndCommentsFixer(Environment(Code, FileName, Ranges), Style)
2318 .process()
2319 .first;
Krasimir Georgiev7cb267a2017-02-27 13:28:36 +00002320}
2321
Krasimir Georgievb03877a2017-06-21 12:03:12 +00002322tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
2323 StringRef Code,
2324 ArrayRef<tooling::Range> Ranges,
2325 StringRef FileName) {
Eric Liu2e538082018-05-09 21:35:52 +00002326 return UsingDeclarationsSorter(Environment(Code, FileName, Ranges), Style)
2327 .process()
2328 .first;
Krasimir Georgievb03877a2017-06-21 12:03:12 +00002329}
2330
Daniel Jasper4db69bd2014-09-04 18:23:42 +00002331LangOptions getFormattingLangOpts(const FormatStyle &Style) {
Daniel Jasperc1fa2812013-01-10 13:08:12 +00002332 LangOptions LangOpts;
2333 LangOpts.CPlusPlus = 1;
Daniel Jasper4db69bd2014-09-04 18:23:42 +00002334 LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2335 LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
Aaron Ballmanc351fba2017-12-04 20:27:34 +00002336 LangOpts.CPlusPlus17 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
Richard Smithc70f1d62017-12-14 15:16:18 +00002337 LangOpts.CPlusPlus2a = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
Daniel Jasper55213652013-03-22 10:01:29 +00002338 LangOpts.LineComment = 1;
Daniel Jasper1dbc2102017-03-31 13:30:24 +00002339 bool AlternativeOperators = Style.isCpp();
Daniel Jasper30a24062014-11-14 09:02:28 +00002340 LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
Daniel Jasperc1fa2812013-01-10 13:08:12 +00002341 LangOpts.Bool = 1;
Erik Pilkingtonfa983902018-10-30 20:31:30 +00002342 LangOpts.ObjC = 1;
Eric Liu4cfb88a2016-04-25 15:09:22 +00002343 LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
Saleem Abdulrasoold170c4b2015-10-04 17:51:05 +00002344 LangOpts.DeclSpecKeyword = 1; // To get __declspec.
Daniel Jasperc1fa2812013-01-10 13:08:12 +00002345 return LangOpts;
2346}
2347
Edwin Vaned544aa72013-09-30 13:31:48 +00002348const char *StyleOptionHelpDescription =
2349 "Coding style, currently supports:\n"
2350 " LLVM, Google, Chromium, Mozilla, WebKit.\n"
2351 "Use -style=file to load style configuration from\n"
2352 ".clang-format file located in one of the parent\n"
2353 "directories of the source file (or current\n"
2354 "directory for stdin).\n"
2355 "Use -style=\"{key: value, ...}\" to set specific\n"
2356 "parameters, e.g.:\n"
2357 " -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
2358
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002359static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
Daniel Jasper498f5582015-12-25 08:53:31 +00002360 if (FileName.endswith(".java"))
Daniel Jasperc58c70e2014-09-15 11:21:46 +00002361 return FormatStyle::LK_Java;
Daniel Jasper498f5582015-12-25 08:53:31 +00002362 if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
2363 return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
Daniel Jasper03a04fe2016-12-12 12:42:29 +00002364 if (FileName.endswith(".m") || FileName.endswith(".mm"))
2365 return FormatStyle::LK_ObjC;
Daniel Jasper498f5582015-12-25 08:53:31 +00002366 if (FileName.endswith_lower(".proto") ||
2367 FileName.endswith_lower(".protodevel"))
Daniel Jasper7052ce62014-01-19 09:04:08 +00002368 return FormatStyle::LK_Proto;
Krasimir Georgiev66496652017-11-17 15:10:49 +00002369 if (FileName.endswith_lower(".textpb") ||
2370 FileName.endswith_lower(".pb.txt") ||
2371 FileName.endswith_lower(".textproto") ||
2372 FileName.endswith_lower(".asciipb"))
2373 return FormatStyle::LK_TextProto;
Daniel Jasper498f5582015-12-25 08:53:31 +00002374 if (FileName.endswith_lower(".td"))
2375 return FormatStyle::LK_TableGen;
Paul Hoadcbb726d2019-03-21 13:09:22 +00002376 if (FileName.endswith_lower(".cs"))
2377 return FormatStyle::LK_CSharp;
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002378 return FormatStyle::LK_Cpp;
Alexander Kornienkocabdd732013-11-29 15:19:43 +00002379}
2380
Ben Hamilton3b345c32018-02-21 15:54:31 +00002381FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
Ben Hamilton6e066352018-02-27 15:56:40 +00002382 const auto GuessedLanguage = getLanguageByFileName(FileName);
2383 if (GuessedLanguage == FormatStyle::LK_Cpp) {
Ben Hamilton07e58362018-02-21 21:27:27 +00002384 auto Extension = llvm::sys::path::extension(FileName);
Ben Hamilton3b345c32018-02-21 15:54:31 +00002385 // If there's no file extension (or it's .h), we need to check the contents
2386 // of the code to see if it contains Objective-C.
Ben Hamilton07e58362018-02-21 21:27:27 +00002387 if (Extension.empty() || Extension == ".h") {
2388 auto NonEmptyFileName = FileName.empty() ? "guess.h" : FileName;
Eric Liu2e538082018-05-09 21:35:52 +00002389 Environment Env(Code, NonEmptyFileName, /*Ranges=*/{});
2390 ObjCHeaderStyleGuesser Guesser(Env, getLLVMStyle());
Ben Hamilton3b345c32018-02-21 15:54:31 +00002391 Guesser.process();
Ben Hamilton6e066352018-02-27 15:56:40 +00002392 if (Guesser.isObjC())
2393 return FormatStyle::LK_ObjC;
Ben Hamilton3b345c32018-02-21 15:54:31 +00002394 }
2395 }
Ben Hamilton6e066352018-02-27 15:56:40 +00002396 return GuessedLanguage;
Ben Hamilton3b345c32018-02-21 15:54:31 +00002397}
2398
Eric Liub4adc912018-06-25 16:29:19 +00002399const char *DefaultFormatStyle = "file";
2400
2401const char *DefaultFallbackStyle = "LLVM";
2402
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002403llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
Antonio Maiorano7eb75072017-01-20 01:22:42 +00002404 StringRef FallbackStyleName,
Jonas Devliegherefc514902018-10-10 13:27:25 +00002405 StringRef Code,
2406 llvm::vfs::FileSystem *FS) {
Eric Liu547d8792016-03-24 13:22:42 +00002407 if (!FS) {
Jonas Devliegherefc514902018-10-10 13:27:25 +00002408 FS = llvm::vfs::getRealFileSystem().get();
Eric Liu547d8792016-03-24 13:22:42 +00002409 }
Jordan Rupprecht8bd97e72019-02-28 19:16:45 +00002410 FormatStyle Style = getLLVMStyle(guessLanguage(FileName, Code));
Daniel Jasper03a04fe2016-12-12 12:42:29 +00002411
Antonio Maiorano7eb75072017-01-20 01:22:42 +00002412 FormatStyle FallbackStyle = getNoStyle();
2413 if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
2414 return make_string_error("Invalid fallback style \"" + FallbackStyleName);
Edwin Vaned544aa72013-09-30 13:31:48 +00002415
2416 if (StyleName.startswith("{")) {
2417 // Parse YAML/JSON style from the command line.
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002418 if (std::error_code ec = parseConfiguration(StyleName, &Style))
2419 return make_string_error("Error parsing -style: " + ec.message());
Edwin Vaned544aa72013-09-30 13:31:48 +00002420 return Style;
2421 }
2422
2423 if (!StyleName.equals_lower("file")) {
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002424 if (!getPredefinedStyle(StyleName, Style.Language, &Style))
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002425 return make_string_error("Invalid value for -style");
Edwin Vaned544aa72013-09-30 13:31:48 +00002426 return Style;
2427 }
2428
Alexander Kornienkoc1637f12013-12-10 11:28:13 +00002429 // Look for .clang-format/_clang-format file in the file's parent directories.
Alexander Kornienkocabdd732013-11-29 15:19:43 +00002430 SmallString<128> UnsuitableConfigFiles;
Edwin Vaned544aa72013-09-30 13:31:48 +00002431 SmallString<128> Path(FileName);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002432 if (std::error_code EC = FS->makeAbsolute(Path))
2433 return make_string_error(EC.message());
Antonio Maiorano34c03762016-12-22 05:10:07 +00002434
Alexander Kornienkoe2e03872013-10-14 00:46:35 +00002435 for (StringRef Directory = Path; !Directory.empty();
Edwin Vaned544aa72013-09-30 13:31:48 +00002436 Directory = llvm::sys::path::parent_path(Directory)) {
Eric Liu547d8792016-03-24 13:22:42 +00002437
2438 auto Status = FS->status(Directory);
2439 if (!Status ||
2440 Status->getType() != llvm::sys::fs::file_type::directory_file) {
Edwin Vaned544aa72013-09-30 13:31:48 +00002441 continue;
Eric Liu547d8792016-03-24 13:22:42 +00002442 }
2443
Edwin Vaned544aa72013-09-30 13:31:48 +00002444 SmallString<128> ConfigFile(Directory);
2445
2446 llvm::sys::path::append(ConfigFile, ".clang-format");
Nicola Zaghen3538b392018-05-15 13:30:56 +00002447 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
Eric Liud4758322016-03-24 13:22:37 +00002448
Eric Liu547d8792016-03-24 13:22:42 +00002449 Status = FS->status(ConfigFile.str());
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002450 bool FoundConfigFile =
Eric Liu547d8792016-03-24 13:22:42 +00002451 Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002452 if (!FoundConfigFile) {
Edwin Vaned544aa72013-09-30 13:31:48 +00002453 // Try _clang-format too, since dotfiles are not commonly used on Windows.
2454 ConfigFile = Directory;
2455 llvm::sys::path::append(ConfigFile, "_clang-format");
Nicola Zaghen3538b392018-05-15 13:30:56 +00002456 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
Eric Liu547d8792016-03-24 13:22:42 +00002457 Status = FS->status(ConfigFile.str());
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002458 FoundConfigFile = Status && (Status->getType() ==
2459 llvm::sys::fs::file_type::regular_file);
Edwin Vaned544aa72013-09-30 13:31:48 +00002460 }
2461
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002462 if (FoundConfigFile) {
Rafael Espindola2d2b4202014-07-06 17:43:24 +00002463 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
Eric Liu547d8792016-03-24 13:22:42 +00002464 FS->getBufferForFile(ConfigFile.str());
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002465 if (std::error_code EC = Text.getError())
2466 return make_string_error(EC.message());
Rafael Espindola2d2b4202014-07-06 17:43:24 +00002467 if (std::error_code ec =
2468 parseConfiguration(Text.get()->getBuffer(), &Style)) {
Rafael Espindolad0136702014-06-12 02:50:04 +00002469 if (ec == ParseError::Unsuitable) {
Alexander Kornienkocabdd732013-11-29 15:19:43 +00002470 if (!UnsuitableConfigFiles.empty())
2471 UnsuitableConfigFiles.append(", ");
2472 UnsuitableConfigFiles.append(ConfigFile);
Alexander Kornienkobc4ae442013-12-02 15:21:38 +00002473 continue;
Alexander Kornienkocabdd732013-11-29 15:19:43 +00002474 }
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002475 return make_string_error("Error reading " + ConfigFile + ": " +
2476 ec.message());
Edwin Vaned544aa72013-09-30 13:31:48 +00002477 }
Nicola Zaghen3538b392018-05-15 13:30:56 +00002478 LLVM_DEBUG(llvm::dbgs()
2479 << "Using configuration file " << ConfigFile << "\n");
Edwin Vaned544aa72013-09-30 13:31:48 +00002480 return Style;
2481 }
2482 }
Antonio Maiorano3adfb6a2017-01-17 00:12:27 +00002483 if (!UnsuitableConfigFiles.empty())
2484 return make_string_error("Configuration file(s) do(es) not support " +
2485 getLanguageName(Style.Language) + ": " +
2486 UnsuitableConfigFiles);
Antonio Maiorano7eb75072017-01-20 01:22:42 +00002487 return FallbackStyle;
Edwin Vaned544aa72013-09-30 13:31:48 +00002488}
2489
Daniel Jasper8d1832e2013-01-07 13:26:07 +00002490} // namespace format
2491} // namespace clang