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 -analyzer-config-compatibility-mode=true -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 CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/clang/lib/Format -I /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Format -I /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn350071/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~svn350071/build-llvm/tools/clang/lib/Format -fdebug-prefix-map=/build/llvm-toolchain-snapshot-8~svn350071=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -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-12-27-042839-1215-1 -x c++ /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Format/Format.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/tools/clang/lib/Format/Format.cpp"
, 1506, __PRETTY_FUNCTION__))
;
1507 IsObjC = guessIsObjC(Env.getSourceManager(), AnnotatedLines,
1508 Tokens.getKeywords());
1509 tooling::Replacements Result;
1510 return {Result, 0};
1511 }
1512
1513 bool isObjC() { return IsObjC; }
1514
1515private:
1516 static bool
1517 guessIsObjC(const SourceManager &SourceManager,
1518 const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
1519 const AdditionalKeywords &Keywords) {
1520 // Keep this array sorted, since we are binary searching over it.
1521 static constexpr llvm::StringLiteral FoundationIdentifiers[] = {
1522 "CGFloat",
1523 "CGPoint",
1524 "CGPointMake",
1525 "CGPointZero",
1526 "CGRect",
1527 "CGRectEdge",
1528 "CGRectInfinite",
1529 "CGRectMake",
1530 "CGRectNull",
1531 "CGRectZero",
1532 "CGSize",
1533 "CGSizeMake",
1534 "CGVector",
1535 "CGVectorMake",
1536 "NSAffineTransform",
1537 "NSArray",
1538 "NSAttributedString",
1539 "NSBlockOperation",
1540 "NSBundle",
1541 "NSCache",
1542 "NSCalendar",
1543 "NSCharacterSet",
1544 "NSCountedSet",
1545 "NSData",
1546 "NSDataDetector",
1547 "NSDecimal",
1548 "NSDecimalNumber",
1549 "NSDictionary",
1550 "NSEdgeInsets",
1551 "NSHashTable",
1552 "NSIndexPath",
1553 "NSIndexSet",
1554 "NSInteger",
1555 "NSInvocationOperation",
1556 "NSLocale",
1557 "NSMapTable",
1558 "NSMutableArray",
1559 "NSMutableAttributedString",
1560 "NSMutableCharacterSet",
1561 "NSMutableData",
1562 "NSMutableDictionary",
1563 "NSMutableIndexSet",
1564 "NSMutableOrderedSet",
1565 "NSMutableSet",
1566 "NSMutableString",
1567 "NSNumber",
1568 "NSNumberFormatter",
1569 "NSObject",
1570 "NSOperation",
1571 "NSOperationQueue",
1572 "NSOperationQueuePriority",
1573 "NSOrderedSet",
1574 "NSPoint",
1575 "NSPointerArray",
1576 "NSQualityOfService",
1577 "NSRange",
1578 "NSRect",
1579 "NSRegularExpression",
1580 "NSSet",
1581 "NSSize",
1582 "NSString",
1583 "NSTimeZone",
1584 "NSUInteger",
1585 "NSURL",
1586 "NSURLComponents",
1587 "NSURLQueryItem",
1588 "NSUUID",
1589 "NSValue",
1590 "UIImage",
1591 "UIView",
1592 };
1593
1594 for (auto Line : AnnotatedLines) {
1595 for (const FormatToken *FormatTok = Line->First; FormatTok;
1596 FormatTok = FormatTok->Next) {
1597 if ((FormatTok->Previous && FormatTok->Previous->is(tok::at) &&
1598 (FormatTok->Tok.getObjCKeywordID() != tok::objc_not_keyword ||
1599 FormatTok->isOneOf(tok::numeric_constant, tok::l_square,
1600 tok::l_brace))) ||
1601 (FormatTok->Tok.isAnyIdentifier() &&
1602 std::binary_search(std::begin(FoundationIdentifiers),
1603 std::end(FoundationIdentifiers),
1604 FormatTok->TokenText)) ||
1605 FormatTok->is(TT_ObjCStringLiteral) ||
1606 FormatTok->isOneOf(Keywords.kw_NS_ENUM, Keywords.kw_NS_OPTIONS,
1607 TT_ObjCBlockLBrace, TT_ObjCBlockLParen,
1608 TT_ObjCDecl, TT_ObjCForIn, TT_ObjCMethodExpr,
1609 TT_ObjCMethodSpecifier, TT_ObjCProperty)) {
1610 LLVM_DEBUG(llvm::dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Detected ObjC at location "
<< FormatTok->Tok.getLocation().printToString( SourceManager
) << " token: " << FormatTok->TokenText <<
" token type: " << getTokenTypeName(FormatTok->Type
) << "\n"; } } while (false)
1611 << "Detected ObjC at location "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Detected ObjC at location "
<< FormatTok->Tok.getLocation().printToString( SourceManager
) << " token: " << FormatTok->TokenText <<
" token type: " << getTokenTypeName(FormatTok->Type
) << "\n"; } } while (false)
1612 << FormatTok->Tok.getLocation().printToString(do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Detected ObjC at location "
<< FormatTok->Tok.getLocation().printToString( SourceManager
) << " token: " << FormatTok->TokenText <<
" token type: " << getTokenTypeName(FormatTok->Type
) << "\n"; } } while (false)
1613 SourceManager)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Detected ObjC at location "
<< FormatTok->Tok.getLocation().printToString( SourceManager
) << " token: " << FormatTok->TokenText <<
" token type: " << getTokenTypeName(FormatTok->Type
) << "\n"; } } while (false)
1614 << " token: " << FormatTok->TokenText << " token type: "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Detected ObjC at location "
<< FormatTok->Tok.getLocation().printToString( SourceManager
) << " token: " << FormatTok->TokenText <<
" token type: " << getTokenTypeName(FormatTok->Type
) << "\n"; } } while (false)
1615 << getTokenTypeName(FormatTok->Type) << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Detected ObjC at location "
<< FormatTok->Tok.getLocation().printToString( SourceManager
) << " token: " << FormatTok->TokenText <<
" token type: " << getTokenTypeName(FormatTok->Type
) << "\n"; } } while (false)
;
1616 return true;
1617 }
1618 if (guessIsObjC(SourceManager, Line->Children, Keywords))
1619 return true;
1620 }
1621 }
1622 return false;
1623 }
1624
1625 bool IsObjC;
1626};
1627
1628struct IncludeDirective {
1629 StringRef Filename;
1630 StringRef Text;
1631 unsigned Offset;
1632 int Category;
1633};
1634
1635struct JavaImportDirective {
1636 StringRef Identifier;
1637 StringRef Text;
1638 unsigned Offset;
1639 std::vector<StringRef> AssociatedCommentLines;
1640 bool IsStatic;
1641};
1642
1643} // end anonymous namespace
1644
1645// Determines whether 'Ranges' intersects with ('Start', 'End').
1646static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
1647 unsigned End) {
1648 for (auto Range : Ranges) {
1649 if (Range.getOffset() < End &&
1650 Range.getOffset() + Range.getLength() > Start)
1651 return true;
1652 }
1653 return false;
1654}
1655
1656// Returns a pair (Index, OffsetToEOL) describing the position of the cursor
1657// before sorting/deduplicating. Index is the index of the include under the
1658// cursor in the original set of includes. If this include has duplicates, it is
1659// the index of the first of the duplicates as the others are going to be
1660// removed. OffsetToEOL describes the cursor's position relative to the end of
1661// its current line.
1662// If `Cursor` is not on any #include, `Index` will be UINT_MAX.
1663static std::pair<unsigned, unsigned>
1664FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
1665 const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
1666 unsigned CursorIndex = UINT_MAX(2147483647 *2U +1U);
1667 unsigned OffsetToEOL = 0;
1668 for (int i = 0, e = Includes.size(); i != e; ++i) {
1669 unsigned Start = Includes[Indices[i]].Offset;
1670 unsigned End = Start + Includes[Indices[i]].Text.size();
1671 if (!(Cursor >= Start && Cursor < End))
1672 continue;
1673 CursorIndex = Indices[i];
1674 OffsetToEOL = End - Cursor;
1675 // Put the cursor on the only remaining #include among the duplicate
1676 // #includes.
1677 while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
1678 CursorIndex = i;
1679 break;
1680 }
1681 return std::make_pair(CursorIndex, OffsetToEOL);
1682}
1683
1684// Sorts and deduplicate a block of includes given by 'Includes' alphabetically
1685// adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
1686// source order.
1687// #include directives with the same text will be deduplicated, and only the
1688// first #include in the duplicate #includes remains. If the `Cursor` is
1689// provided and put on a deleted #include, it will be moved to the remaining
1690// #include in the duplicate #includes.
1691static void sortCppIncludes(const FormatStyle &Style,
1692 const SmallVectorImpl<IncludeDirective> &Includes,
1693 ArrayRef<tooling::Range> Ranges, StringRef FileName,
1694 tooling::Replacements &Replaces, unsigned *Cursor) {
1695 unsigned IncludesBeginOffset = Includes.front().Offset;
1696 unsigned IncludesEndOffset =
1697 Includes.back().Offset + Includes.back().Text.size();
1698 unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
1699 if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
1700 return;
1701 SmallVector<unsigned, 16> Indices;
1702 for (unsigned i = 0, e = Includes.size(); i != e; ++i)
1703 Indices.push_back(i);
1704 std::stable_sort(
1705 Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
1706 return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
1707 std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
1708 });
1709 // The index of the include on which the cursor will be put after
1710 // sorting/deduplicating.
1711 unsigned CursorIndex;
1712 // The offset from cursor to the end of line.
1713 unsigned CursorToEOLOffset;
1714 if (Cursor)
1715 std::tie(CursorIndex, CursorToEOLOffset) =
1716 FindCursorIndex(Includes, Indices, *Cursor);
1717
1718 // Deduplicate #includes.
1719 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1720 [&](unsigned LHSI, unsigned RHSI) {
1721 return Includes[LHSI].Text == Includes[RHSI].Text;
1722 }),
1723 Indices.end());
1724
1725 int CurrentCategory = Includes.front().Category;
1726
1727 // If the #includes are out of order, we generate a single replacement fixing
1728 // the entire block. Otherwise, no replacement is generated.
1729 if (Indices.size() == Includes.size() &&
1730 std::is_sorted(Indices.begin(), Indices.end()) &&
1731 Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Preserve)
1732 return;
1733
1734 std::string result;
1735 for (unsigned Index : Indices) {
1736 if (!result.empty()) {
1737 result += "\n";
1738 if (Style.IncludeStyle.IncludeBlocks ==
1739 tooling::IncludeStyle::IBS_Regroup &&
1740 CurrentCategory != Includes[Index].Category)
1741 result += "\n";
1742 }
1743 result += Includes[Index].Text;
1744 if (Cursor && CursorIndex == Index)
1745 *Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
1746 CurrentCategory = Includes[Index].Category;
1747 }
1748
1749 auto Err = Replaces.add(tooling::Replacement(
1750 FileName, Includes.front().Offset, IncludesBlockSize, result));
1751 // FIXME: better error handling. For now, just skip the replacement for the
1752 // release version.
1753 if (Err) {
1754 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1755 assert(false)((false) ? static_cast<void> (0) : __assert_fail ("false"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Format/Format.cpp"
, 1755, __PRETTY_FUNCTION__))
;
1756 }
1757}
1758
1759namespace {
1760
1761const char CppIncludeRegexPattern[] =
1762 R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
1763
1764} // anonymous namespace
1765
1766tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
1767 ArrayRef<tooling::Range> Ranges,
1768 StringRef FileName,
1769 tooling::Replacements &Replaces,
1770 unsigned *Cursor) {
1771 unsigned Prev = 0;
1772 unsigned SearchFrom = 0;
1773 llvm::Regex IncludeRegex(CppIncludeRegexPattern);
1774 SmallVector<StringRef, 4> Matches;
1775 SmallVector<IncludeDirective, 16> IncludesInBlock;
1776
1777 // In compiled files, consider the first #include to be the main #include of
1778 // the file if it is not a system #include. This ensures that the header
1779 // doesn't have hidden dependencies
1780 // (http://llvm.org/docs/CodingStandards.html#include-style).
1781 //
1782 // FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
1783 // cases where the first #include is unlikely to be the main header.
1784 tooling::IncludeCategoryManager Categories(Style.IncludeStyle, FileName);
1785 bool FirstIncludeBlock = true;
1786 bool MainIncludeFound = false;
1787 bool FormattingOff = false;
1788
1789 for (;;) {
1790 auto Pos = Code.find('\n', SearchFrom);
1791 StringRef Line =
1792 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
1793
1794 StringRef Trimmed = Line.trim();
1795 if (Trimmed == "// clang-format off")
1796 FormattingOff = true;
1797 else if (Trimmed == "// clang-format on")
1798 FormattingOff = false;
1799
1800 const bool EmptyLineSkipped =
1801 Trimmed.empty() &&
1802 (Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Merge ||
1803 Style.IncludeStyle.IncludeBlocks ==
1804 tooling::IncludeStyle::IBS_Regroup);
1805
1806 if (!FormattingOff && !Line.endswith("\\")) {
1807 if (IncludeRegex.match(Line, &Matches)) {
1808 StringRef IncludeName = Matches[2];
1809 int Category = Categories.getIncludePriority(
1810 IncludeName,
1811 /*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
1812 if (Category == 0)
1813 MainIncludeFound = true;
1814 IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
1815 } else if (!IncludesInBlock.empty() && !EmptyLineSkipped) {
1816 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
1817 Cursor);
1818 IncludesInBlock.clear();
1819 FirstIncludeBlock = false;
1820 }
1821 Prev = Pos + 1;
1822 }
1823 if (Pos == StringRef::npos || Pos + 1 == Code.size())
1824 break;
1825 SearchFrom = Pos + 1;
1826 }
1827 if (!IncludesInBlock.empty())
1828 sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
1829 return Replaces;
1830}
1831
1832// Returns group number to use as a first order sort on imports. Gives UINT_MAX
1833// if the import does not match any given groups.
1834static unsigned findJavaImportGroup(const FormatStyle &Style,
1835 StringRef ImportIdentifier) {
1836 unsigned LongestMatchIndex = UINT_MAX(2147483647 *2U +1U);
1837 unsigned LongestMatchLength = 0;
1838 for (unsigned I = 0; I < Style.JavaImportGroups.size(); I++) {
1839 std::string GroupPrefix = Style.JavaImportGroups[I];
1840 if (ImportIdentifier.startswith(GroupPrefix) &&
1841 GroupPrefix.length() > LongestMatchLength) {
1842 LongestMatchIndex = I;
1843 LongestMatchLength = GroupPrefix.length();
1844 }
1845 }
1846 return LongestMatchIndex;
1847}
1848
1849// Sorts and deduplicates a block of includes given by 'Imports' based on
1850// JavaImportGroups, then adding the necessary replacement to 'Replaces'.
1851// Import declarations with the same text will be deduplicated. Between each
1852// import group, a newline is inserted, and within each import group, a
1853// lexicographic sort based on ASCII value is performed.
1854static void sortJavaImports(const FormatStyle &Style,
1855 const SmallVectorImpl<JavaImportDirective> &Imports,
1856 ArrayRef<tooling::Range> Ranges, StringRef FileName,
1857 tooling::Replacements &Replaces) {
1858 unsigned ImportsBeginOffset = Imports.front().Offset;
1859 unsigned ImportsEndOffset =
1860 Imports.back().Offset + Imports.back().Text.size();
1861 unsigned ImportsBlockSize = ImportsEndOffset - ImportsBeginOffset;
1862 if (!affectsRange(Ranges, ImportsBeginOffset, ImportsEndOffset))
1863 return;
1864 SmallVector<unsigned, 16> Indices;
1865 SmallVector<unsigned, 16> JavaImportGroups;
1866 for (unsigned i = 0, e = Imports.size(); i != e; ++i) {
1867 Indices.push_back(i);
1868 JavaImportGroups.push_back(
1869 findJavaImportGroup(Style, Imports[i].Identifier));
1870 }
1871 llvm::sort(Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
1872 // Negating IsStatic to push static imports above non-static imports.
1873 return std::make_tuple(!Imports[LHSI].IsStatic, JavaImportGroups[LHSI],
1874 Imports[LHSI].Identifier) <
1875 std::make_tuple(!Imports[RHSI].IsStatic, JavaImportGroups[RHSI],
1876 Imports[RHSI].Identifier);
1877 });
1878
1879 // Deduplicate imports.
1880 Indices.erase(std::unique(Indices.begin(), Indices.end(),
1881 [&](unsigned LHSI, unsigned RHSI) {
1882 return Imports[LHSI].Text == Imports[RHSI].Text;
1883 }),
1884 Indices.end());
1885
1886 bool CurrentIsStatic = Imports[Indices.front()].IsStatic;
1887 unsigned CurrentImportGroup = JavaImportGroups[Indices.front()];
1888
1889 std::string result;
1890 for (unsigned Index : Indices) {
1891 if (!result.empty()) {
1892 result += "\n";
1893 if (CurrentIsStatic != Imports[Index].IsStatic ||
1894 CurrentImportGroup != JavaImportGroups[Index])
1895 result += "\n";
1896 }
1897 for (StringRef CommentLine : Imports[Index].AssociatedCommentLines) {
1898 result += CommentLine;
1899 result += "\n";
1900 }
1901 result += Imports[Index].Text;
1902 CurrentIsStatic = Imports[Index].IsStatic;
1903 CurrentImportGroup = JavaImportGroups[Index];
1904 }
1905
1906 auto Err = Replaces.add(tooling::Replacement(FileName, Imports.front().Offset,
1907 ImportsBlockSize, result));
1908 // FIXME: better error handling. For now, just skip the replacement for the
1909 // release version.
1910 if (Err) {
1911 llvm::errs() << llvm::toString(std::move(Err)) << "\n";
1912 assert(false)((false) ? static_cast<void> (0) : __assert_fail ("false"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Format/Format.cpp"
, 1912, __PRETTY_FUNCTION__))
;
1913 }
1914}
1915
1916namespace {
1917
1918const char JavaImportRegexPattern[] =
1919 "^[\t ]*import[\t ]*(static[\t ]*)?([^\t ]*)[\t ]*;";
1920
1921} // anonymous namespace
1922
1923tooling::Replacements sortJavaImports(const FormatStyle &Style, StringRef Code,
1924 ArrayRef<tooling::Range> Ranges,
1925 StringRef FileName,
1926 tooling::Replacements &Replaces) {
1927 unsigned Prev = 0;
1928 unsigned SearchFrom = 0;
1929 llvm::Regex ImportRegex(JavaImportRegexPattern);
1930 SmallVector<StringRef, 4> Matches;
1931 SmallVector<JavaImportDirective, 16> ImportsInBlock;
1932 std::vector<StringRef> AssociatedCommentLines;
1933
1934 bool FormattingOff = false;
1935
1936 for (;;) {
1937 auto Pos = Code.find('\n', SearchFrom);
1938 StringRef Line =
1939 Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
1940
1941 StringRef Trimmed = Line.trim();
1942 if (Trimmed == "// clang-format off")
1943 FormattingOff = true;
1944 else if (Trimmed == "// clang-format on")
1945 FormattingOff = false;
1946
1947 if (ImportRegex.match(Line, &Matches)) {
1948 if (FormattingOff) {
1949 // If at least one import line has formatting turned off, turn off
1950 // formatting entirely.
1951 return Replaces;
1952 }
1953 StringRef Static = Matches[1];
1954 StringRef Identifier = Matches[2];
1955 bool IsStatic = false;
1956 if (Static.contains("static")) {
1957 IsStatic = true;
1958 }
1959 ImportsInBlock.push_back({Identifier, Line, Prev, AssociatedCommentLines, IsStatic});
1960 AssociatedCommentLines.clear();
1961 } else if (Trimmed.size() > 0 && !ImportsInBlock.empty()) {
1962 // Associating comments within the imports with the nearest import below
1963 AssociatedCommentLines.push_back(Line);
1964 }
1965 Prev = Pos + 1;
1966 if (Pos == StringRef::npos || Pos + 1 == Code.size())
1967 break;
1968 SearchFrom = Pos + 1;
1969 }
1970 if (!ImportsInBlock.empty())
1971 sortJavaImports(Style, ImportsInBlock, Ranges, FileName, Replaces);
1972 return Replaces;
1973}
1974
1975bool isMpegTS(StringRef Code) {
1976 // MPEG transport streams use the ".ts" file extension. clang-format should
1977 // not attempt to format those. MPEG TS' frame format starts with 0x47 every
1978 // 189 bytes - detect that and return.
1979 return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
1980}
1981
1982bool isLikelyXml(StringRef Code) { return Code.ltrim().startswith("<"); }
1983
1984tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
1985 ArrayRef<tooling::Range> Ranges,
1986 StringRef FileName, unsigned *Cursor) {
1987 tooling::Replacements Replaces;
1988 if (!Style.SortIncludes)
1989 return Replaces;
1990 if (isLikelyXml(Code))
1991 return Replaces;
1992 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
1993 isMpegTS(Code))
1994 return Replaces;
1995 if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
1996 return sortJavaScriptImports(Style, Code, Ranges, FileName);
1997 if (Style.Language == FormatStyle::LanguageKind::LK_Java)
1998 return sortJavaImports(Style, Code, Ranges, FileName, Replaces);
1999 sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
2000 return Replaces;
2001}
2002
2003template <typename T>
2004static llvm::Expected<tooling::Replacements>
2005processReplacements(T ProcessFunc, StringRef Code,
2006 const tooling::Replacements &Replaces,
2007 const FormatStyle &Style) {
2008 if (Replaces.empty())
2009 return tooling::Replacements();
2010
2011 auto NewCode = applyAllReplacements(Code, Replaces);
2012 if (!NewCode)
2013 return NewCode.takeError();
2014 std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
2015 StringRef FileName = Replaces.begin()->getFilePath();
2016
2017 tooling::Replacements FormatReplaces =
2018 ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
2019
2020 return Replaces.merge(FormatReplaces);
2021}
2022
2023llvm::Expected<tooling::Replacements>
2024formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
2025 const FormatStyle &Style) {
2026 // We need to use lambda function here since there are two versions of
2027 // `sortIncludes`.
2028 auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
2029 std::vector<tooling::Range> Ranges,
2030 StringRef FileName) -> tooling::Replacements {
2031 return sortIncludes(Style, Code, Ranges, FileName);
2032 };
2033 auto SortedReplaces =
2034 processReplacements(SortIncludes, Code, Replaces, Style);
2035 if (!SortedReplaces)
2036 return SortedReplaces.takeError();
2037
2038 // We need to use lambda function here since there are two versions of
2039 // `reformat`.
2040 auto Reformat = [](const FormatStyle &Style, StringRef Code,
2041 std::vector<tooling::Range> Ranges,
2042 StringRef FileName) -> tooling::Replacements {
2043 return reformat(Style, Code, Ranges, FileName);
2044 };
2045 return processReplacements(Reformat, Code, *SortedReplaces, Style);
2046}
2047
2048namespace {
2049
2050inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
2051 return Replace.getOffset() == UINT_MAX(2147483647 *2U +1U) && Replace.getLength() == 0 &&
2052 llvm::Regex(CppIncludeRegexPattern)
2053 .match(Replace.getReplacementText());
2054}
2055
2056inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
2057 return Replace.getOffset() == UINT_MAX(2147483647 *2U +1U) && Replace.getLength() == 1;
2058}
2059
2060// FIXME: insert empty lines between newly created blocks.
2061tooling::Replacements
2062fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
2063 const FormatStyle &Style) {
2064 if (!Style.isCpp())
2065 return Replaces;
2066
2067 tooling::Replacements HeaderInsertions;
2068 std::set<llvm::StringRef> HeadersToDelete;
2069 tooling::Replacements Result;
2070 for (const auto &R : Replaces) {
2071 if (isHeaderInsertion(R)) {
2072 // Replacements from \p Replaces must be conflict-free already, so we can
2073 // simply consume the error.
2074 llvm::consumeError(HeaderInsertions.add(R));
2075 } else if (isHeaderDeletion(R)) {
2076 HeadersToDelete.insert(R.getReplacementText());
2077 } else if (R.getOffset() == UINT_MAX(2147483647 *2U +1U)) {
2078 llvm::errs() << "Insertions other than header #include insertion are "
2079 "not supported! "
2080 << R.getReplacementText() << "\n";
2081 } else {
2082 llvm::consumeError(Result.add(R));
2083 }
2084 }
2085 if (HeaderInsertions.empty() && HeadersToDelete.empty())
2086 return Replaces;
2087
2088
2089 StringRef FileName = Replaces.begin()->getFilePath();
2090 tooling::HeaderIncludes Includes(FileName, Code, Style.IncludeStyle);
2091
2092 for (const auto &Header : HeadersToDelete) {
2093 tooling::Replacements Replaces =
2094 Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
2095 for (const auto &R : Replaces) {
2096 auto Err = Result.add(R);
2097 if (Err) {
2098 // Ignore the deletion on conflict.
2099 llvm::errs() << "Failed to add header deletion replacement for "
2100 << Header << ": " << llvm::toString(std::move(Err))
2101 << "\n";
2102 }
2103 }
2104 }
2105
2106 llvm::Regex IncludeRegex = llvm::Regex(CppIncludeRegexPattern);
2107 llvm::SmallVector<StringRef, 4> Matches;
2108 for (const auto &R : HeaderInsertions) {
2109 auto IncludeDirective = R.getReplacementText();
2110 bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
2111 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~svn350071/tools/clang/lib/Format/Format.cpp"
, 2112, __PRETTY_FUNCTION__))
2112 "'#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~svn350071/tools/clang/lib/Format/Format.cpp"
, 2112, __PRETTY_FUNCTION__))
;
2113 (void)Matched;
2114 auto IncludeName = Matches[2];
2115 auto Replace =
2116 Includes.insert(IncludeName.trim("\"<>"), IncludeName.startswith("<"));
2117 if (Replace) {
2118 auto Err = Result.add(*Replace);
2119 if (Err) {
2120 llvm::consumeError(std::move(Err));
2121 unsigned NewOffset = Result.getShiftedCodePosition(Replace->getOffset());
2122 auto Shifted = tooling::Replacement(FileName, NewOffset, 0,
2123 Replace->getReplacementText());
2124 Result = Result.merge(tooling::Replacements(Shifted));
2125 }
2126 }
2127 }
2128 return Result;
2129}
2130
2131} // anonymous namespace
2132
2133llvm::Expected<tooling::Replacements>
2134cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
2135 const FormatStyle &Style) {
2136 // We need to use lambda function here since there are two versions of
2137 // `cleanup`.
2138 auto Cleanup = [](const FormatStyle &Style, StringRef Code,
2139 std::vector<tooling::Range> Ranges,
2140 StringRef FileName) -> tooling::Replacements {
2141 return cleanup(Style, Code, Ranges, FileName);
2142 };
2143 // Make header insertion replacements insert new headers into correct blocks.
2144 tooling::Replacements NewReplaces =
2145 fixCppIncludeInsertions(Code, Replaces, Style);
2146 return processReplacements(Cleanup, Code, NewReplaces, Style);
2147}
2148
2149namespace internal {
2150std::pair<tooling::Replacements, unsigned>
2151reformat(const FormatStyle &Style, StringRef Code,
2152 ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
2153 unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
2154 FormattingAttemptStatus *Status) {
2155 FormatStyle Expanded = expandPresets(Style);
2156 if (Expanded.DisableFormat)
2157 return {tooling::Replacements(), 0};
2158 if (isLikelyXml(Code))
2159 return {tooling::Replacements(), 0};
2160 if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
2161 return {tooling::Replacements(), 0};
2162
2163 typedef std::function<std::pair<tooling::Replacements, unsigned>(
2164 const Environment &)>
2165 AnalyzerPass;
2166 SmallVector<AnalyzerPass, 4> Passes;
2167
2168 if (Style.Language == FormatStyle::LK_Cpp) {
2169 if (Style.FixNamespaceComments)
2170 Passes.emplace_back([&](const Environment &Env) {
2171 return NamespaceEndCommentsFixer(Env, Expanded).process();
2172 });
2173
2174 if (Style.SortUsingDeclarations)
2175 Passes.emplace_back([&](const Environment &Env) {
2176 return UsingDeclarationsSorter(Env, Expanded).process();
2177 });
2178 }
2179
2180 if (Style.Language == FormatStyle::LK_JavaScript &&
2181 Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
2182 Passes.emplace_back([&](const Environment &Env) {
2183 return JavaScriptRequoter(Env, Expanded).process();
2184 });
2185
2186 Passes.emplace_back([&](const Environment &Env) {
2187 return Formatter(Env, Expanded, Status).process();
2188 });
2189
2190 auto Env =
2191 llvm::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
2192 NextStartColumn, LastStartColumn);
2193 llvm::Optional<std::string> CurrentCode = None;
2194 tooling::Replacements Fixes;
2195 unsigned Penalty = 0;
2196 for (size_t I = 0, E = Passes.size(); I < E; ++I) {
2197 std::pair<tooling::Replacements, unsigned> PassFixes = Passes[I](*Env);
2198 auto NewCode = applyAllReplacements(
2199 CurrentCode ? StringRef(*CurrentCode) : Code, PassFixes.first);
2200 if (NewCode) {
2201 Fixes = Fixes.merge(PassFixes.first);
2202 Penalty += PassFixes.second;
2203 if (I + 1 < E) {
2204 CurrentCode = std::move(*NewCode);
2205 Env = llvm::make_unique<Environment>(
2206 *CurrentCode, FileName,
2207 tooling::calculateRangesAfterReplacements(Fixes, Ranges),
2208 FirstStartColumn, NextStartColumn, LastStartColumn);
2209 }
2210 }
2211 }
2212
2213 return {Fixes, Penalty};
2214}
2215} // namespace internal
2216
2217tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2218 ArrayRef<tooling::Range> Ranges,
2219 StringRef FileName,
2220 FormattingAttemptStatus *Status) {
2221 return internal::reformat(Style, Code, Ranges,
2222 /*FirstStartColumn=*/0,
2223 /*NextStartColumn=*/0,
2224 /*LastStartColumn=*/0, FileName, Status)
2225 .first;
2226}
2227
2228tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
2229 ArrayRef<tooling::Range> Ranges,
2230 StringRef FileName) {
2231 // cleanups only apply to C++ (they mostly concern ctor commas etc.)
2232 if (Style.Language != FormatStyle::LK_Cpp)
2233 return tooling::Replacements();
2234 return Cleaner(Environment(Code, FileName, Ranges), Style).process().first;
2235}
2236
2237tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
2238 ArrayRef<tooling::Range> Ranges,
2239 StringRef FileName, bool *IncompleteFormat) {
2240 FormattingAttemptStatus Status;
2241 auto Result = reformat(Style, Code, Ranges, FileName, &Status);
2242 if (!Status.FormatComplete)
2243 *IncompleteFormat = true;
2244 return Result;
2245}
2246
2247tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
2248 StringRef Code,
2249 ArrayRef<tooling::Range> Ranges,
2250 StringRef FileName) {
2251 return NamespaceEndCommentsFixer(Environment(Code, FileName, Ranges), Style)
2252 .process()
2253 .first;
2254}
2255
2256tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
2257 StringRef Code,
2258 ArrayRef<tooling::Range> Ranges,
2259 StringRef FileName) {
2260 return UsingDeclarationsSorter(Environment(Code, FileName, Ranges), Style)
2261 .process()
2262 .first;
2263}
2264
2265LangOptions getFormattingLangOpts(const FormatStyle &Style) {
2266 LangOptions LangOpts;
2267 LangOpts.CPlusPlus = 1;
2268 LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2269 LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2270 LangOpts.CPlusPlus17 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2271 LangOpts.CPlusPlus2a = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
2272 LangOpts.LineComment = 1;
2273 bool AlternativeOperators = Style.isCpp();
2274 LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
2275 LangOpts.Bool = 1;
2276 LangOpts.ObjC = 1;
2277 LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
2278 LangOpts.DeclSpecKeyword = 1; // To get __declspec.
2279 return LangOpts;
2280}
2281
2282const char *StyleOptionHelpDescription =
2283 "Coding style, currently supports:\n"
2284 " LLVM, Google, Chromium, Mozilla, WebKit.\n"
2285 "Use -style=file to load style configuration from\n"
2286 ".clang-format file located in one of the parent\n"
2287 "directories of the source file (or current\n"
2288 "directory for stdin).\n"
2289 "Use -style=\"{key: value, ...}\" to set specific\n"
2290 "parameters, e.g.:\n"
2291 " -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
2292
2293static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
2294 if (FileName.endswith(".java"))
2295 return FormatStyle::LK_Java;
2296 if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
2297 return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
2298 if (FileName.endswith(".m") || FileName.endswith(".mm"))
2299 return FormatStyle::LK_ObjC;
2300 if (FileName.endswith_lower(".proto") ||
2301 FileName.endswith_lower(".protodevel"))
2302 return FormatStyle::LK_Proto;
2303 if (FileName.endswith_lower(".textpb") ||
2304 FileName.endswith_lower(".pb.txt") ||
2305 FileName.endswith_lower(".textproto") ||
2306 FileName.endswith_lower(".asciipb"))
2307 return FormatStyle::LK_TextProto;
2308 if (FileName.endswith_lower(".td"))
2309 return FormatStyle::LK_TableGen;
2310 return FormatStyle::LK_Cpp;
2311}
2312
2313FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
2314 const auto GuessedLanguage = getLanguageByFileName(FileName);
2315 if (GuessedLanguage == FormatStyle::LK_Cpp) {
2316 auto Extension = llvm::sys::path::extension(FileName);
2317 // If there's no file extension (or it's .h), we need to check the contents
2318 // of the code to see if it contains Objective-C.
2319 if (Extension.empty() || Extension == ".h") {
2320 auto NonEmptyFileName = FileName.empty() ? "guess.h" : FileName;
2321 Environment Env(Code, NonEmptyFileName, /*Ranges=*/{});
2322 ObjCHeaderStyleGuesser Guesser(Env, getLLVMStyle());
2323 Guesser.process();
2324 if (Guesser.isObjC())
2325 return FormatStyle::LK_ObjC;
2326 }
2327 }
2328 return GuessedLanguage;
2329}
2330
2331const char *DefaultFormatStyle = "file";
2332
2333const char *DefaultFallbackStyle = "LLVM";
2334
2335llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
2336 StringRef FallbackStyleName,
2337 StringRef Code,
2338 llvm::vfs::FileSystem *FS) {
2339 if (!FS) {
2340 FS = llvm::vfs::getRealFileSystem().get();
2341 }
2342 FormatStyle Style = getLLVMStyle();
2343 Style.Language = guessLanguage(FileName, Code);
2344
2345 FormatStyle FallbackStyle = getNoStyle();
2346 if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
2347 return make_string_error("Invalid fallback style \"" + FallbackStyleName);
2348
2349 if (StyleName.startswith("{")) {
2350 // Parse YAML/JSON style from the command line.
2351 if (std::error_code ec = parseConfiguration(StyleName, &Style))
2352 return make_string_error("Error parsing -style: " + ec.message());
2353 return Style;
2354 }
2355
2356 if (!StyleName.equals_lower("file")) {
2357 if (!getPredefinedStyle(StyleName, Style.Language, &Style))
2358 return make_string_error("Invalid value for -style");
2359 return Style;
2360 }
2361
2362 // Look for .clang-format/_clang-format file in the file's parent directories.
2363 SmallString<128> UnsuitableConfigFiles;
2364 SmallString<128> Path(FileName);
2365 if (std::error_code EC = FS->makeAbsolute(Path))
2366 return make_string_error(EC.message());
2367
2368 for (StringRef Directory = Path; !Directory.empty();
2369 Directory = llvm::sys::path::parent_path(Directory)) {
2370
2371 auto Status = FS->status(Directory);
2372 if (!Status ||
2373 Status->getType() != llvm::sys::fs::file_type::directory_file) {
2374 continue;
2375 }
2376
2377 SmallString<128> ConfigFile(Directory);
2378
2379 llvm::sys::path::append(ConfigFile, ".clang-format");
2380 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Trying " <<
ConfigFile << "...\n"; } } while (false)
;
2381
2382 Status = FS->status(ConfigFile.str());
2383 bool FoundConfigFile =
2384 Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
2385 if (!FoundConfigFile) {
2386 // Try _clang-format too, since dotfiles are not commonly used on Windows.
2387 ConfigFile = Directory;
2388 llvm::sys::path::append(ConfigFile, "_clang-format");
2389 LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Trying " <<
ConfigFile << "...\n"; } } while (false)
;
2390 Status = FS->status(ConfigFile.str());
2391 FoundConfigFile = Status && (Status->getType() ==
2392 llvm::sys::fs::file_type::regular_file);
2393 }
2394
2395 if (FoundConfigFile) {
2396 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
2397 FS->getBufferForFile(ConfigFile.str());
2398 if (std::error_code EC = Text.getError())
2399 return make_string_error(EC.message());
2400 if (std::error_code ec =
2401 parseConfiguration(Text.get()->getBuffer(), &Style)) {
2402 if (ec == ParseError::Unsuitable) {
2403 if (!UnsuitableConfigFiles.empty())
2404 UnsuitableConfigFiles.append(", ");
2405 UnsuitableConfigFiles.append(ConfigFile);
2406 continue;
2407 }
2408 return make_string_error("Error reading " + ConfigFile + ": " +
2409 ec.message());
2410 }
2411 LLVM_DEBUG(llvm::dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Using configuration file "
<< ConfigFile << "\n"; } } while (false)
2412 << "Using configuration file " << ConfigFile << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("format-formatter")) { llvm::dbgs() << "Using configuration file "
<< ConfigFile << "\n"; } } while (false)
;
2413 return Style;
2414 }
2415 }
2416 if (!UnsuitableConfigFiles.empty())
2417 return make_string_error("Configuration file(s) do(es) not support " +
2418 getLanguageName(Style.Language) + ": " +
2419 UnsuitableConfigFiles);
2420 return FallbackStyle;
2421}
2422
2423} // namespace format
2424} // namespace clang

/build/llvm-toolchain-snapshot-8~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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~svn350071/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 function is compatible with the helpers from Support/WithColor.h. You
957/// can pass any of them as the OS. Please consider using them instead of
958/// including 'error: ' in the ErrorBanner.
959///
960/// This is useful in the base level of your program to allow clean termination
961/// (allowing clean deallocation of resources, etc.), while reporting error
962/// information to the user.
963void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
964
965/// Write all error messages (if any) in E to a string. The newline character
966/// is used to separate error messages.
967inline std::string toString(Error E) {
968 SmallVector<std::string, 2> Errors;
969 handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
970 Errors.push_back(EI.message());
971 });
972 return join(Errors.begin(), Errors.end(), "\n");
973}
974
975/// Consume a Error without doing anything. This method should be used
976/// only where an error can be considered a reasonable and expected return
977/// value.
978///
979/// Uses of this method are potentially indicative of design problems: If it's
980/// legitimate to do nothing while processing an "error", the error-producer
981/// might be more clearly refactored to return an Optional<T>.
982inline void consumeError(Error Err) {
983 handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
984}
985
986/// Helper for converting an Error to a bool.
987///
988/// This method returns true if Err is in an error state, or false if it is
989/// in a success state. Puts Err in a checked state in both cases (unlike
990/// Error::operator bool(), which only does this for success states).
991inline bool errorToBool(Error Err) {
992 bool IsError = static_cast<bool>(Err);
993 if (IsError)
994 consumeError(std::move(Err));
995 return IsError;
996}
997
998/// Helper for Errors used as out-parameters.
999///
1000/// This helper is for use with the Error-as-out-parameter idiom, where an error
1001/// is passed to a function or method by reference, rather than being returned.
1002/// In such cases it is helpful to set the checked bit on entry to the function
1003/// so that the error can be written to (unchecked Errors abort on assignment)
1004/// and clear the checked bit on exit so that clients cannot accidentally forget
1005/// to check the result. This helper performs these actions automatically using
1006/// RAII:
1007///
1008/// @code{.cpp}
1009/// Result foo(Error &Err) {
1010/// ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1011/// // <body of foo>
1012/// // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1013/// }
1014/// @endcode
1015///
1016/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1017/// used with optional Errors (Error pointers that are allowed to be null). If
1018/// ErrorAsOutParameter took an Error reference, an instance would have to be
1019/// created inside every condition that verified that Error was non-null. By
1020/// taking an Error pointer we can just create one instance at the top of the
1021/// function.
1022class ErrorAsOutParameter {
1023public:
1024 ErrorAsOutParameter(Error *Err) : Err(Err) {
1025 // Raise the checked bit if Err is success.
1026 if (Err)
1027 (void)!!*Err;
1028 }
1029
1030 ~ErrorAsOutParameter() {
1031 // Clear the checked bit.
1032 if (Err && !*Err)
1033 *Err = Error::success();
1034 }
1035
1036private:
1037 Error *Err;
1038};
1039
1040/// Helper for Expected<T>s used as out-parameters.
1041///
1042/// See ErrorAsOutParameter.
1043template <typename T>
1044class ExpectedAsOutParameter {
1045public:
1046 ExpectedAsOutParameter(Expected<T> *ValOrErr)
1047 : ValOrErr(ValOrErr) {
1048 if (ValOrErr)
1049 (void)!!*ValOrErr;
1050 }
1051
1052 ~ExpectedAsOutParameter() {
1053 if (ValOrErr)
1054 ValOrErr->setUnchecked();
1055 }
1056
1057private:
1058 Expected<T> *ValOrErr;
1059};
1060
1061/// This class wraps a std::error_code in a Error.
1062///
1063/// This is useful if you're writing an interface that returns a Error
1064/// (or Expected) and you want to call code that still returns
1065/// std::error_codes.
1066class ECError : public ErrorInfo<ECError> {
1067 friend Error errorCodeToError(std::error_code);
1068
1069public:
1070 void setErrorCode(std::error_code EC) { this->EC = EC; }
1071 std::error_code convertToErrorCode() const override { return EC; }
1072 void log(raw_ostream &OS) const override { OS << EC.message(); }
1073
1074 // Used by ErrorInfo::classID.
1075 static char ID;
1076
1077protected:
1078 ECError() = default;
1079 ECError(std::error_code EC) : EC(EC) {}
1080
1081 std::error_code EC;
1082};
1083
1084/// The value returned by this function can be returned from convertToErrorCode
1085/// for Error values where no sensible translation to std::error_code exists.
1086/// It should only be used in this situation, and should never be used where a
1087/// sensible conversion to std::error_code is available, as attempts to convert
1088/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1089///error to try to convert such a value).
1090std::error_code inconvertibleErrorCode();
1091
1092/// Helper for converting an std::error_code to a Error.
1093Error errorCodeToError(std::error_code EC);
1094
1095/// Helper for converting an ECError to a std::error_code.
1096///
1097/// This method requires that Err be Error() or an ECError, otherwise it
1098/// will trigger a call to abort().
1099std::error_code errorToErrorCode(Error Err);
1100
1101/// Convert an ErrorOr<T> to an Expected<T>.
1102template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1103 if (auto EC = EO.getError())
1104 return errorCodeToError(EC);
1105 return std::move(*EO);
1106}
1107
1108/// Convert an Expected<T> to an ErrorOr<T>.
1109template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1110 if (auto Err = E.takeError())
1111 return errorToErrorCode(std::move(Err));
1112 return std::move(*E);
1113}
1114
1115/// This class wraps a string in an Error.
1116///
1117/// StringError is useful in cases where the client is not expected to be able
1118/// to consume the specific error message programmatically (for example, if the
1119/// error message is to be presented to the user).
1120///
1121/// StringError can also be used when additional information is to be printed
1122/// along with a error_code message. Depending on the constructor called, this
1123/// class can either display:
1124/// 1. the error_code message (ECError behavior)
1125/// 2. a string
1126/// 3. the error_code message and a string
1127///
1128/// These behaviors are useful when subtyping is required; for example, when a
1129/// specific library needs an explicit error type. In the example below,
1130/// PDBError is derived from StringError:
1131///
1132/// @code{.cpp}
1133/// Expected<int> foo() {
1134/// return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1135/// "Additional information");
1136/// }
1137/// @endcode
1138///
1139class StringError : public ErrorInfo<StringError> {
1140public:
1141 static char ID;
1142
1143 // Prints EC + S and converts to EC
1144 StringError(std::error_code EC, const Twine &S = Twine());
1145
1146 // Prints S and converts to EC
1147 StringError(const Twine &S, std::error_code EC);
1148
1149 void log(raw_ostream &OS) const override;
1150 std::error_code convertToErrorCode() const override;
1151
1152 const std::string &getMessage() const { return Msg; }
1153
1154private:
1155 std::string Msg;
1156 std::error_code EC;
1157 const bool PrintMsgOnly = false;
1158};
1159
1160/// Create formatted StringError object.
1161template <typename... Ts>
1162Error createStringError(std::error_code EC, char const *Fmt,
1163 const Ts &... Vals) {
1164 std::string Buffer;
1165 raw_string_ostream Stream(Buffer);
1166 Stream << format(Fmt, Vals...);
1167 return make_error<StringError>(Stream.str(), EC);
1168}
1169
1170Error createStringError(std::error_code EC, char const *Msg);
1171
1172/// This class wraps a filename and another Error.
1173///
1174/// In some cases, an error needs to live along a 'source' name, in order to
1175/// show more detailed information to the user.
1176class FileError final : public ErrorInfo<FileError> {
1177
1178 friend Error createFileError(std::string, Error);
1179
1180public:
1181 void log(raw_ostream &OS) const override {
1182 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~svn350071/include/llvm/Support/Error.h"
, 1182, __PRETTY_FUNCTION__))
;
1183 OS << "'" << FileName << "': ";
1184 Err->log(OS);
1185 }
1186
1187 Error takeError() { return Error(std::move(Err)); }
1188
1189 std::error_code convertToErrorCode() const override;
1190
1191 // Used by ErrorInfo::classID.
1192 static char ID;
1193
1194private:
1195 FileError(std::string F, std::unique_ptr<ErrorInfoBase> E) {
1196 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~svn350071/include/llvm/Support/Error.h"
, 1196, __PRETTY_FUNCTION__))
;
1197 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~svn350071/include/llvm/Support/Error.h"
, 1198, __PRETTY_FUNCTION__))
1198 "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~svn350071/include/llvm/Support/Error.h"
, 1198, __PRETTY_FUNCTION__))
;
1199 FileName = F;
1200 Err = std::move(E);
1201 }
1202
1203 static Error build(std::string F, Error E) {
1204 return Error(std::unique_ptr<FileError>(new FileError(F, E.takePayload())));
1205 }
1206
1207 std::string FileName;
1208 std::unique_ptr<ErrorInfoBase> Err;
1209};
1210
1211/// Concatenate a source file path and/or name with an Error. The resulting
1212/// Error is unchecked.
1213inline Error createFileError(std::string F, Error E) {
1214 return FileError::build(F, std::move(E));
1215}
1216
1217Error createFileError(std::string F, ErrorSuccess) = delete;
1218
1219/// Helper for check-and-exit error handling.
1220///
1221/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1222///
1223class ExitOnError {
1224public:
1225 /// Create an error on exit helper.
1226 ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1227 : Banner(std::move(Banner)),
1228 GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1229
1230 /// Set the banner string for any errors caught by operator().
1231 void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1232
1233 /// Set the exit-code mapper function.
1234 void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1235 this->GetExitCode = std::move(GetExitCode);
1236 }
1237
1238 /// Check Err. If it's in a failure state log the error(s) and exit.
1239 void operator()(Error Err) const { checkError(std::move(Err)); }
1240
1241 /// Check E. If it's in a success state then return the contained value. If
1242 /// it's in a failure state log the error(s) and exit.
1243 template <typename T> T operator()(Expected<T> &&E) const {
1244 checkError(E.takeError());
1245 return std::move(*E);
1246 }
1247
1248 /// Check E. If it's in a success state then return the contained reference. If
1249 /// it's in a failure state log the error(s) and exit.
1250 template <typename T> T& operator()(Expected<T&> &&E) const {
1251 checkError(E.takeError());
1252 return *E;
1253 }
1254
1255private:
1256 void checkError(Error Err) const {
1257 if (Err) {
1258 int ExitCode = GetExitCode(Err);
1259 logAllUnhandledErrors(std::move(Err), errs(), Banner);
1260 exit(ExitCode);
1261 }
1262 }
1263
1264 std::string Banner;
1265 std::function<int(const Error &)> GetExitCode;
1266};
1267
1268/// Conversion from Error to LLVMErrorRef for C error bindings.
1269inline LLVMErrorRef wrap(Error Err) {
1270 return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1271}
1272
1273/// Conversion from LLVMErrorRef to Error for C error bindings.
1274inline Error unwrap(LLVMErrorRef ErrRef) {
1275 return Error(std::unique_ptr<ErrorInfoBase>(
1276 reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1277}
1278
1279} // end namespace llvm
1280
1281#endif // LLVM_SUPPORT_ERROR_H

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