/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Basic/Diagnostic.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===- Diagnostic.h - C Language Family Diagnostic Handling -----*- C++ -*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | /// \file |
10 | | /// Defines the Diagnostic-related interfaces. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #ifndef LLVM_CLANG_BASIC_DIAGNOSTIC_H |
15 | | #define LLVM_CLANG_BASIC_DIAGNOSTIC_H |
16 | | |
17 | | #include "clang/Basic/DiagnosticIDs.h" |
18 | | #include "clang/Basic/DiagnosticOptions.h" |
19 | | #include "clang/Basic/SourceLocation.h" |
20 | | #include "clang/Basic/Specifiers.h" |
21 | | #include "llvm/ADT/ArrayRef.h" |
22 | | #include "llvm/ADT/DenseMap.h" |
23 | | #include "llvm/ADT/IntrusiveRefCntPtr.h" |
24 | | #include "llvm/ADT/Optional.h" |
25 | | #include "llvm/ADT/SmallVector.h" |
26 | | #include "llvm/ADT/StringRef.h" |
27 | | #include "llvm/ADT/iterator_range.h" |
28 | | #include "llvm/Support/Compiler.h" |
29 | | #include <cassert> |
30 | | #include <cstdint> |
31 | | #include <limits> |
32 | | #include <list> |
33 | | #include <map> |
34 | | #include <memory> |
35 | | #include <string> |
36 | | #include <type_traits> |
37 | | #include <utility> |
38 | | #include <vector> |
39 | | |
40 | | namespace llvm { |
41 | | class Error; |
42 | | class raw_ostream; |
43 | | } // namespace llvm |
44 | | |
45 | | namespace clang { |
46 | | |
47 | | class DeclContext; |
48 | | class DiagnosticBuilder; |
49 | | class DiagnosticConsumer; |
50 | | class IdentifierInfo; |
51 | | class LangOptions; |
52 | | class Preprocessor; |
53 | | class SourceManager; |
54 | | class StoredDiagnostic; |
55 | | |
56 | | namespace tok { |
57 | | |
58 | | enum TokenKind : unsigned short; |
59 | | |
60 | | } // namespace tok |
61 | | |
62 | | /// Annotates a diagnostic with some code that should be |
63 | | /// inserted, removed, or replaced to fix the problem. |
64 | | /// |
65 | | /// This kind of hint should be used when we are certain that the |
66 | | /// introduction, removal, or modification of a particular (small!) |
67 | | /// amount of code will correct a compilation error. The compiler |
68 | | /// should also provide full recovery from such errors, such that |
69 | | /// suppressing the diagnostic output can still result in successful |
70 | | /// compilation. |
71 | | class FixItHint { |
72 | | public: |
73 | | /// Code that should be replaced to correct the error. Empty for an |
74 | | /// insertion hint. |
75 | | CharSourceRange RemoveRange; |
76 | | |
77 | | /// Code in the specific range that should be inserted in the insertion |
78 | | /// location. |
79 | | CharSourceRange InsertFromRange; |
80 | | |
81 | | /// The actual code to insert at the insertion location, as a |
82 | | /// string. |
83 | | std::string CodeToInsert; |
84 | | |
85 | | bool BeforePreviousInsertions = false; |
86 | | |
87 | | /// Empty code modification hint, indicating that no code |
88 | | /// modification is known. |
89 | 403k | FixItHint() = default; |
90 | | |
91 | 395k | bool isNull() const { |
92 | 395k | return !RemoveRange.isValid(); |
93 | 395k | } |
94 | | |
95 | | /// Create a code modification hint that inserts the given |
96 | | /// code string at a specific location. |
97 | | static FixItHint CreateInsertion(SourceLocation InsertionLoc, |
98 | | StringRef Code, |
99 | 279k | bool BeforePreviousInsertions = false) { |
100 | 279k | FixItHint Hint; |
101 | 279k | Hint.RemoveRange = |
102 | 279k | CharSourceRange::getCharRange(InsertionLoc, InsertionLoc); |
103 | 279k | Hint.CodeToInsert = std::string(Code); |
104 | 279k | Hint.BeforePreviousInsertions = BeforePreviousInsertions; |
105 | 279k | return Hint; |
106 | 279k | } |
107 | | |
108 | | /// Create a code modification hint that inserts the given |
109 | | /// code from \p FromRange at a specific location. |
110 | | static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc, |
111 | | CharSourceRange FromRange, |
112 | 118 | bool BeforePreviousInsertions = false) { |
113 | 118 | FixItHint Hint; |
114 | 118 | Hint.RemoveRange = |
115 | 118 | CharSourceRange::getCharRange(InsertionLoc, InsertionLoc); |
116 | 118 | Hint.InsertFromRange = FromRange; |
117 | 118 | Hint.BeforePreviousInsertions = BeforePreviousInsertions; |
118 | 118 | return Hint; |
119 | 118 | } |
120 | | |
121 | | /// Create a code modification hint that removes the given |
122 | | /// source range. |
123 | 32.5k | static FixItHint CreateRemoval(CharSourceRange RemoveRange) { |
124 | 32.5k | FixItHint Hint; |
125 | 32.5k | Hint.RemoveRange = RemoveRange; |
126 | 32.5k | return Hint; |
127 | 32.5k | } |
128 | 31.9k | static FixItHint CreateRemoval(SourceRange RemoveRange) { |
129 | 31.9k | return CreateRemoval(CharSourceRange::getTokenRange(RemoveRange)); |
130 | 31.9k | } |
131 | | |
132 | | /// Create a code modification hint that replaces the given |
133 | | /// source range with the given code string. |
134 | | static FixItHint CreateReplacement(CharSourceRange RemoveRange, |
135 | 38.0k | StringRef Code) { |
136 | 38.0k | FixItHint Hint; |
137 | 38.0k | Hint.RemoveRange = RemoveRange; |
138 | 38.0k | Hint.CodeToInsert = std::string(Code); |
139 | 38.0k | return Hint; |
140 | 38.0k | } |
141 | | |
142 | | static FixItHint CreateReplacement(SourceRange RemoveRange, |
143 | 9.98k | StringRef Code) { |
144 | 9.98k | return CreateReplacement(CharSourceRange::getTokenRange(RemoveRange), Code); |
145 | 9.98k | } |
146 | | }; |
147 | | |
148 | | struct DiagnosticStorage { |
149 | | enum { |
150 | | /// The maximum number of arguments we can hold. We |
151 | | /// currently only support up to 10 arguments (%0-%9). |
152 | | /// |
153 | | /// A single diagnostic with more than that almost certainly has to |
154 | | /// be simplified anyway. |
155 | | MaxArguments = 10 |
156 | | }; |
157 | | |
158 | | /// The number of entries in Arguments. |
159 | | unsigned char NumDiagArgs = 0; |
160 | | |
161 | | /// Specifies for each argument whether it is in DiagArgumentsStr |
162 | | /// or in DiagArguments. |
163 | | unsigned char DiagArgumentsKind[MaxArguments]; |
164 | | |
165 | | /// The values for the various substitution positions. |
166 | | /// |
167 | | /// This is used when the argument is not an std::string. The specific value |
168 | | /// is mangled into an uint64_t and the interpretation depends on exactly |
169 | | /// what sort of argument kind it is. |
170 | | uint64_t DiagArgumentsVal[MaxArguments]; |
171 | | |
172 | | /// The values for the various substitution positions that have |
173 | | /// string arguments. |
174 | | std::string DiagArgumentsStr[MaxArguments]; |
175 | | |
176 | | /// The list of ranges added to this diagnostic. |
177 | | SmallVector<CharSourceRange, 8> DiagRanges; |
178 | | |
179 | | /// If valid, provides a hint with some code to insert, remove, or |
180 | | /// modify at a particular position. |
181 | | SmallVector<FixItHint, 6> FixItHints; |
182 | | |
183 | 1.95M | DiagnosticStorage() = default; |
184 | | }; |
185 | | |
186 | | /// Concrete class used by the front-end to report problems and issues. |
187 | | /// |
188 | | /// This massages the diagnostics (e.g. handling things like "report warnings |
189 | | /// as errors" and passes them off to the DiagnosticConsumer for reporting to |
190 | | /// the user. DiagnosticsEngine is tied to one translation unit and one |
191 | | /// SourceManager. |
192 | | class DiagnosticsEngine : public RefCountedBase<DiagnosticsEngine> { |
193 | | public: |
194 | | /// The level of the diagnostic, after it has been through mapping. |
195 | | enum Level { |
196 | | Ignored = DiagnosticIDs::Ignored, |
197 | | Note = DiagnosticIDs::Note, |
198 | | Remark = DiagnosticIDs::Remark, |
199 | | Warning = DiagnosticIDs::Warning, |
200 | | Error = DiagnosticIDs::Error, |
201 | | Fatal = DiagnosticIDs::Fatal |
202 | | }; |
203 | | |
204 | | enum ArgumentKind { |
205 | | /// std::string |
206 | | ak_std_string, |
207 | | |
208 | | /// const char * |
209 | | ak_c_string, |
210 | | |
211 | | /// int |
212 | | ak_sint, |
213 | | |
214 | | /// unsigned |
215 | | ak_uint, |
216 | | |
217 | | /// enum TokenKind : unsigned |
218 | | ak_tokenkind, |
219 | | |
220 | | /// IdentifierInfo |
221 | | ak_identifierinfo, |
222 | | |
223 | | /// address space |
224 | | ak_addrspace, |
225 | | |
226 | | /// Qualifiers |
227 | | ak_qual, |
228 | | |
229 | | /// QualType |
230 | | ak_qualtype, |
231 | | |
232 | | /// DeclarationName |
233 | | ak_declarationname, |
234 | | |
235 | | /// NamedDecl * |
236 | | ak_nameddecl, |
237 | | |
238 | | /// NestedNameSpecifier * |
239 | | ak_nestednamespec, |
240 | | |
241 | | /// DeclContext * |
242 | | ak_declcontext, |
243 | | |
244 | | /// pair<QualType, QualType> |
245 | | ak_qualtype_pair, |
246 | | |
247 | | /// Attr * |
248 | | ak_attr |
249 | | }; |
250 | | |
251 | | /// Represents on argument value, which is a union discriminated |
252 | | /// by ArgumentKind, with a value. |
253 | | using ArgumentValue = std::pair<ArgumentKind, intptr_t>; |
254 | | |
255 | | private: |
256 | | // Used by __extension__ |
257 | | unsigned char AllExtensionsSilenced = 0; |
258 | | |
259 | | // Treat fatal errors like errors. |
260 | | bool FatalsAsError = false; |
261 | | |
262 | | // Suppress all diagnostics. |
263 | | bool SuppressAllDiagnostics = false; |
264 | | |
265 | | // Elide common types of templates. |
266 | | bool ElideType = true; |
267 | | |
268 | | // Print a tree when comparing templates. |
269 | | bool PrintTemplateTree = false; |
270 | | |
271 | | // Color printing is enabled. |
272 | | bool ShowColors = false; |
273 | | |
274 | | // Which overload candidates to show. |
275 | | OverloadsShown ShowOverloads = Ovl_All; |
276 | | |
277 | | // With Ovl_Best, the number of overload candidates to show when we encounter |
278 | | // an error. |
279 | | // |
280 | | // The value here is the number of candidates to show in the first nontrivial |
281 | | // error. Future errors may show a different number of candidates. |
282 | | unsigned NumOverloadsToShow = 32; |
283 | | |
284 | | // Cap of # errors emitted, 0 -> no limit. |
285 | | unsigned ErrorLimit = 0; |
286 | | |
287 | | // Cap on depth of template backtrace stack, 0 -> no limit. |
288 | | unsigned TemplateBacktraceLimit = 0; |
289 | | |
290 | | // Cap on depth of constexpr evaluation backtrace stack, 0 -> no limit. |
291 | | unsigned ConstexprBacktraceLimit = 0; |
292 | | |
293 | | IntrusiveRefCntPtr<DiagnosticIDs> Diags; |
294 | | IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts; |
295 | | DiagnosticConsumer *Client = nullptr; |
296 | | std::unique_ptr<DiagnosticConsumer> Owner; |
297 | | SourceManager *SourceMgr = nullptr; |
298 | | |
299 | | /// Mapping information for diagnostics. |
300 | | /// |
301 | | /// Mapping info is packed into four bits per diagnostic. The low three |
302 | | /// bits are the mapping (an instance of diag::Severity), or zero if unset. |
303 | | /// The high bit is set when the mapping was established as a user mapping. |
304 | | /// If the high bit is clear, then the low bits are set to the default |
305 | | /// value, and should be mapped with -pedantic, -Werror, etc. |
306 | | /// |
307 | | /// A new DiagState is created and kept around when diagnostic pragmas modify |
308 | | /// the state so that we know what is the diagnostic state at any given |
309 | | /// source location. |
310 | | class DiagState { |
311 | | llvm::DenseMap<unsigned, DiagnosticMapping> DiagMap; |
312 | | |
313 | | public: |
314 | | // "Global" configuration state that can actually vary between modules. |
315 | | |
316 | | // Ignore all warnings: -w |
317 | | unsigned IgnoreAllWarnings : 1; |
318 | | |
319 | | // Enable all warnings. |
320 | | unsigned EnableAllWarnings : 1; |
321 | | |
322 | | // Treat warnings like errors. |
323 | | unsigned WarningsAsErrors : 1; |
324 | | |
325 | | // Treat errors like fatal errors. |
326 | | unsigned ErrorsAsFatal : 1; |
327 | | |
328 | | // Suppress warnings in system headers. |
329 | | unsigned SuppressSystemWarnings : 1; |
330 | | |
331 | | // Map extensions to warnings or errors? |
332 | | diag::Severity ExtBehavior = diag::Severity::Ignored; |
333 | | |
334 | | DiagState() |
335 | | : IgnoreAllWarnings(false), EnableAllWarnings(false), |
336 | | WarningsAsErrors(false), ErrorsAsFatal(false), |
337 | 422k | SuppressSystemWarnings(false) {} |
338 | | |
339 | | using iterator = llvm::DenseMap<unsigned, DiagnosticMapping>::iterator; |
340 | | using const_iterator = |
341 | | llvm::DenseMap<unsigned, DiagnosticMapping>::const_iterator; |
342 | | |
343 | 3.96M | void setMapping(diag::kind Diag, DiagnosticMapping Info) { |
344 | 3.96M | DiagMap[Diag] = Info; |
345 | 3.96M | } |
346 | | |
347 | 0 | DiagnosticMapping lookupMapping(diag::kind Diag) const { |
348 | 0 | return DiagMap.lookup(Diag); |
349 | 0 | } |
350 | | |
351 | | DiagnosticMapping &getOrAddMapping(diag::kind Diag); |
352 | | |
353 | 14.4k | const_iterator begin() const { return DiagMap.begin(); } |
354 | 14.4k | const_iterator end() const { return DiagMap.end(); } |
355 | | }; |
356 | | |
357 | | /// Keeps and automatically disposes all DiagStates that we create. |
358 | | std::list<DiagState> DiagStates; |
359 | | |
360 | | /// A mapping from files to the diagnostic states for those files. Lazily |
361 | | /// built on demand for files in which the diagnostic state has not changed. |
362 | | class DiagStateMap { |
363 | | public: |
364 | | /// Add an initial diagnostic state. |
365 | | void appendFirst(DiagState *State); |
366 | | |
367 | | /// Add a new latest state point. |
368 | | void append(SourceManager &SrcMgr, SourceLocation Loc, DiagState *State); |
369 | | |
370 | | /// Look up the diagnostic state at a given source location. |
371 | | DiagState *lookup(SourceManager &SrcMgr, SourceLocation Loc) const; |
372 | | |
373 | | /// Determine whether this map is empty. |
374 | 255k | bool empty() const { return Files.empty(); } |
375 | | |
376 | | /// Clear out this map. |
377 | 421k | void clear() { |
378 | 421k | Files.clear(); |
379 | 421k | FirstDiagState = CurDiagState = nullptr; |
380 | 421k | CurDiagStateLoc = SourceLocation(); |
381 | 421k | } |
382 | | |
383 | | /// Produce a debugging dump of the diagnostic state. |
384 | | LLVM_DUMP_METHOD void dump(SourceManager &SrcMgr, |
385 | | StringRef DiagName = StringRef()) const; |
386 | | |
387 | | /// Grab the most-recently-added state point. |
388 | 33.2M | DiagState *getCurDiagState() const { return CurDiagState; } |
389 | | |
390 | | /// Get the location at which a diagnostic state was last added. |
391 | 1.31M | SourceLocation getCurDiagStateLoc() const { return CurDiagStateLoc; } |
392 | | |
393 | | private: |
394 | | friend class ASTReader; |
395 | | friend class ASTWriter; |
396 | | |
397 | | /// Represents a point in source where the diagnostic state was |
398 | | /// modified because of a pragma. |
399 | | /// |
400 | | /// 'Loc' can be null if the point represents the diagnostic state |
401 | | /// modifications done through the command-line. |
402 | | struct DiagStatePoint { |
403 | | DiagState *State; |
404 | | unsigned Offset; |
405 | | |
406 | | DiagStatePoint(DiagState *State, unsigned Offset) |
407 | 5.46M | : State(State), Offset(Offset) {} |
408 | | }; |
409 | | |
410 | | /// Description of the diagnostic states and state transitions for a |
411 | | /// particular FileID. |
412 | | struct File { |
413 | | /// The diagnostic state for the parent file. This is strictly redundant, |
414 | | /// as looking up the DecomposedIncludedLoc for the FileID in the Files |
415 | | /// map would give us this, but we cache it here for performance. |
416 | | File *Parent = nullptr; |
417 | | |
418 | | /// The offset of this file within its parent. |
419 | | unsigned ParentOffset = 0; |
420 | | |
421 | | /// Whether this file has any local (not imported from an AST file) |
422 | | /// diagnostic state transitions. |
423 | | bool HasLocalTransitions = false; |
424 | | |
425 | | /// The points within the file where the state changes. There will always |
426 | | /// be at least one of these (the state on entry to the file). |
427 | | llvm::SmallVector<DiagStatePoint, 4> StateTransitions; |
428 | | |
429 | | DiagState *lookup(unsigned Offset) const; |
430 | | }; |
431 | | |
432 | | /// The diagnostic states for each file. |
433 | | mutable std::map<FileID, File> Files; |
434 | | |
435 | | /// The initial diagnostic state. |
436 | | DiagState *FirstDiagState; |
437 | | |
438 | | /// The current diagnostic state. |
439 | | DiagState *CurDiagState; |
440 | | |
441 | | /// The location at which the current diagnostic state was established. |
442 | | SourceLocation CurDiagStateLoc; |
443 | | |
444 | | /// Get the diagnostic state information for a file. |
445 | | File *getFile(SourceManager &SrcMgr, FileID ID) const; |
446 | | }; |
447 | | |
448 | | DiagStateMap DiagStatesByLoc; |
449 | | |
450 | | /// Keeps the DiagState that was active during each diagnostic 'push' |
451 | | /// so we can get back at it when we 'pop'. |
452 | | std::vector<DiagState *> DiagStateOnPushStack; |
453 | | |
454 | 25.3M | DiagState *GetCurDiagState() const { |
455 | 25.3M | return DiagStatesByLoc.getCurDiagState(); |
456 | 25.3M | } |
457 | | |
458 | | void PushDiagStatePoint(DiagState *State, SourceLocation L); |
459 | | |
460 | | /// Finds the DiagStatePoint that contains the diagnostic state of |
461 | | /// the given source location. |
462 | 180M | DiagState *GetDiagStateForLoc(SourceLocation Loc) const { |
463 | 180M | return SourceMgr ? DiagStatesByLoc.lookup(*SourceMgr, Loc)180M |
464 | 180M | : DiagStatesByLoc.getCurDiagState()131k ; |
465 | 180M | } |
466 | | |
467 | | /// Sticky flag set to \c true when an error is emitted. |
468 | | bool ErrorOccurred; |
469 | | |
470 | | /// Sticky flag set to \c true when an "uncompilable error" occurs. |
471 | | /// I.e. an error that was not upgraded from a warning by -Werror. |
472 | | bool UncompilableErrorOccurred; |
473 | | |
474 | | /// Sticky flag set to \c true when a fatal error is emitted. |
475 | | bool FatalErrorOccurred; |
476 | | |
477 | | /// Indicates that an unrecoverable error has occurred. |
478 | | bool UnrecoverableErrorOccurred; |
479 | | |
480 | | /// Counts for DiagnosticErrorTrap to check whether an error occurred |
481 | | /// during a parsing section, e.g. during parsing a function. |
482 | | unsigned TrapNumErrorsOccurred; |
483 | | unsigned TrapNumUnrecoverableErrorsOccurred; |
484 | | |
485 | | /// The level of the last diagnostic emitted. |
486 | | /// |
487 | | /// This is used to emit continuation diagnostics with the same level as the |
488 | | /// diagnostic that they follow. |
489 | | DiagnosticIDs::Level LastDiagLevel; |
490 | | |
491 | | /// Number of warnings reported |
492 | | unsigned NumWarnings; |
493 | | |
494 | | /// Number of errors reported |
495 | | unsigned NumErrors; |
496 | | |
497 | | /// A function pointer that converts an opaque diagnostic |
498 | | /// argument to a strings. |
499 | | /// |
500 | | /// This takes the modifiers and argument that was present in the diagnostic. |
501 | | /// |
502 | | /// The PrevArgs array indicates the previous arguments formatted for this |
503 | | /// diagnostic. Implementations of this function can use this information to |
504 | | /// avoid redundancy across arguments. |
505 | | /// |
506 | | /// This is a hack to avoid a layering violation between libbasic and libsema. |
507 | | using ArgToStringFnTy = void (*)( |
508 | | ArgumentKind Kind, intptr_t Val, |
509 | | StringRef Modifier, StringRef Argument, |
510 | | ArrayRef<ArgumentValue> PrevArgs, |
511 | | SmallVectorImpl<char> &Output, |
512 | | void *Cookie, |
513 | | ArrayRef<intptr_t> QualTypeVals); |
514 | | |
515 | | void *ArgToStringCookie = nullptr; |
516 | | ArgToStringFnTy ArgToStringFn; |
517 | | |
518 | | /// ID of the "delayed" diagnostic, which is a (typically |
519 | | /// fatal) diagnostic that had to be delayed because it was found |
520 | | /// while emitting another diagnostic. |
521 | | unsigned DelayedDiagID; |
522 | | |
523 | | /// First string argument for the delayed diagnostic. |
524 | | std::string DelayedDiagArg1; |
525 | | |
526 | | /// Second string argument for the delayed diagnostic. |
527 | | std::string DelayedDiagArg2; |
528 | | |
529 | | /// Third string argument for the delayed diagnostic. |
530 | | std::string DelayedDiagArg3; |
531 | | |
532 | | /// Optional flag value. |
533 | | /// |
534 | | /// Some flags accept values, for instance: -Wframe-larger-than=<value> and |
535 | | /// -Rpass=<value>. The content of this string is emitted after the flag name |
536 | | /// and '='. |
537 | | std::string FlagValue; |
538 | | |
539 | | public: |
540 | | explicit DiagnosticsEngine(IntrusiveRefCntPtr<DiagnosticIDs> Diags, |
541 | | IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, |
542 | | DiagnosticConsumer *client = nullptr, |
543 | | bool ShouldOwnClient = true); |
544 | | DiagnosticsEngine(const DiagnosticsEngine &) = delete; |
545 | | DiagnosticsEngine &operator=(const DiagnosticsEngine &) = delete; |
546 | | ~DiagnosticsEngine(); |
547 | | |
548 | | LLVM_DUMP_METHOD void dump() const; |
549 | | LLVM_DUMP_METHOD void dump(StringRef DiagName) const; |
550 | | |
551 | 3.49M | const IntrusiveRefCntPtr<DiagnosticIDs> &getDiagnosticIDs() const { |
552 | 3.49M | return Diags; |
553 | 3.49M | } |
554 | | |
555 | | /// Retrieve the diagnostic options. |
556 | 22.0M | DiagnosticOptions &getDiagnosticOptions() const { return *DiagOpts; } |
557 | | |
558 | | using diag_mapping_range = llvm::iterator_range<DiagState::const_iterator>; |
559 | | |
560 | | /// Get the current set of diagnostic mappings. |
561 | 3.70k | diag_mapping_range getDiagnosticMappings() const { |
562 | 3.70k | const DiagState &DS = *GetCurDiagState(); |
563 | 3.70k | return diag_mapping_range(DS.begin(), DS.end()); |
564 | 3.70k | } |
565 | | |
566 | 22.8M | DiagnosticConsumer *getClient() { return Client; } |
567 | 0 | const DiagnosticConsumer *getClient() const { return Client; } |
568 | | |
569 | | /// Determine whether this \c DiagnosticsEngine object own its client. |
570 | 17.6k | bool ownsClient() const { return Owner != nullptr; } |
571 | | |
572 | | /// Return the current diagnostic client along with ownership of that |
573 | | /// client. |
574 | 54.7k | std::unique_ptr<DiagnosticConsumer> takeClient() { return std::move(Owner); } |
575 | | |
576 | 432k | bool hasSourceManager() const { return SourceMgr != nullptr; } |
577 | | |
578 | 21.5M | SourceManager &getSourceManager() const { |
579 | 21.5M | assert(SourceMgr && "SourceManager not set!"); |
580 | 0 | return *SourceMgr; |
581 | 21.5M | } |
582 | | |
583 | 255k | void setSourceManager(SourceManager *SrcMgr) { |
584 | 255k | assert(DiagStatesByLoc.empty() && |
585 | 255k | "Leftover diag state from a different SourceManager."); |
586 | 0 | SourceMgr = SrcMgr; |
587 | 255k | } |
588 | | |
589 | | //===--------------------------------------------------------------------===// |
590 | | // DiagnosticsEngine characterization methods, used by a client to customize |
591 | | // how diagnostics are emitted. |
592 | | // |
593 | | |
594 | | /// Copies the current DiagMappings and pushes the new copy |
595 | | /// onto the top of the stack. |
596 | | void pushMappings(SourceLocation Loc); |
597 | | |
598 | | /// Pops the current DiagMappings off the top of the stack, |
599 | | /// causing the new top of the stack to be the active mappings. |
600 | | /// |
601 | | /// \returns \c true if the pop happens, \c false if there is only one |
602 | | /// DiagMapping on the stack. |
603 | | bool popMappings(SourceLocation Loc); |
604 | | |
605 | | /// Set the diagnostic client associated with this diagnostic object. |
606 | | /// |
607 | | /// \param ShouldOwnClient true if the diagnostic object should take |
608 | | /// ownership of \c client. |
609 | | void setClient(DiagnosticConsumer *client, bool ShouldOwnClient = true); |
610 | | |
611 | | /// Specify a limit for the number of errors we should |
612 | | /// emit before giving up. |
613 | | /// |
614 | | /// Zero disables the limit. |
615 | 59.8k | void setErrorLimit(unsigned Limit) { ErrorLimit = Limit; } |
616 | | |
617 | | /// Specify the maximum number of template instantiation |
618 | | /// notes to emit along with a given diagnostic. |
619 | 147k | void setTemplateBacktraceLimit(unsigned Limit) { |
620 | 147k | TemplateBacktraceLimit = Limit; |
621 | 147k | } |
622 | | |
623 | | /// Retrieve the maximum number of template instantiation |
624 | | /// notes to emit along with a given diagnostic. |
625 | 6.04k | unsigned getTemplateBacktraceLimit() const { |
626 | 6.04k | return TemplateBacktraceLimit; |
627 | 6.04k | } |
628 | | |
629 | | /// Specify the maximum number of constexpr evaluation |
630 | | /// notes to emit along with a given diagnostic. |
631 | 147k | void setConstexprBacktraceLimit(unsigned Limit) { |
632 | 147k | ConstexprBacktraceLimit = Limit; |
633 | 147k | } |
634 | | |
635 | | /// Retrieve the maximum number of constexpr evaluation |
636 | | /// notes to emit along with a given diagnostic. |
637 | 769k | unsigned getConstexprBacktraceLimit() const { |
638 | 769k | return ConstexprBacktraceLimit; |
639 | 769k | } |
640 | | |
641 | | /// When set to true, any unmapped warnings are ignored. |
642 | | /// |
643 | | /// If this and WarningsAsErrors are both set, then this one wins. |
644 | 197k | void setIgnoreAllWarnings(bool Val) { |
645 | 197k | GetCurDiagState()->IgnoreAllWarnings = Val; |
646 | 197k | } |
647 | 3.13M | bool getIgnoreAllWarnings() const { |
648 | 3.13M | return GetCurDiagState()->IgnoreAllWarnings; |
649 | 3.13M | } |
650 | | |
651 | | /// When set to true, any unmapped ignored warnings are no longer |
652 | | /// ignored. |
653 | | /// |
654 | | /// If this and IgnoreAllWarnings are both set, then that one wins. |
655 | 48 | void setEnableAllWarnings(bool Val) { |
656 | 48 | GetCurDiagState()->EnableAllWarnings = Val; |
657 | 48 | } |
658 | 43 | bool getEnableAllWarnings() const { |
659 | 43 | return GetCurDiagState()->EnableAllWarnings; |
660 | 43 | } |
661 | | |
662 | | /// When set to true, any warnings reported are issued as errors. |
663 | 4.93k | void setWarningsAsErrors(bool Val) { |
664 | 4.93k | GetCurDiagState()->WarningsAsErrors = Val; |
665 | 4.93k | } |
666 | 3.77k | bool getWarningsAsErrors() const { |
667 | 3.77k | return GetCurDiagState()->WarningsAsErrors; |
668 | 3.77k | } |
669 | | |
670 | | /// When set to true, any error reported is made a fatal error. |
671 | 2 | void setErrorsAsFatal(bool Val) { GetCurDiagState()->ErrorsAsFatal = Val; } |
672 | 0 | bool getErrorsAsFatal() const { return GetCurDiagState()->ErrorsAsFatal; } |
673 | | |
674 | | /// \brief When set to true, any fatal error reported is made an error. |
675 | | /// |
676 | | /// This setting takes precedence over the setErrorsAsFatal setting above. |
677 | 7 | void setFatalsAsError(bool Val) { FatalsAsError = Val; } |
678 | 0 | bool getFatalsAsError() const { return FatalsAsError; } |
679 | | |
680 | | /// When set to true mask warnings that come from system headers. |
681 | 147k | void setSuppressSystemWarnings(bool Val) { |
682 | 147k | GetCurDiagState()->SuppressSystemWarnings = Val; |
683 | 147k | } |
684 | 16.9M | bool getSuppressSystemWarnings() const { |
685 | 16.9M | return GetCurDiagState()->SuppressSystemWarnings; |
686 | 16.9M | } |
687 | | |
688 | | /// Suppress all diagnostics, to silence the front end when we |
689 | | /// know that we don't want any more diagnostics to be passed along to the |
690 | | /// client |
691 | 1.41k | void setSuppressAllDiagnostics(bool Val) { SuppressAllDiagnostics = Val; } |
692 | 3.53M | bool getSuppressAllDiagnostics() const { return SuppressAllDiagnostics; } |
693 | | |
694 | | /// Set type eliding, to skip outputting same types occurring in |
695 | | /// template types. |
696 | 147k | void setElideType(bool Val) { ElideType = Val; } |
697 | 0 | bool getElideType() { return ElideType; } |
698 | | |
699 | | /// Set tree printing, to outputting the template difference in a |
700 | | /// tree format. |
701 | 147k | void setPrintTemplateTree(bool Val) { PrintTemplateTree = Val; } |
702 | 0 | bool getPrintTemplateTree() { return PrintTemplateTree; } |
703 | | |
704 | | /// Set color printing, so the type diffing will inject color markers |
705 | | /// into the output. |
706 | 147k | void setShowColors(bool Val) { ShowColors = Val; } |
707 | 1.70k | bool getShowColors() { return ShowColors; } |
708 | | |
709 | | /// Specify which overload candidates to show when overload resolution |
710 | | /// fails. |
711 | | /// |
712 | | /// By default, we show all candidates. |
713 | 147k | void setShowOverloads(OverloadsShown Val) { |
714 | 147k | ShowOverloads = Val; |
715 | 147k | } |
716 | 36.8k | OverloadsShown getShowOverloads() const { return ShowOverloads; } |
717 | | |
718 | | /// When a call or operator fails, print out up to this many candidate |
719 | | /// overloads as suggestions. |
720 | | /// |
721 | | /// With Ovl_Best, we set a high limit for the first nontrivial overload set |
722 | | /// we print, and a lower limit for later sets. This way the user has a |
723 | | /// chance of diagnosing at least one callsite in their program without |
724 | | /// having to recompile with -fshow-overloads=all. |
725 | 18.0k | unsigned getNumOverloadCandidatesToShow() const { |
726 | 18.0k | switch (getShowOverloads()) { |
727 | 17.9k | case Ovl_All: |
728 | | // INT_MAX rather than UINT_MAX so that we don't have to think about the |
729 | | // effect of implicit conversions on this value. In practice we'll never |
730 | | // hit 2^31 candidates anyway. |
731 | 17.9k | return std::numeric_limits<int>::max(); |
732 | 74 | case Ovl_Best: |
733 | 74 | return NumOverloadsToShow; |
734 | 18.0k | } |
735 | 0 | llvm_unreachable("invalid OverloadsShown kind"); |
736 | 0 | } |
737 | | |
738 | | /// Call this after showing N overload candidates. This influences the value |
739 | | /// returned by later calls to getNumOverloadCandidatesToShow(). |
740 | 18.8k | void overloadCandidatesShown(unsigned N) { |
741 | | // Current heuristic: Start out with a large value for NumOverloadsToShow, |
742 | | // and then once we print one nontrivially-large overload set, decrease it |
743 | | // for future calls. |
744 | 18.8k | if (N > 4) { |
745 | 465 | NumOverloadsToShow = 4; |
746 | 465 | } |
747 | 18.8k | } |
748 | | |
749 | | /// Pretend that the last diagnostic issued was ignored, so any |
750 | | /// subsequent notes will be suppressed, or restore a prior ignoring |
751 | | /// state after ignoring some diagnostics and their notes, possibly in |
752 | | /// the middle of another diagnostic. |
753 | | /// |
754 | | /// This can be used by clients who suppress diagnostics themselves. |
755 | 2.42M | void setLastDiagnosticIgnored(bool Ignored) { |
756 | 2.42M | if (LastDiagLevel == DiagnosticIDs::Fatal) |
757 | 8 | FatalErrorOccurred = true; |
758 | 2.42M | LastDiagLevel = Ignored ? DiagnosticIDs::Ignored2.21M : DiagnosticIDs::Warning205k ; |
759 | 2.42M | } |
760 | | |
761 | | /// Determine whether the previous diagnostic was ignored. This can |
762 | | /// be used by clients that want to determine whether notes attached to a |
763 | | /// diagnostic will be suppressed. |
764 | 2.25M | bool isLastDiagnosticIgnored() const { |
765 | 2.25M | return LastDiagLevel == DiagnosticIDs::Ignored; |
766 | 2.25M | } |
767 | | |
768 | | /// Controls whether otherwise-unmapped extension diagnostics are |
769 | | /// mapped onto ignore/warning/error. |
770 | | /// |
771 | | /// This corresponds to the GCC -pedantic and -pedantic-errors option. |
772 | 147k | void setExtensionHandlingBehavior(diag::Severity H) { |
773 | 147k | GetCurDiagState()->ExtBehavior = H; |
774 | 147k | } |
775 | 9.66k | diag::Severity getExtensionHandlingBehavior() const { |
776 | 9.66k | return GetCurDiagState()->ExtBehavior; |
777 | 9.66k | } |
778 | | |
779 | | /// Counter bumped when an __extension__ block is/ encountered. |
780 | | /// |
781 | | /// When non-zero, all extension diagnostics are entirely silenced, no |
782 | | /// matter how they are mapped. |
783 | 36.5k | void IncrementAllExtensionsSilenced() { ++AllExtensionsSilenced; } |
784 | 36.5k | void DecrementAllExtensionsSilenced() { --AllExtensionsSilenced; } |
785 | 116M | bool hasAllExtensionsSilenced() { return AllExtensionsSilenced != 0; } |
786 | | |
787 | | /// This allows the client to specify that certain warnings are |
788 | | /// ignored. |
789 | | /// |
790 | | /// Notes can never be mapped, errors can only be mapped to fatal, and |
791 | | /// WARNINGs and EXTENSIONs can be mapped arbitrarily. |
792 | | /// |
793 | | /// \param Loc The source location that this change of diagnostic state should |
794 | | /// take affect. It can be null if we are setting the latest state. |
795 | | void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc); |
796 | | |
797 | | /// Change an entire diagnostic group (e.g. "unknown-pragmas") to |
798 | | /// have the specified mapping. |
799 | | /// |
800 | | /// \returns true (and ignores the request) if "Group" was unknown, false |
801 | | /// otherwise. |
802 | | /// |
803 | | /// \param Flavor The flavor of group to affect. -Rfoo does not affect the |
804 | | /// state of the -Wfoo group and vice versa. |
805 | | /// |
806 | | /// \param Loc The source location that this change of diagnostic state should |
807 | | /// take affect. It can be null if we are setting the state from command-line. |
808 | | bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group, |
809 | | diag::Severity Map, |
810 | | SourceLocation Loc = SourceLocation()); |
811 | | bool setSeverityForGroup(diag::Flavor Flavor, diag::Group Group, |
812 | | diag::Severity Map, |
813 | | SourceLocation Loc = SourceLocation()); |
814 | | |
815 | | /// Set the warning-as-error flag for the given diagnostic group. |
816 | | /// |
817 | | /// This function always only operates on the current diagnostic state. |
818 | | /// |
819 | | /// \returns True if the given group is unknown, false otherwise. |
820 | | bool setDiagnosticGroupWarningAsError(StringRef Group, bool Enabled); |
821 | | |
822 | | /// Set the error-as-fatal flag for the given diagnostic group. |
823 | | /// |
824 | | /// This function always only operates on the current diagnostic state. |
825 | | /// |
826 | | /// \returns True if the given group is unknown, false otherwise. |
827 | | bool setDiagnosticGroupErrorAsFatal(StringRef Group, bool Enabled); |
828 | | |
829 | | /// Add the specified mapping to all diagnostics of the specified |
830 | | /// flavor. |
831 | | /// |
832 | | /// Mainly to be used by -Wno-everything to disable all warnings but allow |
833 | | /// subsequent -W options to enable specific warnings. |
834 | | void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map, |
835 | | SourceLocation Loc = SourceLocation()); |
836 | | |
837 | 22.9M | bool hasErrorOccurred() const { return ErrorOccurred; } |
838 | | |
839 | | /// Errors that actually prevent compilation, not those that are |
840 | | /// upgraded from a warning by -Werror. |
841 | 11.0M | bool hasUncompilableErrorOccurred() const { |
842 | 11.0M | return UncompilableErrorOccurred; |
843 | 11.0M | } |
844 | 6.55M | bool hasFatalErrorOccurred() const { return FatalErrorOccurred; } |
845 | | |
846 | | /// Determine whether any kind of unrecoverable error has occurred. |
847 | 104 | bool hasUnrecoverableErrorOccurred() const { |
848 | 104 | return FatalErrorOccurred || UnrecoverableErrorOccurred102 ; |
849 | 104 | } |
850 | | |
851 | 4.04M | unsigned getNumErrors() const { return NumErrors; } |
852 | 71.0k | unsigned getNumWarnings() const { return NumWarnings; } |
853 | | |
854 | 501 | void setNumWarnings(unsigned NumWarnings) { |
855 | 501 | this->NumWarnings = NumWarnings; |
856 | 501 | } |
857 | | |
858 | | /// Return an ID for a diagnostic with the specified format string and |
859 | | /// level. |
860 | | /// |
861 | | /// If this is the first request for this diagnostic, it is registered and |
862 | | /// created, otherwise the existing ID is returned. |
863 | | /// |
864 | | /// \param FormatString A fixed diagnostic format string that will be hashed |
865 | | /// and mapped to a unique DiagID. |
866 | | template <unsigned N> |
867 | 4.52k | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { |
868 | 4.52k | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, |
869 | 4.52k | StringRef(FormatString, N - 1)); |
870 | 4.52k | } unsigned int clang::DiagnosticsEngine::getCustomDiagID<27u>(clang::DiagnosticsEngine::Level, char const (&) [27u]) Line | Count | Source | 867 | 36 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 36 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 36 | StringRef(FormatString, N - 1)); | 870 | 36 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<37u>(clang::DiagnosticsEngine::Level, char const (&) [37u]) Line | Count | Source | 867 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 2 | StringRef(FormatString, N - 1)); | 870 | 2 | } |
Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<58u>(clang::DiagnosticsEngine::Level, char const (&) [58u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<38u>(clang::DiagnosticsEngine::Level, char const (&) [38u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<63u>(clang::DiagnosticsEngine::Level, char const (&) [63u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<42u>(clang::DiagnosticsEngine::Level, char const (&) [42u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<39u>(clang::DiagnosticsEngine::Level, char const (&) [39u]) unsigned int clang::DiagnosticsEngine::getCustomDiagID<50u>(clang::DiagnosticsEngine::Level, char const (&) [50u]) Line | Count | Source | 867 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 2 | StringRef(FormatString, N - 1)); | 870 | 2 | } |
Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<62u>(clang::DiagnosticsEngine::Level, char const (&) [62u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<46u>(clang::DiagnosticsEngine::Level, char const (&) [46u]) unsigned int clang::DiagnosticsEngine::getCustomDiagID<40u>(clang::DiagnosticsEngine::Level, char const (&) [40u]) Line | Count | Source | 867 | 1 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 1 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 1 | StringRef(FormatString, N - 1)); | 870 | 1 | } |
Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<34u>(clang::DiagnosticsEngine::Level, char const (&) [34u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<35u>(clang::DiagnosticsEngine::Level, char const (&) [35u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<66u>(clang::DiagnosticsEngine::Level, char const (&) [66u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<52u>(clang::DiagnosticsEngine::Level, char const (&) [52u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<44u>(clang::DiagnosticsEngine::Level, char const (&) [44u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<43u>(clang::DiagnosticsEngine::Level, char const (&) [43u]) unsigned int clang::DiagnosticsEngine::getCustomDiagID<60u>(clang::DiagnosticsEngine::Level, char const (&) [60u]) Line | Count | Source | 867 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 2 | StringRef(FormatString, N - 1)); | 870 | 2 | } |
Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<51u>(clang::DiagnosticsEngine::Level, char const (&) [51u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<36u>(clang::DiagnosticsEngine::Level, char const (&) [36u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<49u>(clang::DiagnosticsEngine::Level, char const (&) [49u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<41u>(clang::DiagnosticsEngine::Level, char const (&) [41u]) unsigned int clang::DiagnosticsEngine::getCustomDiagID<61u>(clang::DiagnosticsEngine::Level, char const (&) [61u]) Line | Count | Source | 867 | 164 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 164 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 164 | StringRef(FormatString, N - 1)); | 870 | 164 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<20u>(clang::DiagnosticsEngine::Level, char const (&) [20u]) Line | Count | Source | 867 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 2 | StringRef(FormatString, N - 1)); | 870 | 2 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<3u>(clang::DiagnosticsEngine::Level, char const (&) [3u]) Line | Count | Source | 867 | 3.78k | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 3.78k | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 3.78k | StringRef(FormatString, N - 1)); | 870 | 3.78k | } |
Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<47u>(clang::DiagnosticsEngine::Level, char const (&) [47u]) unsigned int clang::DiagnosticsEngine::getCustomDiagID<88u>(clang::DiagnosticsEngine::Level, char const (&) [88u]) Line | Count | Source | 867 | 1 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 1 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 1 | StringRef(FormatString, N - 1)); | 870 | 1 | } |
Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<133u>(clang::DiagnosticsEngine::Level, char const (&) [133u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<26u>(clang::DiagnosticsEngine::Level, char const (&) [26u]) unsigned int clang::DiagnosticsEngine::getCustomDiagID<54u>(clang::DiagnosticsEngine::Level, char const (&) [54u]) Line | Count | Source | 867 | 250 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 250 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 250 | StringRef(FormatString, N - 1)); | 870 | 250 | } |
Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<73u>(clang::DiagnosticsEngine::Level, char const (&) [73u]) unsigned int clang::DiagnosticsEngine::getCustomDiagID<82u>(clang::DiagnosticsEngine::Level, char const (&) [82u]) Line | Count | Source | 867 | 6 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 6 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 6 | StringRef(FormatString, N - 1)); | 870 | 6 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<141u>(clang::DiagnosticsEngine::Level, char const (&) [141u]) Line | Count | Source | 867 | 22 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 22 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 22 | StringRef(FormatString, N - 1)); | 870 | 22 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<96u>(clang::DiagnosticsEngine::Level, char const (&) [96u]) Line | Count | Source | 867 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 2 | StringRef(FormatString, N - 1)); | 870 | 2 | } |
Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<86u>(clang::DiagnosticsEngine::Level, char const (&) [86u]) Unexecuted instantiation: unsigned int clang::DiagnosticsEngine::getCustomDiagID<83u>(clang::DiagnosticsEngine::Level, char const (&) [83u]) unsigned int clang::DiagnosticsEngine::getCustomDiagID<30u>(clang::DiagnosticsEngine::Level, char const (&) [30u]) Line | Count | Source | 867 | 1 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 1 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 1 | StringRef(FormatString, N - 1)); | 870 | 1 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<124u>(clang::DiagnosticsEngine::Level, char const (&) [124u]) Line | Count | Source | 867 | 10 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 10 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 10 | StringRef(FormatString, N - 1)); | 870 | 10 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<95u>(clang::DiagnosticsEngine::Level, char const (&) [95u]) Line | Count | Source | 867 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 2 | StringRef(FormatString, N - 1)); | 870 | 2 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<68u>(clang::DiagnosticsEngine::Level, char const (&) [68u]) Line | Count | Source | 867 | 78 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 78 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 78 | StringRef(FormatString, N - 1)); | 870 | 78 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<113u>(clang::DiagnosticsEngine::Level, char const (&) [113u]) Line | Count | Source | 867 | 164 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 868 | 164 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 869 | 164 | StringRef(FormatString, N - 1)); | 870 | 164 | } |
|
871 | | |
872 | | /// Converts a diagnostic argument (as an intptr_t) into the string |
873 | | /// that represents it. |
874 | | void ConvertArgToString(ArgumentKind Kind, intptr_t Val, |
875 | | StringRef Modifier, StringRef Argument, |
876 | | ArrayRef<ArgumentValue> PrevArgs, |
877 | | SmallVectorImpl<char> &Output, |
878 | 168k | ArrayRef<intptr_t> QualTypeVals) const { |
879 | 168k | ArgToStringFn(Kind, Val, Modifier, Argument, PrevArgs, Output, |
880 | 168k | ArgToStringCookie, QualTypeVals); |
881 | 168k | } |
882 | | |
883 | 87.0k | void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie) { |
884 | 87.0k | ArgToStringFn = Fn; |
885 | 87.0k | ArgToStringCookie = Cookie; |
886 | 87.0k | } |
887 | | |
888 | | /// Note that the prior diagnostic was emitted by some other |
889 | | /// \c DiagnosticsEngine, and we may be attaching a note to that diagnostic. |
890 | 3.11M | void notePriorDiagnosticFrom(const DiagnosticsEngine &Other) { |
891 | 3.11M | LastDiagLevel = Other.LastDiagLevel; |
892 | 3.11M | } |
893 | | |
894 | | /// Reset the state of the diagnostic object to its initial |
895 | | /// configuration. |
896 | | void Reset(); |
897 | | |
898 | | //===--------------------------------------------------------------------===// |
899 | | // DiagnosticsEngine classification and reporting interfaces. |
900 | | // |
901 | | |
902 | | /// Determine whether the diagnostic is known to be ignored. |
903 | | /// |
904 | | /// This can be used to opportunistically avoid expensive checks when it's |
905 | | /// known for certain that the diagnostic has been suppressed at the |
906 | | /// specified location \p Loc. |
907 | | /// |
908 | | /// \param Loc The source location we are interested in finding out the |
909 | | /// diagnostic state. Can be null in order to query the latest state. |
910 | 168M | bool isIgnored(unsigned DiagID, SourceLocation Loc) const { |
911 | 168M | return Diags->getDiagnosticSeverity(DiagID, Loc, *this) == |
912 | 168M | diag::Severity::Ignored; |
913 | 168M | } |
914 | | |
915 | | /// Based on the way the client configured the DiagnosticsEngine |
916 | | /// object, classify the specified diagnostic ID into a Level, consumable by |
917 | | /// the DiagnosticConsumer. |
918 | | /// |
919 | | /// To preserve invariant assumptions, this function should not be used to |
920 | | /// influence parse or semantic analysis actions. Instead consider using |
921 | | /// \c isIgnored(). |
922 | | /// |
923 | | /// \param Loc The source location we are interested in finding out the |
924 | | /// diagnostic state. Can be null in order to query the latest state. |
925 | 3.08M | Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const { |
926 | 3.08M | return (Level)Diags->getDiagnosticLevel(DiagID, Loc, *this); |
927 | 3.08M | } |
928 | | |
929 | | /// Issue the message to the client. |
930 | | /// |
931 | | /// This actually returns an instance of DiagnosticBuilder which emits the |
932 | | /// diagnostics (through @c ProcessDiag) when it is destroyed. |
933 | | /// |
934 | | /// \param DiagID A member of the @c diag::kind enum. |
935 | | /// \param Loc Represents the source location associated with the diagnostic, |
936 | | /// which can be an invalid location if no position information is available. |
937 | | inline DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID); |
938 | | inline DiagnosticBuilder Report(unsigned DiagID); |
939 | | |
940 | | void Report(const StoredDiagnostic &storedDiag); |
941 | | |
942 | | /// Determine whethere there is already a diagnostic in flight. |
943 | 23 | bool isDiagnosticInFlight() const { |
944 | 23 | return CurDiagID != std::numeric_limits<unsigned>::max(); |
945 | 23 | } |
946 | | |
947 | | /// Set the "delayed" diagnostic that will be emitted once |
948 | | /// the current diagnostic completes. |
949 | | /// |
950 | | /// If a diagnostic is already in-flight but the front end must |
951 | | /// report a problem (e.g., with an inconsistent file system |
952 | | /// state), this routine sets a "delayed" diagnostic that will be |
953 | | /// emitted after the current diagnostic completes. This should |
954 | | /// only be used for fatal errors detected at inconvenient |
955 | | /// times. If emitting a delayed diagnostic causes a second delayed |
956 | | /// diagnostic to be introduced, that second delayed diagnostic |
957 | | /// will be ignored. |
958 | | /// |
959 | | /// \param DiagID The ID of the diagnostic being delayed. |
960 | | /// |
961 | | /// \param Arg1 A string argument that will be provided to the |
962 | | /// diagnostic. A copy of this string will be stored in the |
963 | | /// DiagnosticsEngine object itself. |
964 | | /// |
965 | | /// \param Arg2 A string argument that will be provided to the |
966 | | /// diagnostic. A copy of this string will be stored in the |
967 | | /// DiagnosticsEngine object itself. |
968 | | /// |
969 | | /// \param Arg3 A string argument that will be provided to the |
970 | | /// diagnostic. A copy of this string will be stored in the |
971 | | /// DiagnosticsEngine object itself. |
972 | | void SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1 = "", |
973 | | StringRef Arg2 = "", StringRef Arg3 = ""); |
974 | | |
975 | | /// Clear out the current diagnostic. |
976 | 11.2M | void Clear() { CurDiagID = std::numeric_limits<unsigned>::max(); } |
977 | | |
978 | | /// Return the value associated with this diagnostic flag. |
979 | 11.1k | StringRef getFlagValue() const { return FlagValue; } |
980 | | |
981 | | private: |
982 | | // This is private state used by DiagnosticBuilder. We put it here instead of |
983 | | // in DiagnosticBuilder in order to keep DiagnosticBuilder a small lightweight |
984 | | // object. This implementation choice means that we can only have one |
985 | | // diagnostic "in flight" at a time, but this seems to be a reasonable |
986 | | // tradeoff to keep these objects small. Assertions verify that only one |
987 | | // diagnostic is in flight at a time. |
988 | | friend class Diagnostic; |
989 | | friend class DiagnosticBuilder; |
990 | | friend class DiagnosticErrorTrap; |
991 | | friend class DiagnosticIDs; |
992 | | friend class PartialDiagnostic; |
993 | | |
994 | | /// Report the delayed diagnostic. |
995 | | void ReportDelayed(); |
996 | | |
997 | | /// The location of the current diagnostic that is in flight. |
998 | | SourceLocation CurDiagLoc; |
999 | | |
1000 | | /// The ID of the current diagnostic that is in flight. |
1001 | | /// |
1002 | | /// This is set to std::numeric_limits<unsigned>::max() when there is no |
1003 | | /// diagnostic in flight. |
1004 | | unsigned CurDiagID; |
1005 | | |
1006 | | enum { |
1007 | | /// The maximum number of arguments we can hold. |
1008 | | /// |
1009 | | /// We currently only support up to 10 arguments (%0-%9). A single |
1010 | | /// diagnostic with more than that almost certainly has to be simplified |
1011 | | /// anyway. |
1012 | | MaxArguments = DiagnosticStorage::MaxArguments, |
1013 | | }; |
1014 | | |
1015 | | DiagnosticStorage DiagStorage; |
1016 | | |
1017 | 3.96M | DiagnosticMapping makeUserMapping(diag::Severity Map, SourceLocation L) { |
1018 | 3.96M | bool isPragma = L.isValid(); |
1019 | 3.96M | DiagnosticMapping Mapping = |
1020 | 3.96M | DiagnosticMapping::Make(Map, /*IsUser=*/true, isPragma); |
1021 | | |
1022 | | // If this is a pragma mapping, then set the diagnostic mapping flags so |
1023 | | // that we override command line options. |
1024 | 3.96M | if (isPragma) { |
1025 | 1.31M | Mapping.setNoWarningAsError(true); |
1026 | 1.31M | Mapping.setNoErrorAsFatal(true); |
1027 | 1.31M | } |
1028 | | |
1029 | 3.96M | return Mapping; |
1030 | 3.96M | } |
1031 | | |
1032 | | /// Used to report a diagnostic that is finally fully formed. |
1033 | | /// |
1034 | | /// \returns true if the diagnostic was emitted, false if it was suppressed. |
1035 | 11.0M | bool ProcessDiag() { |
1036 | 11.0M | return Diags->ProcessDiag(*this); |
1037 | 11.0M | } |
1038 | | |
1039 | | /// @name Diagnostic Emission |
1040 | | /// @{ |
1041 | | protected: |
1042 | | friend class ASTReader; |
1043 | | friend class ASTWriter; |
1044 | | |
1045 | | // Sema requires access to the following functions because the current design |
1046 | | // of SFINAE requires it to use its own SemaDiagnosticBuilder, which needs to |
1047 | | // access us directly to ensure we minimize the emitted code for the common |
1048 | | // Sema::Diag() patterns. |
1049 | | friend class Sema; |
1050 | | |
1051 | | /// Emit the current diagnostic and clear the diagnostic state. |
1052 | | /// |
1053 | | /// \param Force Emit the diagnostic regardless of suppression settings. |
1054 | | bool EmitCurrentDiagnostic(bool Force = false); |
1055 | | |
1056 | 174k | unsigned getCurrentDiagID() const { return CurDiagID; } |
1057 | | |
1058 | 95 | SourceLocation getCurrentDiagLoc() const { return CurDiagLoc; } |
1059 | | |
1060 | | /// @} |
1061 | | }; |
1062 | | |
1063 | | /// RAII class that determines when any errors have occurred |
1064 | | /// between the time the instance was created and the time it was |
1065 | | /// queried. |
1066 | | /// |
1067 | | /// Note that you almost certainly do not want to use this. It's usually |
1068 | | /// meaningless to ask whether a particular scope triggered an error message, |
1069 | | /// because error messages outside that scope can mark things invalid (or cause |
1070 | | /// us to reach an error limit), which can suppress errors within that scope. |
1071 | | class DiagnosticErrorTrap { |
1072 | | DiagnosticsEngine &Diag; |
1073 | | unsigned NumErrors; |
1074 | | unsigned NumUnrecoverableErrors; |
1075 | | |
1076 | | public: |
1077 | | explicit DiagnosticErrorTrap(DiagnosticsEngine &Diag) |
1078 | 1.11M | : Diag(Diag) { reset(); } |
1079 | | |
1080 | | /// Determine whether any errors have occurred since this |
1081 | | /// object instance was created. |
1082 | 176 | bool hasErrorOccurred() const { |
1083 | 176 | return Diag.TrapNumErrorsOccurred > NumErrors; |
1084 | 176 | } |
1085 | | |
1086 | | /// Determine whether any unrecoverable errors have occurred since this |
1087 | | /// object instance was created. |
1088 | 81.5M | bool hasUnrecoverableErrorOccurred() const { |
1089 | 81.5M | return Diag.TrapNumUnrecoverableErrorsOccurred > NumUnrecoverableErrors; |
1090 | 81.5M | } |
1091 | | |
1092 | | /// Set to initial state of "no errors occurred". |
1093 | 39.0M | void reset() { |
1094 | 39.0M | NumErrors = Diag.TrapNumErrorsOccurred; |
1095 | 39.0M | NumUnrecoverableErrors = Diag.TrapNumUnrecoverableErrorsOccurred; |
1096 | 39.0M | } |
1097 | | }; |
1098 | | |
1099 | | /// The streaming interface shared between DiagnosticBuilder and |
1100 | | /// PartialDiagnostic. This class is not intended to be constructed directly |
1101 | | /// but only as base class of DiagnosticBuilder and PartialDiagnostic builder. |
1102 | | /// |
1103 | | /// Any new type of argument accepted by DiagnosticBuilder and PartialDiagnostic |
1104 | | /// should be implemented as a '<<' operator of StreamingDiagnostic, e.g. |
1105 | | /// |
1106 | | /// const StreamingDiagnostic& |
1107 | | /// operator<<(const StreamingDiagnostic&, NewArgType); |
1108 | | /// |
1109 | | class StreamingDiagnostic { |
1110 | | public: |
1111 | | /// An allocator for DiagnosticStorage objects, which uses a small cache to |
1112 | | /// objects, used to reduce malloc()/free() traffic for partial diagnostics. |
1113 | | class DiagStorageAllocator { |
1114 | | static const unsigned NumCached = 16; |
1115 | | DiagnosticStorage Cached[NumCached]; |
1116 | | DiagnosticStorage *FreeList[NumCached]; |
1117 | | unsigned NumFreeListEntries; |
1118 | | |
1119 | | public: |
1120 | | DiagStorageAllocator(); |
1121 | | ~DiagStorageAllocator(); |
1122 | | |
1123 | | /// Allocate new storage. |
1124 | 1.52M | DiagnosticStorage *Allocate() { |
1125 | 1.52M | if (NumFreeListEntries == 0) |
1126 | 19.2k | return new DiagnosticStorage; |
1127 | | |
1128 | 1.50M | DiagnosticStorage *Result = FreeList[--NumFreeListEntries]; |
1129 | 1.50M | Result->NumDiagArgs = 0; |
1130 | 1.50M | Result->DiagRanges.clear(); |
1131 | 1.50M | Result->FixItHints.clear(); |
1132 | 1.50M | return Result; |
1133 | 1.52M | } |
1134 | | |
1135 | | /// Free the given storage object. |
1136 | 1.52M | void Deallocate(DiagnosticStorage *S) { |
1137 | 1.52M | if (S >= Cached && S <= Cached + NumCached1.50M ) { |
1138 | 1.50M | FreeList[NumFreeListEntries++] = S; |
1139 | 1.50M | return; |
1140 | 1.50M | } |
1141 | | |
1142 | 18.3k | delete S; |
1143 | 18.3k | } |
1144 | | }; |
1145 | | |
1146 | | protected: |
1147 | | mutable DiagnosticStorage *DiagStorage = nullptr; |
1148 | | |
1149 | | /// Allocator used to allocate storage for this diagnostic. |
1150 | | DiagStorageAllocator *Allocator = nullptr; |
1151 | | |
1152 | | public: |
1153 | | /// Retrieve storage for this particular diagnostic. |
1154 | 1.52M | DiagnosticStorage *getStorage() const { |
1155 | 1.52M | if (DiagStorage) |
1156 | 4 | return DiagStorage; |
1157 | | |
1158 | 1.52M | assert(Allocator); |
1159 | 0 | DiagStorage = Allocator->Allocate(); |
1160 | 1.52M | return DiagStorage; |
1161 | 1.52M | } |
1162 | | |
1163 | 26.0M | void freeStorage() { |
1164 | 26.0M | if (!DiagStorage) |
1165 | 7.29M | return; |
1166 | | |
1167 | | // The hot path for PartialDiagnostic is when we just used it to wrap an ID |
1168 | | // (typically so we have the flexibility of passing a more complex |
1169 | | // diagnostic into the callee, but that does not commonly occur). |
1170 | | // |
1171 | | // Split this out into a slow function for silly compilers (*cough*) which |
1172 | | // can't do decent partial inlining. |
1173 | 18.7M | freeStorageSlow(); |
1174 | 18.7M | } |
1175 | | |
1176 | 18.7M | void freeStorageSlow() { |
1177 | 18.7M | if (!Allocator) |
1178 | 17.2M | return; |
1179 | 1.52M | Allocator->Deallocate(DiagStorage); |
1180 | 1.52M | DiagStorage = nullptr; |
1181 | 1.52M | } |
1182 | | |
1183 | 7.07M | void AddTaggedVal(uint64_t V, DiagnosticsEngine::ArgumentKind Kind) const { |
1184 | 7.07M | if (!DiagStorage) |
1185 | 1.26M | DiagStorage = getStorage(); |
1186 | | |
1187 | 7.07M | assert(DiagStorage->NumDiagArgs < DiagnosticStorage::MaxArguments && |
1188 | 7.07M | "Too many arguments to diagnostic!"); |
1189 | 0 | DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] = Kind; |
1190 | 7.07M | DiagStorage->DiagArgumentsVal[DiagStorage->NumDiagArgs++] = V; |
1191 | 7.07M | } |
1192 | | |
1193 | 1.86M | void AddString(StringRef V) const { |
1194 | 1.86M | if (!DiagStorage) |
1195 | 110k | DiagStorage = getStorage(); |
1196 | | |
1197 | 1.86M | assert(DiagStorage->NumDiagArgs < DiagnosticStorage::MaxArguments && |
1198 | 1.86M | "Too many arguments to diagnostic!"); |
1199 | 0 | DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] = |
1200 | 1.86M | DiagnosticsEngine::ak_std_string; |
1201 | 1.86M | DiagStorage->DiagArgumentsStr[DiagStorage->NumDiagArgs++] = std::string(V); |
1202 | 1.86M | } |
1203 | | |
1204 | 1.78M | void AddSourceRange(const CharSourceRange &R) const { |
1205 | 1.78M | if (!DiagStorage) |
1206 | 40.3k | DiagStorage = getStorage(); |
1207 | | |
1208 | 1.78M | DiagStorage->DiagRanges.push_back(R); |
1209 | 1.78M | } |
1210 | | |
1211 | 395k | void AddFixItHint(const FixItHint &Hint) const { |
1212 | 395k | if (Hint.isNull()) |
1213 | 49.0k | return; |
1214 | | |
1215 | 346k | if (!DiagStorage) |
1216 | 161 | DiagStorage = getStorage(); |
1217 | | |
1218 | 346k | DiagStorage->FixItHints.push_back(Hint); |
1219 | 346k | } |
1220 | | |
1221 | | /// Conversion of StreamingDiagnostic to bool always returns \c true. |
1222 | | /// |
1223 | | /// This allows is to be used in boolean error contexts (where \c true is |
1224 | | /// used to indicate that an error has occurred), like: |
1225 | | /// \code |
1226 | | /// return Diag(...); |
1227 | | /// \endcode |
1228 | 116 | operator bool() const { return true; } |
1229 | | |
1230 | | protected: |
1231 | 10.1M | StreamingDiagnostic() = default; |
1232 | | |
1233 | | /// Construct with an external storage not owned by itself. The allocator |
1234 | | /// is a null pointer in this case. |
1235 | | explicit StreamingDiagnostic(DiagnosticStorage *Storage) |
1236 | 11.2M | : DiagStorage(Storage) {} |
1237 | | |
1238 | | /// Construct with a storage allocator which will manage the storage. The |
1239 | | /// allocator is not a null pointer in this case. |
1240 | | explicit StreamingDiagnostic(DiagStorageAllocator &Alloc) |
1241 | 3.74M | : Allocator(&Alloc) {} |
1242 | | |
1243 | | StreamingDiagnostic(const StreamingDiagnostic &Diag) = default; |
1244 | | StreamingDiagnostic(StreamingDiagnostic &&Diag) = default; |
1245 | | |
1246 | 25.1M | ~StreamingDiagnostic() { freeStorage(); } |
1247 | | }; |
1248 | | |
1249 | | //===----------------------------------------------------------------------===// |
1250 | | // DiagnosticBuilder |
1251 | | //===----------------------------------------------------------------------===// |
1252 | | |
1253 | | /// A little helper class used to produce diagnostics. |
1254 | | /// |
1255 | | /// This is constructed by the DiagnosticsEngine::Report method, and |
1256 | | /// allows insertion of extra information (arguments and source ranges) into |
1257 | | /// the currently "in flight" diagnostic. When the temporary for the builder |
1258 | | /// is destroyed, the diagnostic is issued. |
1259 | | /// |
1260 | | /// Note that many of these will be created as temporary objects (many call |
1261 | | /// sites), so we want them to be small and we never want their address taken. |
1262 | | /// This ensures that compilers with somewhat reasonable optimizers will promote |
1263 | | /// the common fields to registers, eliminating increments of the NumArgs field, |
1264 | | /// for example. |
1265 | | class DiagnosticBuilder : public StreamingDiagnostic { |
1266 | | friend class DiagnosticsEngine; |
1267 | | friend class PartialDiagnostic; |
1268 | | |
1269 | | mutable DiagnosticsEngine *DiagObj = nullptr; |
1270 | | |
1271 | | /// Status variable indicating if this diagnostic is still active. |
1272 | | /// |
1273 | | // NOTE: This field is redundant with DiagObj (IsActive iff (DiagObj == 0)), |
1274 | | // but LLVM is not currently smart enough to eliminate the null check that |
1275 | | // Emit() would end up with if we used that as our status variable. |
1276 | | mutable bool IsActive = false; |
1277 | | |
1278 | | /// Flag indicating that this diagnostic is being emitted via a |
1279 | | /// call to ForceEmit. |
1280 | | mutable bool IsForceEmit = false; |
1281 | | |
1282 | | DiagnosticBuilder() = default; |
1283 | | |
1284 | | explicit DiagnosticBuilder(DiagnosticsEngine *diagObj) |
1285 | | : StreamingDiagnostic(&diagObj->DiagStorage), DiagObj(diagObj), |
1286 | 11.2M | IsActive(true) { |
1287 | 11.2M | assert(diagObj && "DiagnosticBuilder requires a valid DiagnosticsEngine!"); |
1288 | 0 | assert(DiagStorage && |
1289 | 11.2M | "DiagnosticBuilder requires a valid DiagnosticStorage!"); |
1290 | 0 | DiagStorage->NumDiagArgs = 0; |
1291 | 11.2M | DiagStorage->DiagRanges.clear(); |
1292 | 11.2M | DiagStorage->FixItHints.clear(); |
1293 | 11.2M | } |
1294 | | |
1295 | | protected: |
1296 | | /// Clear out the current diagnostic. |
1297 | 17.2M | void Clear() const { |
1298 | 17.2M | DiagObj = nullptr; |
1299 | 17.2M | IsActive = false; |
1300 | 17.2M | IsForceEmit = false; |
1301 | 17.2M | } |
1302 | | |
1303 | | /// Determine whether this diagnostic is still active. |
1304 | 31.8M | bool isActive() const { return IsActive; } |
1305 | | |
1306 | | /// Force the diagnostic builder to emit the diagnostic now. |
1307 | | /// |
1308 | | /// Once this function has been called, the DiagnosticBuilder object |
1309 | | /// should not be used again before it is destroyed. |
1310 | | /// |
1311 | | /// \returns true if a diagnostic was emitted, false if the |
1312 | | /// diagnostic was suppressed. |
1313 | 17.2M | bool Emit() { |
1314 | | // If this diagnostic is inactive, then its soul was stolen by the copy ctor |
1315 | | // (or by a subclass, as in SemaDiagnosticBuilder). |
1316 | 17.2M | if (!isActive()) return false8.87M ; |
1317 | | |
1318 | | // Process the diagnostic. |
1319 | 8.33M | bool Result = DiagObj->EmitCurrentDiagnostic(IsForceEmit); |
1320 | | |
1321 | | // This diagnostic is dead. |
1322 | 8.33M | Clear(); |
1323 | | |
1324 | 8.33M | return Result; |
1325 | 17.2M | } |
1326 | | |
1327 | | public: |
1328 | | /// Copy constructor. When copied, this "takes" the diagnostic info from the |
1329 | | /// input and neuters it. |
1330 | 5.95M | DiagnosticBuilder(const DiagnosticBuilder &D) : StreamingDiagnostic() { |
1331 | 5.95M | DiagObj = D.DiagObj; |
1332 | 5.95M | DiagStorage = D.DiagStorage; |
1333 | 5.95M | IsActive = D.IsActive; |
1334 | 5.95M | IsForceEmit = D.IsForceEmit; |
1335 | 5.95M | D.Clear(); |
1336 | 5.95M | } |
1337 | | |
1338 | 3.13M | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { |
1339 | 3.13M | assert(isActive() && "Clients must not add to cleared diagnostic!"); |
1340 | 0 | const StreamingDiagnostic &DB = *this; |
1341 | 3.13M | DB << V; |
1342 | 3.13M | return *this; |
1343 | 3.13M | } clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::comments::CommandMarkerKind>(clang::comments::CommandMarkerKind const&) const Line | Count | Source | 1338 | 81 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 81 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 81 | DB << V; | 1342 | 81 | return *this; | 1343 | 81 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<int>(int const&) const Line | Count | Source | 1338 | 23.6k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 23.6k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 23.6k | DB << V; | 1342 | 23.6k | return *this; | 1343 | 23.6k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SourceRange>(clang::SourceRange const&) const Line | Count | Source | 1338 | 254k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 254k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 254k | DB << V; | 1342 | 254k | return *this; | 1343 | 254k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned int>(unsigned int const&) const Line | Count | Source | 1338 | 96.1k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 96.1k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 96.1k | DB << V; | 1342 | 96.1k | return *this; | 1343 | 96.1k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXRecordDecl const*>(clang::CXXRecordDecl const* const&) const Line | Count | Source | 1338 | 198 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 198 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 198 | DB << V; | 1342 | 198 | return *this; | 1343 | 198 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXMethodDecl const*>(clang::CXXMethodDecl const* const&) const Line | Count | Source | 1338 | 47 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 47 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 47 | DB << V; | 1342 | 47 | return *this; | 1343 | 47 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char const*>(char const* const&) const Line | Count | Source | 1338 | 8.83k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 8.83k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 8.83k | DB << V; | 1342 | 8.83k | return *this; | 1343 | 8.83k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [21]>(char const (&) [21]) const Line | Count | Source | 1338 | 4.52k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4.52k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4.52k | DB << V; | 1342 | 4.52k | return *this; | 1343 | 4.52k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [17]>(char const (&) [17]) const Line | Count | Source | 1338 | 177 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 177 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 177 | DB << V; | 1342 | 177 | return *this; | 1343 | 177 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<256u> >(llvm::SmallString<256u> const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [9]>(char const (&) [9]) const Line | Count | Source | 1338 | 20.1k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 20.1k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 20.1k | DB << V; | 1342 | 20.1k | return *this; | 1343 | 20.1k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [10]>(char const (&) [10]) const Line | Count | Source | 1338 | 333 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 333 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 333 | DB << V; | 1342 | 333 | return *this; | 1343 | 333 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [12]>(char const (&) [12]) const Line | Count | Source | 1338 | 309 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 309 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 309 | DB << V; | 1342 | 309 | return *this; | 1343 | 309 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [38]>(char const (&) [38]) const Line | Count | Source | 1338 | 14 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 14 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 14 | DB << V; | 1342 | 14 | return *this; | 1343 | 14 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [11]>(char const (&) [11]) const Line | Count | Source | 1338 | 53 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 53 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 53 | DB << V; | 1342 | 53 | return *this; | 1343 | 53 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [84]>(char const (&) [84]) const Line | Count | Source | 1338 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 16 | DB << V; | 1342 | 16 | return *this; | 1343 | 16 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [16]>(char const (&) [16]) const Line | Count | Source | 1338 | 626 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 626 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 626 | DB << V; | 1342 | 626 | return *this; | 1343 | 626 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [14]>(char const (&) [14]) const Line | Count | Source | 1338 | 86 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 86 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 86 | DB << V; | 1342 | 86 | return *this; | 1343 | 86 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [15]>(char const (&) [15]) const Line | Count | Source | 1338 | 31 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 31 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 31 | DB << V; | 1342 | 31 | return *this; | 1343 | 31 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [23]>(char const (&) [23]) const Line | Count | Source | 1338 | 78 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 78 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 78 | DB << V; | 1342 | 78 | return *this; | 1343 | 78 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [8]>(char const (&) [8]) const Line | Count | Source | 1338 | 135 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 135 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 135 | DB << V; | 1342 | 135 | return *this; | 1343 | 135 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [3]>(char const (&) [3]) const Line | Count | Source | 1338 | 263 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 263 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 263 | DB << V; | 1342 | 263 | return *this; | 1343 | 263 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [6]>(char const (&) [6]) const Line | Count | Source | 1338 | 1.74k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1.74k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1.74k | DB << V; | 1342 | 1.74k | return *this; | 1343 | 1.74k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [27]>(char const (&) [27]) const Line | Count | Source | 1338 | 13 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 13 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 13 | DB << V; | 1342 | 13 | return *this; | 1343 | 13 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [33]>(char const (&) [33]) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [35]>(char const (&) [35]) const Line | Count | Source | 1338 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 24 | DB << V; | 1342 | 24 | return *this; | 1343 | 24 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [13]>(char const (&) [13]) const Line | Count | Source | 1338 | 58 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 58 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 58 | DB << V; | 1342 | 58 | return *this; | 1343 | 58 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [4]>(char const (&) [4]) const Line | Count | Source | 1338 | 205 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 205 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 205 | DB << V; | 1342 | 205 | return *this; | 1343 | 205 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<bool>(bool const&) const Line | Count | Source | 1338 | 36.3k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 36.3k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 36.3k | DB << V; | 1342 | 36.3k | return *this; | 1343 | 36.3k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamedDecl const*>(clang::NamedDecl const* const&) const Line | Count | Source | 1338 | 178k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 178k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 178k | DB << V; | 1342 | 178k | return *this; | 1343 | 178k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::StringRef>(llvm::StringRef const&) const Line | Count | Source | 1338 | 75.0k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 75.0k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 75.0k | DB << V; | 1342 | 75.0k | return *this; | 1343 | 75.0k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) const Line | Count | Source | 1338 | 1.31M | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1.31M | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1.31M | DB << V; | 1342 | 1.31M | return *this; | 1343 | 1.31M | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CharSourceRange>(clang::CharSourceRange const&) const Line | Count | Source | 1338 | 5.88k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5.88k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5.88k | DB << V; | 1342 | 5.88k | return *this; | 1343 | 5.88k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<5u> >(llvm::SmallString<5u> const&) const Line | Count | Source | 1338 | 78 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 78 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 78 | DB << V; | 1342 | 78 | return *this; | 1343 | 78 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [2]>(char const (&) [2]) const Line | Count | Source | 1338 | 388 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 388 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 388 | DB << V; | 1342 | 388 | return *this; | 1343 | 388 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NumericLiteralParser::CheckSeparatorKind>(clang::NumericLiteralParser::CheckSeparatorKind const&) const Line | Count | Source | 1338 | 38 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 38 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 38 | DB << V; | 1342 | 38 | return *this; | 1343 | 38 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<32u> >(llvm::SmallString<32u> const&) const Line | Count | Source | 1338 | 528 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 528 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 528 | DB << V; | 1342 | 528 | return *this; | 1343 | 528 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::IdentifierInfo*>(clang::IdentifierInfo* const&) const Line | Count | Source | 1338 | 101k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 101k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 101k | DB << V; | 1342 | 101k | return *this; | 1343 | 101k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FixItHint>(clang::FixItHint const&) const Line | Count | Source | 1338 | 68.4k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 68.4k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 68.4k | DB << V; | 1342 | 68.4k | return *this; | 1343 | 68.4k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<128u> >(llvm::SmallString<128u> const&) const Line | Count | Source | 1338 | 12.7k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 12.7k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 12.7k | DB << V; | 1342 | 12.7k | return *this; | 1343 | 12.7k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<PPElifDiag>(PPElifDiag const&) const Line | Count | Source | 1338 | 34 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 34 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 34 | DB << V; | 1342 | 34 | return *this; | 1343 | 34 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [1]>(char const (&) [1]) const Line | Count | Source | 1338 | 114 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 114 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 114 | DB << V; | 1342 | 114 | return *this; | 1343 | 114 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::IdentifierInfo const*>(clang::IdentifierInfo const* const&) const Line | Count | Source | 1338 | 793 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 793 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 793 | DB << V; | 1342 | 793 | return *this; | 1343 | 793 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::PPCallbacks::PragmaMessageKind>(clang::PPCallbacks::PragmaMessageKind const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [45]>(char const (&) [45]) const Line | Count | Source | 1338 | 90 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 90 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 90 | DB << V; | 1342 | 90 | return *this; | 1343 | 90 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [25]>(char const (&) [25]) const Line | Count | Source | 1338 | 28 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 28 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 28 | DB << V; | 1342 | 28 | return *this; | 1343 | 28 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [28]>(char const (&) [28]) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [19]>(char const (&) [19]) const Line | Count | Source | 1338 | 162 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 162 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 162 | DB << V; | 1342 | 162 | return *this; | 1343 | 162 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [26]>(char const (&) [26]) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [31]>(char const (&) [31]) const Line | Count | Source | 1338 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 16 | DB << V; | 1342 | 16 | return *this; | 1343 | 16 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [18]>(char const (&) [18]) const Line | Count | Source | 1338 | 71 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 71 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 71 | DB << V; | 1342 | 71 | return *this; | 1343 | 71 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [43]>(char const (&) [43]) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [24]>(char const (&) [24]) const Line | Count | Source | 1338 | 41 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 41 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 41 | DB << V; | 1342 | 41 | return *this; | 1343 | 41 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [29]>(char const (&) [29]) const Line | Count | Source | 1338 | 51 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 51 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 51 | DB << V; | 1342 | 51 | return *this; | 1343 | 51 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [34]>(char const (&) [34]) const Line | Count | Source | 1338 | 47 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 47 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 47 | DB << V; | 1342 | 47 | return *this; | 1343 | 47 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [39]>(char const (&) [39]) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [36]>(char const (&) [36]) const Line | Count | Source | 1338 | 14 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 14 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 14 | DB << V; | 1342 | 14 | return *this; | 1343 | 14 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [54]>(char const (&) [54]) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [42]>(char const (&) [42]) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [60]>(char const (&) [60]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [53]>(char const (&) [53]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [22]>(char const (&) [22]) const Line | Count | Source | 1338 | 42 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 42 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 42 | DB << V; | 1342 | 42 | return *this; | 1343 | 42 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [70]>(char const (&) [70]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [49]>(char const (&) [49]) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [7]>(char const (&) [7]) const Line | Count | Source | 1338 | 345 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 345 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 345 | DB << V; | 1342 | 345 | return *this; | 1343 | 345 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [32]>(char const (&) [32]) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [63]>(char const (&) [63]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [75]>(char const (&) [75]) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [37]>(char const (&) [37]) const Line | Count | Source | 1338 | 14 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 14 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 14 | DB << V; | 1342 | 14 | return *this; | 1343 | 14 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [47]>(char const (&) [47]) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [52]>(char const (&) [52]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [62]>(char const (&) [62]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [44]>(char const (&) [44]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [51]>(char const (&) [51]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [76]>(char const (&) [76]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [100]>(char const (&) [100]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [66]>(char const (&) [66]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [81]>(char const (&) [81]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [79]>(char const (&) [79]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [71]>(char const (&) [71]) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [48]>(char const (&) [48]) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [65]>(char const (&) [65]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [59]>(char const (&) [59]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [57]>(char const (&) [57]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [166]>(char const (&) [166]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [40]>(char const (&) [40]) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [50]>(char const (&) [50]) const Line | Count | Source | 1338 | 20 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 20 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 20 | DB << V; | 1342 | 20 | return *this; | 1343 | 20 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [141]>(char const (&) [141]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [87]>(char const (&) [87]) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [94]>(char const (&) [94]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [102]>(char const (&) [102]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [113]>(char const (&) [113]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [111]>(char const (&) [111]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [112]>(char const (&) [112]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [61]>(char const (&) [61]) const Line | Count | Source | 1338 | 17 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 17 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 17 | DB << V; | 1342 | 17 | return *this; | 1343 | 17 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [96]>(char const (&) [96]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [83]>(char const (&) [83]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [98]>(char const (&) [98]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [20]>(char const (&) [20]) const Line | Count | Source | 1338 | 204 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 204 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 204 | DB << V; | 1342 | 204 | return *this; | 1343 | 204 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRDefinitionDataDifference>(clang::ASTReader::diagnoseOdrViolations()::ODRDefinitionDataDifference const&) const Line | Count | Source | 1338 | 20 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 20 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 20 | DB << V; | 1342 | 20 | return *this; | 1343 | 20 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRMismatchDeclDifference>(clang::ASTReader::diagnoseOdrViolations()::ODRMismatchDeclDifference const&) const Line | Count | Source | 1338 | 194 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 194 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 194 | DB << V; | 1342 | 194 | return *this; | 1343 | 194 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FunctionDecl*>(clang::FunctionDecl* const&) const Line | Count | Source | 1338 | 219k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 219k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 219k | DB << V; | 1342 | 219k | return *this; | 1343 | 219k | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRFunctionDifference>(clang::ASTReader::diagnoseOdrViolations()::ODRFunctionDifference const&) const Line | Count | Source | 1338 | 72 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 72 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 72 | DB << V; | 1342 | 72 | return *this; | 1343 | 72 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::EnumDecl*>(clang::EnumDecl* const&) const Line | Count | Source | 1338 | 65 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 65 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 65 | DB << V; | 1342 | 65 | return *this; | 1343 | 65 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODREnumDifference>(clang::ASTReader::diagnoseOdrViolations()::ODREnumDifference const&) const Line | Count | Source | 1338 | 26 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 26 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 26 | DB << V; | 1342 | 26 | return *this; | 1343 | 26 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::getInputFile(clang::serialization::ModuleFile&, unsigned int, bool)::Change::ModificationKind>(clang::ASTReader::getInputFile(clang::serialization::ModuleFile&, unsigned int, bool)::Change::ModificationKind const&) const Line | Count | Source | 1338 | 10 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 10 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 10 | DB << V; | 1342 | 10 | return *this; | 1343 | 10 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamedDecl*>(clang::NamedDecl* const&) const Line | Count | Source | 1338 | 120k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 120k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 120k | DB << V; | 1342 | 120k | return *this; | 1343 | 120k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclContext*>(clang::DeclContext* const&) const Line | Count | Source | 1338 | 56.0k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 56.0k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 56.0k | DB << V; | 1342 | 56.0k | return *this; | 1343 | 56.0k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::QualType>(clang::QualType const&) const Line | Count | Source | 1338 | 256k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 256k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 256k | DB << V; | 1342 | 256k | return *this; | 1343 | 256k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclarationName>(clang::DeclarationName const&) const Line | Count | Source | 1338 | 26.1k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 26.1k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 26.1k | DB << V; | 1342 | 26.1k | return *this; | 1343 | 26.1k | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRMismatchDecl>(clang::ASTReader::diagnoseOdrViolations()::ODRMismatchDecl const&) const Line | Count | Source | 1338 | 88 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 88 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 88 | DB << V; | 1342 | 88 | return *this; | 1343 | 88 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXRecordDecl*>(clang::CXXRecordDecl* const&) const Line | Count | Source | 1338 | 7.79k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 7.79k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 7.79k | DB << V; | 1342 | 7.79k | return *this; | 1343 | 7.79k | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRTemplateDifference>(clang::ASTReader::diagnoseOdrViolations()::ODRTemplateDifference const&) const Line | Count | Source | 1338 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 16 | DB << V; | 1342 | 16 | return *this; | 1343 | 16 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::$_10>(clang::ASTReader::diagnoseOdrViolations()::$_10 const&) const Line | Count | Source | 1338 | 68 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 68 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 68 | DB << V; | 1342 | 68 | return *this; | 1343 | 68 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateArgument>(clang::TemplateArgument const&) const Line | Count | Source | 1338 | 734 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 734 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 734 | DB << V; | 1342 | 734 | return *this; | 1343 | 734 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FunctionTemplateDecl*>(clang::FunctionTemplateDecl* const&) const Line | Count | Source | 1338 | 123 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 123 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 123 | DB << V; | 1342 | 123 | return *this; | 1343 | 123 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Expr*>(clang::Expr* const&) const Line | Count | Source | 1338 | 337 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 337 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 337 | DB << V; | 1342 | 337 | return *this; | 1343 | 337 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::EnumConstantDecl const*>(clang::EnumConstantDecl const* const&) const Line | Count | Source | 1338 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 8 | DB << V; | 1342 | 8 | return *this; | 1343 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [5]>(char const (&) [5]) const Line | Count | Source | 1338 | 2.27k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2.27k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2.27k | DB << V; | 1342 | 2.27k | return *this; | 1343 | 2.27k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [69]>(char const (&) [69]) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [68]>(char const (&) [68]) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [107]>(char const (&) [107]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [41]>(char const (&) [41]) const Line | Count | Source | 1338 | 12 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 12 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 12 | DB << V; | 1342 | 12 | return *this; | 1343 | 12 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [144]>(char const (&) [144]) const Line | Count | Source | 1338 | 28 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 28 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 28 | DB << V; | 1342 | 28 | return *this; | 1343 | 28 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [30]>(char const (&) [30]) const Line | Count | Source | 1338 | 30 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 30 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 30 | DB << V; | 1342 | 30 | return *this; | 1343 | 30 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [56]>(char const (&) [56]) const Line | Count | Source | 1338 | 45 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 45 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 45 | DB << V; | 1342 | 45 | return *this; | 1343 | 45 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<64u> >(llvm::SmallString<64u> const&) const Line | Count | Source | 1338 | 48 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 48 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 48 | DB << V; | 1342 | 48 | return *this; | 1343 | 48 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<512u> >(llvm::SmallString<512u> const&) const Line | Count | Source | 1338 | 302 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 302 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 302 | DB << V; | 1342 | 302 | return *this; | 1343 | 302 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MSPropertyDecl const*>(clang::MSPropertyDecl const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
ParseOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::OMPContextLvl>((anonymous namespace)::OMPContextLvl const&) const Line | Count | Source | 1338 | 172 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 172 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 172 | DB << V; | 1342 | 172 | return *this; | 1343 | 172 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::PragmaClangSectionKind>(clang::Sema::PragmaClangSectionKind const&) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
ParsePragma.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::TokFPAnnotValue::FlagKinds>((anonymous namespace)::TokFPAnnotValue::FlagKinds const&) const Line | Count | Source | 1338 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 6 | DB << V; | 1342 | 6 | return *this; | 1343 | 6 | } |
ParseStmt.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::MisleadingStatementKind>((anonymous namespace)::MisleadingStatementKind const&) const Line | Count | Source | 1338 | 46 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 46 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 46 | DB << V; | 1342 | 46 | return *this; | 1343 | 46 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::tok::TokenKind>(clang::tok::TokenKind const&) const Line | Count | Source | 1338 | 44.1k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 44.1k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 44.1k | DB << V; | 1342 | 44.1k | return *this; | 1343 | 44.1k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Parser::ExtraSemiKind>(clang::Parser::ExtraSemiKind const&) const Line | Count | Source | 1338 | 1.39k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1.39k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1.39k | DB << V; | 1342 | 1.39k | return *this; | 1343 | 1.39k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCMethodDecl const*>(clang::ObjCMethodDecl const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [46]>(char const (&) [46]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NoDestroyAttr const*>(clang::NoDestroyAttr const* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NotTailCalledAttr const*>(clang::NotTailCalledAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [86]>(char const (&) [86]) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CFUnknownTransferAttr const*>(clang::CFUnknownTransferAttr const* const&) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CFAuditedTransferAttr const*>(clang::CFAuditedTransferAttr const* const&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TargetClonesAttr const*>(clang::TargetClonesAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TargetAttr const*>(clang::TargetAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CPUSpecificAttr const*>(clang::CPUSpecificAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CPUDispatchAttr const*>(clang::CPUDispatchAttr const* const&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDASharedAttr const*>(clang::CUDASharedAttr const* const&) const Line | Count | Source | 1338 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 6 | DB << V; | 1342 | 6 | return *this; | 1343 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::HIPManagedAttr const*>(clang::HIPManagedAttr const* const&) const Line | Count | Source | 1338 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 8 | DB << V; | 1342 | 8 | return *this; | 1343 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDAGlobalAttr const*>(clang::CUDAGlobalAttr const* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDADeviceBuiltinTextureTypeAttr const*>(clang::CUDADeviceBuiltinTextureTypeAttr const* const&) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDADeviceBuiltinSurfaceTypeAttr const*>(clang::CUDADeviceBuiltinSurfaceTypeAttr const* const&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDADeviceAttr const*>(clang::CUDADeviceAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDAHostAttr const*>(clang::CUDAHostAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDAConstantAttr const*>(clang::CUDAConstantAttr const* const&) const Line | Count | Source | 1338 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 8 | DB << V; | 1342 | 8 | return *this; | 1343 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::HotAttr const*>(clang::HotAttr const* const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::InternalLinkageAttr const*>(clang::InternalLinkageAttr const* const&) const Line | Count | Source | 1338 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 6 | DB << V; | 1342 | 6 | return *this; | 1343 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [58]>(char const (&) [58]) const Line | Count | Source | 1338 | 230 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 230 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 230 | DB << V; | 1342 | 230 | return *this; | 1343 | 230 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NakedAttr const*>(clang::NakedAttr const* const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ColdAttr const*>(clang::ColdAttr const* const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CommonAttr const*>(clang::CommonAttr const* const&) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Mips16Attr const*>(clang::Mips16Attr const* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MipsInterruptAttr const*>(clang::MipsInterruptAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MicroMipsAttr const*>(clang::MicroMipsAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MipsShortCallAttr const*>(clang::MipsShortCallAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MipsLongCallAttr const*>(clang::MipsLongCallAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DisableTailCallsAttr const*>(clang::DisableTailCallsAttr const* const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlwaysDestroyAttr const*>(clang::AlwaysDestroyAttr const* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RandomizeLayoutAttr const*>(clang::RandomizeLayoutAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SpeculativeLoadHardeningAttr const*>(clang::SpeculativeLoadHardeningAttr const* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlwaysInlineAttr const*>(clang::AlwaysInlineAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [92]>(char const (&) [92]) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [67]>(char const (&) [67]) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::PointerAttr const*>(clang::PointerAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::OwnerAttr const*>(clang::OwnerAttr const* const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NoRandomizeLayoutAttr const*>(clang::NoRandomizeLayoutAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [77]>(char const (&) [77]) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NoSpeculativeLoadHardeningAttr const*>(clang::NoSpeculativeLoadHardeningAttr const* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [150]>(char const (&) [150]) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ValueDecl*>(clang::ValueDecl* const&) const Line | Count | Source | 1338 | 7.97k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 7.97k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 7.97k | DB << V; | 1342 | 7.97k | return *this; | 1343 | 7.97k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CanonicalDeclPtr<clang::FunctionDecl> >(clang::CanonicalDeclPtr<clang::FunctionDecl> const&) const Line | Count | Source | 1338 | 118 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 118 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 118 | DB << V; | 1342 | 118 | return *this; | 1343 | 118 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FunctionDecl const*>(clang::FunctionDecl const* const&) const Line | Count | Source | 1338 | 10.4k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 10.4k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 10.4k | DB << V; | 1342 | 10.4k | return *this; | 1343 | 10.4k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarDecl const*>(clang::VarDecl const* const&) const Line | Count | Source | 1338 | 5.88k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5.88k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5.88k | DB << V; | 1342 | 5.88k | return *this; | 1343 | 5.88k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTContext::SectionInfo>(clang::ASTContext::SectionInfo const&) const Line | Count | Source | 1338 | 23 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 23 | DB << V; | 1342 | 23 | return *this; | 1343 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParsedAttr>(clang::ParsedAttr const&) const Line | Count | Source | 1338 | 19.5k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 19.5k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 19.5k | DB << V; | 1342 | 19.5k | return *this; | 1343 | 19.5k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallVector<clang::FixItHint, 12u> >(llvm::SmallVector<clang::FixItHint, 12u> const&) const Line | Count | Source | 1338 | 30.1k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 30.1k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 30.1k | DB << V; | 1342 | 30.1k | return *this; | 1343 | 30.1k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<CastType>(CastType const&) const Line | Count | Source | 1338 | 399 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 399 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 399 | DB << V; | 1342 | 399 | return *this; | 1343 | 399 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::ArrayRef<clang::FixItHint> >(llvm::ArrayRef<clang::FixItHint> const&) const Line | Count | Source | 1338 | 31.0k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 31.0k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 31.0k | DB << V; | 1342 | 31.0k | return *this; | 1343 | 31.0k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned long long>(unsigned long long const&) const Line | Count | Source | 1338 | 22 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 22 | DB << V; | 1342 | 22 | return *this; | 1343 | 22 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<AbsoluteValueKind>(AbsoluteValueKind const&) const Line | Count | Source | 1338 | 768 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 768 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 768 | DB << V; | 1342 | 768 | return *this; | 1343 | 768 | } |
SemaChecking.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_21>(clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_21 const&) const Line | Count | Source | 1338 | 253 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 253 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 253 | DB << V; | 1342 | 253 | return *this; | 1343 | 253 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCIvarDecl*>(clang::ObjCIvarDecl* const&) const Line | Count | Source | 1338 | 46 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 46 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 46 | DB << V; | 1342 | 46 | return *this; | 1343 | 46 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ConceptSpecializationExpr*>(clang::ConceptSpecializationExpr* const&) const Line | Count | Source | 1338 | 36 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 36 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 36 | DB << V; | 1342 | 36 | return *this; | 1343 | 36 | } |
SemaCoroutine.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag>(isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag const&) const Line | Count | Source | 1338 | 42 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 42 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 42 | DB << V; | 1342 | 42 | return *this; | 1343 | 42 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXMethodDecl*>(clang::CXXMethodDecl* const&) const Line | Count | Source | 1338 | 23 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 23 | DB << V; | 1342 | 23 | return *this; | 1343 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ClassTemplateDecl*>(clang::ClassTemplateDecl* const&) const Line | Count | Source | 1338 | 62 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 62 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 62 | DB << V; | 1342 | 62 | return *this; | 1343 | 62 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlignedAttr const*>(clang::AlignedAttr const* const&) const Line | Count | Source | 1338 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 6 | DB << V; | 1342 | 6 | return *this; | 1343 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlignedAttr*>(clang::AlignedAttr* const&) const Line | Count | Source | 1338 | 25 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 25 | DB << V; | 1342 | 25 | return *this; | 1343 | 25 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DLLImportAttr const*>(clang::DLLImportAttr const* const&) const Line | Count | Source | 1338 | 511 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 511 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 511 | DB << V; | 1342 | 511 | return *this; | 1343 | 511 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ErrorAttr*>(clang::ErrorAttr* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AnyX86NoCallerSavedRegistersAttr*>(clang::AnyX86NoCallerSavedRegistersAttr* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXX11NoReturnAttr const*>(clang::CXX11NoReturnAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypedefNameDecl*>(clang::TypedefNameDecl* const&) const Line | Count | Source | 1338 | 79 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 79 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 79 | DB << V; | 1342 | 79 | return *this; | 1343 | 79 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::InheritableAttr const*>(clang::InheritableAttr const* const&) const Line | Count | Source | 1338 | 431 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 431 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 431 | DB << V; | 1342 | 431 | return *this; | 1343 | 431 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<ShadowedDeclKind>(ShadowedDeclKind const&) const Line | Count | Source | 1338 | 149 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 149 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 149 | DB << V; | 1342 | 149 | return *this; | 1343 | 149 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclContext const*>(clang::DeclContext const* const&) const Line | Count | Source | 1338 | 52 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 52 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 52 | DB << V; | 1342 | 52 | return *this; | 1343 | 52 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::StorageClass>(clang::StorageClass const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::NonTrivialCUnionContext>(clang::Sema::NonTrivialCUnionContext const&) const Line | Count | Source | 1338 | 81 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 81 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 81 | DB << V; | 1342 | 81 | return *this; | 1343 | 81 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallVector<clang::FixItHint, 1u> >(llvm::SmallVector<clang::FixItHint, 1u> const&) const Line | Count | Source | 1338 | 17 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 17 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 17 | DB << V; | 1342 | 17 | return *this; | 1343 | 17 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::UsedAttr*>(clang::UsedAttr* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RetainAttr*>(clang::RetainAttr* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParmVarDecl const*>(clang::ParmVarDecl const* const&) const Line | Count | Source | 1338 | 49 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 49 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 49 | DB << V; | 1342 | 49 | return *this; | 1343 | 49 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypedefDecl*>(clang::TypedefDecl* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TagDecl*>(clang::TagDecl* const&) const Line | Count | Source | 1338 | 12 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 12 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 12 | DB << V; | 1342 | 12 | return *this; | 1343 | 12 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CXXSpecialMember>(clang::Sema::CXXSpecialMember const&) const Line | Count | Source | 1338 | 625 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 625 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 625 | DB << V; | 1342 | 625 | return *this; | 1343 | 625 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::EnumConstantDecl*>(clang::EnumConstantDecl* const&) const Line | Count | Source | 1338 | 25 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 25 | DB << V; | 1342 | 25 | return *this; | 1343 | 25 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeArgumentNType>(clang::AttributeArgumentNType const&) const Line | Count | Source | 1338 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 7 | DB << V; | 1342 | 7 | return *this; | 1343 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::OwnershipAttr const*>(clang::OwnershipAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VecReturnAttr*>(clang::VecReturnAttr* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeDeclKind>(clang::AttributeDeclKind const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
SemaDeclAttr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<handleXReturnsXRetainedAttr(clang::Sema&, clang::Decl*, clang::ParsedAttr const&)::$_3>(handleXReturnsXRetainedAttr(clang::Sema&, clang::Decl*, clang::ParsedAttr const&)::$_3 const&) const Line | Count | Source | 1338 | 13 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 13 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 13 | DB << V; | 1342 | 13 | return *this; | 1343 | 13 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SwiftAsyncAttr const*>(clang::SwiftAsyncAttr const* const&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SwiftAsyncErrorAttr const*>(clang::SwiftAsyncErrorAttr const* const&) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeCommonInfo>(clang::AttributeCommonInfo const&) const Line | Count | Source | 1338 | 61 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 61 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 61 | DB << V; | 1342 | 61 | return *this; | 1343 | 61 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ErrorAttr const*>(clang::ErrorAttr const* const&) const Line | Count | Source | 1338 | 11 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 11 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 11 | DB << V; | 1342 | 11 | return *this; | 1343 | 11 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SwiftNameAttr const*>(clang::SwiftNameAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlwaysInlineAttr*>(clang::AlwaysInlineAttr* const&) const Line | Count | Source | 1338 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 7 | DB << V; | 1342 | 7 | return *this; | 1343 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MinSizeAttr*>(clang::MinSizeAttr* const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParameterABIAttr*>(clang::ParameterABIAttr* const&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DLLImportAttr*>(clang::DLLImportAttr* const&) const Line | Count | Source | 1338 | 169 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 169 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 169 | DB << V; | 1342 | 169 | return *this; | 1343 | 169 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ReqdWorkGroupSizeAttr const*>(clang::ReqdWorkGroupSizeAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::WorkGroupSizeHintAttr const*>(clang::WorkGroupSizeHintAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VecTypeHintAttr const*>(clang::VecTypeHintAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::OpenCLIntelReqdSubGroupSizeAttr const*>(clang::OpenCLIntelReqdSubGroupSizeAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUFlatWorkGroupSizeAttr const*>(clang::AMDGPUFlatWorkGroupSizeAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUWavesPerEUAttr const*>(clang::AMDGPUWavesPerEUAttr const* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUNumSGPRAttr const*>(clang::AMDGPUNumSGPRAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUNumVGPRAttr const*>(clang::AMDGPUNumVGPRAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::AbstractDiagSelID>(clang::Sema::AbstractDiagSelID const&) const Line | Count | Source | 1338 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 16 | DB << V; | 1342 | 16 | return *this; | 1343 | 16 | } |
SemaDeclCXX.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::DefaultedComparisonSubobject::$_8>((anonymous namespace)::DefaultedComparisonSubobject::$_8 const&) const Line | Count | Source | 1338 | 40 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 40 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 40 | DB << V; | 1342 | 40 | return *this; | 1343 | 40 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<TrivialSubobjectKind>(TrivialSubobjectKind const&) const Line | Count | Source | 1338 | 215 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 215 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 215 | DB << V; | 1342 | 215 | return *this; | 1343 | 215 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXConstructorDecl*>(clang::CXXConstructorDecl* const&) const Line | Count | Source | 1338 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 7 | DB << V; | 1342 | 7 | return *this; | 1343 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DecompositionDecl*>(clang::DecompositionDecl* const&) const Line | Count | Source | 1338 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 7 | DB << V; | 1342 | 7 | return *this; | 1343 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AccessSpecifier>(clang::AccessSpecifier const&) const Line | Count | Source | 1338 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 8 | DB << V; | 1342 | 8 | return *this; | 1343 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Attr*>(clang::Attr* const&) const Line | Count | Source | 1338 | 40 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 40 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 40 | DB << V; | 1342 | 40 | return *this; | 1343 | 40 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::InheritableAttr*>(clang::InheritableAttr* const&) const Line | Count | Source | 1338 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 24 | DB << V; | 1342 | 24 | return *this; | 1343 | 24 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ClassTemplateSpecializationDecl*>(clang::ClassTemplateSpecializationDecl* const&) const Line | Count | Source | 1338 | 78 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 78 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 78 | DB << V; | 1342 | 78 | return *this; | 1343 | 78 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateDecl*>(clang::TemplateDecl* const&) const Line | Count | Source | 1338 | 1.22k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1.22k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1.22k | DB << V; | 1342 | 1.22k | return *this; | 1343 | 1.22k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCMethodDecl*>(clang::ObjCMethodDecl* const&) const Line | Count | Source | 1338 | 2.65k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2.65k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2.65k | DB << V; | 1342 | 2.65k | return *this; | 1343 | 2.65k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCInterfaceDecl const*>(clang::ObjCInterfaceDecl const* const&) const Line | Count | Source | 1338 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 8 | DB << V; | 1342 | 8 | return *this; | 1343 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCCategoryDecl*>(clang::ObjCCategoryDecl* const&) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCProtocolDecl const*>(clang::ObjCProtocolDecl const* const&) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCMethodFamily>(clang::ObjCMethodFamily const&) const Line | Count | Source | 1338 | 48 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 48 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 48 | DB << V; | 1342 | 48 | return *this; | 1343 | 48 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCProtocolDecl*>(clang::ObjCProtocolDecl* const&) const Line | Count | Source | 1338 | 41 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 41 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 41 | DB << V; | 1342 | 41 | return *this; | 1343 | 41 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Selector>(clang::Selector const&) const Line | Count | Source | 1338 | 3.65k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3.65k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3.65k | DB << V; | 1342 | 3.65k | return *this; | 1343 | 3.65k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCIvarDecl const*>(clang::ObjCIvarDecl const* const&) const Line | Count | Source | 1338 | 10 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 10 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 10 | DB << V; | 1342 | 10 | return *this; | 1343 | 10 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ValueDecl const*>(clang::ValueDecl const* const&) const Line | Count | Source | 1338 | 11.2k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 11.2k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 11.2k | DB << V; | 1342 | 11.2k | return *this; | 1343 | 11.2k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CanQual<clang::Type> >(clang::CanQual<clang::Type> const&) const Line | Count | Source | 1338 | 96 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 96 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 96 | DB << V; | 1342 | 96 | return *this; | 1343 | 96 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<40u> >(llvm::SmallString<40u> const&) const Line | Count | Source | 1338 | 8.78k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 8.78k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 8.78k | DB << V; | 1342 | 8.78k | return *this; | 1343 | 8.78k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SourceLocation>(clang::SourceLocation const&) const Line | Count | Source | 1338 | 652 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 652 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 652 | DB << V; | 1342 | 652 | return *this; | 1343 | 652 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ObjCLiteralKind>(clang::Sema::ObjCLiteralKind const&) const Line | Count | Source | 1338 | 79 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 79 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 79 | DB << V; | 1342 | 79 | return *this; | 1343 | 79 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FieldDecl const*>(clang::FieldDecl const* const&) const Line | Count | Source | 1338 | 159 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 159 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 159 | DB << V; | 1342 | 159 | return *this; | 1343 | 159 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<OriginalExprKind>(OriginalExprKind const&) const Line | Count | Source | 1338 | 11 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 11 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 11 | DB << V; | 1342 | 11 | return *this; | 1343 | 11 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TagTypeKind>(clang::TagTypeKind const&) const Line | Count | Source | 1338 | 80 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 80 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 80 | DB << V; | 1342 | 80 | return *this; | 1343 | 80 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::NonTagKind>(clang::Sema::NonTagKind const&) const Line | Count | Source | 1338 | 28 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 28 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 28 | DB << V; | 1342 | 28 | return *this; | 1343 | 28 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypeAliasTemplateDecl*>(clang::TypeAliasTemplateDecl* const&) const Line | Count | Source | 1338 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 7 | DB << V; | 1342 | 7 | return *this; | 1343 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::UsingPackDecl*>(clang::UsingPackDecl* const&) const Line | Count | Source | 1338 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 2 | DB << V; | 1342 | 2 | return *this; | 1343 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CUDAFunctionTarget>(clang::Sema::CUDAFunctionTarget const&) const Line | Count | Source | 1338 | 262 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 262 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 262 | DB << V; | 1342 | 262 | return *this; | 1343 | 262 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::VariadicCallType>(clang::Sema::VariadicCallType const&) const Line | Count | Source | 1338 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 6 | DB << V; | 1342 | 6 | return *this; | 1343 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RecordDecl*>(clang::RecordDecl* const&) const Line | Count | Source | 1338 | 23 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 23 | DB << V; | 1342 | 23 | return *this; | 1343 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarDecl*>(clang::VarDecl* const&) const Line | Count | Source | 1338 | 7.49k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 7.49k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 7.49k | DB << V; | 1342 | 7.49k | return *this; | 1343 | 7.49k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::AssignmentAction>(clang::Sema::AssignmentAction const&) const Line | Count | Source | 1338 | 13 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 13 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 13 | DB << V; | 1342 | 13 | return *this; | 1343 | 13 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCBridgeCastKind>(clang::ObjCBridgeCastKind const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FieldDecl*>(clang::FieldDecl* const&) const Line | Count | Source | 1338 | 617 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 617 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 617 | DB << V; | 1342 | 617 | return *this; | 1343 | 617 | } |
SemaInit.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::ReferenceKind>((anonymous namespace)::ReferenceKind const&) const Line | Count | Source | 1338 | 126 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 126 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 126 | DB << V; | 1342 | 126 | return *this; | 1343 | 126 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateName>(clang::TemplateName const&) const Line | Count | Source | 1338 | 441 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 441 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 441 | DB << V; | 1342 | 441 | return *this; | 1343 | 441 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers::ObjCLifetime>(clang::Qualifiers::ObjCLifetime const&) const Line | Count | Source | 1338 | 251 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 251 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 251 | DB << V; | 1342 | 251 | return *this; | 1343 | 251 | } |
SemaObjCProperty.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<SelectPropertyForSynthesisFromProtocols(clang::Sema&, clang::SourceLocation, clang::ObjCInterfaceDecl*, clang::ObjCPropertyDecl*)::MismatchKind>(SelectPropertyForSynthesisFromProtocols(clang::Sema&, clang::SourceLocation, clang::ObjCInterfaceDecl*, clang::ObjCPropertyDecl*)::MismatchKind const&) const Line | Count | Source | 1338 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 24 | DB << V; | 1342 | 24 | return *this; | 1343 | 24 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCPropertyDecl*>(clang::ObjCPropertyDecl* const&) const Line | Count | Source | 1338 | 31 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 31 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 31 | DB << V; | 1342 | 31 | return *this; | 1343 | 31 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<reportOriginalDsa(clang::Sema&, (anonymous namespace)::DSAStackTy const*, clang::ValueDecl const*, (anonymous namespace)::DSAStackTy::DSAVarData const&, bool)::$_39>(reportOriginalDsa(clang::Sema&, (anonymous namespace)::DSAStackTy const*, clang::ValueDecl const*, (anonymous namespace)::DSAStackTy::DSAVarData const&, bool)::$_39 const&) const Line | Count | Source | 1338 | 1.08k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1.08k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1.08k | DB << V; | 1342 | 1.08k | return *this; | 1343 | 1.08k | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<getPrivateItem(clang::Sema&, clang::Expr*&, clang::SourceLocation&, clang::SourceRange&, bool)::$_43>(getPrivateItem(clang::Sema&, clang::Expr*&, clang::SourceLocation&, clang::SourceRange&, bool)::$_43 const&) const Line | Count | Source | 1338 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 24 | DB << V; | 1342 | 24 | return *this; | 1343 | 24 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<checkNestingOfRegions(clang::Sema&, (anonymous namespace)::DSAStackTy const*, llvm::omp::Directive, clang::DeclarationNameInfo const&, llvm::omp::Directive, clang::OpenMPBindClauseKind, clang::SourceLocation)::$_42>(checkNestingOfRegions(clang::Sema&, (anonymous namespace)::DSAStackTy const*, llvm::omp::Directive, clang::DeclarationNameInfo const&, llvm::omp::Directive, clang::OpenMPBindClauseKind, clang::SourceLocation)::$_42 const&) const Line | Count | Source | 1338 | 6.18k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 6.18k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 6.18k | DB << V; | 1342 | 6.18k | return *this; | 1343 | 6.18k | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::OpenMPAtomicUpdateChecker::ExprAnalysisErrorCode>((anonymous namespace)::OpenMPAtomicUpdateChecker::ExprAnalysisErrorCode const&) const Line | Count | Source | 1338 | 942 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 942 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 942 | DB << V; | 1342 | 942 | return *this; | 1343 | 942 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_19>(clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_19 const&) const Line | Count | Source | 1338 | 108 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 108 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 108 | DB << V; | 1342 | 108 | return *this; | 1343 | 108 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_20>(clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_20 const&) const Line | Count | Source | 1338 | 72 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 72 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 72 | DB << V; | 1342 | 72 | return *this; | 1343 | 72 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_21>(clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_21 const&) const Line | Count | Source | 1338 | 108 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 108 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 108 | DB << V; | 1342 | 108 | return *this; | 1343 | 108 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::OpenMPAtomicCompareChecker::ErrorTy>((anonymous namespace)::OpenMPAtomicCompareChecker::ErrorTy const&) const Line | Count | Source | 1338 | 100 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 100 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 100 | DB << V; | 1342 | 100 | return *this; | 1343 | 100 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CCEKind>(clang::Sema::CCEKind const&) const Line | Count | Source | 1338 | 138 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 138 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 138 | DB << V; | 1342 | 138 | return *this; | 1343 | 138 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers>(clang::Qualifiers const&) const Line | Count | Source | 1338 | 9 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 9 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 9 | DB << V; | 1342 | 9 | return *this; | 1343 | 9 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::WarnUnusedResultAttr const*>(clang::WarnUnusedResultAttr const* const&) const Line | Count | Source | 1338 | 125 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 125 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 125 | DB << V; | 1342 | 125 | return *this; | 1343 | 125 | } |
SemaStmt.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::BeginEndFunction>((anonymous namespace)::BeginEndFunction const&) const Line | Count | Source | 1338 | 40 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 40 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 40 | DB << V; | 1342 | 40 | return *this; | 1343 | 40 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::LabelDecl*>(clang::LabelDecl* const&) const Line | Count | Source | 1338 | 376 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 376 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 376 | DB << V; | 1342 | 376 | return *this; | 1343 | 376 | } |
SemaStmt.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::checkMustTailAttr(clang::Stmt const*, clang::Attr const&)::FuncType::$_6>(clang::Sema::checkMustTailAttr(clang::Stmt const*, clang::Attr const&)::FuncType::$_6 const&) const Line | Count | Source | 1338 | 12 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 12 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 12 | DB << V; | 1342 | 12 | return *this; | 1343 | 12 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Attr const*>(clang::Attr const* const&) const Line | Count | Source | 1338 | 38 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 38 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 38 | DB << V; | 1342 | 38 | return *this; | 1343 | 38 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<16u> >(llvm::SmallString<16u> const&) const Line | Count | Source | 1338 | 223 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 223 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 223 | DB << V; | 1342 | 223 | return *this; | 1343 | 223 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParmVarDecl*>(clang::ParmVarDecl* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::sema::FunctionScopeInfo::'unnamed'>(clang::sema::FunctionScopeInfo::'unnamed' const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
SemaStmtAsm.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<checkExprMemoryConstraintCompat(clang::Sema&, clang::Expr*, clang::TargetInfo::ConstraintInfo&, bool)::$_2>(checkExprMemoryConstraintCompat(clang::Sema&, clang::Expr*, clang::TargetInfo::ConstraintInfo&, bool)::$_2 const&) const Line | Count | Source | 1338 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 6 | DB << V; | 1342 | 6 | return *this; | 1343 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::LikelyAttr const*>(clang::LikelyAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::UnlikelyAttr const*>(clang::UnlikelyAttr const* const&) const Line | Count | Source | 1338 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 1 | DB << V; | 1342 | 1 | return *this; | 1343 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamespaceDecl*>(clang::NamespaceDecl* const&) const Line | Count | Source | 1338 | 39 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 39 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 39 | DB << V; | 1342 | 39 | return *this; | 1343 | 39 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NestedNameSpecifier*>(clang::NestedNameSpecifier* const&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ConceptDecl*>(clang::ConceptDecl* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarTemplateSpecializationDecl*>(clang::VarTemplateSpecializationDecl* const&) const Line | Count | Source | 1338 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 3 | DB << V; | 1342 | 3 | return *this; | 1343 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateTemplateParmDecl*>(clang::TemplateTemplateParmDecl* const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
SemaTemplate.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CheckDependentFunctionTemplateSpecialization(clang::FunctionDecl*, clang::TemplateArgumentListInfo const&, clang::LookupResult&)::DiscardReason>(clang::Sema::CheckDependentFunctionTemplateSpecialization(clang::FunctionDecl*, clang::TemplateArgumentListInfo const&, clang::LookupResult&)::DiscardReason const&) const Line | Count | Source | 1338 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 4 | DB << V; | 1342 | 4 | return *this; | 1343 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarTemplateDecl*>(clang::VarTemplateDecl* const&) const Line | Count | Source | 1338 | 21 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 21 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 21 | DB << V; | 1342 | 21 | return *this; | 1343 | 21 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeducedTemplateArgument>(clang::DeducedTemplateArgument const&) const Line | Count | Source | 1338 | 25 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 25 | DB << V; | 1342 | 25 | return *this; | 1343 | 25 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AnnotateAttr const*>(clang::AnnotateAttr const* const&) const Line | Count | Source | 1338 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 6 | DB << V; | 1342 | 6 | return *this; | 1343 | 6 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MSPropertyDecl*>(clang::MSPropertyDecl* const&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCInterfaceDecl*>(clang::ObjCInterfaceDecl* const&) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
SemaType.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::QualifiedFunctionKind>((anonymous namespace)::QualifiedFunctionKind const&) const Line | Count | Source | 1338 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 24 | DB << V; | 1342 | 24 | return *this; | 1343 | 24 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<TypeDiagSelector>(TypeDiagSelector const&) const Line | Count | Source | 1338 | 33 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 33 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 33 | DB << V; | 1342 | 33 | return *this; | 1343 | 33 | } |
SemaType.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<GetFullTypeForDeclarator((anonymous namespace)::TypeProcessingState&, clang::QualType, clang::TypeSourceInfo*)::$_7>(GetFullTypeForDeclarator((anonymous namespace)::TypeProcessingState&, clang::QualType, clang::TypeSourceInfo*)::$_7 const&) const Line | Count | Source | 1338 | 50 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 50 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 50 | DB << V; | 1342 | 50 | return *this; | 1343 | 50 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ArrayType::ArraySizeModifier>(clang::ArrayType::ArraySizeModifier const&) const Line | Count | Source | 1338 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 5 | DB << V; | 1342 | 5 | return *this; | 1343 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::ArrayRef<clang::SourceRange> >(llvm::ArrayRef<clang::SourceRange> const&) const Line | Count | Source | 1338 | 25.2k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1339 | 25.2k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1340 | 0 | const StreamingDiagnostic &DB = *this; | 1341 | 25.2k | DB << V; | 1342 | 25.2k | return *this; | 1343 | 25.2k | } |
|
1344 | | |
1345 | | // It is necessary to limit this to rvalue reference to avoid calling this |
1346 | | // function with a bitfield lvalue argument since non-const reference to |
1347 | | // bitfield is not allowed. |
1348 | | template <typename T, typename = typename std::enable_if< |
1349 | | !std::is_lvalue_reference<T>::value>::type> |
1350 | 5.57M | const DiagnosticBuilder &operator<<(T &&V) const { |
1351 | 5.57M | assert(isActive() && "Clients must not add to cleared diagnostic!"); |
1352 | 0 | const StreamingDiagnostic &DB = *this; |
1353 | 5.57M | DB << std::move(V); |
1354 | 5.57M | return *this; |
1355 | 5.57M | } clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned long, void>(unsigned long&&) const Line | Count | Source | 1350 | 23 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 23 | DB << std::move(V); | 1354 | 23 | return *this; | 1355 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::comments::CommandMarkerKind, void>(clang::comments::CommandMarkerKind&&) const Line | Count | Source | 1350 | 501 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 501 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 501 | DB << std::move(V); | 1354 | 501 | return *this; | 1355 | 501 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned int, void>(unsigned int&&) const Line | Count | Source | 1350 | 2.91M | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 2.91M | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 2.91M | DB << std::move(V); | 1354 | 2.91M | return *this; | 1355 | 2.91M | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::IdentifierInfo*, void>(clang::IdentifierInfo*&&) const Line | Count | Source | 1350 | 156k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 156k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 156k | DB << std::move(V); | 1354 | 156k | return *this; | 1355 | 156k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::QualType, void>(clang::QualType&&) const Line | Count | Source | 1350 | 107k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 107k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 107k | DB << std::move(V); | 1354 | 107k | return *this; | 1355 | 107k | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VTableComponent::Kind, void>(clang::VTableComponent::Kind&&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::Error, void>(llvm::Error&&) const Line | Count | Source | 1350 | 6 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 6 | DB << std::move(V); | 1354 | 6 | return *this; | 1355 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SourceRange, void>(clang::SourceRange&&) const Line | Count | Source | 1350 | 1.04M | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 1.04M | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 1.04M | DB << std::move(V); | 1354 | 1.04M | return *this; | 1355 | 1.04M | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char const*, void>(char const*&&) const Line | Count | Source | 1350 | 14.5k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 14.5k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 14.5k | DB << std::move(V); | 1354 | 14.5k | return *this; | 1355 | 14.5k | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DiagnosticOptions::'unnamed', void>(clang::DiagnosticOptions::'unnamed'&&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, void>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&&) const Line | Count | Source | 1350 | 170k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 170k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 170k | DB << std::move(V); | 1354 | 170k | return *this; | 1355 | 170k | } |
Lexer.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<maybeDiagnoseIDCharCompat(clang::DiagnosticsEngine&, unsigned int, clang::CharSourceRange, bool)::$_0, void>(maybeDiagnoseIDCharCompat(clang::DiagnosticsEngine&, unsigned int, clang::CharSourceRange, bool)::$_0&&) const Line | Count | Source | 1350 | 7 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 7 | DB << std::move(V); | 1354 | 7 | return *this; | 1355 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::StringRef, void>(llvm::StringRef&&) const Line | Count | Source | 1350 | 119k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 119k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 119k | DB << std::move(V); | 1354 | 119k | return *this; | 1355 | 119k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<int, void>(int&&) const Line | Count | Source | 1350 | 558k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 558k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 558k | DB << std::move(V); | 1354 | 558k | return *this; | 1355 | 558k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FixItHint, void>(clang::FixItHint&&) const Line | Count | Source | 1350 | 324k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 324k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 324k | DB << std::move(V); | 1354 | 324k | return *this; | 1355 | 324k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CharSourceRange, void>(clang::CharSourceRange&&) const Line | Count | Source | 1350 | 559 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 559 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 559 | DB << std::move(V); | 1354 | 559 | return *this; | 1355 | 559 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<PPElifDiag, void>(PPElifDiag&&) const Line | Count | Source | 1350 | 46 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 46 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 46 | DB << std::move(V); | 1354 | 46 | return *this; | 1355 | 46 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<bool, void>(bool&&) const Line | Count | Source | 1350 | 83.5k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 83.5k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 83.5k | DB << std::move(V); | 1354 | 83.5k | return *this; | 1355 | 83.5k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SourceLocation, void>(clang::SourceLocation&&) const Line | Count | Source | 1350 | 370 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 370 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 370 | DB << std::move(V); | 1354 | 370 | return *this; | 1355 | 370 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::tok::TokenKind, void>(clang::tok::TokenKind&&) const Line | Count | Source | 1350 | 980 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 980 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 980 | DB << std::move(V); | 1354 | 980 | return *this; | 1355 | 980 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const, void>(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&&) const Line | Count | Source | 1350 | 3 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 3 | DB << std::move(V); | 1354 | 3 | return *this; | 1355 | 3 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::$_11, void>(clang::ASTReader::diagnoseOdrViolations()::$_11&&) const Line | Count | Source | 1350 | 6 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 6 | DB << std::move(V); | 1354 | 6 | return *this; | 1355 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclarationName, void>(clang::DeclarationName&&) const Line | Count | Source | 1350 | 59.7k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 59.7k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 59.7k | DB << std::move(V); | 1354 | 59.7k | return *this; | 1355 | 59.7k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ObjCContainerKind, void>(clang::Sema::ObjCContainerKind&&) const Line | Count | Source | 1350 | 37 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 37 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 37 | DB << std::move(V); | 1354 | 37 | return *this; | 1355 | 37 | } |
ParseOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::OMPContextLvl, void>((anonymous namespace)::OMPContextLvl&&) const Line | Count | Source | 1350 | 606 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 606 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 606 | DB << std::move(V); | 1354 | 606 | return *this; | 1355 | 606 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeDeclKind, void>(clang::AttributeDeclKind&&) const Line | Count | Source | 1350 | 69 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 69 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 69 | DB << std::move(V); | 1354 | 69 | return *this; | 1355 | 69 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<CastType, void>(CastType&&) const Line | Count | Source | 1350 | 138 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 138 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 138 | DB << std::move(V); | 1354 | 138 | return *this; | 1355 | 138 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Expr*, void>(clang::Expr*&&) const Line | Count | Source | 1350 | 62 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 62 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 62 | DB << std::move(V); | 1354 | 62 | return *this; | 1355 | 62 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::AssignmentAction, void>(clang::Sema::AssignmentAction&&) const Line | Count | Source | 1350 | 114 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 114 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 114 | DB << std::move(V); | 1354 | 114 | return *this; | 1355 | 114 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ConceptDecl*, void>(clang::ConceptDecl*&&) const Line | Count | Source | 1350 | 62 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 62 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 62 | DB << std::move(V); | 1354 | 62 | return *this; | 1355 | 62 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FunctionDecl*, void>(clang::FunctionDecl*&&) const Line | Count | Source | 1350 | 379 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 379 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 379 | DB << std::move(V); | 1354 | 379 | return *this; | 1355 | 379 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarDecl*, void>(clang::VarDecl*&&) const Line | Count | Source | 1350 | 516 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 516 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 516 | DB << std::move(V); | 1354 | 516 | return *this; | 1355 | 516 | } |
SemaDecl.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<CheckMultiVersionValue(clang::Sema&, clang::FunctionDecl const*)::ErrType, void>(CheckMultiVersionValue(clang::Sema&, clang::FunctionDecl const*)::ErrType&&) const Line | Count | Source | 1350 | 1 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 1 | DB << std::move(V); | 1354 | 1 | return *this; | 1355 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RecordDecl const*, void>(clang::RecordDecl const*&&) const Line | Count | Source | 1350 | 4 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 4 | DB << std::move(V); | 1354 | 4 | return *this; | 1355 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<ShadowedDeclKind, void>(ShadowedDeclKind&&) const Line | Count | Source | 1350 | 48 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 48 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 48 | DB << std::move(V); | 1354 | 48 | return *this; | 1355 | 48 | } |
SemaDecl.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::areMultiversionVariantFunctionsCompatible(clang::FunctionDecl const*, clang::FunctionDecl const*, clang::PartialDiagnostic const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, bool, bool, bool)::DoesntSupport, void>(clang::Sema::areMultiversionVariantFunctionsCompatible(clang::FunctionDecl const*, clang::FunctionDecl const*, clang::PartialDiagnostic const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, bool, bool, bool)::DoesntSupport&&) const Line | Count | Source | 1350 | 28 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 28 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 28 | DB << std::move(V); | 1354 | 28 | return *this; | 1355 | 28 | } |
SemaDecl.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::areMultiversionVariantFunctionsCompatible(clang::FunctionDecl const*, clang::FunctionDecl const*, clang::PartialDiagnostic const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, bool, bool, bool)::Different, void>(clang::Sema::areMultiversionVariantFunctionsCompatible(clang::FunctionDecl const*, clang::FunctionDecl const*, clang::PartialDiagnostic const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, std::__1::pair<clang::SourceLocation, clang::PartialDiagnostic> const&, bool, bool, bool)::Different&&) const Line | Count | Source | 1350 | 27 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 27 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 27 | DB << std::move(V); | 1354 | 27 | return *this; | 1355 | 27 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamedDecl const*, void>(clang::NamedDecl const*&&) const Line | Count | Source | 1350 | 44 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 44 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 44 | DB << std::move(V); | 1354 | 44 | return *this; | 1355 | 44 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDALaunchBoundsAttr const*, void>(clang::CUDALaunchBoundsAttr const*&&) const Line | Count | Source | 1350 | 7 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 7 | DB << std::move(V); | 1354 | 7 | return *this; | 1355 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUFlatWorkGroupSizeAttr const*, void>(clang::AMDGPUFlatWorkGroupSizeAttr const*&&) const Line | Count | Source | 1350 | 11 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 11 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 11 | DB << std::move(V); | 1354 | 11 | return *this; | 1355 | 11 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUWavesPerEUAttr const*, void>(clang::AMDGPUWavesPerEUAttr const*&&) const Line | Count | Source | 1350 | 11 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 11 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 11 | DB << std::move(V); | 1354 | 11 | return *this; | 1355 | 11 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParsedAttr const*, void>(clang::ParsedAttr const*&&) const Line | Count | Source | 1350 | 86 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 86 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 86 | DB << std::move(V); | 1354 | 86 | return *this; | 1355 | 86 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<AttributeLangSupport::LANG, void>(AttributeLangSupport::LANG&&) const Line | Count | Source | 1350 | 3 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 3 | DB << std::move(V); | 1354 | 3 | return *this; | 1355 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypedefNameDecl*, void>(clang::TypedefNameDecl*&&) const Line | Count | Source | 1350 | 30 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 30 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 30 | DB << std::move(V); | 1354 | 30 | return *this; | 1355 | 30 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AssumeAlignedAttr*, void>(clang::AssumeAlignedAttr*&&) const Line | Count | Source | 1350 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 5 | DB << std::move(V); | 1354 | 5 | return *this; | 1355 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AllocAlignAttr*, void>(clang::AllocAlignAttr*&&) const Line | Count | Source | 1350 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 5 | DB << std::move(V); | 1354 | 5 | return *this; | 1355 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AllocAlignAttr const*, void>(clang::AllocAlignAttr const*&&) const Line | Count | Source | 1350 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 5 | DB << std::move(V); | 1354 | 5 | return *this; | 1355 | 5 | } |
SemaDeclAttr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::FirstParam, void>(clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::FirstParam&&) const Line | Count | Source | 1350 | 22 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 22 | DB << std::move(V); | 1354 | 22 | return *this; | 1355 | 22 | } |
SemaDeclAttr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::SecondParam, void>(clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::SecondParam&&) const Line | Count | Source | 1350 | 22 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 22 | DB << std::move(V); | 1354 | 22 | return *this; | 1355 | 22 | } |
SemaDeclAttr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::ThirdParam, void>(clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::ThirdParam&&) const Line | Count | Source | 1350 | 22 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 22 | DB << std::move(V); | 1354 | 22 | return *this; | 1355 | 22 | } |
SemaDeclAttr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::checkTargetClonesAttrString(clang::SourceLocation, llvm::StringRef, clang::StringLiteral const*, bool&, bool&, llvm::SmallVectorImpl<llvm::StringRef>&)::FirstParam, void>(clang::Sema::checkTargetClonesAttrString(clang::SourceLocation, llvm::StringRef, clang::StringLiteral const*, bool&, bool&, llvm::SmallVectorImpl<llvm::StringRef>&)::FirstParam&&) const Line | Count | Source | 1350 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 5 | DB << std::move(V); | 1354 | 5 | return *this; | 1355 | 5 | } |
SemaDeclAttr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::checkTargetClonesAttrString(clang::SourceLocation, llvm::StringRef, clang::StringLiteral const*, bool&, bool&, llvm::SmallVectorImpl<llvm::StringRef>&)::SecondParam, void>(clang::Sema::checkTargetClonesAttrString(clang::SourceLocation, llvm::StringRef, clang::StringLiteral const*, bool&, bool&, llvm::SmallVectorImpl<llvm::StringRef>&)::SecondParam&&) const Line | Count | Source | 1350 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 5 | DB << std::move(V); | 1354 | 5 | return *this; | 1355 | 5 | } |
SemaDeclAttr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::checkTargetClonesAttrString(clang::SourceLocation, llvm::StringRef, clang::StringLiteral const*, bool&, bool&, llvm::SmallVectorImpl<llvm::StringRef>&)::ThirdParam, void>(clang::Sema::checkTargetClonesAttrString(clang::SourceLocation, llvm::StringRef, clang::StringLiteral const*, bool&, bool&, llvm::SmallVectorImpl<llvm::StringRef>&)::ThirdParam&&) const Line | Count | Source | 1350 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 5 | DB << std::move(V); | 1354 | 5 | return *this; | 1355 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlignValueAttr*, void>(clang::AlignValueAttr*&&) const Line | Count | Source | 1350 | 1 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 1 | DB << std::move(V); | 1354 | 1 | return *this; | 1355 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlignedAttr*, void>(clang::AlignedAttr*&&) const Line | Count | Source | 1350 | 20 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 20 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 20 | DB << std::move(V); | 1354 | 20 | return *this; | 1355 | 20 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::InternalLinkageAttr const*, void>(clang::InternalLinkageAttr const*&&) const clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SwiftNameAttr const*, void>(clang::SwiftNameAttr const*&&) const Line | Count | Source | 1350 | 1 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 1 | DB << std::move(V); | 1354 | 1 | return *this; | 1355 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AccessSpecifier, void>(clang::AccessSpecifier&&) const Line | Count | Source | 1350 | 8 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 8 | DB << std::move(V); | 1354 | 8 | return *this; | 1355 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamespaceDecl*, void>(clang::NamespaceDecl*&&) const Line | Count | Source | 1350 | 1 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 1 | DB << std::move(V); | 1354 | 1 | return *this; | 1355 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CanQual<clang::Type>, void>(clang::CanQual<clang::Type>&&) const Line | Count | Source | 1350 | 21 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 21 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 21 | DB << std::move(V); | 1354 | 21 | return *this; | 1355 | 21 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<std::__1::pair<clang::NullabilityKind, bool>, void>(std::__1::pair<clang::NullabilityKind, bool>&&) const Line | Count | Source | 1350 | 144 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 144 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 144 | DB << std::move(V); | 1354 | 144 | return *this; | 1355 | 144 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TagTypeKind, void>(clang::TagTypeKind&&) const Line | Count | Source | 1350 | 279 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 279 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 279 | DB << std::move(V); | 1354 | 279 | return *this; | 1355 | 279 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCMethodDecl const*, void>(clang::ObjCMethodDecl const*&&) const Line | Count | Source | 1350 | 2 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 2 | DB << std::move(V); | 1354 | 2 | return *this; | 1355 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Selector, void>(clang::Selector&&) const Line | Count | Source | 1350 | 170 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 170 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 170 | DB << std::move(V); | 1354 | 170 | return *this; | 1355 | 170 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::IdentifierInfo const*, void>(clang::IdentifierInfo const*&&) const Line | Count | Source | 1350 | 140 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 140 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 140 | DB << std::move(V); | 1354 | 140 | return *this; | 1355 | 140 | } |
SemaExpr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<$_15, void>($_15&&) const Line | Count | Source | 1350 | 347 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 347 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 347 | DB << std::move(V); | 1354 | 347 | return *this; | 1355 | 347 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::NonTagKind, void>(clang::Sema::NonTagKind&&) const Line | Count | Source | 1350 | 7 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 7 | DB << std::move(V); | 1354 | 7 | return *this; | 1355 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXRecordDecl*, void>(clang::CXXRecordDecl*&&) const Line | Count | Source | 1350 | 670 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 670 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 670 | DB << std::move(V); | 1354 | 670 | return *this; | 1355 | 670 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ValueDecl const*, void>(clang::ValueDecl const*&&) const Line | Count | Source | 1350 | 64 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 64 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 64 | DB << std::move(V); | 1354 | 64 | return *this; | 1355 | 64 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclContext*, void>(clang::DeclContext*&&) const Line | Count | Source | 1350 | 180 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 180 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 180 | DB << std::move(V); | 1354 | 180 | return *this; | 1355 | 180 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NestedNameSpecifier*, void>(clang::NestedNameSpecifier*&&) const Line | Count | Source | 1350 | 386 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 386 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 386 | DB << std::move(V); | 1354 | 386 | return *this; | 1355 | 386 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParmVarDecl*, void>(clang::ParmVarDecl*&&) const Line | Count | Source | 1350 | 388 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 388 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 388 | DB << std::move(V); | 1354 | 388 | return *this; | 1355 | 388 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ValueDecl*, void>(clang::ValueDecl*&&) const Line | Count | Source | 1350 | 242 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 242 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 242 | DB << std::move(V); | 1354 | 242 | return *this; | 1355 | 242 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FieldDecl*, void>(clang::FieldDecl*&&) const Line | Count | Source | 1350 | 388 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 388 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 388 | DB << std::move(V); | 1354 | 388 | return *this; | 1355 | 388 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers, void>(clang::Qualifiers&&) const Line | Count | Source | 1350 | 72 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 72 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 72 | DB << std::move(V); | 1354 | 72 | return *this; | 1355 | 72 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::QualType const, void>(clang::QualType const&&) const Line | Count | Source | 1350 | 42 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 42 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 42 | DB << std::move(V); | 1354 | 42 | return *this; | 1355 | 42 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::checkOpenMPDeclareVariantFunction(clang::OpaquePtr<clang::DeclGroupRef>, clang::Expr*, clang::OMPTraitInfo&, unsigned int, clang::SourceRange)::DoesntSupport, void>(clang::Sema::checkOpenMPDeclareVariantFunction(clang::OpaquePtr<clang::DeclGroupRef>, clang::Expr*, clang::OMPTraitInfo&, unsigned int, clang::SourceRange)::DoesntSupport&&) const Line | Count | Source | 1350 | 12 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 12 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 12 | DB << std::move(V); | 1354 | 12 | return *this; | 1355 | 12 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::LangAS, void>(clang::LangAS&&) const Line | Count | Source | 1350 | 112 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 112 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 112 | DB << std::move(V); | 1354 | 112 | return *this; | 1355 | 112 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers::ObjCLifetime, void>(clang::Qualifiers::ObjCLifetime&&) const Line | Count | Source | 1350 | 34 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 34 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 34 | DB << std::move(V); | 1354 | 34 | return *this; | 1355 | 34 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers::GC, void>(clang::Qualifiers::GC&&) const Line | Count | Source | 1350 | 4 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 4 | DB << std::move(V); | 1354 | 4 | return *this; | 1355 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateDecl*, void>(clang::TemplateDecl*&&) const Line | Count | Source | 1350 | 6 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 6 | DB << std::move(V); | 1354 | 6 | return *this; | 1355 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RefQualifierKind, void>(clang::RefQualifierKind&&) const Line | Count | Source | 1350 | 22 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 22 | DB << std::move(V); | 1354 | 22 | return *this; | 1355 | 22 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamedDecl*, void>(clang::NamedDecl*&&) const Line | Count | Source | 1350 | 490 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 490 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 490 | DB << std::move(V); | 1354 | 490 | return *this; | 1355 | 490 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CXXSpecialMember, void>(clang::Sema::CXXSpecialMember&&) const Line | Count | Source | 1350 | 1.04k | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 1.04k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 1.04k | DB << std::move(V); | 1354 | 1.04k | return *this; | 1355 | 1.04k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXRecordDecl const*, void>(clang::CXXRecordDecl const*&&) const Line | Count | Source | 1350 | 52 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 52 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 52 | DB << std::move(V); | 1354 | 52 | return *this; | 1355 | 52 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MSPropertyDecl*, void>(clang::MSPropertyDecl*&&) const Line | Count | Source | 1350 | 25 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 25 | DB << std::move(V); | 1354 | 25 | return *this; | 1355 | 25 | } |
SemaStmt.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::BeginEndFunction, void>((anonymous namespace)::BeginEndFunction&&) const Line | Count | Source | 1350 | 6 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 6 | DB << std::move(V); | 1354 | 6 | return *this; | 1355 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Attr const*, void>(clang::Attr const*&&) const Line | Count | Source | 1350 | 841 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 841 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 841 | DB << std::move(V); | 1354 | 841 | return *this; | 1355 | 841 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CUDAFunctionTarget, void>(clang::Sema::CUDAFunctionTarget&&) const Line | Count | Source | 1350 | 99 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 99 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 99 | DB << std::move(V); | 1354 | 99 | return *this; | 1355 | 99 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypeAliasTemplateDecl*, void>(clang::TypeAliasTemplateDecl*&&) const Line | Count | Source | 1350 | 14 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 14 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 14 | DB << std::move(V); | 1354 | 14 | return *this; | 1355 | 14 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::BindingDecl*, void>(clang::BindingDecl*&&) const Line | Count | Source | 1350 | 10 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 10 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 10 | DB << std::move(V); | 1354 | 10 | return *this; | 1355 | 10 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<TypeDiagSelector, void>(TypeDiagSelector&&) const Line | Count | Source | 1350 | 25 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 25 | DB << std::move(V); | 1354 | 25 | return *this; | 1355 | 25 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned long long, void>(unsigned long long&&) const Line | Count | Source | 1350 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 5 | DB << std::move(V); | 1354 | 5 | return *this; | 1355 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeArgumentNType, void>(clang::AttributeArgumentNType&&) const Line | Count | Source | 1350 | 184 | const DiagnosticBuilder &operator<<(T &&V) const { | 1351 | 184 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1352 | 0 | const StreamingDiagnostic &DB = *this; | 1353 | 184 | DB << std::move(V); | 1354 | 184 | return *this; | 1355 | 184 | } |
|
1356 | | |
1357 | | DiagnosticBuilder &operator=(const DiagnosticBuilder &) = delete; |
1358 | | |
1359 | | /// Emits the diagnostic. |
1360 | 17.2M | ~DiagnosticBuilder() { Emit(); } |
1361 | | |
1362 | | /// Forces the diagnostic to be emitted. |
1363 | 162 | const DiagnosticBuilder &setForceEmit() const { |
1364 | 162 | IsForceEmit = true; |
1365 | 162 | return *this; |
1366 | 162 | } |
1367 | | |
1368 | 2.57k | void addFlagValue(StringRef V) const { DiagObj->FlagValue = std::string(V); } |
1369 | | }; |
1370 | | |
1371 | | struct AddFlagValue { |
1372 | | StringRef Val; |
1373 | | |
1374 | 2.57k | explicit AddFlagValue(StringRef V) : Val(V) {} |
1375 | | }; |
1376 | | |
1377 | | /// Register a value for the flag in the current diagnostic. This |
1378 | | /// value will be shown as the suffix "=value" after the flag name. It is |
1379 | | /// useful in cases where the diagnostic flag accepts values (e.g., |
1380 | | /// -Rpass or -Wframe-larger-than). |
1381 | | inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, |
1382 | 2.57k | const AddFlagValue V) { |
1383 | 2.57k | DB.addFlagValue(V.Val); |
1384 | 2.57k | return DB; |
1385 | 2.57k | } |
1386 | | |
1387 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1388 | 1.77M | StringRef S) { |
1389 | 1.77M | DB.AddString(S); |
1390 | 1.77M | return DB; |
1391 | 1.77M | } |
1392 | | |
1393 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1394 | 57.7k | const char *Str) { |
1395 | 57.7k | DB.AddTaggedVal(reinterpret_cast<intptr_t>(Str), |
1396 | 57.7k | DiagnosticsEngine::ak_c_string); |
1397 | 57.7k | return DB; |
1398 | 57.7k | } |
1399 | | |
1400 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1401 | 680k | int I) { |
1402 | 680k | DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint); |
1403 | 680k | return DB; |
1404 | 680k | } |
1405 | | |
1406 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1407 | 0 | long I) { |
1408 | 0 | DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint); |
1409 | 0 | return DB; |
1410 | 0 | } |
1411 | | |
1412 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1413 | 0 | long long I) { |
1414 | 0 | DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint); |
1415 | 0 | return DB; |
1416 | 0 | } |
1417 | | |
1418 | | // We use enable_if here to prevent that this overload is selected for |
1419 | | // pointers or other arguments that are implicitly convertible to bool. |
1420 | | template <typename T> |
1421 | | inline std::enable_if_t<std::is_same<T, bool>::value, |
1422 | | const StreamingDiagnostic &> |
1423 | 315k | operator<<(const StreamingDiagnostic &DB, T I) { |
1424 | 315k | DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint); |
1425 | 315k | return DB; |
1426 | 315k | } |
1427 | | |
1428 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1429 | 3.06M | unsigned I) { |
1430 | 3.06M | DB.AddTaggedVal(I, DiagnosticsEngine::ak_uint); |
1431 | 3.06M | return DB; |
1432 | 3.06M | } |
1433 | | |
1434 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1435 | 23 | unsigned long I) { |
1436 | 23 | DB.AddTaggedVal(I, DiagnosticsEngine::ak_uint); |
1437 | 23 | return DB; |
1438 | 23 | } |
1439 | | |
1440 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1441 | 27 | unsigned long long I) { |
1442 | 27 | DB.AddTaggedVal(I, DiagnosticsEngine::ak_uint); |
1443 | 27 | return DB; |
1444 | 27 | } |
1445 | | |
1446 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1447 | 45.1k | tok::TokenKind I) { |
1448 | 45.1k | DB.AddTaggedVal(static_cast<unsigned>(I), DiagnosticsEngine::ak_tokenkind); |
1449 | 45.1k | return DB; |
1450 | 45.1k | } |
1451 | | |
1452 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1453 | 260k | const IdentifierInfo *II) { |
1454 | 260k | DB.AddTaggedVal(reinterpret_cast<intptr_t>(II), |
1455 | 260k | DiagnosticsEngine::ak_identifierinfo); |
1456 | 260k | return DB; |
1457 | 260k | } |
1458 | | |
1459 | | // Adds a DeclContext to the diagnostic. The enable_if template magic is here |
1460 | | // so that we only match those arguments that are (statically) DeclContexts; |
1461 | | // other arguments that derive from DeclContext (e.g., RecordDecls) will not |
1462 | | // match. |
1463 | | template <typename T> |
1464 | | inline std::enable_if_t< |
1465 | | std::is_same<std::remove_const_t<T>, DeclContext>::value, |
1466 | | const StreamingDiagnostic &> |
1467 | 56.5k | operator<<(const StreamingDiagnostic &DB, T *DC) { |
1468 | 56.5k | DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC), |
1469 | 56.5k | DiagnosticsEngine::ak_declcontext); |
1470 | 56.5k | return DB; |
1471 | 56.5k | } std::__1::enable_if<std::is_same<std::__1::remove_const<clang::DeclContext>::type, clang::DeclContext>::value, clang::StreamingDiagnostic const&>::type clang::operator<<<clang::DeclContext>(clang::StreamingDiagnostic const&, clang::DeclContext*) Line | Count | Source | 1467 | 56.5k | operator<<(const StreamingDiagnostic &DB, T *DC) { | 1468 | 56.5k | DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC), | 1469 | 56.5k | DiagnosticsEngine::ak_declcontext); | 1470 | 56.5k | return DB; | 1471 | 56.5k | } |
std::__1::enable_if<std::is_same<std::__1::remove_const<clang::DeclContext const>::type, clang::DeclContext>::value, clang::StreamingDiagnostic const&>::type clang::operator<<<clang::DeclContext const>(clang::StreamingDiagnostic const&, clang::DeclContext const*) Line | Count | Source | 1467 | 52 | operator<<(const StreamingDiagnostic &DB, T *DC) { | 1468 | 52 | DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC), | 1469 | 52 | DiagnosticsEngine::ak_declcontext); | 1470 | 52 | return DB; | 1471 | 52 | } |
|
1472 | | |
1473 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1474 | 1.48M | SourceRange R) { |
1475 | 1.48M | DB.AddSourceRange(CharSourceRange::getTokenRange(R)); |
1476 | 1.48M | return DB; |
1477 | 1.48M | } |
1478 | | |
1479 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1480 | 25.2k | ArrayRef<SourceRange> Ranges) { |
1481 | 25.2k | for (SourceRange R : Ranges) |
1482 | 39.4k | DB.AddSourceRange(CharSourceRange::getTokenRange(R)); |
1483 | 25.2k | return DB; |
1484 | 25.2k | } |
1485 | | |
1486 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1487 | 10.0k | const CharSourceRange &R) { |
1488 | 10.0k | DB.AddSourceRange(R); |
1489 | 10.0k | return DB; |
1490 | 10.0k | } |
1491 | | |
1492 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1493 | 393k | const FixItHint &Hint) { |
1494 | 393k | DB.AddFixItHint(Hint); |
1495 | 393k | return DB; |
1496 | 393k | } |
1497 | | |
1498 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1499 | 61.2k | ArrayRef<FixItHint> Hints) { |
1500 | 61.2k | for (const FixItHint &Hint : Hints) |
1501 | 1.46k | DB.AddFixItHint(Hint); |
1502 | 61.2k | return DB; |
1503 | 61.2k | } |
1504 | | |
1505 | | inline const StreamingDiagnostic & |
1506 | | operator<<(const StreamingDiagnostic &DB, |
1507 | 0 | const llvm::Optional<SourceRange> &Opt) { |
1508 | 0 | if (Opt) |
1509 | 0 | DB << *Opt; |
1510 | 0 | return DB; |
1511 | 0 | } |
1512 | | |
1513 | | inline const StreamingDiagnostic & |
1514 | | operator<<(const StreamingDiagnostic &DB, |
1515 | 0 | const llvm::Optional<CharSourceRange> &Opt) { |
1516 | 0 | if (Opt) |
1517 | 0 | DB << *Opt; |
1518 | 0 | return DB; |
1519 | 0 | } |
1520 | | |
1521 | | inline const StreamingDiagnostic & |
1522 | | operator<<(const StreamingDiagnostic &DB, |
1523 | 0 | const llvm::Optional<FixItHint> &Opt) { |
1524 | 0 | if (Opt) |
1525 | 0 | DB << *Opt; |
1526 | 0 | return DB; |
1527 | 0 | } |
1528 | | |
1529 | | /// A nullability kind paired with a bit indicating whether it used a |
1530 | | /// context-sensitive keyword. |
1531 | | using DiagNullabilityKind = std::pair<NullabilityKind, bool>; |
1532 | | |
1533 | | const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1534 | | DiagNullabilityKind nullability); |
1535 | | |
1536 | | inline DiagnosticBuilder DiagnosticsEngine::Report(SourceLocation Loc, |
1537 | 11.2M | unsigned DiagID) { |
1538 | 11.2M | assert(CurDiagID == std::numeric_limits<unsigned>::max() && |
1539 | 11.2M | "Multiple diagnostics in flight at once!"); |
1540 | 0 | CurDiagLoc = Loc; |
1541 | 11.2M | CurDiagID = DiagID; |
1542 | 11.2M | FlagValue.clear(); |
1543 | 11.2M | return DiagnosticBuilder(this); |
1544 | 11.2M | } |
1545 | | |
1546 | | const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1547 | | llvm::Error &&E); |
1548 | | |
1549 | 151k | inline DiagnosticBuilder DiagnosticsEngine::Report(unsigned DiagID) { |
1550 | 151k | return Report(SourceLocation(), DiagID); |
1551 | 151k | } |
1552 | | |
1553 | | //===----------------------------------------------------------------------===// |
1554 | | // Diagnostic |
1555 | | //===----------------------------------------------------------------------===// |
1556 | | |
1557 | | /// A little helper class (which is basically a smart pointer that forwards |
1558 | | /// info from DiagnosticsEngine) that allows clients to enquire about the |
1559 | | /// currently in-flight diagnostic. |
1560 | | class Diagnostic { |
1561 | | const DiagnosticsEngine *DiagObj; |
1562 | | StringRef StoredDiagMessage; |
1563 | | |
1564 | | public: |
1565 | 14.7M | explicit Diagnostic(const DiagnosticsEngine *DO) : DiagObj(DO) {} |
1566 | | Diagnostic(const DiagnosticsEngine *DO, StringRef storedDiagMessage) |
1567 | 150 | : DiagObj(DO), StoredDiagMessage(storedDiagMessage) {} |
1568 | | |
1569 | 631k | const DiagnosticsEngine *getDiags() const { return DiagObj; } |
1570 | 11.7M | unsigned getID() const { return DiagObj->CurDiagID; } |
1571 | 12.0M | const SourceLocation &getLocation() const { return DiagObj->CurDiagLoc; } |
1572 | 414k | bool hasSourceManager() const { return DiagObj->hasSourceManager(); } |
1573 | 786k | SourceManager &getSourceManager() const { return DiagObj->getSourceManager();} |
1574 | | |
1575 | 4.57M | unsigned getNumArgs() const { return DiagObj->DiagStorage.NumDiagArgs; } |
1576 | | |
1577 | | /// Return the kind of the specified index. |
1578 | | /// |
1579 | | /// Based on the kind of argument, the accessors below can be used to get |
1580 | | /// the value. |
1581 | | /// |
1582 | | /// \pre Idx < getNumArgs() |
1583 | 3.81M | DiagnosticsEngine::ArgumentKind getArgKind(unsigned Idx) const { |
1584 | 3.81M | assert(Idx < getNumArgs() && "Argument index out of range!"); |
1585 | 0 | return (DiagnosticsEngine::ArgumentKind) |
1586 | 3.81M | DiagObj->DiagStorage.DiagArgumentsKind[Idx]; |
1587 | 3.81M | } |
1588 | | |
1589 | | /// Return the provided argument string specified by \p Idx. |
1590 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_std_string |
1591 | 322k | const std::string &getArgStdStr(unsigned Idx) const { |
1592 | 322k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_std_string && |
1593 | 322k | "invalid argument accessor!"); |
1594 | 0 | return DiagObj->DiagStorage.DiagArgumentsStr[Idx]; |
1595 | 322k | } |
1596 | | |
1597 | | /// Return the specified C string argument. |
1598 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_c_string |
1599 | 17.0k | const char *getArgCStr(unsigned Idx) const { |
1600 | 17.0k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_c_string && |
1601 | 17.0k | "invalid argument accessor!"); |
1602 | 0 | return reinterpret_cast<const char *>( |
1603 | 17.0k | DiagObj->DiagStorage.DiagArgumentsVal[Idx]); |
1604 | 17.0k | } |
1605 | | |
1606 | | /// Return the specified signed integer argument. |
1607 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_sint |
1608 | 115k | int64_t getArgSInt(unsigned Idx) const { |
1609 | 115k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_sint && |
1610 | 115k | "invalid argument accessor!"); |
1611 | 0 | return (int64_t)DiagObj->DiagStorage.DiagArgumentsVal[Idx]; |
1612 | 115k | } |
1613 | | |
1614 | | /// Return the specified unsigned integer argument. |
1615 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_uint |
1616 | 77.7k | uint64_t getArgUInt(unsigned Idx) const { |
1617 | 77.7k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_uint && |
1618 | 77.7k | "invalid argument accessor!"); |
1619 | 0 | return DiagObj->DiagStorage.DiagArgumentsVal[Idx]; |
1620 | 77.7k | } |
1621 | | |
1622 | | /// Return the specified IdentifierInfo argument. |
1623 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_identifierinfo |
1624 | 9.39k | const IdentifierInfo *getArgIdentifier(unsigned Idx) const { |
1625 | 9.39k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_identifierinfo && |
1626 | 9.39k | "invalid argument accessor!"); |
1627 | 0 | return reinterpret_cast<IdentifierInfo *>( |
1628 | 9.39k | DiagObj->DiagStorage.DiagArgumentsVal[Idx]); |
1629 | 9.39k | } |
1630 | | |
1631 | | /// Return the specified non-string argument in an opaque form. |
1632 | | /// \pre getArgKind(Idx) != DiagnosticsEngine::ak_std_string |
1633 | 991k | uint64_t getRawArg(unsigned Idx) const { |
1634 | 991k | assert(getArgKind(Idx) != DiagnosticsEngine::ak_std_string && |
1635 | 991k | "invalid argument accessor!"); |
1636 | 0 | return DiagObj->DiagStorage.DiagArgumentsVal[Idx]; |
1637 | 991k | } |
1638 | | |
1639 | | /// Return the number of source ranges associated with this diagnostic. |
1640 | 294k | unsigned getNumRanges() const { |
1641 | 294k | return DiagObj->DiagStorage.DiagRanges.size(); |
1642 | 294k | } |
1643 | | |
1644 | | /// \pre Idx < getNumRanges() |
1645 | 136k | const CharSourceRange &getRange(unsigned Idx) const { |
1646 | 136k | assert(Idx < getNumRanges() && "Invalid diagnostic range index!"); |
1647 | 0 | return DiagObj->DiagStorage.DiagRanges[Idx]; |
1648 | 136k | } |
1649 | | |
1650 | | /// Return an array reference for this diagnostic's ranges. |
1651 | 43.6k | ArrayRef<CharSourceRange> getRanges() const { |
1652 | 43.6k | return DiagObj->DiagStorage.DiagRanges; |
1653 | 43.6k | } |
1654 | | |
1655 | 160k | unsigned getNumFixItHints() const { |
1656 | 160k | return DiagObj->DiagStorage.FixItHints.size(); |
1657 | 160k | } |
1658 | | |
1659 | 1.05k | const FixItHint &getFixItHint(unsigned Idx) const { |
1660 | 1.05k | assert(Idx < getNumFixItHints() && "Invalid index!"); |
1661 | 0 | return DiagObj->DiagStorage.FixItHints[Idx]; |
1662 | 1.05k | } |
1663 | | |
1664 | 44.0k | ArrayRef<FixItHint> getFixItHints() const { |
1665 | 44.0k | return DiagObj->DiagStorage.FixItHints; |
1666 | 44.0k | } |
1667 | | |
1668 | | /// Format this diagnostic into a string, substituting the |
1669 | | /// formal arguments into the %0 slots. |
1670 | | /// |
1671 | | /// The result is appended onto the \p OutStr array. |
1672 | | void FormatDiagnostic(SmallVectorImpl<char> &OutStr) const; |
1673 | | |
1674 | | /// Format the given format-string into the output buffer using the |
1675 | | /// arguments stored in this diagnostic. |
1676 | | void FormatDiagnostic(const char *DiagStr, const char *DiagEnd, |
1677 | | SmallVectorImpl<char> &OutStr) const; |
1678 | | }; |
1679 | | |
1680 | | /** |
1681 | | * Represents a diagnostic in a form that can be retained until its |
1682 | | * corresponding source manager is destroyed. |
1683 | | */ |
1684 | | class StoredDiagnostic { |
1685 | | unsigned ID; |
1686 | | DiagnosticsEngine::Level Level; |
1687 | | FullSourceLoc Loc; |
1688 | | std::string Message; |
1689 | | std::vector<CharSourceRange> Ranges; |
1690 | | std::vector<FixItHint> FixIts; |
1691 | | |
1692 | | public: |
1693 | | StoredDiagnostic() = default; |
1694 | | StoredDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info); |
1695 | | StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID, |
1696 | | StringRef Message); |
1697 | | StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID, |
1698 | | StringRef Message, FullSourceLoc Loc, |
1699 | | ArrayRef<CharSourceRange> Ranges, |
1700 | | ArrayRef<FixItHint> Fixits); |
1701 | | |
1702 | | /// Evaluates true when this object stores a diagnostic. |
1703 | 0 | explicit operator bool() const { return !Message.empty(); } |
1704 | | |
1705 | 22.6k | unsigned getID() const { return ID; } |
1706 | 9.53k | DiagnosticsEngine::Level getLevel() const { return Level; } |
1707 | 27.5k | const FullSourceLoc &getLocation() const { return Loc; } |
1708 | 2.07k | StringRef getMessage() const { return Message; } |
1709 | | |
1710 | 97 | void setLocation(FullSourceLoc Loc) { this->Loc = Loc; } |
1711 | | |
1712 | | using range_iterator = std::vector<CharSourceRange>::const_iterator; |
1713 | | |
1714 | 253 | range_iterator range_begin() const { return Ranges.begin(); } |
1715 | 151 | range_iterator range_end() const { return Ranges.end(); } |
1716 | 883 | unsigned range_size() const { return Ranges.size(); } |
1717 | | |
1718 | 666 | ArrayRef<CharSourceRange> getRanges() const { |
1719 | 666 | return llvm::makeArrayRef(Ranges); |
1720 | 666 | } |
1721 | | |
1722 | | using fixit_iterator = std::vector<FixItHint>::const_iterator; |
1723 | | |
1724 | 192 | fixit_iterator fixit_begin() const { return FixIts.begin(); } |
1725 | 150 | fixit_iterator fixit_end() const { return FixIts.end(); } |
1726 | 823 | unsigned fixit_size() const { return FixIts.size(); } |
1727 | | |
1728 | 664 | ArrayRef<FixItHint> getFixIts() const { |
1729 | 664 | return llvm::makeArrayRef(FixIts); |
1730 | 664 | } |
1731 | | }; |
1732 | | |
1733 | | // Simple debug printing of StoredDiagnostic. |
1734 | | llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const StoredDiagnostic &); |
1735 | | |
1736 | | /// Abstract interface, implemented by clients of the front-end, which |
1737 | | /// formats and prints fully processed diagnostics. |
1738 | | class DiagnosticConsumer { |
1739 | | protected: |
1740 | | unsigned NumWarnings = 0; ///< Number of warnings reported |
1741 | | unsigned NumErrors = 0; ///< Number of errors reported |
1742 | | |
1743 | | public: |
1744 | 467k | DiagnosticConsumer() = default; |
1745 | | virtual ~DiagnosticConsumer(); |
1746 | | |
1747 | 144k | unsigned getNumErrors() const { return NumErrors; } |
1748 | 62.0k | unsigned getNumWarnings() const { return NumWarnings; } |
1749 | 206 | virtual void clear() { NumWarnings = NumErrors = 0; } |
1750 | | |
1751 | | /// Callback to inform the diagnostic client that processing |
1752 | | /// of a source file is beginning. |
1753 | | /// |
1754 | | /// Note that diagnostics may be emitted outside the processing of a source |
1755 | | /// file, for example during the parsing of command line options. However, |
1756 | | /// diagnostics with source range information are required to only be emitted |
1757 | | /// in between BeginSourceFile() and EndSourceFile(). |
1758 | | /// |
1759 | | /// \param LangOpts The language options for the source file being processed. |
1760 | | /// \param PP The preprocessor object being used for the source; this is |
1761 | | /// optional, e.g., it may not be present when processing AST source files. |
1762 | | virtual void BeginSourceFile(const LangOptions &LangOpts, |
1763 | 2.09k | const Preprocessor *PP = nullptr) {} |
1764 | | |
1765 | | /// Callback to inform the diagnostic client that processing |
1766 | | /// of a source file has ended. |
1767 | | /// |
1768 | | /// The diagnostic client should assume that any objects made available via |
1769 | | /// BeginSourceFile() are inaccessible. |
1770 | 5.01k | virtual void EndSourceFile() {} |
1771 | | |
1772 | | /// Callback to inform the diagnostic client that processing of all |
1773 | | /// source files has ended. |
1774 | 81.3k | virtual void finish() {} |
1775 | | |
1776 | | /// Indicates whether the diagnostics handled by this |
1777 | | /// DiagnosticConsumer should be included in the number of diagnostics |
1778 | | /// reported by DiagnosticsEngine. |
1779 | | /// |
1780 | | /// The default implementation returns true. |
1781 | | virtual bool IncludeInDiagnosticCounts() const; |
1782 | | |
1783 | | /// Handle this diagnostic, reporting it to the user or |
1784 | | /// capturing it to a log as needed. |
1785 | | /// |
1786 | | /// The default implementation just keeps track of the total number of |
1787 | | /// warnings and errors. |
1788 | | virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
1789 | | const Diagnostic &Info); |
1790 | | }; |
1791 | | |
1792 | | /// A diagnostic client that ignores all diagnostics. |
1793 | | class IgnoringDiagConsumer : public DiagnosticConsumer { |
1794 | | virtual void anchor(); |
1795 | | |
1796 | | void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
1797 | 72 | const Diagnostic &Info) override { |
1798 | | // Just ignore it. |
1799 | 72 | } |
1800 | | }; |
1801 | | |
1802 | | /// Diagnostic consumer that forwards diagnostics along to an |
1803 | | /// existing, already-initialized diagnostic consumer. |
1804 | | /// |
1805 | | class ForwardingDiagnosticConsumer : public DiagnosticConsumer { |
1806 | | DiagnosticConsumer &Target; |
1807 | | |
1808 | | public: |
1809 | 1.85k | ForwardingDiagnosticConsumer(DiagnosticConsumer &Target) : Target(Target) {} |
1810 | | ~ForwardingDiagnosticConsumer() override; |
1811 | | |
1812 | | void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
1813 | | const Diagnostic &Info) override; |
1814 | | void clear() override; |
1815 | | |
1816 | | bool IncludeInDiagnosticCounts() const override; |
1817 | | }; |
1818 | | |
1819 | | // Struct used for sending info about how a type should be printed. |
1820 | | struct TemplateDiffTypes { |
1821 | | intptr_t FromType; |
1822 | | intptr_t ToType; |
1823 | | unsigned PrintTree : 1; |
1824 | | unsigned PrintFromType : 1; |
1825 | | unsigned ElideType : 1; |
1826 | | unsigned ShowColors : 1; |
1827 | | |
1828 | | // The printer sets this variable to true if the template diff was used. |
1829 | | unsigned TemplateDiffUsed : 1; |
1830 | | }; |
1831 | | |
1832 | | /// Special character that the diagnostic printer will use to toggle the bold |
1833 | | /// attribute. The character itself will be not be printed. |
1834 | | const char ToggleHighlight = 127; |
1835 | | |
1836 | | /// ProcessWarningOptions - Initialize the diagnostic client and process the |
1837 | | /// warning options specified on the command line. |
1838 | | void ProcessWarningOptions(DiagnosticsEngine &Diags, |
1839 | | const DiagnosticOptions &Opts, |
1840 | | bool ReportDiags = true); |
1841 | | |
1842 | | } // namespace clang |
1843 | | |
1844 | | #endif // LLVM_CLANG_BASIC_DIAGNOSTIC_H |