Bug Summary

File:include/llvm/Support/Error.h
Warning:line 201, column 5
Potential leak of memory pointed to by 'Payload._M_t._M_head_impl'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Format.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/Format -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/Format -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp

1//===--- Format.cpp - Format C++ code -------------------------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9///
10/// \file
11/// This file implements functions declared in Format.h. This will be
12/// split into separate files as we go.
13///
14//===----------------------------------------------------------------------===//
15
16#include "clang/Format/Format.h"
17#include "AffectedRangeManager.h"
18#include "ContinuationIndenter.h"
19#include "FormatInternal.h"
20#include "FormatTokenLexer.h"
21#include "NamespaceEndCommentsFixer.h"
22#include "SortJavaScriptImports.h"
23#include "TokenAnalyzer.h"
24#include "TokenAnnotator.h"
25#include "UnwrappedLineFormatter.h"
26#include "UnwrappedLineParser.h"
27#include "UsingDeclarationsSorter.h"
28#include "WhitespaceManager.h"
29#include "clang/Basic/Diagnostic.h"
30#include "clang/Basic/DiagnosticOptions.h"
31#include "clang/Basic/SourceManager.h"
32#include "clang/Lex/Lexer.h"
33#include "clang/Tooling/Inclusions/HeaderIncludes.h"
34#include "llvm/ADT/STLExtras.h"
35#include "llvm/ADT/StringRef.h"
36#include "llvm/Support/Allocator.h"
37#include "llvm/Support/Debug.h"
38#include "llvm/Support/Path.h"
39#include "llvm/Support/Regex.h"
40#include "llvm/Support/VirtualFileSystem.h"
41#include "llvm/Support/YAMLTraits.h"
42#include <algorithm>
43#include <memory>
44#include <mutex>
45#include <string>
46#include <unordered_map>
47
48#define DEBUG_TYPE"format-formatter" "format-formatter"
49
50using clang::format::FormatStyle;
51
52LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::RawStringFormat)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<clang::format::FormatStyle::RawStringFormat>::value &&
!std::is_same<clang::format::FormatStyle::RawStringFormat
, std::string>::value && !std::is_same<clang::format
::FormatStyle::RawStringFormat, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<clang::format
::FormatStyle::RawStringFormat> { static const bool flow =
false; }; } }
53
54namespace llvm {
55namespace yaml {
56template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
57 static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
58 IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
59 IO.enumCase(Value, "Java", FormatStyle::LK_Java);
60 IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
61 IO.enumCase(Value, "ObjC", FormatStyle::LK_ObjC);
62 IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
63 IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
64 IO.enumCase(Value, "TextProto", FormatStyle::LK_TextProto);
65 }
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);
85 IO.enumCase(Value, "ForContinuationAndIndentation",
86 FormatStyle::UT_ForContinuationAndIndentation);
87 }
88};
89
90template <> 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
98template <> 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);
105 IO.enumCase(Value, "InlineOnly", FormatStyle::SFS_InlineOnly);
106 IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
107 }
108};
109
110template <> struct ScalarEnumerationTraits<FormatStyle::BinPackStyle> {
111 static void enumeration(IO &IO, FormatStyle::BinPackStyle &Value) {
112 IO.enumCase(Value, "Auto", FormatStyle::BPS_Auto);
113 IO.enumCase(Value, "Always", FormatStyle::BPS_Always);
114 IO.enumCase(Value, "Never", FormatStyle::BPS_Never);
115 }
116};
117
118template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
119 static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
120 IO.enumCase(Value, "All", FormatStyle::BOS_All);
121 IO.enumCase(Value, "true", FormatStyle::BOS_All);
122 IO.enumCase(Value, "None", FormatStyle::BOS_None);
123 IO.enumCase(Value, "false", FormatStyle::BOS_None);
124 IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
125 }
126};
127
128template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
129 static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
130 IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
131 IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
132 IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla);
133 IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
134 IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
135 IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
136 IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit);
137 IO.enumCase(Value, "Custom", FormatStyle::BS_Custom);
138 }
139};
140
141template <>
142struct ScalarEnumerationTraits<FormatStyle::BreakConstructorInitializersStyle> {
143 static void
144 enumeration(IO &IO, FormatStyle::BreakConstructorInitializersStyle &Value) {
145 IO.enumCase(Value, "BeforeColon", FormatStyle::BCIS_BeforeColon);
146 IO.enumCase(Value, "BeforeComma", FormatStyle::BCIS_BeforeComma);
147 IO.enumCase(Value, "AfterColon", FormatStyle::BCIS_AfterColon);
148 }
149};
150
151template <>
152struct ScalarEnumerationTraits<FormatStyle::BreakInheritanceListStyle> {
153 static void
154 enumeration(IO &IO, FormatStyle::BreakInheritanceListStyle &Value) {
155 IO.enumCase(Value, "BeforeColon", FormatStyle::BILS_BeforeColon);
156 IO.enumCase(Value, "BeforeComma", FormatStyle::BILS_BeforeComma);
157 IO.enumCase(Value, "AfterColon", FormatStyle::BILS_AfterColon);
158 }
159};
160
161template <>
162struct ScalarEnumerationTraits<FormatStyle::PPDirectiveIndentStyle> {
163 static void enumeration(IO &IO, FormatStyle::PPDirectiveIndentStyle &Value) {
164 IO.enumCase(Value, "None", FormatStyle::PPDIS_None);
165 IO.enumCase(Value, "AfterHash", FormatStyle::PPDIS_AfterHash);
166 }
167};
168
169template <>
170struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
171 static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
172 IO.enumCase(Value, "None", FormatStyle::RTBS_None);
173 IO.enumCase(Value, "All", FormatStyle::RTBS_All);
174 IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
175 IO.enumCase(Value, "TopLevelDefinitions",
176 FormatStyle::RTBS_TopLevelDefinitions);
177 IO.enumCase(Value, "AllDefinitions", FormatStyle::RTBS_AllDefinitions);
178 }
179};
180
181template <>
182struct ScalarEnumerationTraits<FormatStyle::BreakTemplateDeclarationsStyle> {
183 static void enumeration(IO &IO, FormatStyle::BreakTemplateDeclarationsStyle &Value) {
184 IO.enumCase(Value, "No", FormatStyle::BTDS_No);
185 IO.enumCase(Value, "MultiLine", FormatStyle::BTDS_MultiLine);
186 IO.enumCase(Value, "Yes", FormatStyle::BTDS_Yes);
187
188 // For backward compatibility.
189 IO.enumCase(Value, "false", FormatStyle::BTDS_MultiLine);
190 IO.enumCase(Value, "true", FormatStyle::BTDS_Yes);
191 }
192};
193
194template <>
195struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
196 static void
197 enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) {
198 IO.enumCase(Value, "None", FormatStyle::DRTBS_None);
199 IO.enumCase(Value, "All", FormatStyle::DRTBS_All);
200 IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel);
201
202 // For backward compatibility.
203 IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
204 IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
205 }
206};
207
208template <>
209struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
210 static void enumeration(IO &IO,
211 FormatStyle::NamespaceIndentationKind &Value) {
212 IO.enumCase(Value, "None", FormatStyle::NI_None);
213 IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
214 IO.enumCase(Value, "All", FormatStyle::NI_All);
215 }
216};
217
218template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
219 static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
220 IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
221 IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign);
222 IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
223
224 // For backward compatibility.
225 IO.enumCase(Value, "true", FormatStyle::BAS_Align);
226 IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
227 }
228};
229
230template <>
231struct ScalarEnumerationTraits<FormatStyle::EscapedNewlineAlignmentStyle> {
232 static void enumeration(IO &IO,
233 FormatStyle::EscapedNewlineAlignmentStyle &Value) {
234 IO.enumCase(Value, "DontAlign", FormatStyle::ENAS_DontAlign);
235 IO.enumCase(Value, "Left", FormatStyle::ENAS_Left);
236 IO.enumCase(Value, "Right", FormatStyle::ENAS_Right);
237
238 // For backward compatibility.
239 IO.enumCase(Value, "true", FormatStyle::ENAS_Left);
240 IO.enumCase(Value, "false", FormatStyle::ENAS_Right);
241 }
242};
243
244template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
245 static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
246 IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
247 IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
248 IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
249
250 // For backward compatibility.
251 IO.enumCase(Value, "true", FormatStyle::PAS_Left);
252 IO.enumCase(Value, "false", FormatStyle::PAS_Right);
253 }
254};
255
256template <>
257struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
258 static void enumeration(IO &IO,
259 FormatStyle::SpaceBeforeParensOptions &Value) {
260 IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
261 IO.enumCase(Value, "ControlStatements",
262 FormatStyle::SBPO_ControlStatements);
263 IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
264
265 // For backward compatibility.
266 IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
267 IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
268 }
269};
270
271template <> struct MappingTraits<FormatStyle> {
272 static void mapping(IO &IO, FormatStyle &Style) {
273 // When reading, read the language first, we need it for getPredefinedStyle.
274 IO.mapOptional("Language", Style.Language);
275
276 if (IO.outputting()) {
277 StringRef StylesArray[] = {"LLVM", "Google", "Chromium",
278 "Mozilla", "WebKit", "GNU"};
279 ArrayRef<StringRef> Styles(StylesArray);
280 for (size_t i = 0, e = Styles.size(); i < e; ++i) {
281 StringRef StyleName(Styles[i]);
282 FormatStyle PredefinedStyle;
283 if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
284 Style == PredefinedStyle) {
285 IO.mapOptional("# BasedOnStyle", StyleName);
286 break;
287 }
288 }
289 } else {
290 StringRef BasedOnStyle;
291 IO.mapOptional("BasedOnStyle", BasedOnStyle);
292 if (!BasedOnStyle.empty()) {
293 FormatStyle::LanguageKind OldLanguage = Style.Language;
294 FormatStyle::LanguageKind Language =
295 ((FormatStyle *)IO.getContext())->Language;
296 if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
297 IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
298 return;
299 }
300 Style.Language = OldLanguage;
301 }
302 }
303
304 // For backward compatibility.
305 if (!IO.outputting()) {
306 IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlines);
307 IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
308 IO.mapOptional("IndentFunctionDeclarationAfterType",
309 Style.IndentWrappedFunctionNames);
310 IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
311 IO.mapOptional("SpaceAfterControlStatementKeyword",
312 Style.SpaceBeforeParens);
313 }
314
315 IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
316 IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
317 IO.mapOptional("AlignConsecutiveAssignments",
318 Style.AlignConsecutiveAssignments);
319 IO.mapOptional("AlignConsecutiveDeclarations",
320 Style.AlignConsecutiveDeclarations);
321 IO.mapOptional("AlignEscapedNewlines", Style.AlignEscapedNewlines);
322 IO.mapOptional("AlignOperands", Style.AlignOperands);
323 IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
324 IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
325 Style.AllowAllParametersOfDeclarationOnNextLine);
326 IO.mapOptional("AllowShortBlocksOnASingleLine",
327 Style.AllowShortBlocksOnASingleLine);
328 IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
329 Style.AllowShortCaseLabelsOnASingleLine);
330 IO.mapOptional("AllowShortFunctionsOnASingleLine",
331 Style.AllowShortFunctionsOnASingleLine);
332 IO.mapOptional("AllowShortIfStatementsOnASingleLine",
333 Style.AllowShortIfStatementsOnASingleLine);
334 IO.mapOptional("AllowShortLoopsOnASingleLine",
335 Style.AllowShortLoopsOnASingleLine);
336 IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
337 Style.AlwaysBreakAfterDefinitionReturnType);
338 IO.mapOptional("AlwaysBreakAfterReturnType",
339 Style.AlwaysBreakAfterReturnType);
340 // If AlwaysBreakAfterDefinitionReturnType was specified but
341 // AlwaysBreakAfterReturnType was not, initialize the latter from the
342 // former for backwards compatibility.
343 if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
344 Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
345 if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
346 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
347 else if (Style.AlwaysBreakAfterDefinitionReturnType ==
348 FormatStyle::DRTBS_TopLevel)
349 Style.AlwaysBreakAfterReturnType =
350 FormatStyle::RTBS_TopLevelDefinitions;
351 }
352
353 IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
354 Style.AlwaysBreakBeforeMultilineStrings);
355 IO.mapOptional("AlwaysBreakTemplateDeclarations",
356 Style.AlwaysBreakTemplateDeclarations);
357 IO.mapOptional("BinPackArguments", Style.BinPackArguments);
358 IO.mapOptional("BinPackParameters", Style.BinPackParameters);
359 IO.mapOptional("BraceWrapping", Style.BraceWrapping);
360 IO.mapOptional("BreakBeforeBinaryOperators",
361 Style.BreakBeforeBinaryOperators);
362 IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
363
364 bool BreakBeforeInheritanceComma = false;
365 IO.mapOptional("BreakBeforeInheritanceComma",
366 BreakBeforeInheritanceComma);
367 IO.mapOptional("BreakInheritanceList",
368 Style.BreakInheritanceList);
369 // If BreakBeforeInheritanceComma was specified but
370 // BreakInheritance was not, initialize the latter from the
371 // former for backwards compatibility.
372 if (BreakBeforeInheritanceComma &&
373 Style.BreakInheritanceList == FormatStyle::BILS_BeforeColon)
374 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
375
376 IO.mapOptional("BreakBeforeTernaryOperators",
377 Style.BreakBeforeTernaryOperators);
378
379 bool BreakConstructorInitializersBeforeComma = false;
380 IO.mapOptional("BreakConstructorInitializersBeforeComma",
381 BreakConstructorInitializersBeforeComma);
382 IO.mapOptional("BreakConstructorInitializers",
383 Style.BreakConstructorInitializers);
384 // If BreakConstructorInitializersBeforeComma was specified but
385 // BreakConstructorInitializers was not, initialize the latter from the
386 // former for backwards compatibility.
387 if (BreakConstructorInitializersBeforeComma &&
388 Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeColon)
389 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
390
391 IO.mapOptional("BreakAfterJavaFieldAnnotations",
392 Style.BreakAfterJavaFieldAnnotations);
393 IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
394 IO.mapOptional("ColumnLimit", Style.ColumnLimit);
395 IO.mapOptional("CommentPragmas", Style.CommentPragmas);
396 IO.mapOptional("CompactNamespaces", Style.CompactNamespaces);
397 IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
398 Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
399 IO.mapOptional("ConstructorInitializerIndentWidth",
400 Style.ConstructorInitializerIndentWidth);
401 IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
402 IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
403 IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
404 IO.mapOptional("DisableFormat", Style.DisableFormat);
405 IO.mapOptional("ExperimentalAutoDetectBinPacking",
406 Style.ExperimentalAutoDetectBinPacking);
407 IO.mapOptional("FixNamespaceComments", Style.FixNamespaceComments);
408 IO.mapOptional("ForEachMacros", Style.ForEachMacros);
409 IO.mapOptional("IncludeBlocks", Style.IncludeStyle.IncludeBlocks);
410 IO.mapOptional("IncludeCategories", Style.IncludeStyle.IncludeCategories);
411 IO.mapOptional("IncludeIsMainRegex", Style.IncludeStyle.IncludeIsMainRegex);
412 IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
413 IO.mapOptional("IndentPPDirectives", Style.IndentPPDirectives);
414 IO.mapOptional("IndentWidth", Style.IndentWidth);
415 IO.mapOptional("IndentWrappedFunctionNames",
416 Style.IndentWrappedFunctionNames);
417 IO.mapOptional("JavaImportGroups", Style.JavaImportGroups);
418 IO.mapOptional("JavaScriptQuotes", Style.JavaScriptQuotes);
419 IO.mapOptional("JavaScriptWrapImports", Style.JavaScriptWrapImports);
420 IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
421 Style.KeepEmptyLinesAtTheStartOfBlocks);
422 IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
423 IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
424 IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
425 IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
426 IO.mapOptional("ObjCBinPackProtocolList", Style.ObjCBinPackProtocolList);
427 IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
428 IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
429 IO.mapOptional("ObjCSpaceBeforeProtocolList",
430 Style.ObjCSpaceBeforeProtocolList);
431 IO.mapOptional("PenaltyBreakAssignment", Style.PenaltyBreakAssignment);
432 IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
433 Style.PenaltyBreakBeforeFirstCallParameter);
434 IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
435 IO.mapOptional("PenaltyBreakFirstLessLess",
436 Style.PenaltyBreakFirstLessLess);
437 IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
438 IO.mapOptional("PenaltyBreakTemplateDeclaration",
439 Style.PenaltyBreakTemplateDeclaration);
440 IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
441 IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
442 Style.PenaltyReturnTypeOnItsOwnLine);
443 IO.mapOptional("PointerAlignment", Style.PointerAlignment);
444 IO.mapOptional("RawStringFormats", Style.RawStringFormats);
445 IO.mapOptional("ReflowComments", Style.ReflowComments);
446 IO.mapOptional("SortIncludes", Style.SortIncludes);
447 IO.mapOptional("SortUsingDeclarations", Style.SortUsingDeclarations);
448 IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
449 IO.mapOptional("SpaceAfterTemplateKeyword",
450 Style.SpaceAfterTemplateKeyword);
451 IO.mapOptional("SpaceBeforeAssignmentOperators",
452 Style.SpaceBeforeAssignmentOperators);
453 IO.mapOptional("SpaceBeforeCpp11BracedList",
454 Style.SpaceBeforeCpp11BracedList);
455 IO.mapOptional("SpaceBeforeCtorInitializerColon",
456 Style.SpaceBeforeCtorInitializerColon);
457 IO.mapOptional("SpaceBeforeInheritanceColon",
458 Style.SpaceBeforeInheritanceColon);
459 IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
460 IO.mapOptional("SpaceBeforeRangeBasedForLoopColon",
461 Style.SpaceBeforeRangeBasedForLoopColon);
462 IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
463 IO.mapOptional("SpacesBeforeTrailingComments",
464 Style.SpacesBeforeTrailingComments);
465 IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
466 IO.mapOptional("SpacesInContainerLiterals",
467 Style.SpacesInContainerLiterals);
468 IO.mapOptional("SpacesInCStyleCastParentheses",
469 Style.SpacesInCStyleCastParentheses);
470 IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
471 IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
472 IO.mapOptional("Standard", Style.Standard);
473 IO.mapOptional("StatementMacros", Style.StatementMacros);
474 IO.mapOptional("TabWidth", Style.TabWidth);
475 IO.mapOptional("UseTab", Style.UseTab);
476 }
477};
478
479template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
480 static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
481 IO.mapOptional("AfterClass", Wrapping.AfterClass);
482 IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
483 IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
484 IO.mapOptional("AfterFunction", Wrapping.AfterFunction);
485 IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace);
486 IO.mapOptional("AfterObjCDeclaration", Wrapping.AfterObjCDeclaration);
487 IO.mapOptional("AfterStruct", Wrapping.AfterStruct);
488 IO.mapOptional("AfterUnion", Wrapping.AfterUnion);
489 IO.mapOptional("AfterExternBlock", Wrapping.AfterExternBlock);
490 IO.mapOptional("BeforeCatch", Wrapping.BeforeCatch);
491 IO.mapOptional("BeforeElse", Wrapping.BeforeElse);
492 IO.mapOptional("IndentBraces", Wrapping.IndentBraces);
493 IO.mapOptional("SplitEmptyFunction", Wrapping.SplitEmptyFunction);
494 IO.mapOptional("SplitEmptyRecord", Wrapping.SplitEmptyRecord);
495 IO.mapOptional("SplitEmptyNamespace", Wrapping.SplitEmptyNamespace);
496 }
497};
498
499template <> struct MappingTraits<FormatStyle::RawStringFormat> {
500 static void mapping(IO &IO, FormatStyle::RawStringFormat &Format) {
501 IO.mapOptional("Language", Format.Language);
502 IO.mapOptional("Delimiters", Format.Delimiters);
503 IO.mapOptional("EnclosingFunctions", Format.EnclosingFunctions);
504 IO.mapOptional("CanonicalDelimiter", Format.CanonicalDelimiter);
505 IO.mapOptional("BasedOnStyle", Format.BasedOnStyle);
506 }
507};
508
509// Allows to read vector<FormatStyle> while keeping default values.
510// IO.getContext() should contain a pointer to the FormatStyle structure, that
511// will be used to get default values for missing keys.
512// If the first element has no Language specified, it will be treated as the
513// default one for the following elements.
514template <> struct DocumentListTraits<std::vector<FormatStyle>> {
515 static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
516 return Seq.size();
517 }
518 static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
519 size_t Index) {
520 if (Index >= Seq.size()) {
521 assert(Index == Seq.size())((Index == Seq.size()) ? static_cast<void> (0) : __assert_fail
("Index == Seq.size()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 521, __PRETTY_FUNCTION__))
;
522 FormatStyle Template;
523 if (!Seq.empty() && Seq[0].Language == FormatStyle::LK_None) {
524 Template = Seq[0];
525 } else {
526 Template = *((const FormatStyle *)IO.getContext());
527 Template.Language = FormatStyle::LK_None;
528 }
529 Seq.resize(Index + 1, Template);
530 }
531 return Seq[Index];
532 }
533};
534} // namespace yaml
535} // namespace llvm
536
537namespace clang {
538namespace format {
539
540const std::error_category &getParseCategory() {
541 static const ParseErrorCategory C{};
542 return C;
543}
544std::error_code make_error_code(ParseError e) {
545 return std::error_code(static_cast<int>(e), getParseCategory());
546}
547
548inline llvm::Error make_string_error(const llvm::Twine &Message) {
549 return llvm::make_error<llvm::StringError>(Message,
1
Calling 'make_error<llvm::StringError, const llvm::Twine &, std::error_code>'
550 llvm::inconvertibleErrorCode());
551}
552
553const char *ParseErrorCategory::name() const noexcept {
554 return "clang-format.parse_error";
555}
556
557std::string ParseErrorCategory::message(int EV) const {
558 switch (static_cast<ParseError>(EV)) {
559 case ParseError::Success:
560 return "Success";
561 case ParseError::Error:
562 return "Invalid argument";
563 case ParseError::Unsuitable:
564 return "Unsuitable";
565 }
566 llvm_unreachable("unexpected parse error")::llvm::llvm_unreachable_internal("unexpected parse error", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 566)
;
567}
568
569static FormatStyle expandPresets(const FormatStyle &Style) {
570 if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
571 return Style;
572 FormatStyle Expanded = Style;
573 Expanded.BraceWrapping = {false, false, false, false, false,
574 false, false, false, false, false,
575 false, false, true, true, true};
576 switch (Style.BreakBeforeBraces) {
577 case FormatStyle::BS_Linux:
578 Expanded.BraceWrapping.AfterClass = true;
579 Expanded.BraceWrapping.AfterFunction = true;
580 Expanded.BraceWrapping.AfterNamespace = true;
581 break;
582 case FormatStyle::BS_Mozilla:
583 Expanded.BraceWrapping.AfterClass = true;
584 Expanded.BraceWrapping.AfterEnum = true;
585 Expanded.BraceWrapping.AfterFunction = true;
586 Expanded.BraceWrapping.AfterStruct = true;
587 Expanded.BraceWrapping.AfterUnion = true;
588 Expanded.BraceWrapping.AfterExternBlock = true;
589 Expanded.BraceWrapping.SplitEmptyFunction = true;
590 Expanded.BraceWrapping.SplitEmptyRecord = false;
591 break;
592 case FormatStyle::BS_Stroustrup:
593 Expanded.BraceWrapping.AfterFunction = true;
594 Expanded.BraceWrapping.BeforeCatch = true;
595 Expanded.BraceWrapping.BeforeElse = true;
596 break;
597 case FormatStyle::BS_Allman:
598 Expanded.BraceWrapping.AfterClass = true;
599 Expanded.BraceWrapping.AfterControlStatement = true;
600 Expanded.BraceWrapping.AfterEnum = true;
601 Expanded.BraceWrapping.AfterFunction = true;
602 Expanded.BraceWrapping.AfterNamespace = true;
603 Expanded.BraceWrapping.AfterObjCDeclaration = true;
604 Expanded.BraceWrapping.AfterStruct = true;
605 Expanded.BraceWrapping.AfterExternBlock = true;
606 Expanded.BraceWrapping.BeforeCatch = true;
607 Expanded.BraceWrapping.BeforeElse = true;
608 break;
609 case FormatStyle::BS_GNU:
610 Expanded.BraceWrapping = {true, true, true, true, true, true, true, true,
611 true, true, true, true, true, true, true};
612 break;
613 case FormatStyle::BS_WebKit:
614 Expanded.BraceWrapping.AfterFunction = true;
615 break;
616 default:
617 break;
618 }
619 return Expanded;
620}
621
622FormatStyle getLLVMStyle() {
623 FormatStyle LLVMStyle;
624 LLVMStyle.Language = FormatStyle::LK_Cpp;
625 LLVMStyle.AccessModifierOffset = -2;
626 LLVMStyle.AlignEscapedNewlines = FormatStyle::ENAS_Right;
627 LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
628 LLVMStyle.AlignOperands = true;
629 LLVMStyle.AlignTrailingComments = true;
630 LLVMStyle.AlignConsecutiveAssignments = false;
631 LLVMStyle.AlignConsecutiveDeclarations = false;
632 LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
633 LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
634 LLVMStyle.AllowShortBlocksOnASingleLine = false;
635 LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
636 LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
637 LLVMStyle.AllowShortLoopsOnASingleLine = false;
638 LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
639 LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
640 LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
641 LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
642 LLVMStyle.BinPackArguments = true;
643 LLVMStyle.BinPackParameters = true;
644 LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
645 LLVMStyle.BreakBeforeTernaryOperators = true;
646 LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
647 LLVMStyle.BraceWrapping = {false, false, false, false, false,
648 false, false, false, false, false,
649 false, false, true, true, true};
650 LLVMStyle.BreakAfterJavaFieldAnnotations = false;
651 LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
652 LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
653 LLVMStyle.BreakStringLiterals = true;
654 LLVMStyle.ColumnLimit = 80;
655 LLVMStyle.CommentPragmas = "^ IWYU pragma:";
656 LLVMStyle.CompactNamespaces = false;
657 LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
658 LLVMStyle.ConstructorInitializerIndentWidth = 4;
659 LLVMStyle.ContinuationIndentWidth = 4;
660 LLVMStyle.Cpp11BracedListStyle = true;
661 LLVMStyle.DerivePointerAlignment = false;
662 LLVMStyle.ExperimentalAutoDetectBinPacking = false;
663 LLVMStyle.FixNamespaceComments = true;
664 LLVMStyle.ForEachMacros.push_back("foreach");
665 LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
666 LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
667 LLVMStyle.IncludeStyle.IncludeCategories = {
668 {"^\"(llvm|llvm-c|clang|clang-c)/", 2},
669 {"^(<|\"(gtest|gmock|isl|json)/)", 3},
670 {".*", 1}};
671 LLVMStyle.IncludeStyle.IncludeIsMainRegex = "(Test)?$";
672 LLVMStyle.IncludeStyle.IncludeBlocks = tooling::IncludeStyle::IBS_Preserve;
673 LLVMStyle.IndentCaseLabels = false;
674 LLVMStyle.IndentPPDirectives = FormatStyle::PPDIS_None;
675 LLVMStyle.IndentWrappedFunctionNames = false;
676 LLVMStyle.IndentWidth = 2;
677 LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
678 LLVMStyle.JavaScriptWrapImports = true;
679 LLVMStyle.TabWidth = 8;
680 LLVMStyle.MaxEmptyLinesToKeep = 1;
681 LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
682 LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
683 LLVMStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
684 LLVMStyle.ObjCBlockIndentWidth = 2;
685 LLVMStyle.ObjCSpaceAfterProperty = false;
686 LLVMStyle.ObjCSpaceBeforeProtocolList = true;
687 LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
688 LLVMStyle.SpacesBeforeTrailingComments = 1;
689 LLVMStyle.Standard = FormatStyle::LS_Cpp11;
690 LLVMStyle.UseTab = FormatStyle::UT_Never;
691 LLVMStyle.ReflowComments = true;
692 LLVMStyle.SpacesInParentheses = false;
693 LLVMStyle.SpacesInSquareBrackets = false;
694 LLVMStyle.SpaceInEmptyParentheses = false;
695 LLVMStyle.SpacesInContainerLiterals = true;
696 LLVMStyle.SpacesInCStyleCastParentheses = false;
697 LLVMStyle.SpaceAfterCStyleCast = false;
698 LLVMStyle.SpaceAfterTemplateKeyword = true;
699 LLVMStyle.SpaceBeforeCtorInitializerColon = true;
700 LLVMStyle.SpaceBeforeInheritanceColon = true;
701 LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
702 LLVMStyle.SpaceBeforeRangeBasedForLoopColon = true;
703 LLVMStyle.SpaceBeforeAssignmentOperators = true;
704 LLVMStyle.SpaceBeforeCpp11BracedList = false;
705 LLVMStyle.SpacesInAngles = false;
706
707 LLVMStyle.PenaltyBreakAssignment = prec::Assignment;
708 LLVMStyle.PenaltyBreakComment = 300;
709 LLVMStyle.PenaltyBreakFirstLessLess = 120;
710 LLVMStyle.PenaltyBreakString = 1000;
711 LLVMStyle.PenaltyExcessCharacter = 1000000;
712 LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
713 LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
714 LLVMStyle.PenaltyBreakTemplateDeclaration = prec::Relational;
715
716 LLVMStyle.DisableFormat = false;
717 LLVMStyle.SortIncludes = true;
718 LLVMStyle.SortUsingDeclarations = true;
719 LLVMStyle.StatementMacros.push_back("Q_UNUSED");
720 LLVMStyle.StatementMacros.push_back("QT_REQUIRE_VERSION");
721
722 return LLVMStyle;
723}
724
725FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
726 if (Language == FormatStyle::LK_TextProto) {
727 FormatStyle GoogleStyle = getGoogleStyle(FormatStyle::LK_Proto);
728 GoogleStyle.Language = FormatStyle::LK_TextProto;
729
730 return GoogleStyle;
731 }
732
733 FormatStyle GoogleStyle = getLLVMStyle();
734 GoogleStyle.Language = Language;
735
736 GoogleStyle.AccessModifierOffset = -1;
737 GoogleStyle.AlignEscapedNewlines = FormatStyle::ENAS_Left;
738 GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
739 GoogleStyle.AllowShortLoopsOnASingleLine = true;
740 GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
741 GoogleStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
742 GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
743 GoogleStyle.DerivePointerAlignment = true;
744 GoogleStyle.IncludeStyle.IncludeCategories = {
745 {"^<ext/.*\\.h>", 2}, {"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
746 GoogleStyle.IncludeStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
747 GoogleStyle.IndentCaseLabels = true;
748 GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
749 GoogleStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Never;
750 GoogleStyle.ObjCSpaceAfterProperty = false;
751 GoogleStyle.ObjCSpaceBeforeProtocolList = true;
752 GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
753 GoogleStyle.RawStringFormats = {
754 {
755 FormatStyle::LK_Cpp,
756 /*Delimiters=*/
757 {
758 "cc",
759 "CC",
760 "cpp",
761 "Cpp",
762 "CPP",
763 "c++",
764 "C++",
765 },
766 /*EnclosingFunctionNames=*/
767 {},
768 /*CanonicalDelimiter=*/"",
769 /*BasedOnStyle=*/"google",
770 },
771 {
772 FormatStyle::LK_TextProto,
773 /*Delimiters=*/
774 {
775 "pb",
776 "PB",
777 "proto",
778 "PROTO",
779 },
780 /*EnclosingFunctionNames=*/
781 {
782 "EqualsProto",
783 "EquivToProto",
784 "PARSE_PARTIAL_TEXT_PROTO",
785 "PARSE_TEST_PROTO",
786 "PARSE_TEXT_PROTO",
787 "ParseTextOrDie",
788 "ParseTextProtoOrDie",
789 },
790 /*CanonicalDelimiter=*/"",
791 /*BasedOnStyle=*/"google",
792 },
793 };
794 GoogleStyle.SpacesBeforeTrailingComments = 2;
795 GoogleStyle.Standard = FormatStyle::LS_Auto;
796
797 GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
798 GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
799
800 if (Language == FormatStyle::LK_Java) {
801 GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
802 GoogleStyle.AlignOperands = false;
803 GoogleStyle.AlignTrailingComments = false;
804 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
805 GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
806 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
807 GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
808 GoogleStyle.ColumnLimit = 100;
809 GoogleStyle.SpaceAfterCStyleCast = true;
810 GoogleStyle.SpacesBeforeTrailingComments = 1;
811 } else if (Language == FormatStyle::LK_JavaScript) {
812 GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
813 GoogleStyle.AlignOperands = false;
814 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
815 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
816 GoogleStyle.BreakBeforeTernaryOperators = false;
817 // taze:, triple slash directives (`/// <...`), @see, which is commonly
818 // followed by overlong URLs.
819 GoogleStyle.CommentPragmas = "(taze:|^/[ \t]*<|@see)";
820 GoogleStyle.MaxEmptyLinesToKeep = 3;
821 GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
822 GoogleStyle.SpacesInContainerLiterals = false;
823 GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
824 GoogleStyle.JavaScriptWrapImports = false;
825 } else if (Language == FormatStyle::LK_Proto) {
826 GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
827 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
828 GoogleStyle.SpacesInContainerLiterals = false;
829 GoogleStyle.Cpp11BracedListStyle = false;
830 // This affects protocol buffer options specifications and text protos.
831 // Text protos are currently mostly formatted inside C++ raw string literals
832 // and often the current breaking behavior of string literals is not
833 // beneficial there. Investigate turning this on once proper string reflow
834 // has been implemented.
835 GoogleStyle.BreakStringLiterals = false;
836 } else if (Language == FormatStyle::LK_ObjC) {
837 GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
838 GoogleStyle.ColumnLimit = 100;
839 }
840
841 return GoogleStyle;
842}
843
844FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
845 FormatStyle ChromiumStyle = getGoogleStyle(Language);
846 if (Language == FormatStyle::LK_Java) {
847 ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
848 ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
849 ChromiumStyle.ContinuationIndentWidth = 8;
850 ChromiumStyle.IndentWidth = 4;
851 // See styleguide for import groups:
852 // https://chromium.googlesource.com/chromium/src/+/master/styleguide/java/java.md#Import-Order
853 ChromiumStyle.JavaImportGroups = {
854 "android",
855 "com",
856 "dalvik",
857 "junit",
858 "org",
859 "com.google.android.apps.chrome",
860 "org.chromium",
861 "java",
862 "javax",
863 };
864 ChromiumStyle.SortIncludes = true;
865 } else if (Language == FormatStyle::LK_JavaScript) {
866 ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
867 ChromiumStyle.AllowShortLoopsOnASingleLine = false;
868 } else {
869 ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
870 ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
871 ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
872 ChromiumStyle.AllowShortLoopsOnASingleLine = false;
873 ChromiumStyle.BinPackParameters = false;
874 ChromiumStyle.DerivePointerAlignment = false;
875 if (Language == FormatStyle::LK_ObjC)
876 ChromiumStyle.ColumnLimit = 80;
877 }
878 return ChromiumStyle;
879}
880
881FormatStyle getMozillaStyle() {
882 FormatStyle MozillaStyle = getLLVMStyle();
883 MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
884 MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
885 MozillaStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
886 MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
887 FormatStyle::DRTBS_TopLevel;
888 MozillaStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
889 MozillaStyle.BinPackParameters = false;
890 MozillaStyle.BinPackArguments = false;
891 MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
892 MozillaStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
893 MozillaStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
894 MozillaStyle.ConstructorInitializerIndentWidth = 2;
895 MozillaStyle.ContinuationIndentWidth = 2;
896 MozillaStyle.Cpp11BracedListStyle = false;
897 MozillaStyle.FixNamespaceComments = false;
898 MozillaStyle.IndentCaseLabels = true;
899 MozillaStyle.ObjCSpaceAfterProperty = true;
900 MozillaStyle.ObjCSpaceBeforeProtocolList = false;
901 MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
902 MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
903 MozillaStyle.SpaceAfterTemplateKeyword = false;
904 return MozillaStyle;
905}
906
907FormatStyle getWebKitStyle() {
908 FormatStyle Style = getLLVMStyle();
909 Style.AccessModifierOffset = -4;
910 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
911 Style.AlignOperands = false;
912 Style.AlignTrailingComments = false;
913 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
914 Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
915 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
916 Style.Cpp11BracedListStyle = false;
917 Style.ColumnLimit = 0;
918 Style.FixNamespaceComments = false;
919 Style.IndentWidth = 4;
920 Style.NamespaceIndentation = FormatStyle::NI_Inner;
921 Style.ObjCBlockIndentWidth = 4;
922 Style.ObjCSpaceAfterProperty = true;
923 Style.PointerAlignment = FormatStyle::PAS_Left;
924 Style.SpaceBeforeCpp11BracedList = true;
925 return Style;
926}
927
928FormatStyle getGNUStyle() {
929 FormatStyle Style = getLLVMStyle();
930 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
931 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
932 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
933 Style.BreakBeforeBraces = FormatStyle::BS_GNU;
934 Style.BreakBeforeTernaryOperators = true;
935 Style.Cpp11BracedListStyle = false;
936 Style.ColumnLimit = 79;
937 Style.FixNamespaceComments = false;
938 Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
939 Style.Standard = FormatStyle::LS_Cpp03;
940 return Style;
941}
942
943FormatStyle getNoStyle() {
944 FormatStyle NoStyle = getLLVMStyle();
945 NoStyle.DisableFormat = true;
946 NoStyle.SortIncludes = false;
947 NoStyle.SortUsingDeclarations = false;
948 return NoStyle;
949}
950
951bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
952 FormatStyle *Style) {
953 if (Name.equals_lower("llvm")) {
954 *Style = getLLVMStyle();
955 } else if (Name.equals_lower("chromium")) {
956 *Style = getChromiumStyle(Language);
957 } else if (Name.equals_lower("mozilla")) {
958 *Style = getMozillaStyle();
959 } else if (Name.equals_lower("google")) {
960 *Style = getGoogleStyle(Language);
961 } else if (Name.equals_lower("webkit")) {
962 *Style = getWebKitStyle();
963 } else if (Name.equals_lower("gnu")) {
964 *Style = getGNUStyle();
965 } else if (Name.equals_lower("none")) {
966 *Style = getNoStyle();
967 } else {
968 return false;
969 }
970
971 Style->Language = Language;
972 return true;
973}
974
975std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
976 assert(Style)((Style) ? static_cast<void> (0) : __assert_fail ("Style"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 976, __PRETTY_FUNCTION__))
;
977 FormatStyle::LanguageKind Language = Style->Language;
978 assert(Language != FormatStyle::LK_None)((Language != FormatStyle::LK_None) ? static_cast<void>
(0) : __assert_fail ("Language != FormatStyle::LK_None", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 978, __PRETTY_FUNCTION__))
;
979 if (Text.trim().empty())
980 return make_error_code(ParseError::Error);
981 Style->StyleSet.Clear();
982 std::vector<FormatStyle> Styles;
983 llvm::yaml::Input Input(Text);
984 // DocumentListTraits<vector<FormatStyle>> uses the context to get default
985 // values for the fields, keys for which are missing from the configuration.
986 // Mapping also uses the context to get the language to find the correct
987 // base style.
988 Input.setContext(Style);
989 Input >> Styles;
990 if (Input.error())
991 return Input.error();
992
993 for (unsigned i = 0; i < Styles.size(); ++i) {
994 // Ensures that only the first configuration can skip the Language option.
995 if (Styles[i].Language == FormatStyle::LK_None && i != 0)
996 return make_error_code(ParseError::Error);
997 // Ensure that each language is configured at most once.
998 for (unsigned j = 0; j < i; ++j) {
999 if (Styles[i].Language == Styles[j].Language) {
1000 LLVM_DEBUG(llvm::dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Duplicate languages in the config file on positions "
<< j << " and " << i << "\n"; } } while
(false)
1001 << "Duplicate languages in the config file on positions "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Duplicate languages in the config file on positions "
<< j << " and " << i << "\n"; } } while
(false)
1002 << j << " and " << i << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Duplicate languages in the config file on positions "
<< j << " and " << i << "\n"; } } while
(false)
;
1003 return make_error_code(ParseError::Error);
1004 }
1005 }
1006 }
1007 // Look for a suitable configuration starting from the end, so we can
1008 // find the configuration for the specific language first, and the default
1009 // configuration (which can only be at slot 0) after it.
1010 FormatStyle::FormatStyleSet StyleSet;
1011 bool LanguageFound = false;
1012 for (int i = Styles.size() - 1; i >= 0; --i) {
1013 if (Styles[i].Language != FormatStyle::LK_None)
1014 StyleSet.Add(Styles[i]);
1015 if (Styles[i].Language == Language)
1016 LanguageFound = true;
1017 }
1018 if (!LanguageFound) {
1019 if (Styles.empty() || Styles[0].Language != FormatStyle::LK_None)
1020 return make_error_code(ParseError::Unsuitable);
1021 FormatStyle DefaultStyle = Styles[0];
1022 DefaultStyle.Language = Language;
1023 StyleSet.Add(std::move(DefaultStyle));
1024 }
1025 *Style = *StyleSet.Get(Language);
1026 return make_error_code(ParseError::Success);
1027}
1028
1029std::string configurationAsText(const FormatStyle &Style) {
1030 std::string Text;
1031 llvm::raw_string_ostream Stream(Text);
1032 llvm::yaml::Output Output(Stream);
1033 // We use the same mapping method for input and output, so we need a non-const
1034 // reference here.
1035 FormatStyle NonConstStyle = expandPresets(Style);
1036 Output << NonConstStyle;
1037 return Stream.str();
1038}
1039
1040llvm::Optional<FormatStyle>
1041FormatStyle::FormatStyleSet::Get(FormatStyle::LanguageKind Language) const {
1042 if (!Styles)
1043 return None;
1044 auto It = Styles->find(Language);
1045 if (It == Styles->end())
1046 return None;
1047 FormatStyle Style = It->second;
1048 Style.StyleSet = *this;
1049 return Style;
1050}
1051
1052void FormatStyle::FormatStyleSet::Add(FormatStyle Style) {
1053 assert(Style.Language != LK_None &&((Style.Language != LK_None && "Cannot add a style for LK_None to a StyleSet"
) ? static_cast<void> (0) : __assert_fail ("Style.Language != LK_None && \"Cannot add a style for LK_None to a StyleSet\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1054, __PRETTY_FUNCTION__))
1054 "Cannot add a style for LK_None to a StyleSet")((Style.Language != LK_None && "Cannot add a style for LK_None to a StyleSet"
) ? static_cast<void> (0) : __assert_fail ("Style.Language != LK_None && \"Cannot add a style for LK_None to a StyleSet\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1054, __PRETTY_FUNCTION__))
;
1055 assert(((!Style.StyleSet.Styles && "Cannot add a style associated with an existing StyleSet to a StyleSet"
) ? static_cast<void> (0) : __assert_fail ("!Style.StyleSet.Styles && \"Cannot add a style associated with an existing StyleSet to a StyleSet\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1057, __PRETTY_FUNCTION__))
1056 !Style.StyleSet.Styles &&((!Style.StyleSet.Styles && "Cannot add a style associated with an existing StyleSet to a StyleSet"
) ? static_cast<void> (0) : __assert_fail ("!Style.StyleSet.Styles && \"Cannot add a style associated with an existing StyleSet to a StyleSet\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1057, __PRETTY_FUNCTION__))
1057 "Cannot add a style associated with an existing StyleSet to a StyleSet")((!Style.StyleSet.Styles && "Cannot add a style associated with an existing StyleSet to a StyleSet"
) ? static_cast<void> (0) : __assert_fail ("!Style.StyleSet.Styles && \"Cannot add a style associated with an existing StyleSet to a StyleSet\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1057, __PRETTY_FUNCTION__))
;
1058 if (!Styles)
1059 Styles = std::make_shared<MapType>();
1060 (*Styles)[Style.Language] = std::move(Style);
1061}
1062
1063void FormatStyle::FormatStyleSet::Clear() {
1064 Styles.reset();
1065}
1066
1067llvm::Optional<FormatStyle>
1068FormatStyle::GetLanguageStyle(FormatStyle::LanguageKind Language) const {
1069 return StyleSet.Get(Language);
1070}
1071
1072namespace {
1073
1074class JavaScriptRequoter : public TokenAnalyzer {
1075public:
1076 JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
1077 : TokenAnalyzer(Env, Style) {}
1078
1079 std::pair<tooling::Replacements, unsigned>
1080 analyze(TokenAnnotator &Annotator,
1081 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1082 FormatTokenLexer &Tokens) override {
1083 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
1084 tooling::Replacements Result;
1085 requoteJSStringLiteral(AnnotatedLines, Result);
1086 return {Result, 0};
1087 }
1088
1089private:
1090 // Replaces double/single-quoted string literal as appropriate, re-escaping
1091 // the contents in the process.
1092 void requoteJSStringLiteral(SmallVectorImpl<AnnotatedLine *> &Lines,
1093 tooling::Replacements &Result) {
1094 for (AnnotatedLine *Line : Lines) {
1095 requoteJSStringLiteral(Line->Children, Result);
1096 if (!Line->Affected)
1097 continue;
1098 for (FormatToken *FormatTok = Line->First; FormatTok;
1099 FormatTok = FormatTok->Next) {
1100 StringRef Input = FormatTok->TokenText;
1101 if (FormatTok->Finalized || !FormatTok->isStringLiteral() ||
1102 // NB: testing for not starting with a double quote to avoid
1103 // breaking `template strings`.
1104 (Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
1105 !Input.startswith("\"")) ||
1106 (Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
1107 !Input.startswith("\'")))
1108 continue;
1109
1110 // Change start and end quote.
1111 bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
1112 SourceLocation Start = FormatTok->Tok.getLocation();
1113 auto Replace = [&](SourceLocation Start, unsigned Length,
1114 StringRef ReplacementText) {
1115 auto Err = Result.add(tooling::Replacement(
1116 Env.getSourceManager(), Start, Length, ReplacementText));
1117 // FIXME: handle error. For now, print error message and skip the
1118 // replacement for release version.
1119 if (Err) {
1120 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1121 assert(false)((false) ? static_cast<void> (0) : __assert_fail ("false"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1121, __PRETTY_FUNCTION__))
;
1122 }
1123 };
1124 Replace(Start, 1, IsSingle ? "'" : "\"");
1125 Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
1126 IsSingle ? "'" : "\"");
1127
1128 // Escape internal quotes.
1129 bool Escaped = false;
1130 for (size_t i = 1; i < Input.size() - 1; i++) {
1131 switch (Input[i]) {
1132 case '\\':
1133 if (!Escaped && i + 1 < Input.size() &&
1134 ((IsSingle && Input[i + 1] == '"') ||
1135 (!IsSingle && Input[i + 1] == '\''))) {
1136 // Remove this \, it's escaping a " or ' that no longer needs
1137 // escaping
1138 Replace(Start.getLocWithOffset(i), 1, "");
1139 continue;
1140 }
1141 Escaped = !Escaped;
1142 break;
1143 case '\"':
1144 case '\'':
1145 if (!Escaped && IsSingle == (Input[i] == '\'')) {
1146 // Escape the quote.
1147 Replace(Start.getLocWithOffset(i), 0, "\\");
1148 }
1149 Escaped = false;
1150 break;
1151 default:
1152 Escaped = false;
1153 break;
1154 }
1155 }
1156 }
1157 }
1158 }
1159};
1160
1161class Formatter : public TokenAnalyzer {
1162public:
1163 Formatter(const Environment &Env, const FormatStyle &Style,
1164 FormattingAttemptStatus *Status)
1165 : TokenAnalyzer(Env, Style), Status(Status) {}
1166
1167 std::pair<tooling::Replacements, unsigned>
1168 analyze(TokenAnnotator &Annotator,
1169 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1170 FormatTokenLexer &Tokens) override {
1171 tooling::Replacements Result;
1172 deriveLocalStyle(AnnotatedLines);
1173 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
1174 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1175 Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
1176 }
1177 Annotator.setCommentLineLevels(AnnotatedLines);
1178
1179 WhitespaceManager Whitespaces(
1180 Env.getSourceManager(), Style,
1181 inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
1182 ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
1183 Env.getSourceManager(), Whitespaces, Encoding,
1184 BinPackInconclusiveFunctions);
1185 unsigned Penalty =
1186 UnwrappedLineFormatter(&Indenter, &Whitespaces, Style,
1187 Tokens.getKeywords(), Env.getSourceManager(),
1188 Status)
1189 .format(AnnotatedLines, /*DryRun=*/false,
1190 /*AdditionalIndent=*/0,
1191 /*FixBadIndentation=*/false,
1192 /*FirstStartColumn=*/Env.getFirstStartColumn(),
1193 /*NextStartColumn=*/Env.getNextStartColumn(),
1194 /*LastStartColumn=*/Env.getLastStartColumn());
1195 for (const auto &R : Whitespaces.generateReplacements())
1196 if (Result.add(R))
1197 return std::make_pair(Result, 0);
1198 return std::make_pair(Result, Penalty);
1199 }
1200
1201private:
1202 static bool inputUsesCRLF(StringRef Text) {
1203 return Text.count('\r') * 2 > Text.count('\n');
1204 }
1205
1206 bool
1207 hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
1208 for (const AnnotatedLine *Line : Lines) {
1209 if (hasCpp03IncompatibleFormat(Line->Children))
1210 return true;
1211 for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
1212 if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
1213 if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
1214 return true;
1215 if (Tok->is(TT_TemplateCloser) &&
1216 Tok->Previous->is(TT_TemplateCloser))
1217 return true;
1218 }
1219 }
1220 }
1221 return false;
1222 }
1223
1224 int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
1225 int AlignmentDiff = 0;
1226 for (const AnnotatedLine *Line : Lines) {
1227 AlignmentDiff += countVariableAlignments(Line->Children);
1228 for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
1229 if (!Tok->is(TT_PointerOrReference))
1230 continue;
1231 bool SpaceBefore =
1232 Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
1233 bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
1234 Tok->Next->WhitespaceRange.getEnd();
1235 if (SpaceBefore && !SpaceAfter)
1236 ++AlignmentDiff;
1237 if (!SpaceBefore && SpaceAfter)
1238 --AlignmentDiff;
1239 }
1240 }
1241 return AlignmentDiff;
1242 }
1243
1244 void
1245 deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
1246 bool HasBinPackedFunction = false;
1247 bool HasOnePerLineFunction = false;
1248 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1249 if (!AnnotatedLines[i]->First->Next)
1250 continue;
1251 FormatToken *Tok = AnnotatedLines[i]->First->Next;
1252 while (Tok->Next) {
1253 if (Tok->PackingKind == PPK_BinPacked)
1254 HasBinPackedFunction = true;
1255 if (Tok->PackingKind == PPK_OnePerLine)
1256 HasOnePerLineFunction = true;
1257
1258 Tok = Tok->Next;
1259 }
1260 }
1261 if (Style.DerivePointerAlignment)
1262 Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
1263 ? FormatStyle::PAS_Left
1264 : FormatStyle::PAS_Right;
1265 if (Style.Standard == FormatStyle::LS_Auto)
1266 Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
1267 ? FormatStyle::LS_Cpp11
1268 : FormatStyle::LS_Cpp03;
1269 BinPackInconclusiveFunctions =
1270 HasBinPackedFunction || !HasOnePerLineFunction;
1271 }
1272
1273 bool BinPackInconclusiveFunctions;
1274 FormattingAttemptStatus *Status;
1275};
1276
1277// This class clean up the erroneous/redundant code around the given ranges in
1278// file.
1279class Cleaner : public TokenAnalyzer {
1280public:
1281 Cleaner(const Environment &Env, const FormatStyle &Style)
1282 : TokenAnalyzer(Env, Style),
1283 DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
1284
1285 // FIXME: eliminate unused parameters.
1286 std::pair<tooling::Replacements, unsigned>
1287 analyze(TokenAnnotator &Annotator,
1288 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1289 FormatTokenLexer &Tokens) override {
1290 // FIXME: in the current implementation the granularity of affected range
1291 // is an annotated line. However, this is not sufficient. Furthermore,
1292 // redundant code introduced by replacements does not necessarily
1293 // intercept with ranges of replacements that result in the redundancy.
1294 // To determine if some redundant code is actually introduced by
1295 // replacements(e.g. deletions), we need to come up with a more
1296 // sophisticated way of computing affected ranges.
1297 AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
1298
1299 checkEmptyNamespace(AnnotatedLines);
1300
1301 for (auto &Line : AnnotatedLines) {
1302 if (Line->Affected) {
1303 cleanupRight(Line->First, tok::comma, tok::comma);
1304 cleanupRight(Line->First, TT_CtorInitializerColon, tok::comma);
1305 cleanupRight(Line->First, tok::l_paren, tok::comma);
1306 cleanupLeft(Line->First, tok::comma, tok::r_paren);
1307 cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
1308 cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
1309 cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
1310 }
1311 }
1312
1313 return {generateFixes(), 0};
1314 }
1315
1316private:
1317 bool containsOnlyComments(const AnnotatedLine &Line) {
1318 for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
1319 if (Tok->isNot(tok::comment))
1320 return false;
1321 }
1322 return true;
1323 }
1324
1325 // Iterate through all lines and remove any empty (nested) namespaces.
1326 void checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
1327 std::set<unsigned> DeletedLines;
1328 for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
1329 auto &Line = *AnnotatedLines[i];
1330 if (Line.startsWithNamespace()) {
1331 checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
1332 }
1333 }
1334
1335 for (auto Line : DeletedLines) {
1336 FormatToken *Tok = AnnotatedLines[Line]->First;
1337 while (Tok) {
1338 deleteToken(Tok);
1339 Tok = Tok->Next;
1340 }
1341 }
1342 }
1343
1344 // The function checks if the namespace, which starts from \p CurrentLine, and
1345 // its nested namespaces are empty and delete them if they are empty. It also
1346 // sets \p NewLine to the last line checked.
1347 // Returns true if the current namespace is empty.
1348 bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1349 unsigned CurrentLine, unsigned &NewLine,
1350 std::set<unsigned> &DeletedLines) {
1351 unsigned InitLine = CurrentLine, End = AnnotatedLines.size();
1352 if (Style.BraceWrapping.AfterNamespace) {
1353 // If the left brace is in a new line, we should consume it first so that
1354 // it does not make the namespace non-empty.
1355 // FIXME: error handling if there is no left brace.
1356 if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
1357 NewLine = CurrentLine;
1358 return false;
1359 }
1360 } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
1361 return false;
1362 }
1363 while (++CurrentLine < End) {
1364 if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
1365 break;
1366
1367 if (AnnotatedLines[CurrentLine]->startsWithNamespace()) {
1368 if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
1369 DeletedLines))
1370 return false;
1371 CurrentLine = NewLine;
1372 continue;
1373 }
1374
1375 if (containsOnlyComments(*AnnotatedLines[CurrentLine]))
1376 continue;
1377
1378 // If there is anything other than comments or nested namespaces in the
1379 // current namespace, the namespace cannot be empty.
1380 NewLine = CurrentLine;
1381 return false;
1382 }
1383
1384 NewLine = CurrentLine;
1385 if (CurrentLine >= End)
1386 return false;
1387
1388 // Check if the empty namespace is actually affected by changed ranges.
1389 if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
1390 AnnotatedLines[InitLine]->First->Tok.getLocation(),
1391 AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
1392 return false;
1393
1394 for (unsigned i = InitLine; i <= CurrentLine; ++i) {
1395 DeletedLines.insert(i);
1396 }
1397
1398 return true;
1399 }
1400
1401 // Checks pairs {start, start->next},..., {end->previous, end} and deletes one
1402 // of the token in the pair if the left token has \p LK token kind and the
1403 // right token has \p RK token kind. If \p DeleteLeft is true, the left token
1404 // is deleted on match; otherwise, the right token is deleted.
1405 template <typename LeftKind, typename RightKind>
1406 void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
1407 bool DeleteLeft) {
1408 auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
1409 for (auto *Res = Tok.Next; Res; Res = Res->Next)
1410 if (!Res->is(tok::comment) &&
1411 DeletedTokens.find(Res) == DeletedTokens.end())
1412 return Res;
1413 return nullptr;
1414 };
1415 for (auto *Left = Start; Left;) {
1416 auto *Right = NextNotDeleted(*Left);
1417 if (!Right)
1418 break;
1419 if (Left->is(LK) && Right->is(RK)) {
1420 deleteToken(DeleteLeft ? Left : Right);
1421 for (auto *Tok = Left->Next; Tok && Tok != Right; Tok = Tok->Next)
1422 deleteToken(Tok);
1423 // If the right token is deleted, we should keep the left token
1424 // unchanged and pair it with the new right token.
1425 if (!DeleteLeft)
1426 continue;
1427 }
1428 Left = Right;
1429 }
1430 }
1431
1432 template <typename LeftKind, typename RightKind>
1433 void cleanupLeft(FormatToken *Start, LeftKind LK, RightKind RK) {
1434 cleanupPair(Start, LK, RK, /*DeleteLeft=*/true);
1435 }
1436
1437 template <typename LeftKind, typename RightKind>
1438 void cleanupRight(FormatToken *Start, LeftKind LK, RightKind RK) {
1439 cleanupPair(Start, LK, RK, /*DeleteLeft=*/false);
1440 }
1441
1442 // Delete the given token.
1443 inline void deleteToken(FormatToken *Tok) {
1444 if (Tok)
1445 DeletedTokens.insert(Tok);
1446 }
1447
1448 tooling::Replacements generateFixes() {
1449 tooling::Replacements Fixes;
1450 std::vector<FormatToken *> Tokens;
1451 std::copy(DeletedTokens.begin(), DeletedTokens.end(),
1452 std::back_inserter(Tokens));
1453
1454 // Merge multiple continuous token deletions into one big deletion so that
1455 // the number of replacements can be reduced. This makes computing affected
1456 // ranges more efficient when we run reformat on the changed code.
1457 unsigned Idx = 0;
1458 while (Idx < Tokens.size()) {
1459 unsigned St = Idx, End = Idx;
1460 while ((End + 1) < Tokens.size() &&
1461 Tokens[End]->Next == Tokens[End + 1]) {
1462 End++;
1463 }
1464 auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
1465 Tokens[End]->Tok.getEndLoc());
1466 auto Err =
1467 Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
1468 // FIXME: better error handling. for now just print error message and skip
1469 // for the release version.
1470 if (Err) {
1471 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1472 assert(false && "Fixes must not conflict!")((false && "Fixes must not conflict!") ? static_cast<
void> (0) : __assert_fail ("false && \"Fixes must not conflict!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1472, __PRETTY_FUNCTION__))
;
1473 }
1474 Idx = End + 1;
1475 }
1476
1477 return Fixes;
1478 }
1479
1480 // Class for less-than inequality comparason for the set `RedundantTokens`.
1481 // We store tokens in the order they appear in the translation unit so that
1482 // we do not need to sort them in `generateFixes()`.
1483 struct FormatTokenLess {
1484 FormatTokenLess(const SourceManager &SM) : SM(SM) {}
1485
1486 bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
1487 return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
1488 RHS->Tok.getLocation());
1489 }
1490 const SourceManager &SM;
1491 };
1492
1493 // Tokens to be deleted.
1494 std::set<FormatToken *, FormatTokenLess> DeletedTokens;
1495};
1496
1497class ObjCHeaderStyleGuesser : public TokenAnalyzer {
1498public:
1499 ObjCHeaderStyleGuesser(const Environment &Env, const FormatStyle &Style)
1500 : TokenAnalyzer(Env, Style), IsObjC(false) {}
1501
1502 std::pair<tooling::Replacements, unsigned>
1503 analyze(TokenAnnotator &Annotator,
1504 SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1505 FormatTokenLexer &Tokens) override {
1506 assert(Style.Language == FormatStyle::LK_Cpp)((Style.Language == FormatStyle::LK_Cpp) ? static_cast<void
> (0) : __assert_fail ("Style.Language == FormatStyle::LK_Cpp"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1506, __PRETTY_FUNCTION__))
;
1507 IsObjC = guessIsObjC(AnnotatedLines, Tokens.getKeywords());
1508 tooling::Replacements Result;
1509 return {Result, 0};
1510 }
1511
1512 bool isObjC() { return IsObjC; }
1513
1514private:
1515 static bool guessIsObjC(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1516 const AdditionalKeywords &Keywords) {
1517 // Keep this array sorted, since we are binary searching over it.
1518 static constexpr llvm::StringLiteral FoundationIdentifiers[] = {
1519 "CGFloat",
1520 "CGPoint",
1521 "CGPointMake",
1522 "CGPointZero",
1523 "CGRect",
1524 "CGRectEdge",
1525 "CGRectInfinite",
1526 "CGRectMake",
1527 "CGRectNull",
1528 "CGRectZero",
1529 "CGSize",
1530 "CGSizeMake",
1531 "CGVector",
1532 "CGVectorMake",
1533 "NSAffineTransform",
1534 "NSArray",
1535 "NSAttributedString",
1536 "NSBlockOperation",
1537 "NSBundle",
1538 "NSCache",
1539 "NSCalendar",
1540 "NSCharacterSet",
1541 "NSCountedSet",
1542 "NSData",
1543 "NSDataDetector",
1544 "NSDecimal",
1545 "NSDecimalNumber",
1546 "NSDictionary",
1547 "NSEdgeInsets",
1548 "NSHashTable",
1549 "NSIndexPath",
1550 "NSIndexSet",
1551 "NSInteger",
1552 "NSInvocationOperation",
1553 "NSLocale",
1554 "NSMapTable",
1555 "NSMutableArray",
1556 "NSMutableAttributedString",
1557 "NSMutableCharacterSet",
1558 "NSMutableData",
1559 "NSMutableDictionary",
1560 "NSMutableIndexSet",
1561 "NSMutableOrderedSet",
1562 "NSMutableSet",
1563 "NSMutableString",
1564 "NSNumber",
1565 "NSNumberFormatter",
1566 "NSObject",
1567 "NSOperation",
1568 "NSOperationQueue",
1569 "NSOperationQueuePriority",
1570 "NSOrderedSet",
1571 "NSPoint",
1572 "NSPointerArray",
1573 "NSQualityOfService",
1574 "NSRange",
1575 "NSRect",
1576 "NSRegularExpression",
1577 "NSSet",
1578 "NSSize",
1579 "NSString",
1580 "NSTimeZone",
1581 "NSUInteger",
1582 "NSURL",
1583 "NSURLComponents",
1584 "NSURLQueryItem",
1585 "NSUUID",
1586 "NSValue",
1587 "UIImage",
1588 "UIView",
1589 };
1590
1591 for (auto Line : AnnotatedLines) {
1592 for (const FormatToken *FormatTok = Line->First; FormatTok;
1593 FormatTok = FormatTok->Next) {
1594 if ((FormatTok->Previous && FormatTok->Previous->is(tok::at) &&
1595 (FormatTok->Tok.getObjCKeywordID() != tok::objc_not_keyword ||
1596 FormatTok->isOneOf(tok::numeric_constant, tok::l_square,
1597 tok::l_brace))) ||
1598 (FormatTok->Tok.isAnyIdentifier() &&
1599 std::binary_search(std::begin(FoundationIdentifiers),
1600 std::end(FoundationIdentifiers),
1601 FormatTok->TokenText)) ||
1602 FormatTok->is(TT_ObjCStringLiteral) ||
1603 FormatTok->isOneOf(Keywords.kw_NS_ENUM, Keywords.kw_NS_OPTIONS,
1604 TT_ObjCBlockLBrace, TT_ObjCBlockLParen,
1605 TT_ObjCDecl, TT_ObjCForIn, TT_ObjCMethodExpr,
1606 TT_ObjCMethodSpecifier, TT_ObjCProperty)) {
1607 return true;
1608 }
1609 if (guessIsObjC(Line->Children, Keywords))
1610 return true;
1611 }
1612 }
1613 return false;
1614 }
1615
1616 bool IsObjC;
1617};
1618
1619struct IncludeDirective {
1620 StringRef Filename;
1621 StringRef Text;
1622 unsigned Offset;
1623 int Category;
1624};
1625
1626struct JavaImportDirective {
1627 StringRef Identifier;
1628 StringRef Text;
1629 unsigned Offset;
1630 std::vector<StringRef> AssociatedCommentLines;
1631 bool IsStatic;
1632};
1633
1634} // end anonymous namespace
1635
1636// Determines whether 'Ranges' intersects with ('Start', 'End').
1637static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
1638 unsigned End) {
1639 for (auto Range : Ranges) {
1640 if (Range.getOffset() < End &&
1641 Range.getOffset() + Range.getLength() > Start)
1642 return true;
1643 }
1644 return false;
1645}
1646
1647// Returns a pair (Index, OffsetToEOL) describing the position of the cursor
1648// before sorting/deduplicating. Index is the index of the include under the
1649// cursor in the original set of includes. If this include has duplicates, it is
1650// the index of the first of the duplicates as the others are going to be
1651// removed. OffsetToEOL describes the cursor's position relative to the end of
1652// its current line.
1653// If `Cursor` is not on any #include, `Index` will be UINT_MAX.
1654static std::pair<unsigned, unsigned>
1655FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
1656 const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
1657 unsigned CursorIndex = UINT_MAX(2147483647 *2U +1U);
1658 unsigned OffsetToEOL = 0;
1659 for (int i = 0, e = Includes.size(); i != e; ++i) {
1660 unsigned Start = Includes[Indices[i]].Offset;
1661 unsigned End = Start + Includes[Indices[i]].Text.size();
1662 if (!(Cursor >= Start && Cursor < End))
1663 continue;
1664 CursorIndex = Indices[i];
1665 OffsetToEOL = End - Cursor;
1666 // Put the cursor on the only remaining #include among the duplicate
1667 // #includes.
1668 while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
1669 CursorIndex = i;
1670 break;
1671 }
1672 return std::make_pair(CursorIndex, OffsetToEOL);
1673}
1674
1675// Sorts and deduplicate a block of includes given by 'Includes' alphabetically
1676// adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
1677// source order.
1678// #include directives with the same text will be deduplicated, and only the
1679// first #include in the duplicate #includes remains. If the `Cursor` is
1680// provided and put on a deleted #include, it will be moved to the remaining
1681// #include in the duplicate #includes.
1682static void sortCppIncludes(const FormatStyle &Style,
1683 const SmallVectorImpl<IncludeDirective> &Includes,
1684 ArrayRef<tooling::Range> Ranges, StringRef FileName,
1685 tooling::Replacements &Replaces, unsigned *Cursor) {
1686 unsigned IncludesBeginOffset = Includes.front().Offset;
1687 unsigned IncludesEndOffset =
1688 Includes.back().Offset + Includes.back().Text.size();
1689 unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
1690 if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
1691 return;
1692 SmallVector<unsigned, 16> Indices;
1693 for (unsigned i = 0, e = Includes.size(); i != e; ++i)
1694 Indices.push_back(i);
1695 std::stable_sort(
1696 Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
1697 return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
1698 std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
1699 });
1700 // The index of the include on which the cursor will be put after
1701 // sorting/deduplicating.
1702 unsigned CursorIndex;
1703 // The offset from cursor to the end of line.
1704 unsigned CursorToEOLOffset;
1705 if (Cursor)
1706 std::tie(CursorIndex, CursorToEOLOffset) =
1707 FindCursorIndex(Includes, Indices, *Cursor);
1708
1709 // Deduplicate #includes.
1710 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1711 [&](unsigned LHSI, unsigned RHSI) {
1712 return Includes[LHSI].Text == Includes[RHSI].Text;
1713 }),
1714 Indices.end());
1715
1716 int CurrentCategory = Includes.front().Category;
1717
1718 // If the #includes are out of order, we generate a single replacement fixing
1719 // the entire block. Otherwise, no replacement is generated.
1720 if (Indices.size() == Includes.size() &&
1721 std::is_sorted(Indices.begin(), Indices.end()) &&
1722 Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Preserve)
1723 return;
1724
1725 std::string result;
1726 for (unsigned Index : Indices) {
1727 if (!result.empty()) {
1728 result += "\n";
1729 if (Style.IncludeStyle.IncludeBlocks ==
1730 tooling::IncludeStyle::IBS_Regroup &&
1731 CurrentCategory != Includes[Index].Category)
1732 result += "\n";
1733 }
1734 result += Includes[Index].Text;
1735 if (Cursor && CursorIndex == Index)
1736 *Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
1737 CurrentCategory = Includes[Index].Category;
1738 }
1739
1740 auto Err = Replaces.add(tooling::Replacement(
1741 FileName, Includes.front().Offset, IncludesBlockSize, result));
1742 // FIXME: better error handling. For now, just skip the replacement for the
1743 // release version.
1744 if (Err) {
1745 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1746 assert(false)((false) ? static_cast<void> (0) : __assert_fail ("false"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1746, __PRETTY_FUNCTION__))
;
1747 }
1748}
1749
1750namespace {
1751
1752const char CppIncludeRegexPattern[] =
1753 R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
1754
1755} // anonymous namespace
1756
1757tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
1758 ArrayRef<tooling::Range> Ranges,
1759 StringRef FileName,
1760 tooling::Replacements &Replaces,
1761 unsigned *Cursor) {
1762 unsigned Prev = 0;
1763 unsigned SearchFrom = 0;
1764 llvm::Regex IncludeRegex(CppIncludeRegexPattern);
1765 SmallVector<StringRef, 4> Matches;
1766 SmallVector<IncludeDirective, 16> IncludesInBlock;
1767
1768 // In compiled files, consider the first #include to be the main #include of
1769 // the file if it is not a system #include. This ensures that the header
1770 // doesn't have hidden dependencies
1771 // (http://llvm.org/docs/CodingStandards.html#include-style).
1772 //
1773 // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
1774 // cases where the first #include is unlikely to be the main header.
1775 tooling::IncludeCategoryManager Categories(Style.IncludeStyle, FileName);
1776 bool FirstIncludeBlock = true;
1777 bool MainIncludeFound = false;
1778 bool FormattingOff = false;
1779
1780 for (;;) {
1781 auto Pos = Code.find('\n', SearchFrom);
1782 StringRef Line =
1783 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
1784
1785 StringRef Trimmed = Line.trim();
1786 if (Trimmed == "// clang-format off")
1787 FormattingOff = true;
1788 else if (Trimmed == "// clang-format on")
1789 FormattingOff = false;
1790
1791 const bool EmptyLineSkipped =
1792 Trimmed.empty() &&
1793 (Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Merge ||
1794 Style.IncludeStyle.IncludeBlocks ==
1795 tooling::IncludeStyle::IBS_Regroup);
1796
1797 if (!FormattingOff && !Line.endswith("\\")) {
1798 if (IncludeRegex.match(Line, &Matches)) {
1799 StringRef IncludeName = Matches[2];
1800 int Category = Categories.getIncludePriority(
1801 IncludeName,
1802 /*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
1803 if (Category == 0)
1804 MainIncludeFound = true;
1805 IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
1806 } else if (!IncludesInBlock.empty() && !EmptyLineSkipped) {
1807 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
1808 Cursor);
1809 IncludesInBlock.clear();
1810 FirstIncludeBlock = false;
1811 }
1812 Prev = Pos + 1;
1813 }
1814 if (Pos == StringRef::npos || Pos + 1 == Code.size())
1815 break;
1816 SearchFrom = Pos + 1;
1817 }
1818 if (!IncludesInBlock.empty())
1819 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
1820 return Replaces;
1821}
1822
1823// Returns group number to use as a first order sort on imports. Gives UINT_MAX
1824// if the import does not match any given groups.
1825static unsigned findJavaImportGroup(const FormatStyle &Style,
1826 StringRef ImportIdentifier) {
1827 unsigned LongestMatchIndex = UINT_MAX(2147483647 *2U +1U);
1828 unsigned LongestMatchLength = 0;
1829 for (unsigned I = 0; I < Style.JavaImportGroups.size(); I++) {
1830 std::string GroupPrefix = Style.JavaImportGroups[I];
1831 if (ImportIdentifier.startswith(GroupPrefix) &&
1832 GroupPrefix.length() > LongestMatchLength) {
1833 LongestMatchIndex = I;
1834 LongestMatchLength = GroupPrefix.length();
1835 }
1836 }
1837 return LongestMatchIndex;
1838}
1839
1840// Sorts and deduplicates a block of includes given by 'Imports' based on
1841// JavaImportGroups, then adding the necessary replacement to 'Replaces'.
1842// Import declarations with the same text will be deduplicated. Between each
1843// import group, a newline is inserted, and within each import group, a
1844// lexicographic sort based on ASCII value is performed.
1845static void sortJavaImports(const FormatStyle &Style,
1846 const SmallVectorImpl<JavaImportDirective> &Imports,
1847 ArrayRef<tooling::Range> Ranges, StringRef FileName,
1848 tooling::Replacements &Replaces) {
1849 unsigned ImportsBeginOffset = Imports.front().Offset;
1850 unsigned ImportsEndOffset =
1851 Imports.back().Offset + Imports.back().Text.size();
1852 unsigned ImportsBlockSize = ImportsEndOffset - ImportsBeginOffset;
1853 if (!affectsRange(Ranges, ImportsBeginOffset, ImportsEndOffset))
1854 return;
1855 SmallVector<unsigned, 16> Indices;
1856 SmallVector<unsigned, 16> JavaImportGroups;
1857 for (unsigned i = 0, e = Imports.size(); i != e; ++i) {
1858 Indices.push_back(i);
1859 JavaImportGroups.push_back(
1860 findJavaImportGroup(Style, Imports[i].Identifier));
1861 }
1862 llvm::sort(Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
1863 // Negating IsStatic to push static imports above non-static imports.
1864 return std::make_tuple(!Imports[LHSI].IsStatic, JavaImportGroups[LHSI],
1865 Imports[LHSI].Identifier) <
1866 std::make_tuple(!Imports[RHSI].IsStatic, JavaImportGroups[RHSI],
1867 Imports[RHSI].Identifier);
1868 });
1869
1870 // Deduplicate imports.
1871 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1872 [&](unsigned LHSI, unsigned RHSI) {
1873 return Imports[LHSI].Text == Imports[RHSI].Text;
1874 }),
1875 Indices.end());
1876
1877 bool CurrentIsStatic = Imports[Indices.front()].IsStatic;
1878 unsigned CurrentImportGroup = JavaImportGroups[Indices.front()];
1879
1880 std::string result;
1881 for (unsigned Index : Indices) {
1882 if (!result.empty()) {
1883 result += "\n";
1884 if (CurrentIsStatic != Imports[Index].IsStatic ||
1885 CurrentImportGroup != JavaImportGroups[Index])
1886 result += "\n";
1887 }
1888 for (StringRef CommentLine : Imports[Index].AssociatedCommentLines) {
1889 result += CommentLine;
1890 result += "\n";
1891 }
1892 result += Imports[Index].Text;
1893 CurrentIsStatic = Imports[Index].IsStatic;
1894 CurrentImportGroup = JavaImportGroups[Index];
1895 }
1896
1897 auto Err = Replaces.add(tooling::Replacement(FileName, Imports.front().Offset,
1898 ImportsBlockSize, result));
1899 // FIXME: better error handling. For now, just skip the replacement for the
1900 // release version.
1901 if (Err) {
1902 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1903 assert(false)((false) ? static_cast<void> (0) : __assert_fail ("false"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 1903, __PRETTY_FUNCTION__))
;
1904 }
1905}
1906
1907namespace {
1908
1909const char JavaImportRegexPattern[] =
1910 "^[\t ]*import[\t ]*(static[\t ]*)?([^\t ]*)[\t ]*;";
1911
1912} // anonymous namespace
1913
1914tooling::Replacements sortJavaImports(const FormatStyle &Style, StringRef Code,
1915 ArrayRef<tooling::Range> Ranges,
1916 StringRef FileName,
1917 tooling::Replacements &Replaces) {
1918 unsigned Prev = 0;
1919 unsigned SearchFrom = 0;
1920 llvm::Regex ImportRegex(JavaImportRegexPattern);
1921 SmallVector<StringRef, 4> Matches;
1922 SmallVector<JavaImportDirective, 16> ImportsInBlock;
1923 std::vector<StringRef> AssociatedCommentLines;
1924
1925 bool FormattingOff = false;
1926
1927 for (;;) {
1928 auto Pos = Code.find('\n', SearchFrom);
1929 StringRef Line =
1930 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
1931
1932 StringRef Trimmed = Line.trim();
1933 if (Trimmed == "// clang-format off")
1934 FormattingOff = true;
1935 else if (Trimmed == "// clang-format on")
1936 FormattingOff = false;
1937
1938 if (ImportRegex.match(Line, &Matches)) {
1939 if (FormattingOff) {
1940 // If at least one import line has formatting turned off, turn off
1941 // formatting entirely.
1942 return Replaces;
1943 }
1944 StringRef Static = Matches[1];
1945 StringRef Identifier = Matches[2];
1946 bool IsStatic = false;
1947 if (Static.contains("static")) {
1948 IsStatic = true;
1949 }
1950 ImportsInBlock.push_back({Identifier, Line, Prev, AssociatedCommentLines, IsStatic});
1951 AssociatedCommentLines.clear();
1952 } else if (Trimmed.size() > 0 && !ImportsInBlock.empty()) {
1953 // Associating comments within the imports with the nearest import below
1954 AssociatedCommentLines.push_back(Line);
1955 }
1956 Prev = Pos + 1;
1957 if (Pos == StringRef::npos || Pos + 1 == Code.size())
1958 break;
1959 SearchFrom = Pos + 1;
1960 }
1961 if (!ImportsInBlock.empty())
1962 sortJavaImports(Style, ImportsInBlock, Ranges, FileName, Replaces);
1963 return Replaces;
1964}
1965
1966bool isMpegTS(StringRef Code) {
1967 // MPEG transport streams use the ".ts" file extension. clang-format should
1968 // not attempt to format those. MPEG TS' frame format starts with 0x47 every
1969 // 189 bytes - detect that and return.
1970 return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
1971}
1972
1973bool isLikelyXml(StringRef Code) { return Code.ltrim().startswith("<"); }
1974
1975tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
1976 ArrayRef<tooling::Range> Ranges,
1977 StringRef FileName, unsigned *Cursor) {
1978 tooling::Replacements Replaces;
1979 if (!Style.SortIncludes)
1980 return Replaces;
1981 if (isLikelyXml(Code))
1982 return Replaces;
1983 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
1984 isMpegTS(Code))
1985 return Replaces;
1986 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
1987 return sortJavaScriptImports(Style, Code, Ranges, FileName);
1988 if (Style.Language == FormatStyle::LanguageKind::LK_Java)
1989 return sortJavaImports(Style, Code, Ranges, FileName, Replaces);
1990 sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
1991 return Replaces;
1992}
1993
1994template <typename T>
1995static llvm::Expected<tooling::Replacements>
1996processReplacements(T ProcessFunc, StringRef Code,
1997 const tooling::Replacements &Replaces,
1998 const FormatStyle &Style) {
1999 if (Replaces.empty())
2000 return tooling::Replacements();
2001
2002 auto NewCode = applyAllReplacements(Code, Replaces);
2003 if (!NewCode)
2004 return NewCode.takeError();
2005 std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
2006 StringRef FileName = Replaces.begin()->getFilePath();
2007
2008 tooling::Replacements FormatReplaces =
2009 ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
2010
2011 return Replaces.merge(FormatReplaces);
2012}
2013
2014llvm::Expected<tooling::Replacements>
2015formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
2016 const FormatStyle &Style) {
2017 // We need to use lambda function here since there are two versions of
2018 // `sortIncludes`.
2019 auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
2020 std::vector<tooling::Range> Ranges,
2021 StringRef FileName) -> tooling::Replacements {
2022 return sortIncludes(Style, Code, Ranges, FileName);
2023 };
2024 auto SortedReplaces =
2025 processReplacements(SortIncludes, Code, Replaces, Style);
2026 if (!SortedReplaces)
2027 return SortedReplaces.takeError();
2028
2029 // We need to use lambda function here since there are two versions of
2030 // `reformat`.
2031 auto Reformat = [](const FormatStyle &Style, StringRef Code,
2032 std::vector<tooling::Range> Ranges,
2033 StringRef FileName) -> tooling::Replacements {
2034 return reformat(Style, Code, Ranges, FileName);
2035 };
2036 return processReplacements(Reformat, Code, *SortedReplaces, Style);
2037}
2038
2039namespace {
2040
2041inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
2042 return Replace.getOffset() == UINT_MAX(2147483647 *2U +1U) && Replace.getLength() == 0 &&
2043 llvm::Regex(CppIncludeRegexPattern)
2044 .match(Replace.getReplacementText());
2045}
2046
2047inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
2048 return Replace.getOffset() == UINT_MAX(2147483647 *2U +1U) && Replace.getLength() == 1;
2049}
2050
2051// FIXME: insert empty lines between newly created blocks.
2052tooling::Replacements
2053fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
2054 const FormatStyle &Style) {
2055 if (!Style.isCpp())
2056 return Replaces;
2057
2058 tooling::Replacements HeaderInsertions;
2059 std::set<llvm::StringRef> HeadersToDelete;
2060 tooling::Replacements Result;
2061 for (const auto &R : Replaces) {
2062 if (isHeaderInsertion(R)) {
2063 // Replacements from \p Replaces must be conflict-free already, so we can
2064 // simply consume the error.
2065 llvm::consumeError(HeaderInsertions.add(R));
2066 } else if (isHeaderDeletion(R)) {
2067 HeadersToDelete.insert(R.getReplacementText());
2068 } else if (R.getOffset() == UINT_MAX(2147483647 *2U +1U)) {
2069 llvm::errs() << "Insertions other than header #include insertion are "
2070 "not supported! "
2071 << R.getReplacementText() << "\n";
2072 } else {
2073 llvm::consumeError(Result.add(R));
2074 }
2075 }
2076 if (HeaderInsertions.empty() && HeadersToDelete.empty())
2077 return Replaces;
2078
2079
2080 StringRef FileName = Replaces.begin()->getFilePath();
2081 tooling::HeaderIncludes Includes(FileName, Code, Style.IncludeStyle);
2082
2083 for (const auto &Header : HeadersToDelete) {
2084 tooling::Replacements Replaces =
2085 Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
2086 for (const auto &R : Replaces) {
2087 auto Err = Result.add(R);
2088 if (Err) {
2089 // Ignore the deletion on conflict.
2090 llvm::errs() << "Failed to add header deletion replacement for "
2091 << Header << ": " << llvm::toString(std::move(Err))
2092 << "\n";
2093 }
2094 }
2095 }
2096
2097 llvm::Regex IncludeRegex = llvm::Regex(CppIncludeRegexPattern);
2098 llvm::SmallVector<StringRef, 4> Matches;
2099 for (const auto &R : HeaderInsertions) {
2100 auto IncludeDirective = R.getReplacementText();
2101 bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
2102 assert(Matched && "Header insertion replacement must have replacement text "((Matched && "Header insertion replacement must have replacement text "
"'#include ...'") ? static_cast<void> (0) : __assert_fail
("Matched && \"Header insertion replacement must have replacement text \" \"'#include ...'\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 2103, __PRETTY_FUNCTION__))
2103 "'#include ...'")((Matched && "Header insertion replacement must have replacement text "
"'#include ...'") ? static_cast<void> (0) : __assert_fail
("Matched && \"Header insertion replacement must have replacement text \" \"'#include ...'\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Format/Format.cpp"
, 2103, __PRETTY_FUNCTION__))
;
2104 (void)Matched;
2105 auto IncludeName = Matches[2];
2106 auto Replace =
2107 Includes.insert(IncludeName.trim("\"<>"), IncludeName.startswith("<"));
2108 if (Replace) {
2109 auto Err = Result.add(*Replace);
2110 if (Err) {
2111 llvm::consumeError(std::move(Err));
2112 unsigned NewOffset = Result.getShiftedCodePosition(Replace->getOffset());
2113 auto Shifted = tooling::Replacement(FileName, NewOffset, 0,
2114 Replace->getReplacementText());
2115 Result = Result.merge(tooling::Replacements(Shifted));
2116 }
2117 }
2118 }
2119 return Result;
2120}
2121
2122} // anonymous namespace
2123
2124llvm::Expected<tooling::Replacements>
2125cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
2126 const FormatStyle &Style) {
2127 // We need to use lambda function here since there are two versions of
2128 // `cleanup`.
2129 auto Cleanup = [](const FormatStyle &Style, StringRef Code,
2130 std::vector<tooling::Range> Ranges,
2131 StringRef FileName) -> tooling::Replacements {
2132 return cleanup(Style, Code, Ranges, FileName);
2133 };
2134 // Make header insertion replacements insert new headers into correct blocks.
2135 tooling::Replacements NewReplaces =
2136 fixCppIncludeInsertions(Code, Replaces, Style);
2137 return processReplacements(Cleanup, Code, NewReplaces, Style);
2138}
2139
2140namespace internal {
2141std::pair<tooling::Replacements, unsigned>
2142reformat(const FormatStyle &Style, StringRef Code,
2143 ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
2144 unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
2145 FormattingAttemptStatus *Status) {
2146 FormatStyle Expanded = expandPresets(Style);
2147 if (Expanded.DisableFormat)
2148 return {tooling::Replacements(), 0};
2149 if (isLikelyXml(Code))
2150 return {tooling::Replacements(), 0};
2151 if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
2152 return {tooling::Replacements(), 0};
2153
2154 typedef std::function<std::pair<tooling::Replacements, unsigned>(
2155 const Environment &)>
2156 AnalyzerPass;
2157 SmallVector<AnalyzerPass, 4> Passes;
2158
2159 if (Style.Language == FormatStyle::LK_Cpp) {
2160 if (Style.FixNamespaceComments)
2161 Passes.emplace_back([&](const Environment &Env) {
2162 return NamespaceEndCommentsFixer(Env, Expanded).process();
2163 });
2164
2165 if (Style.SortUsingDeclarations)
2166 Passes.emplace_back([&](const Environment &Env) {
2167 return UsingDeclarationsSorter(Env, Expanded).process();
2168 });
2169 }
2170
2171 if (Style.Language == FormatStyle::LK_JavaScript &&
2172 Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
2173 Passes.emplace_back([&](const Environment &Env) {
2174 return JavaScriptRequoter(Env, Expanded).process();
2175 });
2176
2177 Passes.emplace_back([&](const Environment &Env) {
2178 return Formatter(Env, Expanded, Status).process();
2179 });
2180
2181 auto Env =
2182 llvm::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
2183 NextStartColumn, LastStartColumn);
2184 llvm::Optional<std::string> CurrentCode = None;
2185 tooling::Replacements Fixes;
2186 unsigned Penalty = 0;
2187 for (size_t I = 0, E = Passes.size(); I < E; ++I) {
2188 std::pair<tooling::Replacements, unsigned> PassFixes = Passes[I](*Env);
2189 auto NewCode = applyAllReplacements(
2190 CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first);
2191 if (NewCode) {
2192 Fixes = Fixes.merge(PassFixes.first);
2193 Penalty += PassFixes.second;
2194 if (I + 1 < E) {
2195 CurrentCode = std::move(*NewCode);
2196 Env = llvm::make_unique<Environment>(
2197 *CurrentCode, FileName,
2198 tooling::calculateRangesAfterReplacements(Fixes, Ranges),
2199 FirstStartColumn, NextStartColumn, LastStartColumn);
2200 }
2201 }
2202 }
2203
2204 return {Fixes, Penalty};
2205}
2206} // namespace internal
2207
2208tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2209 ArrayRef<tooling::Range> Ranges,
2210 StringRef FileName,
2211 FormattingAttemptStatus *Status) {
2212 return internal::reformat(Style, Code, Ranges,
2213 /*FirstStartColumn=*/0,
2214 /*NextStartColumn=*/0,
2215 /*LastStartColumn=*/0, FileName, Status)
2216 .first;
2217}
2218
2219tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
2220 ArrayRef<tooling::Range> Ranges,
2221 StringRef FileName) {
2222 // cleanups only apply to C++ (they mostly concern ctor commas etc.)
2223 if (Style.Language != FormatStyle::LK_Cpp)
2224 return tooling::Replacements();
2225 return Cleaner(Environment(Code, FileName, Ranges), Style).process().first;
2226}
2227
2228tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2229 ArrayRef<tooling::Range> Ranges,
2230 StringRef FileName, bool *IncompleteFormat) {
2231 FormattingAttemptStatus Status;
2232 auto Result = reformat(Style, Code, Ranges, FileName, &Status);
2233 if (!Status.FormatComplete)
2234 *IncompleteFormat = true;
2235 return Result;
2236}
2237
2238tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
2239 StringRef Code,
2240 ArrayRef<tooling::Range> Ranges,
2241 StringRef FileName) {
2242 return NamespaceEndCommentsFixer(Environment(Code, FileName, Ranges), Style)
2243 .process()
2244 .first;
2245}
2246
2247tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
2248 StringRef Code,
2249 ArrayRef<tooling::Range> Ranges,
2250 StringRef FileName) {
2251 return UsingDeclarationsSorter(Environment(Code, FileName, Ranges), Style)
2252 .process()
2253 .first;
2254}
2255
2256LangOptions getFormattingLangOpts(const FormatStyle &Style) {
2257 LangOptions LangOpts;
2258 LangOpts.CPlusPlus = 1;
2259 LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2260 LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2261 LangOpts.CPlusPlus17 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2262 LangOpts.CPlusPlus2a = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2263 LangOpts.LineComment = 1;
2264 bool AlternativeOperators = Style.isCpp();
2265 LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
2266 LangOpts.Bool = 1;
2267 LangOpts.ObjC1 = 1;
2268 LangOpts.ObjC2 = 1;
2269 LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
2270 LangOpts.DeclSpecKeyword = 1; // To get __declspec.
2271 return LangOpts;
2272}
2273
2274const char *StyleOptionHelpDescription =
2275 "Coding style, currently supports:\n"
2276 " LLVM, Google, Chromium, Mozilla, WebKit.\n"
2277 "Use -style=file to load style configuration from\n"
2278 ".clang-format file located in one of the parent\n"
2279 "directories of the source file (or current\n"
2280 "directory for stdin).\n"
2281 "Use -style=\"{key: value, ...}\" to set specific\n"
2282 "parameters, e.g.:\n"
2283 " -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
2284
2285static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
2286 if (FileName.endswith(".java"))
2287 return FormatStyle::LK_Java;
2288 if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
2289 return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
2290 if (FileName.endswith(".m") || FileName.endswith(".mm"))
2291 return FormatStyle::LK_ObjC;
2292 if (FileName.endswith_lower(".proto") ||
2293 FileName.endswith_lower(".protodevel"))
2294 return FormatStyle::LK_Proto;
2295 if (FileName.endswith_lower(".textpb") ||
2296 FileName.endswith_lower(".pb.txt") ||
2297 FileName.endswith_lower(".textproto") ||
2298 FileName.endswith_lower(".asciipb"))
2299 return FormatStyle::LK_TextProto;
2300 if (FileName.endswith_lower(".td"))
2301 return FormatStyle::LK_TableGen;
2302 return FormatStyle::LK_Cpp;
2303}
2304
2305FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
2306 const auto GuessedLanguage = getLanguageByFileName(FileName);
2307 if (GuessedLanguage == FormatStyle::LK_Cpp) {
2308 auto Extension = llvm::sys::path::extension(FileName);
2309 // If there's no file extension (or it's .h), we need to check the contents
2310 // of the code to see if it contains Objective-C.
2311 if (Extension.empty() || Extension == ".h") {
2312 auto NonEmptyFileName = FileName.empty() ? "guess.h" : FileName;
2313 Environment Env(Code, NonEmptyFileName, /*Ranges=*/{});
2314 ObjCHeaderStyleGuesser Guesser(Env, getLLVMStyle());
2315 Guesser.process();
2316 if (Guesser.isObjC())
2317 return FormatStyle::LK_ObjC;
2318 }
2319 }
2320 return GuessedLanguage;
2321}
2322
2323const char *DefaultFormatStyle = "file";
2324
2325const char *DefaultFallbackStyle = "LLVM";
2326
2327llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
2328 StringRef FallbackStyleName,
2329 StringRef Code,
2330 llvm::vfs::FileSystem *FS) {
2331 if (!FS) {
2332 FS = llvm::vfs::getRealFileSystem().get();
2333 }
2334 FormatStyle Style = getLLVMStyle();
2335 Style.Language = guessLanguage(FileName, Code);
2336
2337 FormatStyle FallbackStyle = getNoStyle();
2338 if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
2339 return make_string_error("Invalid fallback style \"" + FallbackStyleName);
2340
2341 if (StyleName.startswith("{")) {
2342 // Parse YAML/JSON style from the command line.
2343 if (std::error_code ec = parseConfiguration(StyleName, &Style))
2344 return make_string_error("Error parsing -style: " + ec.message());
2345 return Style;
2346 }
2347
2348 if (!StyleName.equals_lower("file")) {
2349 if (!getPredefinedStyle(StyleName, Style.Language, &Style))
2350 return make_string_error("Invalid value for -style");
2351 return Style;
2352 }
2353
2354 // Look for .clang-format/_clang-format file in the file's parent directories.
2355 SmallString<128> UnsuitableConfigFiles;
2356 SmallString<128> Path(FileName);
2357 if (std::error_code EC = FS->makeAbsolute(Path))
2358 return make_string_error(EC.message());
2359
2360 for (StringRef Directory = Path; !Directory.empty();
2361 Directory = llvm::sys::path::parent_path(Directory)) {
2362
2363 auto Status = FS->status(Directory);
2364 if (!Status ||
2365 Status->getType() != llvm::sys::fs::file_type::directory_file) {
2366 continue;
2367 }
2368
2369 SmallString<128> ConfigFile(Directory);
2370
2371 llvm::sys::path::append(ConfigFile, ".clang-format");
2372 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Trying " <<
ConfigFile << "...\n"; } } while (false)
;
2373
2374 Status = FS->status(ConfigFile.str());
2375 bool FoundConfigFile =
2376 Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
2377 if (!FoundConfigFile) {
2378 // Try _clang-format too, since dotfiles are not commonly used on Windows.
2379 ConfigFile = Directory;
2380 llvm::sys::path::append(ConfigFile, "_clang-format");
2381 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Trying " <<
ConfigFile << "...\n"; } } while (false)
;
2382 Status = FS->status(ConfigFile.str());
2383 FoundConfigFile = Status && (Status->getType() ==
2384 llvm::sys::fs::file_type::regular_file);
2385 }
2386
2387 if (FoundConfigFile) {
2388 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
2389 FS->getBufferForFile(ConfigFile.str());
2390 if (std::error_code EC = Text.getError())
2391 return make_string_error(EC.message());
2392 if (std::error_code ec =
2393 parseConfiguration(Text.get()->getBuffer(), &Style)) {
2394 if (ec == ParseError::Unsuitable) {
2395 if (!UnsuitableConfigFiles.empty())
2396 UnsuitableConfigFiles.append(", ");
2397 UnsuitableConfigFiles.append(ConfigFile);
2398 continue;
2399 }
2400 return make_string_error("Error reading " + ConfigFile + ": " +
2401 ec.message());
2402 }
2403 LLVM_DEBUG(llvm::dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Using configuration file "
<< ConfigFile << "\n"; } } while (false)
2404 << "Using configuration file " << ConfigFile << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Using configuration file "
<< ConfigFile << "\n"; } } while (false)
;
2405 return Style;
2406 }
2407 }
2408 if (!UnsuitableConfigFiles.empty())
2409 return make_string_error("Configuration file(s) do(es) not support " +
2410 getLanguageName(Style.Language) + ": " +
2411 UnsuitableConfigFiles);
2412 return FallbackStyle;
2413}
2414
2415} // namespace format
2416} // namespace clang

/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h

1//===- llvm/Support/Error.h - Recoverable error handling --------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines an API used to report recoverable errors.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_SUPPORT_ERROR_H
15#define LLVM_SUPPORT_ERROR_H
16
17#include "llvm-c/Error.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/ADT/StringExtras.h"
21#include "llvm/ADT/Twine.h"
22#include "llvm/Config/abi-breaking.h"
23#include "llvm/Support/AlignOf.h"
24#include "llvm/Support/Compiler.h"
25#include "llvm/Support/Debug.h"
26#include "llvm/Support/ErrorHandling.h"
27#include "llvm/Support/ErrorOr.h"
28#include "llvm/Support/Format.h"
29#include "llvm/Support/raw_ostream.h"
30#include <algorithm>
31#include <cassert>
32#include <cstdint>
33#include <cstdlib>
34#include <functional>
35#include <memory>
36#include <new>
37#include <string>
38#include <system_error>
39#include <type_traits>
40#include <utility>
41#include <vector>
42
43namespace llvm {
44
45class ErrorSuccess;
46
47/// Base class for error info classes. Do not extend this directly: Extend
48/// the ErrorInfo template subclass instead.
49class ErrorInfoBase {
50public:
51 virtual ~ErrorInfoBase() = default;
52
53 /// Print an error message to an output stream.
54 virtual void log(raw_ostream &OS) const = 0;
55
56 /// Return the error message as a string.
57 virtual std::string message() const {
58 std::string Msg;
59 raw_string_ostream OS(Msg);
60 log(OS);
61 return OS.str();
62 }
63
64 /// Convert this error to a std::error_code.
65 ///
66 /// This is a temporary crutch to enable interaction with code still
67 /// using std::error_code. It will be removed in the future.
68 virtual std::error_code convertToErrorCode() const = 0;
69
70 // Returns the class ID for this type.
71 static const void *classID() { return &ID; }
72
73 // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
74 virtual const void *dynamicClassID() const = 0;
75
76 // Check whether this instance is a subclass of the class identified by
77 // ClassID.
78 virtual bool isA(const void *const ClassID) const {
79 return ClassID == classID();
80 }
81
82 // Check whether this instance is a subclass of ErrorInfoT.
83 template <typename ErrorInfoT> bool isA() const {
84 return isA(ErrorInfoT::classID());
85 }
86
87private:
88 virtual void anchor();
89
90 static char ID;
91};
92
93/// Lightweight error class with error context and mandatory checking.
94///
95/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
96/// are represented by setting the pointer to a ErrorInfoBase subclass
97/// instance containing information describing the failure. Success is
98/// represented by a null pointer value.
99///
100/// Instances of Error also contains a 'Checked' flag, which must be set
101/// before the destructor is called, otherwise the destructor will trigger a
102/// runtime error. This enforces at runtime the requirement that all Error
103/// instances be checked or returned to the caller.
104///
105/// There are two ways to set the checked flag, depending on what state the
106/// Error instance is in. For Error instances indicating success, it
107/// is sufficient to invoke the boolean conversion operator. E.g.:
108///
109/// @code{.cpp}
110/// Error foo(<...>);
111///
112/// if (auto E = foo(<...>))
113/// return E; // <- Return E if it is in the error state.
114/// // We have verified that E was in the success state. It can now be safely
115/// // destroyed.
116/// @endcode
117///
118/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
119/// without testing the return value will raise a runtime error, even if foo
120/// returns success.
121///
122/// For Error instances representing failure, you must use either the
123/// handleErrors or handleAllErrors function with a typed handler. E.g.:
124///
125/// @code{.cpp}
126/// class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
127/// // Custom error info.
128/// };
129///
130/// Error foo(<...>) { return make_error<MyErrorInfo>(...); }
131///
132/// auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
133/// auto NewE =
134/// handleErrors(E,
135/// [](const MyErrorInfo &M) {
136/// // Deal with the error.
137/// },
138/// [](std::unique_ptr<OtherError> M) -> Error {
139/// if (canHandle(*M)) {
140/// // handle error.
141/// return Error::success();
142/// }
143/// // Couldn't handle this error instance. Pass it up the stack.
144/// return Error(std::move(M));
145/// );
146/// // Note - we must check or return NewE in case any of the handlers
147/// // returned a new error.
148/// @endcode
149///
150/// The handleAllErrors function is identical to handleErrors, except
151/// that it has a void return type, and requires all errors to be handled and
152/// no new errors be returned. It prevents errors (assuming they can all be
153/// handled) from having to be bubbled all the way to the top-level.
154///
155/// *All* Error instances must be checked before destruction, even if
156/// they're moved-assigned or constructed from Success values that have already
157/// been checked. This enforces checking through all levels of the call stack.
158class LLVM_NODISCARD[[clang::warn_unused_result]] Error {
159 // Both ErrorList and FileError need to be able to yank ErrorInfoBase
160 // pointers out of this class to add to the error list.
161 friend class ErrorList;
162 friend class FileError;
163
164 // handleErrors needs to be able to set the Checked flag.
165 template <typename... HandlerTs>
166 friend Error handleErrors(Error E, HandlerTs &&... Handlers);
167
168 // Expected<T> needs to be able to steal the payload when constructed from an
169 // error.
170 template <typename T> friend class Expected;
171
172 // wrap needs to be able to steal the payload.
173 friend LLVMErrorRef wrap(Error);
174
175protected:
176 /// Create a success value. Prefer using 'Error::success()' for readability
177 Error() {
178 setPtr(nullptr);
179 setChecked(false);
180 }
181
182public:
183 /// Create a success value.
184 static ErrorSuccess success();
185
186 // Errors are not copy-constructable.
187 Error(const Error &Other) = delete;
188
189 /// Move-construct an error value. The newly constructed error is considered
190 /// unchecked, even if the source error had been checked. The original error
191 /// becomes a checked Success value, regardless of its original state.
192 Error(Error &&Other) {
193 setChecked(true);
194 *this = std::move(Other);
195 }
196
197 /// Create an error value. Prefer using the 'make_error' function, but
198 /// this constructor can be useful when "re-throwing" errors from handlers.
199 Error(std::unique_ptr<ErrorInfoBase> Payload) {
200 setPtr(Payload.release());
201 setChecked(false);
6
Potential leak of memory pointed to by 'Payload._M_t._M_head_impl'
202 }
203
204 // Errors are not copy-assignable.
205 Error &operator=(const Error &Other) = delete;
206
207 /// Move-assign an error value. The current error must represent success, you
208 /// you cannot overwrite an unhandled error. The current error is then
209 /// considered unchecked. The source error becomes a checked success value,
210 /// regardless of its original state.
211 Error &operator=(Error &&Other) {
212 // Don't allow overwriting of unchecked values.
213 assertIsChecked();
214 setPtr(Other.getPtr());
215
216 // This Error is unchecked, even if the source error was checked.
217 setChecked(false);
218
219 // Null out Other's payload and set its checked bit.
220 Other.setPtr(nullptr);
221 Other.setChecked(true);
222
223 return *this;
224 }
225
226 /// Destroy a Error. Fails with a call to abort() if the error is
227 /// unchecked.
228 ~Error() {
229 assertIsChecked();
230 delete getPtr();
231 }
232
233 /// Bool conversion. Returns true if this Error is in a failure state,
234 /// and false if it is in an accept state. If the error is in a Success state
235 /// it will be considered checked.
236 explicit operator bool() {
237 setChecked(getPtr() == nullptr);
238 return getPtr() != nullptr;
239 }
240
241 /// Check whether one error is a subclass of another.
242 template <typename ErrT> bool isA() const {
243 return getPtr() && getPtr()->isA(ErrT::classID());
244 }
245
246 /// Returns the dynamic class id of this error, or null if this is a success
247 /// value.
248 const void* dynamicClassID() const {
249 if (!getPtr())
250 return nullptr;
251 return getPtr()->dynamicClassID();
252 }
253
254private:
255#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
256 // assertIsChecked() happens very frequently, but under normal circumstances
257 // is supposed to be a no-op. So we want it to be inlined, but having a bunch
258 // of debug prints can cause the function to be too large for inlining. So
259 // it's important that we define this function out of line so that it can't be
260 // inlined.
261 LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
262 void fatalUncheckedError() const;
263#endif
264
265 void assertIsChecked() {
266#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
267 if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
268 fatalUncheckedError();
269#endif
270 }
271
272 ErrorInfoBase *getPtr() const {
273 return reinterpret_cast<ErrorInfoBase*>(
274 reinterpret_cast<uintptr_t>(Payload) &
275 ~static_cast<uintptr_t>(0x1));
276 }
277
278 void setPtr(ErrorInfoBase *EI) {
279#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
280 Payload = reinterpret_cast<ErrorInfoBase*>(
281 (reinterpret_cast<uintptr_t>(EI) &
282 ~static_cast<uintptr_t>(0x1)) |
283 (reinterpret_cast<uintptr_t>(Payload) & 0x1));
284#else
285 Payload = EI;
286#endif
287 }
288
289 bool getChecked() const {
290#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
291 return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
292#else
293 return true;
294#endif
295 }
296
297 void setChecked(bool V) {
298 Payload = reinterpret_cast<ErrorInfoBase*>(
299 (reinterpret_cast<uintptr_t>(Payload) &
300 ~static_cast<uintptr_t>(0x1)) |
301 (V ? 0 : 1));
302 }
303
304 std::unique_ptr<ErrorInfoBase> takePayload() {
305 std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
306 setPtr(nullptr);
307 setChecked(true);
308 return Tmp;
309 }
310
311 friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
312 if (auto P = E.getPtr())
313 P->log(OS);
314 else
315 OS << "success";
316 return OS;
317 }
318
319 ErrorInfoBase *Payload = nullptr;
320};
321
322/// Subclass of Error for the sole purpose of identifying the success path in
323/// the type system. This allows to catch invalid conversion to Expected<T> at
324/// compile time.
325class ErrorSuccess final : public Error {};
326
327inline ErrorSuccess Error::success() { return ErrorSuccess(); }
328
329/// Make a Error instance representing failure using the given error info
330/// type.
331template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
332 return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
2
Calling 'make_unique<llvm::StringError, const llvm::Twine &, std::error_code>'
4
Returned allocated memory
5
Calling constructor for 'Error'
333}
334
335/// Base class for user error types. Users should declare their error types
336/// like:
337///
338/// class MyError : public ErrorInfo<MyError> {
339/// ....
340/// };
341///
342/// This class provides an implementation of the ErrorInfoBase::kind
343/// method, which is used by the Error RTTI system.
344template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
345class ErrorInfo : public ParentErrT {
346public:
347 using ParentErrT::ParentErrT; // inherit constructors
348
349 static const void *classID() { return &ThisErrT::ID; }
350
351 const void *dynamicClassID() const override { return &ThisErrT::ID; }
352
353 bool isA(const void *const ClassID) const override {
354 return ClassID == classID() || ParentErrT::isA(ClassID);
355 }
356};
357
358/// Special ErrorInfo subclass representing a list of ErrorInfos.
359/// Instances of this class are constructed by joinError.
360class ErrorList final : public ErrorInfo<ErrorList> {
361 // handleErrors needs to be able to iterate the payload list of an
362 // ErrorList.
363 template <typename... HandlerTs>
364 friend Error handleErrors(Error E, HandlerTs &&... Handlers);
365
366 // joinErrors is implemented in terms of join.
367 friend Error joinErrors(Error, Error);
368
369public:
370 void log(raw_ostream &OS) const override {
371 OS << "Multiple errors:\n";
372 for (auto &ErrPayload : Payloads) {
373 ErrPayload->log(OS);
374 OS << "\n";
375 }
376 }
377
378 std::error_code convertToErrorCode() const override;
379
380 // Used by ErrorInfo::classID.
381 static char ID;
382
383private:
384 ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
385 std::unique_ptr<ErrorInfoBase> Payload2) {
386 assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&((!Payload1->isA<ErrorList>() && !Payload2->
isA<ErrorList>() && "ErrorList constructor payloads should be singleton errors"
) ? static_cast<void> (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 387, __PRETTY_FUNCTION__))
387 "ErrorList constructor payloads should be singleton errors")((!Payload1->isA<ErrorList>() && !Payload2->
isA<ErrorList>() && "ErrorList constructor payloads should be singleton errors"
) ? static_cast<void> (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 387, __PRETTY_FUNCTION__))
;
388 Payloads.push_back(std::move(Payload1));
389 Payloads.push_back(std::move(Payload2));
390 }
391
392 static Error join(Error E1, Error E2) {
393 if (!E1)
394 return E2;
395 if (!E2)
396 return E1;
397 if (E1.isA<ErrorList>()) {
398 auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
399 if (E2.isA<ErrorList>()) {
400 auto E2Payload = E2.takePayload();
401 auto &E2List = static_cast<ErrorList &>(*E2Payload);
402 for (auto &Payload : E2List.Payloads)
403 E1List.Payloads.push_back(std::move(Payload));
404 } else
405 E1List.Payloads.push_back(E2.takePayload());
406
407 return E1;
408 }
409 if (E2.isA<ErrorList>()) {
410 auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
411 E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
412 return E2;
413 }
414 return Error(std::unique_ptr<ErrorList>(
415 new ErrorList(E1.takePayload(), E2.takePayload())));
416 }
417
418 std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
419};
420
421/// Concatenate errors. The resulting Error is unchecked, and contains the
422/// ErrorInfo(s), if any, contained in E1, followed by the
423/// ErrorInfo(s), if any, contained in E2.
424inline Error joinErrors(Error E1, Error E2) {
425 return ErrorList::join(std::move(E1), std::move(E2));
426}
427
428/// Tagged union holding either a T or a Error.
429///
430/// This class parallels ErrorOr, but replaces error_code with Error. Since
431/// Error cannot be copied, this class replaces getError() with
432/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
433/// error class type.
434template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected {
435 template <class T1> friend class ExpectedAsOutParameter;
436 template <class OtherT> friend class Expected;
437
438 static const bool isRef = std::is_reference<T>::value;
439
440 using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
441
442 using error_type = std::unique_ptr<ErrorInfoBase>;
443
444public:
445 using storage_type = typename std::conditional<isRef, wrap, T>::type;
446 using value_type = T;
447
448private:
449 using reference = typename std::remove_reference<T>::type &;
450 using const_reference = const typename std::remove_reference<T>::type &;
451 using pointer = typename std::remove_reference<T>::type *;
452 using const_pointer = const typename std::remove_reference<T>::type *;
453
454public:
455 /// Create an Expected<T> error value from the given Error.
456 Expected(Error Err)
457 : HasError(true)
458#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
459 // Expected is unchecked upon construction in Debug builds.
460 , Unchecked(true)
461#endif
462 {
463 assert(Err && "Cannot create Expected<T> from Error success value.")((Err && "Cannot create Expected<T> from Error success value."
) ? static_cast<void> (0) : __assert_fail ("Err && \"Cannot create Expected<T> from Error success value.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 463, __PRETTY_FUNCTION__))
;
464 new (getErrorStorage()) error_type(Err.takePayload());
465 }
466
467 /// Forbid to convert from Error::success() implicitly, this avoids having
468 /// Expected<T> foo() { return Error::success(); } which compiles otherwise
469 /// but triggers the assertion above.
470 Expected(ErrorSuccess) = delete;
471
472 /// Create an Expected<T> success value from the given OtherT value, which
473 /// must be convertible to T.
474 template <typename OtherT>
475 Expected(OtherT &&Val,
476 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
477 * = nullptr)
478 : HasError(false)
479#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
480 // Expected is unchecked upon construction in Debug builds.
481 , Unchecked(true)
482#endif
483 {
484 new (getStorage()) storage_type(std::forward<OtherT>(Val));
485 }
486
487 /// Move construct an Expected<T> value.
488 Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
489
490 /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
491 /// must be convertible to T.
492 template <class OtherT>
493 Expected(Expected<OtherT> &&Other,
494 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
495 * = nullptr) {
496 moveConstruct(std::move(Other));
497 }
498
499 /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
500 /// isn't convertible to T.
501 template <class OtherT>
502 explicit Expected(
503 Expected<OtherT> &&Other,
504 typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
505 nullptr) {
506 moveConstruct(std::move(Other));
507 }
508
509 /// Move-assign from another Expected<T>.
510 Expected &operator=(Expected &&Other) {
511 moveAssign(std::move(Other));
512 return *this;
513 }
514
515 /// Destroy an Expected<T>.
516 ~Expected() {
517 assertIsChecked();
518 if (!HasError)
519 getStorage()->~storage_type();
520 else
521 getErrorStorage()->~error_type();
522 }
523
524 /// Return false if there is an error.
525 explicit operator bool() {
526#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
527 Unchecked = HasError;
528#endif
529 return !HasError;
530 }
531
532 /// Returns a reference to the stored T value.
533 reference get() {
534 assertIsChecked();
535 return *getStorage();
536 }
537
538 /// Returns a const reference to the stored T value.
539 const_reference get() const {
540 assertIsChecked();
541 return const_cast<Expected<T> *>(this)->get();
542 }
543
544 /// Check that this Expected<T> is an error of type ErrT.
545 template <typename ErrT> bool errorIsA() const {
546 return HasError && (*getErrorStorage())->template isA<ErrT>();
547 }
548
549 /// Take ownership of the stored error.
550 /// After calling this the Expected<T> is in an indeterminate state that can
551 /// only be safely destructed. No further calls (beside the destructor) should
552 /// be made on the Expected<T> vaule.
553 Error takeError() {
554#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
555 Unchecked = false;
556#endif
557 return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
558 }
559
560 /// Returns a pointer to the stored T value.
561 pointer operator->() {
562 assertIsChecked();
563 return toPointer(getStorage());
564 }
565
566 /// Returns a const pointer to the stored T value.
567 const_pointer operator->() const {
568 assertIsChecked();
569 return toPointer(getStorage());
570 }
571
572 /// Returns a reference to the stored T value.
573 reference operator*() {
574 assertIsChecked();
575 return *getStorage();
576 }
577
578 /// Returns a const reference to the stored T value.
579 const_reference operator*() const {
580 assertIsChecked();
581 return *getStorage();
582 }
583
584private:
585 template <class T1>
586 static bool compareThisIfSameType(const T1 &a, const T1 &b) {
587 return &a == &b;
588 }
589
590 template <class T1, class T2>
591 static bool compareThisIfSameType(const T1 &a, const T2 &b) {
592 return false;
593 }
594
595 template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
596 HasError = Other.HasError;
597#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
598 Unchecked = true;
599 Other.Unchecked = false;
600#endif
601
602 if (!HasError)
603 new (getStorage()) storage_type(std::move(*Other.getStorage()));
604 else
605 new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
606 }
607
608 template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
609 assertIsChecked();
610
611 if (compareThisIfSameType(*this, Other))
612 return;
613
614 this->~Expected();
615 new (this) Expected(std::move(Other));
616 }
617
618 pointer toPointer(pointer Val) { return Val; }
619
620 const_pointer toPointer(const_pointer Val) const { return Val; }
621
622 pointer toPointer(wrap *Val) { return &Val->get(); }
623
624 const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
625
626 storage_type *getStorage() {
627 assert(!HasError && "Cannot get value when an error exists!")((!HasError && "Cannot get value when an error exists!"
) ? static_cast<void> (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 627, __PRETTY_FUNCTION__))
;
628 return reinterpret_cast<storage_type *>(TStorage.buffer);
629 }
630
631 const storage_type *getStorage() const {
632 assert(!HasError && "Cannot get value when an error exists!")((!HasError && "Cannot get value when an error exists!"
) ? static_cast<void> (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 632, __PRETTY_FUNCTION__))
;
633 return reinterpret_cast<const storage_type *>(TStorage.buffer);
634 }
635
636 error_type *getErrorStorage() {
637 assert(HasError && "Cannot get error when a value exists!")((HasError && "Cannot get error when a value exists!"
) ? static_cast<void> (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 637, __PRETTY_FUNCTION__))
;
638 return reinterpret_cast<error_type *>(ErrorStorage.buffer);
639 }
640
641 const error_type *getErrorStorage() const {
642 assert(HasError && "Cannot get error when a value exists!")((HasError && "Cannot get error when a value exists!"
) ? static_cast<void> (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 642, __PRETTY_FUNCTION__))
;
643 return reinterpret_cast<const error_type *>(ErrorStorage.buffer);
644 }
645
646 // Used by ExpectedAsOutParameter to reset the checked flag.
647 void setUnchecked() {
648#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
649 Unchecked = true;
650#endif
651 }
652
653#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
654 LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
655 LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline))
656 void fatalUncheckedExpected() const {
657 dbgs() << "Expected<T> must be checked before access or destruction.\n";
658 if (HasError) {
659 dbgs() << "Unchecked Expected<T> contained error:\n";
660 (*getErrorStorage())->log(dbgs());
661 } else
662 dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
663 "values in success mode must still be checked prior to being "
664 "destroyed).\n";
665 abort();
666 }
667#endif
668
669 void assertIsChecked() {
670#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
671 if (LLVM_UNLIKELY(Unchecked)__builtin_expect((bool)(Unchecked), false))
672 fatalUncheckedExpected();
673#endif
674 }
675
676 union {
677 AlignedCharArrayUnion<storage_type> TStorage;
678 AlignedCharArrayUnion<error_type> ErrorStorage;
679 };
680 bool HasError : 1;
681#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
682 bool Unchecked : 1;
683#endif
684};
685
686/// Report a serious error, calling any installed error handler. See
687/// ErrorHandling.h.
688LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void report_fatal_error(Error Err,
689 bool gen_crash_diag = true);
690
691/// Report a fatal error if Err is a failure value.
692///
693/// This function can be used to wrap calls to fallible functions ONLY when it
694/// is known that the Error will always be a success value. E.g.
695///
696/// @code{.cpp}
697/// // foo only attempts the fallible operation if DoFallibleOperation is
698/// // true. If DoFallibleOperation is false then foo always returns
699/// // Error::success().
700/// Error foo(bool DoFallibleOperation);
701///
702/// cantFail(foo(false));
703/// @endcode
704inline void cantFail(Error Err, const char *Msg = nullptr) {
705 if (Err) {
706 if (!Msg)
707 Msg = "Failure value returned from cantFail wrapped call";
708 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 708)
;
709 }
710}
711
712/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
713/// returns the contained value.
714///
715/// This function can be used to wrap calls to fallible functions ONLY when it
716/// is known that the Error will always be a success value. E.g.
717///
718/// @code{.cpp}
719/// // foo only attempts the fallible operation if DoFallibleOperation is
720/// // true. If DoFallibleOperation is false then foo always returns an int.
721/// Expected<int> foo(bool DoFallibleOperation);
722///
723/// int X = cantFail(foo(false));
724/// @endcode
725template <typename T>
726T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
727 if (ValOrErr)
728 return std::move(*ValOrErr);
729 else {
730 if (!Msg)
731 Msg = "Failure value returned from cantFail wrapped call";
732 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 732)
;
733 }
734}
735
736/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
737/// returns the contained reference.
738///
739/// This function can be used to wrap calls to fallible functions ONLY when it
740/// is known that the Error will always be a success value. E.g.
741///
742/// @code{.cpp}
743/// // foo only attempts the fallible operation if DoFallibleOperation is
744/// // true. If DoFallibleOperation is false then foo always returns a Bar&.
745/// Expected<Bar&> foo(bool DoFallibleOperation);
746///
747/// Bar &X = cantFail(foo(false));
748/// @endcode
749template <typename T>
750T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
751 if (ValOrErr)
752 return *ValOrErr;
753 else {
754 if (!Msg)
755 Msg = "Failure value returned from cantFail wrapped call";
756 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 756)
;
757 }
758}
759
760/// Helper for testing applicability of, and applying, handlers for
761/// ErrorInfo types.
762template <typename HandlerT>
763class ErrorHandlerTraits
764 : public ErrorHandlerTraits<decltype(
765 &std::remove_reference<HandlerT>::type::operator())> {};
766
767// Specialization functions of the form 'Error (const ErrT&)'.
768template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
769public:
770 static bool appliesTo(const ErrorInfoBase &E) {
771 return E.template isA<ErrT>();
772 }
773
774 template <typename HandlerT>
775 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
776 assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 776, __PRETTY_FUNCTION__))
;
777 return H(static_cast<ErrT &>(*E));
778 }
779};
780
781// Specialization functions of the form 'void (const ErrT&)'.
782template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
783public:
784 static bool appliesTo(const ErrorInfoBase &E) {
785 return E.template isA<ErrT>();
786 }
787
788 template <typename HandlerT>
789 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
790 assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 790, __PRETTY_FUNCTION__))
;
791 H(static_cast<ErrT &>(*E));
792 return Error::success();
793 }
794};
795
796/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
797template <typename ErrT>
798class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
799public:
800 static bool appliesTo(const ErrorInfoBase &E) {
801 return E.template isA<ErrT>();
802 }
803
804 template <typename HandlerT>
805 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
806 assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 806, __PRETTY_FUNCTION__))
;
807 std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
808 return H(std::move(SubE));
809 }
810};
811
812/// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
813template <typename ErrT>
814class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
815public:
816 static bool appliesTo(const ErrorInfoBase &E) {
817 return E.template isA<ErrT>();
818 }
819
820 template <typename HandlerT>
821 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
822 assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 822, __PRETTY_FUNCTION__))
;
823 std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
824 H(std::move(SubE));
825 return Error::success();
826 }
827};
828
829// Specialization for member functions of the form 'RetT (const ErrT&)'.
830template <typename C, typename RetT, typename ErrT>
831class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
832 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
833
834// Specialization for member functions of the form 'RetT (const ErrT&) const'.
835template <typename C, typename RetT, typename ErrT>
836class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
837 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
838
839// Specialization for member functions of the form 'RetT (const ErrT&)'.
840template <typename C, typename RetT, typename ErrT>
841class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
842 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
843
844// Specialization for member functions of the form 'RetT (const ErrT&) const'.
845template <typename C, typename RetT, typename ErrT>
846class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
847 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
848
849/// Specialization for member functions of the form
850/// 'RetT (std::unique_ptr<ErrT>)'.
851template <typename C, typename RetT, typename ErrT>
852class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
853 : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
854
855/// Specialization for member functions of the form
856/// 'RetT (std::unique_ptr<ErrT>) const'.
857template <typename C, typename RetT, typename ErrT>
858class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
859 : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
860
861inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
862 return Error(std::move(Payload));
863}
864
865template <typename HandlerT, typename... HandlerTs>
866Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
867 HandlerT &&Handler, HandlerTs &&... Handlers) {
868 if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
869 return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
870 std::move(Payload));
871 return handleErrorImpl(std::move(Payload),
872 std::forward<HandlerTs>(Handlers)...);
873}
874
875/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
876/// unhandled errors (or Errors returned by handlers) are re-concatenated and
877/// returned.
878/// Because this function returns an error, its result must also be checked
879/// or returned. If you intend to handle all errors use handleAllErrors
880/// (which returns void, and will abort() on unhandled errors) instead.
881template <typename... HandlerTs>
882Error handleErrors(Error E, HandlerTs &&... Hs) {
883 if (!E)
884 return Error::success();
885
886 std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
887
888 if (Payload->isA<ErrorList>()) {
889 ErrorList &List = static_cast<ErrorList &>(*Payload);
890 Error R;
891 for (auto &P : List.Payloads)
892 R = ErrorList::join(
893 std::move(R),
894 handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
895 return R;
896 }
897
898 return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
899}
900
901/// Behaves the same as handleErrors, except that by contract all errors
902/// *must* be handled by the given handlers (i.e. there must be no remaining
903/// errors after running the handlers, or llvm_unreachable is called).
904template <typename... HandlerTs>
905void handleAllErrors(Error E, HandlerTs &&... Handlers) {
906 cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
907}
908
909/// Check that E is a non-error, then drop it.
910/// If E is an error, llvm_unreachable will be called.
911inline void handleAllErrors(Error E) {
912 cantFail(std::move(E));
913}
914
915/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
916///
917/// If the incoming value is a success value it is returned unmodified. If it
918/// is a failure value then it the contained error is passed to handleErrors.
919/// If handleErrors is able to handle the error then the RecoveryPath functor
920/// is called to supply the final result. If handleErrors is not able to
921/// handle all errors then the unhandled errors are returned.
922///
923/// This utility enables the follow pattern:
924///
925/// @code{.cpp}
926/// enum FooStrategy { Aggressive, Conservative };
927/// Expected<Foo> foo(FooStrategy S);
928///
929/// auto ResultOrErr =
930/// handleExpected(
931/// foo(Aggressive),
932/// []() { return foo(Conservative); },
933/// [](AggressiveStrategyError&) {
934/// // Implicitly conusme this - we'll recover by using a conservative
935/// // strategy.
936/// });
937///
938/// @endcode
939template <typename T, typename RecoveryFtor, typename... HandlerTs>
940Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
941 HandlerTs &&... Handlers) {
942 if (ValOrErr)
943 return ValOrErr;
944
945 if (auto Err = handleErrors(ValOrErr.takeError(),
946 std::forward<HandlerTs>(Handlers)...))
947 return std::move(Err);
948
949 return RecoveryPath();
950}
951
952/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
953/// will be printed before the first one is logged. A newline will be printed
954/// after each error.
955///
956/// This is useful in the base level of your program to allow clean termination
957/// (allowing clean deallocation of resources, etc.), while reporting error
958/// information to the user.
959void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner);
960
961/// Write all error messages (if any) in E to a string. The newline character
962/// is used to separate error messages.
963inline std::string toString(Error E) {
964 SmallVector<std::string, 2> Errors;
965 handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
966 Errors.push_back(EI.message());
967 });
968 return join(Errors.begin(), Errors.end(), "\n");
969}
970
971/// Consume a Error without doing anything. This method should be used
972/// only where an error can be considered a reasonable and expected return
973/// value.
974///
975/// Uses of this method are potentially indicative of design problems: If it's
976/// legitimate to do nothing while processing an "error", the error-producer
977/// might be more clearly refactored to return an Optional<T>.
978inline void consumeError(Error Err) {
979 handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
980}
981
982/// Helper for converting an Error to a bool.
983///
984/// This method returns true if Err is in an error state, or false if it is
985/// in a success state. Puts Err in a checked state in both cases (unlike
986/// Error::operator bool(), which only does this for success states).
987inline bool errorToBool(Error Err) {
988 bool IsError = static_cast<bool>(Err);
989 if (IsError)
990 consumeError(std::move(Err));
991 return IsError;
992}
993
994/// Helper for Errors used as out-parameters.
995///
996/// This helper is for use with the Error-as-out-parameter idiom, where an error
997/// is passed to a function or method by reference, rather than being returned.
998/// In such cases it is helpful to set the checked bit on entry to the function
999/// so that the error can be written to (unchecked Errors abort on assignment)
1000/// and clear the checked bit on exit so that clients cannot accidentally forget
1001/// to check the result. This helper performs these actions automatically using
1002/// RAII:
1003///
1004/// @code{.cpp}
1005/// Result foo(Error &Err) {
1006/// ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1007/// // <body of foo>
1008/// // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1009/// }
1010/// @endcode
1011///
1012/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1013/// used with optional Errors (Error pointers that are allowed to be null). If
1014/// ErrorAsOutParameter took an Error reference, an instance would have to be
1015/// created inside every condition that verified that Error was non-null. By
1016/// taking an Error pointer we can just create one instance at the top of the
1017/// function.
1018class ErrorAsOutParameter {
1019public:
1020 ErrorAsOutParameter(Error *Err) : Err(Err) {
1021 // Raise the checked bit if Err is success.
1022 if (Err)
1023 (void)!!*Err;
1024 }
1025
1026 ~ErrorAsOutParameter() {
1027 // Clear the checked bit.
1028 if (Err && !*Err)
1029 *Err = Error::success();
1030 }
1031
1032private:
1033 Error *Err;
1034};
1035
1036/// Helper for Expected<T>s used as out-parameters.
1037///
1038/// See ErrorAsOutParameter.
1039template <typename T>
1040class ExpectedAsOutParameter {
1041public:
1042 ExpectedAsOutParameter(Expected<T> *ValOrErr)
1043 : ValOrErr(ValOrErr) {
1044 if (ValOrErr)
1045 (void)!!*ValOrErr;
1046 }
1047
1048 ~ExpectedAsOutParameter() {
1049 if (ValOrErr)
1050 ValOrErr->setUnchecked();
1051 }
1052
1053private:
1054 Expected<T> *ValOrErr;
1055};
1056
1057/// This class wraps a std::error_code in a Error.
1058///
1059/// This is useful if you're writing an interface that returns a Error
1060/// (or Expected) and you want to call code that still returns
1061/// std::error_codes.
1062class ECError : public ErrorInfo<ECError> {
1063 friend Error errorCodeToError(std::error_code);
1064
1065public:
1066 void setErrorCode(std::error_code EC) { this->EC = EC; }
1067 std::error_code convertToErrorCode() const override { return EC; }
1068 void log(raw_ostream &OS) const override { OS << EC.message(); }
1069
1070 // Used by ErrorInfo::classID.
1071 static char ID;
1072
1073protected:
1074 ECError() = default;
1075 ECError(std::error_code EC) : EC(EC) {}
1076
1077 std::error_code EC;
1078};
1079
1080/// The value returned by this function can be returned from convertToErrorCode
1081/// for Error values where no sensible translation to std::error_code exists.
1082/// It should only be used in this situation, and should never be used where a
1083/// sensible conversion to std::error_code is available, as attempts to convert
1084/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1085///error to try to convert such a value).
1086std::error_code inconvertibleErrorCode();
1087
1088/// Helper for converting an std::error_code to a Error.
1089Error errorCodeToError(std::error_code EC);
1090
1091/// Helper for converting an ECError to a std::error_code.
1092///
1093/// This method requires that Err be Error() or an ECError, otherwise it
1094/// will trigger a call to abort().
1095std::error_code errorToErrorCode(Error Err);
1096
1097/// Convert an ErrorOr<T> to an Expected<T>.
1098template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1099 if (auto EC = EO.getError())
1100 return errorCodeToError(EC);
1101 return std::move(*EO);
1102}
1103
1104/// Convert an Expected<T> to an ErrorOr<T>.
1105template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1106 if (auto Err = E.takeError())
1107 return errorToErrorCode(std::move(Err));
1108 return std::move(*E);
1109}
1110
1111/// This class wraps a string in an Error.
1112///
1113/// StringError is useful in cases where the client is not expected to be able
1114/// to consume the specific error message programmatically (for example, if the
1115/// error message is to be presented to the user).
1116///
1117/// StringError can also be used when additional information is to be printed
1118/// along with a error_code message. Depending on the constructor called, this
1119/// class can either display:
1120/// 1. the error_code message (ECError behavior)
1121/// 2. a string
1122/// 3. the error_code message and a string
1123///
1124/// These behaviors are useful when subtyping is required; for example, when a
1125/// specific library needs an explicit error type. In the example below,
1126/// PDBError is derived from StringError:
1127///
1128/// @code{.cpp}
1129/// Expected<int> foo() {
1130/// return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1131/// "Additional information");
1132/// }
1133/// @endcode
1134///
1135class StringError : public ErrorInfo<StringError> {
1136public:
1137 static char ID;
1138
1139 // Prints EC + S and converts to EC
1140 StringError(std::error_code EC, const Twine &S = Twine());
1141
1142 // Prints S and converts to EC
1143 StringError(const Twine &S, std::error_code EC);
1144
1145 void log(raw_ostream &OS) const override;
1146 std::error_code convertToErrorCode() const override;
1147
1148 const std::string &getMessage() const { return Msg; }
1149
1150private:
1151 std::string Msg;
1152 std::error_code EC;
1153 const bool PrintMsgOnly = false;
1154};
1155
1156/// Create formatted StringError object.
1157template <typename... Ts>
1158Error createStringError(std::error_code EC, char const *Fmt,
1159 const Ts &... Vals) {
1160 std::string Buffer;
1161 raw_string_ostream Stream(Buffer);
1162 Stream << format(Fmt, Vals...);
1163 return make_error<StringError>(Stream.str(), EC);
1164}
1165
1166Error createStringError(std::error_code EC, char const *Msg);
1167
1168/// This class wraps a filename and another Error.
1169///
1170/// In some cases, an error needs to live along a 'source' name, in order to
1171/// show more detailed information to the user.
1172class FileError final : public ErrorInfo<FileError> {
1173
1174 friend Error createFileError(std::string, Error);
1175
1176public:
1177 void log(raw_ostream &OS) const override {
1178 assert(Err && !FileName.empty() && "Trying to log after takeError().")((Err && !FileName.empty() && "Trying to log after takeError()."
) ? static_cast<void> (0) : __assert_fail ("Err && !FileName.empty() && \"Trying to log after takeError().\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1178, __PRETTY_FUNCTION__))
;
1179 OS << "'" << FileName << "': ";
1180 Err->log(OS);
1181 }
1182
1183 Error takeError() { return Error(std::move(Err)); }
1184
1185 std::error_code convertToErrorCode() const override;
1186
1187 // Used by ErrorInfo::classID.
1188 static char ID;
1189
1190private:
1191 FileError(std::string F, std::unique_ptr<ErrorInfoBase> E) {
1192 assert(E && "Cannot create FileError from Error success value.")((E && "Cannot create FileError from Error success value."
) ? static_cast<void> (0) : __assert_fail ("E && \"Cannot create FileError from Error success value.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1192, __PRETTY_FUNCTION__))
;
1193 assert(!F.empty() &&((!F.empty() && "The file name provided to FileError must not be empty."
) ? static_cast<void> (0) : __assert_fail ("!F.empty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1194, __PRETTY_FUNCTION__))
1194 "The file name provided to FileError must not be empty.")((!F.empty() && "The file name provided to FileError must not be empty."
) ? static_cast<void> (0) : __assert_fail ("!F.empty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1194, __PRETTY_FUNCTION__))
;
1195 FileName = F;
1196 Err = std::move(E);
1197 }
1198
1199 static Error build(std::string F, Error E) {
1200 return Error(std::unique_ptr<FileError>(new FileError(F, E.takePayload())));
1201 }
1202
1203 std::string FileName;
1204 std::unique_ptr<ErrorInfoBase> Err;
1205};
1206
1207/// Concatenate a source file path and/or name with an Error. The resulting
1208/// Error is unchecked.
1209inline Error createFileError(std::string F, Error E) {
1210 return FileError::build(F, std::move(E));
1211}
1212
1213Error createFileError(std::string F, ErrorSuccess) = delete;
1214
1215/// Helper for check-and-exit error handling.
1216///
1217/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1218///
1219class ExitOnError {
1220public:
1221 /// Create an error on exit helper.
1222 ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1223 : Banner(std::move(Banner)),
1224 GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1225
1226 /// Set the banner string for any errors caught by operator().
1227 void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1228
1229 /// Set the exit-code mapper function.
1230 void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1231 this->GetExitCode = std::move(GetExitCode);
1232 }
1233
1234 /// Check Err. If it's in a failure state log the error(s) and exit.
1235 void operator()(Error Err) const { checkError(std::move(Err)); }
1236
1237 /// Check E. If it's in a success state then return the contained value. If
1238 /// it's in a failure state log the error(s) and exit.
1239 template <typename T> T operator()(Expected<T> &&E) const {
1240 checkError(E.takeError());
1241 return std::move(*E);
1242 }
1243
1244 /// Check E. If it's in a success state then return the contained reference. If
1245 /// it's in a failure state log the error(s) and exit.
1246 template <typename T> T& operator()(Expected<T&> &&E) const {
1247 checkError(E.takeError());
1248 return *E;
1249 }
1250
1251private:
1252 void checkError(Error Err) const {
1253 if (Err) {
1254 int ExitCode = GetExitCode(Err);
1255 logAllUnhandledErrors(std::move(Err), errs(), Banner);
1256 exit(ExitCode);
1257 }
1258 }
1259
1260 std::string Banner;
1261 std::function<int(const Error &)> GetExitCode;
1262};
1263
1264/// Conversion from Error to LLVMErrorRef for C error bindings.
1265inline LLVMErrorRef wrap(Error Err) {
1266 return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1267}
1268
1269/// Conversion from LLVMErrorRef to Error for C error bindings.
1270inline Error unwrap(LLVMErrorRef ErrRef) {
1271 return Error(std::unique_ptr<ErrorInfoBase>(
1272 reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1273}
1274
1275} // end namespace llvm
1276
1277#endif // LLVM_SUPPORT_ERROR_H

/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h

1//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains some templates that are useful if you are working with the
11// STL at all.
12//
13// No library is required when using these functions.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_ADT_STLEXTRAS_H
18#define LLVM_ADT_STLEXTRAS_H
19
20#include "llvm/ADT/Optional.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/iterator.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/Config/abi-breaking.h"
25#include "llvm/Support/ErrorHandling.h"
26#include <algorithm>
27#include <cassert>
28#include <cstddef>
29#include <cstdint>
30#include <cstdlib>
31#include <functional>
32#include <initializer_list>
33#include <iterator>
34#include <limits>
35#include <memory>
36#include <tuple>
37#include <type_traits>
38#include <utility>
39
40#ifdef EXPENSIVE_CHECKS
41#include <random> // for std::mt19937
42#endif
43
44namespace llvm {
45
46// Only used by compiler if both template types are the same. Useful when
47// using SFINAE to test for the existence of member functions.
48template <typename T, T> struct SameType;
49
50namespace detail {
51
52template <typename RangeT>
53using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
54
55template <typename RangeT>
56using ValueOfRange = typename std::remove_reference<decltype(
57 *std::begin(std::declval<RangeT &>()))>::type;
58
59} // end namespace detail
60
61//===----------------------------------------------------------------------===//
62// Extra additions to <type_traits>
63//===----------------------------------------------------------------------===//
64
65template <typename T>
66struct negation : std::integral_constant<bool, !bool(T::value)> {};
67
68template <typename...> struct conjunction : std::true_type {};
69template <typename B1> struct conjunction<B1> : B1 {};
70template <typename B1, typename... Bn>
71struct conjunction<B1, Bn...>
72 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
73
74//===----------------------------------------------------------------------===//
75// Extra additions to <functional>
76//===----------------------------------------------------------------------===//
77
78template <class Ty> struct identity {
79 using argument_type = Ty;
80
81 Ty &operator()(Ty &self) const {
82 return self;
83 }
84 const Ty &operator()(const Ty &self) const {
85 return self;
86 }
87};
88
89template <class Ty> struct less_ptr {
90 bool operator()(const Ty* left, const Ty* right) const {
91 return *left < *right;
92 }
93};
94
95template <class Ty> struct greater_ptr {
96 bool operator()(const Ty* left, const Ty* right) const {
97 return *right < *left;
98 }
99};
100
101/// An efficient, type-erasing, non-owning reference to a callable. This is
102/// intended for use as the type of a function parameter that is not used
103/// after the function in question returns.
104///
105/// This class does not own the callable, so it is not in general safe to store
106/// a function_ref.
107template<typename Fn> class function_ref;
108
109template<typename Ret, typename ...Params>
110class function_ref<Ret(Params...)> {
111 Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
112 intptr_t callable;
113
114 template<typename Callable>
115 static Ret callback_fn(intptr_t callable, Params ...params) {
116 return (*reinterpret_cast<Callable*>(callable))(
117 std::forward<Params>(params)...);
118 }
119
120public:
121 function_ref() = default;
122 function_ref(std::nullptr_t) {}
123
124 template <typename Callable>
125 function_ref(Callable &&callable,
126 typename std::enable_if<
127 !std::is_same<typename std::remove_reference<Callable>::type,
128 function_ref>::value>::type * = nullptr)
129 : callback(callback_fn<typename std::remove_reference<Callable>::type>),
130 callable(reinterpret_cast<intptr_t>(&callable)) {}
131
132 Ret operator()(Params ...params) const {
133 return callback(callable, std::forward<Params>(params)...);
134 }
135
136 operator bool() const { return callback; }
137};
138
139// deleter - Very very very simple method that is used to invoke operator
140// delete on something. It is used like this:
141//
142// for_each(V.begin(), B.end(), deleter<Interval>);
143template <class T>
144inline void deleter(T *Ptr) {
145 delete Ptr;
146}
147
148//===----------------------------------------------------------------------===//
149// Extra additions to <iterator>
150//===----------------------------------------------------------------------===//
151
152namespace adl_detail {
153
154using std::begin;
155
156template <typename ContainerTy>
157auto adl_begin(ContainerTy &&container)
158 -> decltype(begin(std::forward<ContainerTy>(container))) {
159 return begin(std::forward<ContainerTy>(container));
160}
161
162using std::end;
163
164template <typename ContainerTy>
165auto adl_end(ContainerTy &&container)
166 -> decltype(end(std::forward<ContainerTy>(container))) {
167 return end(std::forward<ContainerTy>(container));
168}
169
170using std::swap;
171
172template <typename T>
173void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
174 std::declval<T>()))) {
175 swap(std::forward<T>(lhs), std::forward<T>(rhs));
176}
177
178} // end namespace adl_detail
179
180template <typename ContainerTy>
181auto adl_begin(ContainerTy &&container)
182 -> decltype(adl_detail::adl_begin(std::forward<ContainerTy>(container))) {
183 return adl_detail::adl_begin(std::forward<ContainerTy>(container));
184}
185
186template <typename ContainerTy>
187auto adl_end(ContainerTy &&container)
188 -> decltype(adl_detail::adl_end(std::forward<ContainerTy>(container))) {
189 return adl_detail::adl_end(std::forward<ContainerTy>(container));
190}
191
192template <typename T>
193void adl_swap(T &&lhs, T &&rhs) noexcept(
194 noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
195 adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
196}
197
198// mapped_iterator - This is a simple iterator adapter that causes a function to
199// be applied whenever operator* is invoked on the iterator.
200
201template <typename ItTy, typename FuncTy,
202 typename FuncReturnTy =
203 decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
204class mapped_iterator
205 : public iterator_adaptor_base<
206 mapped_iterator<ItTy, FuncTy>, ItTy,
207 typename std::iterator_traits<ItTy>::iterator_category,
208 typename std::remove_reference<FuncReturnTy>::type> {
209public:
210 mapped_iterator(ItTy U, FuncTy F)
211 : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
212
213 ItTy getCurrent() { return this->I; }
214
215 FuncReturnTy operator*() { return F(*this->I); }
216
217private:
218 FuncTy F;
219};
220
221// map_iterator - Provide a convenient way to create mapped_iterators, just like
222// make_pair is useful for creating pairs...
223template <class ItTy, class FuncTy>
224inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
225 return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
226}
227
228/// Helper to determine if type T has a member called rbegin().
229template <typename Ty> class has_rbegin_impl {
230 using yes = char[1];
231 using no = char[2];
232
233 template <typename Inner>
234 static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
235
236 template <typename>
237 static no& test(...);
238
239public:
240 static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
241};
242
243/// Metafunction to determine if T& or T has a member called rbegin().
244template <typename Ty>
245struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
246};
247
248// Returns an iterator_range over the given container which iterates in reverse.
249// Note that the container must have rbegin()/rend() methods for this to work.
250template <typename ContainerTy>
251auto reverse(ContainerTy &&C,
252 typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
253 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
254 return make_range(C.rbegin(), C.rend());
255}
256
257// Returns a std::reverse_iterator wrapped around the given iterator.
258template <typename IteratorTy>
259std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
260 return std::reverse_iterator<IteratorTy>(It);
261}
262
263// Returns an iterator_range over the given container which iterates in reverse.
264// Note that the container must have begin()/end() methods which return
265// bidirectional iterators for this to work.
266template <typename ContainerTy>
267auto reverse(
268 ContainerTy &&C,
269 typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
270 -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
271 llvm::make_reverse_iterator(std::begin(C)))) {
272 return make_range(llvm::make_reverse_iterator(std::end(C)),
273 llvm::make_reverse_iterator(std::begin(C)));
274}
275
276/// An iterator adaptor that filters the elements of given inner iterators.
277///
278/// The predicate parameter should be a callable object that accepts the wrapped
279/// iterator's reference type and returns a bool. When incrementing or
280/// decrementing the iterator, it will call the predicate on each element and
281/// skip any where it returns false.
282///
283/// \code
284/// int A[] = { 1, 2, 3, 4 };
285/// auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
286/// // R contains { 1, 3 }.
287/// \endcode
288///
289/// Note: filter_iterator_base implements support for forward iteration.
290/// filter_iterator_impl exists to provide support for bidirectional iteration,
291/// conditional on whether the wrapped iterator supports it.
292template <typename WrappedIteratorT, typename PredicateT, typename IterTag>
293class filter_iterator_base
294 : public iterator_adaptor_base<
295 filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
296 WrappedIteratorT,
297 typename std::common_type<
298 IterTag, typename std::iterator_traits<
299 WrappedIteratorT>::iterator_category>::type> {
300 using BaseT = iterator_adaptor_base<
301 filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
302 WrappedIteratorT,
303 typename std::common_type<
304 IterTag, typename std::iterator_traits<
305 WrappedIteratorT>::iterator_category>::type>;
306
307protected:
308 WrappedIteratorT End;
309 PredicateT Pred;
310
311 void findNextValid() {
312 while (this->I != End && !Pred(*this->I))
313 BaseT::operator++();
314 }
315
316 // Construct the iterator. The begin iterator needs to know where the end
317 // is, so that it can properly stop when it gets there. The end iterator only
318 // needs the predicate to support bidirectional iteration.
319 filter_iterator_base(WrappedIteratorT Begin, WrappedIteratorT End,
320 PredicateT Pred)
321 : BaseT(Begin), End(End), Pred(Pred) {
322 findNextValid();
323 }
324
325public:
326 using BaseT::operator++;
327
328 filter_iterator_base &operator++() {
329 BaseT::operator++();
330 findNextValid();
331 return *this;
332 }
333};
334
335/// Specialization of filter_iterator_base for forward iteration only.
336template <typename WrappedIteratorT, typename PredicateT,
337 typename IterTag = std::forward_iterator_tag>
338class filter_iterator_impl
339 : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
340 using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>;
341
342public:
343 filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
344 PredicateT Pred)
345 : BaseT(Begin, End, Pred) {}
346};
347
348/// Specialization of filter_iterator_base for bidirectional iteration.
349template <typename WrappedIteratorT, typename PredicateT>
350class filter_iterator_impl<WrappedIteratorT, PredicateT,
351 std::bidirectional_iterator_tag>
352 : public filter_iterator_base<WrappedIteratorT, PredicateT,
353 std::bidirectional_iterator_tag> {
354 using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT,
355 std::bidirectional_iterator_tag>;
356 void findPrevValid() {
357 while (!this->Pred(*this->I))
358 BaseT::operator--();
359 }
360
361public:
362 using BaseT::operator--;
363
364 filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
365 PredicateT Pred)
366 : BaseT(Begin, End, Pred) {}
367
368 filter_iterator_impl &operator--() {
369 BaseT::operator--();
370 findPrevValid();
371 return *this;
372 }
373};
374
375namespace detail {
376
377template <bool is_bidirectional> struct fwd_or_bidi_tag_impl {
378 using type = std::forward_iterator_tag;
379};
380
381template <> struct fwd_or_bidi_tag_impl<true> {
382 using type = std::bidirectional_iterator_tag;
383};
384
385/// Helper which sets its type member to forward_iterator_tag if the category
386/// of \p IterT does not derive from bidirectional_iterator_tag, and to
387/// bidirectional_iterator_tag otherwise.
388template <typename IterT> struct fwd_or_bidi_tag {
389 using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
390 std::bidirectional_iterator_tag,
391 typename std::iterator_traits<IterT>::iterator_category>::value>::type;
392};
393
394} // namespace detail
395
396/// Defines filter_iterator to a suitable specialization of
397/// filter_iterator_impl, based on the underlying iterator's category.
398template <typename WrappedIteratorT, typename PredicateT>
399using filter_iterator = filter_iterator_impl<
400 WrappedIteratorT, PredicateT,
401 typename detail::fwd_or_bidi_tag<WrappedIteratorT>::type>;
402
403/// Convenience function that takes a range of elements and a predicate,
404/// and return a new filter_iterator range.
405///
406/// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the
407/// lifetime of that temporary is not kept by the returned range object, and the
408/// temporary is going to be dropped on the floor after the make_iterator_range
409/// full expression that contains this function call.
410template <typename RangeT, typename PredicateT>
411iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
412make_filter_range(RangeT &&Range, PredicateT Pred) {
413 using FilterIteratorT =
414 filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
415 return make_range(
416 FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
417 std::end(std::forward<RangeT>(Range)), Pred),
418 FilterIteratorT(std::end(std::forward<RangeT>(Range)),
419 std::end(std::forward<RangeT>(Range)), Pred));
420}
421
422/// A pseudo-iterator adaptor that is designed to implement "early increment"
423/// style loops.
424///
425/// This is *not a normal iterator* and should almost never be used directly. It
426/// is intended primarily to be used with range based for loops and some range
427/// algorithms.
428///
429/// The iterator isn't quite an `OutputIterator` or an `InputIterator` but
430/// somewhere between them. The constraints of these iterators are:
431///
432/// - On construction or after being incremented, it is comparable and
433/// dereferencable. It is *not* incrementable.
434/// - After being dereferenced, it is neither comparable nor dereferencable, it
435/// is only incrementable.
436///
437/// This means you can only dereference the iterator once, and you can only
438/// increment it once between dereferences.
439template <typename WrappedIteratorT>
440class early_inc_iterator_impl
441 : public iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
442 WrappedIteratorT, std::input_iterator_tag> {
443 using BaseT =
444 iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
445 WrappedIteratorT, std::input_iterator_tag>;
446
447 using PointerT = typename std::iterator_traits<WrappedIteratorT>::pointer;
448
449protected:
450#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
451 bool IsEarlyIncremented = false;
452#endif
453
454public:
455 early_inc_iterator_impl(WrappedIteratorT I) : BaseT(I) {}
456
457 using BaseT::operator*;
458 typename BaseT::reference operator*() {
459#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
460 assert(!IsEarlyIncremented && "Cannot dereference twice!")((!IsEarlyIncremented && "Cannot dereference twice!")
? static_cast<void> (0) : __assert_fail ("!IsEarlyIncremented && \"Cannot dereference twice!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h"
, 460, __PRETTY_FUNCTION__))
;
461 IsEarlyIncremented = true;
462#endif
463 return *(this->I)++;
464 }
465
466 using BaseT::operator++;
467 early_inc_iterator_impl &operator++() {
468#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
469 assert(IsEarlyIncremented && "Cannot increment before dereferencing!")((IsEarlyIncremented && "Cannot increment before dereferencing!"
) ? static_cast<void> (0) : __assert_fail ("IsEarlyIncremented && \"Cannot increment before dereferencing!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h"
, 469, __PRETTY_FUNCTION__))
;
470 IsEarlyIncremented = false;
471#endif
472 return *this;
473 }
474
475 using BaseT::operator==;
476 bool operator==(const early_inc_iterator_impl &RHS) const {
477#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
478 assert(!IsEarlyIncremented && "Cannot compare after dereferencing!")((!IsEarlyIncremented && "Cannot compare after dereferencing!"
) ? static_cast<void> (0) : __assert_fail ("!IsEarlyIncremented && \"Cannot compare after dereferencing!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h"
, 478, __PRETTY_FUNCTION__))
;
479#endif
480 return BaseT::operator==(RHS);
481 }
482};
483
484/// Make a range that does early increment to allow mutation of the underlying
485/// range without disrupting iteration.
486///
487/// The underlying iterator will be incremented immediately after it is
488/// dereferenced, allowing deletion of the current node or insertion of nodes to
489/// not disrupt iteration provided they do not invalidate the *next* iterator --
490/// the current iterator can be invalidated.
491///
492/// This requires a very exact pattern of use that is only really suitable to
493/// range based for loops and other range algorithms that explicitly guarantee
494/// to dereference exactly once each element, and to increment exactly once each
495/// element.
496template <typename RangeT>
497iterator_range<early_inc_iterator_impl<detail::IterOfRange<RangeT>>>
498make_early_inc_range(RangeT &&Range) {
499 using EarlyIncIteratorT =
500 early_inc_iterator_impl<detail::IterOfRange<RangeT>>;
501 return make_range(EarlyIncIteratorT(std::begin(std::forward<RangeT>(Range))),
502 EarlyIncIteratorT(std::end(std::forward<RangeT>(Range))));
503}
504
505// forward declarations required by zip_shortest/zip_first
506template <typename R, typename UnaryPredicate>
507bool all_of(R &&range, UnaryPredicate P);
508
509template <size_t... I> struct index_sequence;
510
511template <class... Ts> struct index_sequence_for;
512
513namespace detail {
514
515using std::declval;
516
517// We have to alias this since inlining the actual type at the usage site
518// in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
519template<typename... Iters> struct ZipTupleType {
520 using type = std::tuple<decltype(*declval<Iters>())...>;
521};
522
523template <typename ZipType, typename... Iters>
524using zip_traits = iterator_facade_base<
525 ZipType, typename std::common_type<std::bidirectional_iterator_tag,
526 typename std::iterator_traits<
527 Iters>::iterator_category...>::type,
528 // ^ TODO: Implement random access methods.
529 typename ZipTupleType<Iters...>::type,
530 typename std::iterator_traits<typename std::tuple_element<
531 0, std::tuple<Iters...>>::type>::difference_type,
532 // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
533 // inner iterators have the same difference_type. It would fail if, for
534 // instance, the second field's difference_type were non-numeric while the
535 // first is.
536 typename ZipTupleType<Iters...>::type *,
537 typename ZipTupleType<Iters...>::type>;
538
539template <typename ZipType, typename... Iters>
540struct zip_common : public zip_traits<ZipType, Iters...> {
541 using Base = zip_traits<ZipType, Iters...>;
542 using value_type = typename Base::value_type;
543
544 std::tuple<Iters...> iterators;
545
546protected:
547 template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
548 return value_type(*std::get<Ns>(iterators)...);
549 }
550
551 template <size_t... Ns>
552 decltype(iterators) tup_inc(index_sequence<Ns...>) const {
553 return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
554 }
555
556 template <size_t... Ns>
557 decltype(iterators) tup_dec(index_sequence<Ns...>) const {
558 return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
559 }
560
561public:
562 zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
563
564 value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
565
566 const value_type operator*() const {
567 return deref(index_sequence_for<Iters...>{});
568 }
569
570 ZipType &operator++() {
571 iterators = tup_inc(index_sequence_for<Iters...>{});
572 return *reinterpret_cast<ZipType *>(this);
573 }
574
575 ZipType &operator--() {
576 static_assert(Base::IsBidirectional,
577 "All inner iterators must be at least bidirectional.");
578 iterators = tup_dec(index_sequence_for<Iters...>{});
579 return *reinterpret_cast<ZipType *>(this);
580 }
581};
582
583template <typename... Iters>
584struct zip_first : public zip_common<zip_first<Iters...>, Iters...> {
585 using Base = zip_common<zip_first<Iters...>, Iters...>;
586
587 bool operator==(const zip_first<Iters...> &other) const {
588 return std::get<0>(this->iterators) == std::get<0>(other.iterators);
589 }
590
591 zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
592};
593
594template <typename... Iters>
595class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
596 template <size_t... Ns>
597 bool test(const zip_shortest<Iters...> &other, index_sequence<Ns...>) const {
598 return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
599 std::get<Ns>(other.iterators)...},
600 identity<bool>{});
601 }
602
603public:
604 using Base = zip_common<zip_shortest<Iters...>, Iters...>;
605
606 zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
607
608 bool operator==(const zip_shortest<Iters...> &other) const {
609 return !test(other, index_sequence_for<Iters...>{});
610 }
611};
612
613template <template <typename...> class ItType, typename... Args> class zippy {
614public:
615 using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
616 using iterator_category = typename iterator::iterator_category;
617 using value_type = typename iterator::value_type;
618 using difference_type = typename iterator::difference_type;
619 using pointer = typename iterator::pointer;
620 using reference = typename iterator::reference;
621
622private:
623 std::tuple<Args...> ts;
624
625 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
626 return iterator(std::begin(std::get<Ns>(ts))...);
627 }
628 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
629 return iterator(std::end(std::get<Ns>(ts))...);
630 }
631
632public:
633 zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
634
635 iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
636 iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
637};
638
639} // end namespace detail
640
641/// zip iterator for two or more iteratable types.
642template <typename T, typename U, typename... Args>
643detail::zippy<detail::zip_shortest, T, U, Args...> zip(T &&t, U &&u,
644 Args &&... args) {
645 return detail::zippy<detail::zip_shortest, T, U, Args...>(
646 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
647}
648
649/// zip iterator that, for the sake of efficiency, assumes the first iteratee to
650/// be the shortest.
651template <typename T, typename U, typename... Args>
652detail::zippy<detail::zip_first, T, U, Args...> zip_first(T &&t, U &&u,
653 Args &&... args) {
654 return detail::zippy<detail::zip_first, T, U, Args...>(
655 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
656}
657
658/// Iterator wrapper that concatenates sequences together.
659///
660/// This can concatenate different iterators, even with different types, into
661/// a single iterator provided the value types of all the concatenated
662/// iterators expose `reference` and `pointer` types that can be converted to
663/// `ValueT &` and `ValueT *` respectively. It doesn't support more
664/// interesting/customized pointer or reference types.
665///
666/// Currently this only supports forward or higher iterator categories as
667/// inputs and always exposes a forward iterator interface.
668template <typename ValueT, typename... IterTs>
669class concat_iterator
670 : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
671 std::forward_iterator_tag, ValueT> {
672 using BaseT = typename concat_iterator::iterator_facade_base;
673
674 /// We store both the current and end iterators for each concatenated
675 /// sequence in a tuple of pairs.
676 ///
677 /// Note that something like iterator_range seems nice at first here, but the
678 /// range properties are of little benefit and end up getting in the way
679 /// because we need to do mutation on the current iterators.
680 std::tuple<IterTs...> Begins;
681 std::tuple<IterTs...> Ends;
682
683 /// Attempts to increment a specific iterator.
684 ///
685 /// Returns true if it was able to increment the iterator. Returns false if
686 /// the iterator is already at the end iterator.
687 template <size_t Index> bool incrementHelper() {
688 auto &Begin = std::get<Index>(Begins);
689 auto &End = std::get<Index>(Ends);
690 if (Begin == End)
691 return false;
692
693 ++Begin;
694 return true;
695 }
696
697 /// Increments the first non-end iterator.
698 ///
699 /// It is an error to call this with all iterators at the end.
700 template <size_t... Ns> void increment(index_sequence<Ns...>) {
701 // Build a sequence of functions to increment each iterator if possible.
702 bool (concat_iterator::*IncrementHelperFns[])() = {
703 &concat_iterator::incrementHelper<Ns>...};
704
705 // Loop over them, and stop as soon as we succeed at incrementing one.
706 for (auto &IncrementHelperFn : IncrementHelperFns)
707 if ((this->*IncrementHelperFn)())
708 return;
709
710 llvm_unreachable("Attempted to increment an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to increment an end concat iterator!"
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h"
, 710)
;
711 }
712
713 /// Returns null if the specified iterator is at the end. Otherwise,
714 /// dereferences the iterator and returns the address of the resulting
715 /// reference.
716 template <size_t Index> ValueT *getHelper() const {
717 auto &Begin = std::get<Index>(Begins);
718 auto &End = std::get<Index>(Ends);
719 if (Begin == End)
720 return nullptr;
721
722 return &*Begin;
723 }
724
725 /// Finds the first non-end iterator, dereferences, and returns the resulting
726 /// reference.
727 ///
728 /// It is an error to call this with all iterators at the end.
729 template <size_t... Ns> ValueT &get(index_sequence<Ns...>) const {
730 // Build a sequence of functions to get from iterator if possible.
731 ValueT *(concat_iterator::*GetHelperFns[])() const = {
732 &concat_iterator::getHelper<Ns>...};
733
734 // Loop over them, and return the first result we find.
735 for (auto &GetHelperFn : GetHelperFns)
736 if (ValueT *P = (this->*GetHelperFn)())
737 return *P;
738
739 llvm_unreachable("Attempted to get a pointer from an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to get a pointer from an end concat iterator!"
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h"
, 739)
;
740 }
741
742public:
743 /// Constructs an iterator from a squence of ranges.
744 ///
745 /// We need the full range to know how to switch between each of the
746 /// iterators.
747 template <typename... RangeTs>
748 explicit concat_iterator(RangeTs &&... Ranges)
749 : Begins(std::begin(Ranges)...), Ends(std::end(Ranges)...) {}
750
751 using BaseT::operator++;
752
753 concat_iterator &operator++() {
754 increment(index_sequence_for<IterTs...>());
755 return *this;
756 }
757
758 ValueT &operator*() const { return get(index_sequence_for<IterTs...>()); }
759
760 bool operator==(const concat_iterator &RHS) const {
761 return Begins == RHS.Begins && Ends == RHS.Ends;
762 }
763};
764
765namespace detail {
766
767/// Helper to store a sequence of ranges being concatenated and access them.
768///
769/// This is designed to facilitate providing actual storage when temporaries
770/// are passed into the constructor such that we can use it as part of range
771/// based for loops.
772template <typename ValueT, typename... RangeTs> class concat_range {
773public:
774 using iterator =
775 concat_iterator<ValueT,
776 decltype(std::begin(std::declval<RangeTs &>()))...>;
777
778private:
779 std::tuple<RangeTs...> Ranges;
780
781 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) {
782 return iterator(std::get<Ns>(Ranges)...);
783 }
784 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) {
785 return iterator(make_range(std::end(std::get<Ns>(Ranges)),
786 std::end(std::get<Ns>(Ranges)))...);
787 }
788
789public:
790 concat_range(RangeTs &&... Ranges)
791 : Ranges(std::forward<RangeTs>(Ranges)...) {}
792
793 iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
794 iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
795};
796
797} // end namespace detail
798
799/// Concatenated range across two or more ranges.
800///
801/// The desired value type must be explicitly specified.
802template <typename ValueT, typename... RangeTs>
803detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) {
804 static_assert(sizeof...(RangeTs) > 1,
805 "Need more than one range to concatenate!");
806 return detail::concat_range<ValueT, RangeTs...>(
807 std::forward<RangeTs>(Ranges)...);
808}
809
810//===----------------------------------------------------------------------===//
811// Extra additions to <utility>
812//===----------------------------------------------------------------------===//
813
814/// Function object to check whether the first component of a std::pair
815/// compares less than the first component of another std::pair.
816struct less_first {
817 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
818 return lhs.first < rhs.first;
819 }
820};
821
822/// Function object to check whether the second component of a std::pair
823/// compares less than the second component of another std::pair.
824struct less_second {
825 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
826 return lhs.second < rhs.second;
827 }
828};
829
830/// \brief Function object to apply a binary function to the first component of
831/// a std::pair.
832template<typename FuncTy>
833struct on_first {
834 FuncTy func;
835
836 template <typename T>
837 auto operator()(const T &lhs, const T &rhs) const
838 -> decltype(func(lhs.first, rhs.first)) {
839 return func(lhs.first, rhs.first);
840 }
841};
842
843// A subset of N3658. More stuff can be added as-needed.
844
845/// Represents a compile-time sequence of integers.
846template <class T, T... I> struct integer_sequence {
847 using value_type = T;
848
849 static constexpr size_t size() { return sizeof...(I); }
850};
851
852/// Alias for the common case of a sequence of size_ts.
853template <size_t... I>
854struct index_sequence : integer_sequence<std::size_t, I...> {};
855
856template <std::size_t N, std::size_t... I>
857struct build_index_impl : build_index_impl<N - 1, N - 1, I...> {};
858template <std::size_t... I>
859struct build_index_impl<0, I...> : index_sequence<I...> {};
860
861/// Creates a compile-time integer sequence for a parameter pack.
862template <class... Ts>
863struct index_sequence_for : build_index_impl<sizeof...(Ts)> {};
864
865/// Utility type to build an inheritance chain that makes it easy to rank
866/// overload candidates.
867template <int N> struct rank : rank<N - 1> {};
868template <> struct rank<0> {};
869
870/// traits class for checking whether type T is one of any of the given
871/// types in the variadic list.
872template <typename T, typename... Ts> struct is_one_of {
873 static const bool value = false;
874};
875
876template <typename T, typename U, typename... Ts>
877struct is_one_of<T, U, Ts...> {
878 static const bool value =
879 std::is_same<T, U>::value || is_one_of<T, Ts...>::value;
880};
881
882/// traits class for checking whether type T is a base class for all
883/// the given types in the variadic list.
884template <typename T, typename... Ts> struct are_base_of {
885 static const bool value = true;
886};
887
888template <typename T, typename U, typename... Ts>
889struct are_base_of<T, U, Ts...> {
890 static const bool value =
891 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
892};
893
894//===----------------------------------------------------------------------===//
895// Extra additions for arrays
896//===----------------------------------------------------------------------===//
897
898/// Find the length of an array.
899template <class T, std::size_t N>
900constexpr inline size_t array_lengthof(T (&)[N]) {
901 return N;
902}
903
904/// Adapt std::less<T> for array_pod_sort.
905template<typename T>
906inline int array_pod_sort_comparator(const void *P1, const void *P2) {
907 if (std::less<T>()(*reinterpret_cast<const T*>(P1),
908 *reinterpret_cast<const T*>(P2)))
909 return -1;
910 if (std::less<T>()(*reinterpret_cast<const T*>(P2),
911 *reinterpret_cast<const T*>(P1)))
912 return 1;
913 return 0;
914}
915
916/// get_array_pod_sort_comparator - This is an internal helper function used to
917/// get type deduction of T right.
918template<typename T>
919inline int (*get_array_pod_sort_comparator(const T &))
920 (const void*, const void*) {
921 return array_pod_sort_comparator<T>;
922}
923
924/// array_pod_sort - This sorts an array with the specified start and end
925/// extent. This is just like std::sort, except that it calls qsort instead of
926/// using an inlined template. qsort is slightly slower than std::sort, but
927/// most sorts are not performance critical in LLVM and std::sort has to be
928/// template instantiated for each type, leading to significant measured code
929/// bloat. This function should generally be used instead of std::sort where
930/// possible.
931///
932/// This function assumes that you have simple POD-like types that can be
933/// compared with std::less and can be moved with memcpy. If this isn't true,
934/// you should use std::sort.
935///
936/// NOTE: If qsort_r were portable, we could allow a custom comparator and
937/// default to std::less.
938template<class IteratorTy>
939inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
940 // Don't inefficiently call qsort with one element or trigger undefined
941 // behavior with an empty sequence.
942 auto NElts = End - Start;
943 if (NElts <= 1) return;
944#ifdef EXPENSIVE_CHECKS
945 std::mt19937 Generator(std::random_device{}());
946 std::shuffle(Start, End, Generator);
947#endif
948 qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
949}
950
951template <class IteratorTy>
952inline void array_pod_sort(
953 IteratorTy Start, IteratorTy End,
954 int (*Compare)(
955 const typename std::iterator_traits<IteratorTy>::value_type *,
956 const typename std::iterator_traits<IteratorTy>::value_type *)) {
957 // Don't inefficiently call qsort with one element or trigger undefined
958 // behavior with an empty sequence.
959 auto NElts = End - Start;
960 if (NElts <= 1) return;
961#ifdef EXPENSIVE_CHECKS
962 std::mt19937 Generator(std::random_device{}());
963 std::shuffle(Start, End, Generator);
964#endif
965 qsort(&*Start, NElts, sizeof(*Start),
966 reinterpret_cast<int (*)(const void *, const void *)>(Compare));
967}
968
969// Provide wrappers to std::sort which shuffle the elements before sorting
970// to help uncover non-deterministic behavior (PR35135).
971template <typename IteratorTy>
972inline void sort(IteratorTy Start, IteratorTy End) {
973#ifdef EXPENSIVE_CHECKS
974 std::mt19937 Generator(std::random_device{}());
975 std::shuffle(Start, End, Generator);
976#endif
977 std::sort(Start, End);
978}
979
980template <typename Container> inline void sort(Container &&C) {
981 llvm::sort(adl_begin(C), adl_end(C));
982}
983
984template <typename IteratorTy, typename Compare>
985inline void sort(IteratorTy Start, IteratorTy End, Compare Comp) {
986#ifdef EXPENSIVE_CHECKS
987 std::mt19937 Generator(std::random_device{}());
988 std::shuffle(Start, End, Generator);
989#endif
990 std::sort(Start, End, Comp);
991}
992
993template <typename Container, typename Compare>
994inline void sort(Container &&C, Compare Comp) {
995 llvm::sort(adl_begin(C), adl_end(C), Comp);
996}
997
998//===----------------------------------------------------------------------===//
999// Extra additions to <algorithm>
1000//===----------------------------------------------------------------------===//
1001
1002/// For a container of pointers, deletes the pointers and then clears the
1003/// container.
1004template<typename Container>
1005void DeleteContainerPointers(Container &C) {
1006 for (auto V : C)
1007 delete V;
1008 C.clear();
1009}
1010
1011/// In a container of pairs (usually a map) whose second element is a pointer,
1012/// deletes the second elements and then clears the container.
1013template<typename Container>
1014void DeleteContainerSeconds(Container &C) {
1015 for (auto &V : C)
1016 delete V.second;
1017 C.clear();
1018}
1019
1020/// Get the size of a range. This is a wrapper function around std::distance
1021/// which is only enabled when the operation is O(1).
1022template <typename R>
1023auto size(R &&Range, typename std::enable_if<
1024 std::is_same<typename std::iterator_traits<decltype(
1025 Range.begin())>::iterator_category,
1026 std::random_access_iterator_tag>::value,
1027 void>::type * = nullptr)
1028 -> decltype(std::distance(Range.begin(), Range.end())) {
1029 return std::distance(Range.begin(), Range.end());
1030}
1031
1032/// Provide wrappers to std::for_each which take ranges instead of having to
1033/// pass begin/end explicitly.
1034template <typename R, typename UnaryPredicate>
1035UnaryPredicate for_each(R &&Range, UnaryPredicate P) {
1036 return std::for_each(adl_begin(Range), adl_end(Range), P);
1037}
1038
1039/// Provide wrappers to std::all_of which take ranges instead of having to pass
1040/// begin/end explicitly.
1041template <typename R, typename UnaryPredicate>
1042bool all_of(R &&Range, UnaryPredicate P) {
1043 return std::all_of(adl_begin(Range), adl_end(Range), P);
1044}
1045
1046/// Provide wrappers to std::any_of which take ranges instead of having to pass
1047/// begin/end explicitly.
1048template <typename R, typename UnaryPredicate>
1049bool any_of(R &&Range, UnaryPredicate P) {
1050 return std::any_of(adl_begin(Range), adl_end(Range), P);
1051}
1052
1053/// Provide wrappers to std::none_of which take ranges instead of having to pass
1054/// begin/end explicitly.
1055template <typename R, typename UnaryPredicate>
1056bool none_of(R &&Range, UnaryPredicate P) {
1057 return std::none_of(adl_begin(Range), adl_end(Range), P);
1058}
1059
1060/// Provide wrappers to std::find which take ranges instead of having to pass
1061/// begin/end explicitly.
1062template <typename R, typename T>
1063auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range)) {
1064 return std::find(adl_begin(Range), adl_end(Range), Val);
1065}
1066
1067/// Provide wrappers to std::find_if which take ranges instead of having to pass
1068/// begin/end explicitly.
1069template <typename R, typename UnaryPredicate>
1070auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1071 return std::find_if(adl_begin(Range), adl_end(Range), P);
1072}
1073
1074template <typename R, typename UnaryPredicate>
1075auto find_if_not(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1076 return std::find_if_not(adl_begin(Range), adl_end(Range), P);
1077}
1078
1079/// Provide wrappers to std::remove_if which take ranges instead of having to
1080/// pass begin/end explicitly.
1081template <typename R, typename UnaryPredicate>
1082auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1083 return std::remove_if(adl_begin(Range), adl_end(Range), P);
1084}
1085
1086/// Provide wrappers to std::copy_if which take ranges instead of having to
1087/// pass begin/end explicitly.
1088template <typename R, typename OutputIt, typename UnaryPredicate>
1089OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) {
1090 return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
1091}
1092
1093template <typename R, typename OutputIt>
1094OutputIt copy(R &&Range, OutputIt Out) {
1095 return std::copy(adl_begin(Range), adl_end(Range), Out);
1096}
1097
1098/// Wrapper function around std::find to detect if an element exists
1099/// in a container.
1100template <typename R, typename E>
1101bool is_contained(R &&Range, const E &Element) {
1102 return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
1103}
1104
1105/// Wrapper function around std::count to count the number of times an element
1106/// \p Element occurs in the given range \p Range.
1107template <typename R, typename E>
1108auto count(R &&Range, const E &Element) ->
1109 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
1110 return std::count(adl_begin(Range), adl_end(Range), Element);
1111}
1112
1113/// Wrapper function around std::count_if to count the number of times an
1114/// element satisfying a given predicate occurs in a range.
1115template <typename R, typename UnaryPredicate>
1116auto count_if(R &&Range, UnaryPredicate P) ->
1117 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
1118 return std::count_if(adl_begin(Range), adl_end(Range), P);
1119}
1120
1121/// Wrapper function around std::transform to apply a function to a range and
1122/// store the result elsewhere.
1123template <typename R, typename OutputIt, typename UnaryPredicate>
1124OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P) {
1125 return std::transform(adl_begin(Range), adl_end(Range), d_first, P);
1126}
1127
1128/// Provide wrappers to std::partition which take ranges instead of having to
1129/// pass begin/end explicitly.
1130template <typename R, typename UnaryPredicate>
1131auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1132 return std::partition(adl_begin(Range), adl_end(Range), P);
1133}
1134
1135/// Provide wrappers to std::lower_bound which take ranges instead of having to
1136/// pass begin/end explicitly.
1137template <typename R, typename ForwardIt>
1138auto lower_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range)) {
1139 return std::lower_bound(adl_begin(Range), adl_end(Range), I);
1140}
1141
1142template <typename R, typename ForwardIt, typename Compare>
1143auto lower_bound(R &&Range, ForwardIt I, Compare C)
1144 -> decltype(adl_begin(Range)) {
1145 return std::lower_bound(adl_begin(Range), adl_end(Range), I, C);
1146}
1147
1148/// Provide wrappers to std::upper_bound which take ranges instead of having to
1149/// pass begin/end explicitly.
1150template <typename R, typename ForwardIt>
1151auto upper_bound(R &&Range, ForwardIt I) -> decltype(adl_begin(Range)) {
1152 return std::upper_bound(adl_begin(Range), adl_end(Range), I);
1153}
1154
1155template <typename R, typename ForwardIt, typename Compare>
1156auto upper_bound(R &&Range, ForwardIt I, Compare C)
1157 -> decltype(adl_begin(Range)) {
1158 return std::upper_bound(adl_begin(Range), adl_end(Range), I, C);
1159}
1160/// Wrapper function around std::equal to detect if all elements
1161/// in a container are same.
1162template <typename R>
1163bool is_splat(R &&Range) {
1164 size_t range_size = size(Range);
1165 return range_size != 0 && (range_size == 1 ||
1166 std::equal(adl_begin(Range) + 1, adl_end(Range), adl_begin(Range)));
1167}
1168
1169/// Given a range of type R, iterate the entire range and return a
1170/// SmallVector with elements of the vector. This is useful, for example,
1171/// when you want to iterate a range and then sort the results.
1172template <unsigned Size, typename R>
1173SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>
1174to_vector(R &&Range) {
1175 return {adl_begin(Range), adl_end(Range)};
1176}
1177
1178/// Provide a container algorithm similar to C++ Library Fundamentals v2's
1179/// `erase_if` which is equivalent to:
1180///
1181/// C.erase(remove_if(C, pred), C.end());
1182///
1183/// This version works for any container with an erase method call accepting
1184/// two iterators.
1185template <typename Container, typename UnaryPredicate>
1186void erase_if(Container &C, UnaryPredicate P) {
1187 C.erase(remove_if(C, P), C.end());
1188}
1189
1190//===----------------------------------------------------------------------===//
1191// Extra additions to <memory>
1192//===----------------------------------------------------------------------===//
1193
1194// Implement make_unique according to N3656.
1195
1196/// Constructs a `new T()` with the given args and returns a
1197/// `unique_ptr<T>` which owns the object.
1198///
1199/// Example:
1200///
1201/// auto p = make_unique<int>();
1202/// auto p = make_unique<std::tuple<int, int>>(0, 1);
1203template <class T, class... Args>
1204typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
1205make_unique(Args &&... args) {
1206 return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
3
Memory is allocated
1207}
1208
1209/// Constructs a `new T[n]` with the given args and returns a
1210/// `unique_ptr<T[]>` which owns the object.
1211///
1212/// \param n size of the new array.
1213///
1214/// Example:
1215///
1216/// auto p = make_unique<int[]>(2); // value-initializes the array with 0's.
1217template <class T>
1218typename std::enable_if<std::is_array<T>::value && std::extent<T>::value == 0,
1219 std::unique_ptr<T>>::type
1220make_unique(size_t n) {
1221 return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
1222}
1223
1224/// This function isn't used and is only here to provide better compile errors.
1225template <class T, class... Args>
1226typename std::enable_if<std::extent<T>::value != 0>::type
1227make_unique(Args &&...) = delete;
1228
1229struct FreeDeleter {
1230 void operator()(void* v) {
1231 ::free(v);
1232 }
1233};
1234
1235template<typename First, typename Second>
1236struct pair_hash {
1237 size_t operator()(const std::pair<First, Second> &P) const {
1238 return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
1239 }
1240};
1241
1242/// A functor like C++14's std::less<void> in its absence.
1243struct less {
1244 template <typename A, typename B> bool operator()(A &&a, B &&b) const {
1245 return std::forward<A>(a) < std::forward<B>(b);
1246 }
1247};
1248
1249/// A functor like C++14's std::equal<void> in its absence.
1250struct equal {
1251 template <typename A, typename B> bool operator()(A &&a, B &&b) const {
1252 return std::forward<A>(a) == std::forward<B>(b);
1253 }
1254};
1255
1256/// Binary functor that adapts to any other binary functor after dereferencing
1257/// operands.
1258template <typename T> struct deref {
1259 T func;
1260
1261 // Could be further improved to cope with non-derivable functors and
1262 // non-binary functors (should be a variadic template member function
1263 // operator()).
1264 template <typename A, typename B>
1265 auto operator()(A &lhs, B &rhs) const -> decltype(func(*lhs, *rhs)) {
1266 assert(lhs)((lhs) ? static_cast<void> (0) : __assert_fail ("lhs", "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h"
, 1266, __PRETTY_FUNCTION__))
;
1267 assert(rhs)((rhs) ? static_cast<void> (0) : __assert_fail ("rhs", "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h"
, 1267, __PRETTY_FUNCTION__))
;
1268 return func(*lhs, *rhs);
1269 }
1270};
1271
1272namespace detail {
1273
1274template <typename R> class enumerator_iter;
1275
1276template <typename R> struct result_pair {
1277 friend class enumerator_iter<R>;
1278
1279 result_pair() = default;
1280 result_pair(std::size_t Index, IterOfRange<R> Iter)
1281 : Index(Index), Iter(Iter) {}
1282
1283 result_pair<R> &operator=(const result_pair<R> &Other) {
1284 Index = Other.Index;
1285 Iter = Other.Iter;
1286 return *this;
1287 }
1288
1289 std::size_t index() const { return Index; }
1290 const ValueOfRange<R> &value() const { return *Iter; }
1291 ValueOfRange<R> &value() { return *Iter; }
1292
1293private:
1294 std::size_t Index = std::numeric_limits<std::size_t>::max();
1295 IterOfRange<R> Iter;
1296};
1297
1298template <typename R>
1299class enumerator_iter
1300 : public iterator_facade_base<
1301 enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
1302 typename std::iterator_traits<IterOfRange<R>>::difference_type,
1303 typename std::iterator_traits<IterOfRange<R>>::pointer,
1304 typename std::iterator_traits<IterOfRange<R>>::reference> {
1305 using result_type = result_pair<R>;
1306
1307public:
1308 explicit enumerator_iter(IterOfRange<R> EndIter)
1309 : Result(std::numeric_limits<size_t>::max(), EndIter) {}
1310
1311 enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
1312 : Result(Index, Iter) {}
1313
1314 result_type &operator*() { return Result; }
1315 const result_type &operator*() const { return Result; }
1316
1317 enumerator_iter<R> &operator++() {
1318 assert(Result.Index != std::numeric_limits<size_t>::max())((Result.Index != std::numeric_limits<size_t>::max()) ?
static_cast<void> (0) : __assert_fail ("Result.Index != std::numeric_limits<size_t>::max()"
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/ADT/STLExtras.h"
, 1318, __PRETTY_FUNCTION__))
;
1319 ++Result.Iter;
1320 ++Result.Index;
1321 return *this;
1322 }
1323
1324 bool operator==(const enumerator_iter<R> &RHS) const {
1325 // Don't compare indices here, only iterators. It's possible for an end
1326 // iterator to have different indices depending on whether it was created
1327 // by calling std::end() versus incrementing a valid iterator.
1328 return Result.Iter == RHS.Result.Iter;
1329 }
1330
1331 enumerator_iter<R> &operator=(const enumerator_iter<R> &Other) {
1332 Result = Other.Result;
1333 return *this;
1334 }
1335
1336private:
1337 result_type Result;
1338};
1339
1340template <typename R> class enumerator {
1341public:
1342 explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
1343
1344 enumerator_iter<R> begin() {
1345 return enumerator_iter<R>(0, std::begin(TheRange));
1346 }
1347
1348 enumerator_iter<R> end() {
1349 return enumerator_iter<R>(std::end(TheRange));
1350 }
1351
1352private:
1353 R TheRange;
1354};
1355
1356} // end namespace detail
1357
1358/// Given an input range, returns a new range whose values are are pair (A,B)
1359/// such that A is the 0-based index of the item in the sequence, and B is
1360/// the value from the original sequence. Example:
1361///
1362/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
1363/// for (auto X : enumerate(Items)) {
1364/// printf("Item %d - %c\n", X.index(), X.value());
1365/// }
1366///
1367/// Output:
1368/// Item 0 - A
1369/// Item 1 - B
1370/// Item 2 - C
1371/// Item 3 - D
1372///
1373template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
1374 return detail::enumerator<R>(std::forward<R>(TheRange));
1375}
1376
1377namespace detail {
1378
1379template <typename F, typename Tuple, std::size_t... I>
1380auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
1381 -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
1382 return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
1383}
1384
1385} // end namespace detail
1386
1387/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
1388/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
1389/// return the result.
1390template <typename F, typename Tuple>
1391auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
1392 std::forward<F>(f), std::forward<Tuple>(t),
1393 build_index_impl<
1394 std::tuple_size<typename std::decay<Tuple>::type>::value>{})) {
1395 using Indices = build_index_impl<
1396 std::tuple_size<typename std::decay<Tuple>::type>::value>;
1397
1398 return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
1399 Indices{});
1400}
1401
1402} // end namespace llvm
1403
1404#endif // LLVM_ADT_STLEXTRAS_H