/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 | 421k | FixItHint() = default; |
90 | | |
91 | 413k | bool isNull() const { |
92 | 413k | return !RemoveRange.isValid(); |
93 | 413k | } |
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 | 285k | bool BeforePreviousInsertions = false) { |
100 | 285k | FixItHint Hint; |
101 | 285k | Hint.RemoveRange = |
102 | 285k | CharSourceRange::getCharRange(InsertionLoc, InsertionLoc); |
103 | 285k | Hint.CodeToInsert = std::string(Code); |
104 | 285k | Hint.BeforePreviousInsertions = BeforePreviousInsertions; |
105 | 285k | return Hint; |
106 | 285k | } |
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.8k | static FixItHint CreateRemoval(CharSourceRange RemoveRange) { |
124 | 32.8k | FixItHint Hint; |
125 | 32.8k | Hint.RemoveRange = RemoveRange; |
126 | 32.8k | return Hint; |
127 | 32.8k | } |
128 | 32.2k | static FixItHint CreateRemoval(SourceRange RemoveRange) { |
129 | 32.2k | return CreateRemoval(CharSourceRange::getTokenRange(RemoveRange)); |
130 | 32.2k | } |
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 | 44.6k | StringRef Code) { |
136 | 44.6k | FixItHint Hint; |
137 | 44.6k | Hint.RemoveRange = RemoveRange; |
138 | 44.6k | Hint.CodeToInsert = std::string(Code); |
139 | 44.6k | return Hint; |
140 | 44.6k | } |
141 | | |
142 | | static FixItHint CreateReplacement(SourceRange RemoveRange, |
143 | 10.1k | StringRef Code) { |
144 | 10.1k | return CreateReplacement(CharSourceRange::getTokenRange(RemoveRange), Code); |
145 | 10.1k | } |
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.99M | 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 | 430k | 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.36M | void setMapping(diag::kind Diag, DiagnosticMapping Info) { |
344 | 3.36M | DiagMap[Diag] = Info; |
345 | 3.36M | } |
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.3k | const_iterator begin() const { return DiagMap.begin(); } |
354 | 14.3k | 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 | 258k | bool empty() const { return Files.empty(); } |
375 | | |
376 | | /// Clear out this map. |
377 | 429k | void clear() { |
378 | 429k | Files.clear(); |
379 | 429k | FirstDiagState = CurDiagState = nullptr; |
380 | 429k | CurDiagStateLoc = SourceLocation(); |
381 | 429k | } |
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 | 32.1M | DiagState *getCurDiagState() const { return CurDiagState; } |
389 | | |
390 | | /// Get the location at which a diagnostic state was last added. |
391 | 709k | 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.84M | : 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.4M | DiagState *GetCurDiagState() const { |
455 | 25.4M | return DiagStatesByLoc.getCurDiagState(); |
456 | 25.4M | } |
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 | 191M | DiagState *GetDiagStateForLoc(SourceLocation Loc) const { |
463 | 191M | return SourceMgr ? DiagStatesByLoc.lookup(*SourceMgr, Loc)191M |
464 | 191M | : DiagStatesByLoc.getCurDiagState()135k ; |
465 | 191M | } |
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 | | friend void DiagnosticsTestHelper(DiagnosticsEngine &); |
549 | | LLVM_DUMP_METHOD void dump() const; |
550 | | LLVM_DUMP_METHOD void dump(StringRef DiagName) const; |
551 | | |
552 | 3.84M | const IntrusiveRefCntPtr<DiagnosticIDs> &getDiagnosticIDs() const { |
553 | 3.84M | return Diags; |
554 | 3.84M | } |
555 | | |
556 | | /// Retrieve the diagnostic options. |
557 | 11.5M | DiagnosticOptions &getDiagnosticOptions() const { return *DiagOpts; } |
558 | | |
559 | | using diag_mapping_range = llvm::iterator_range<DiagState::const_iterator>; |
560 | | |
561 | | /// Get the current set of diagnostic mappings. |
562 | 3.70k | diag_mapping_range getDiagnosticMappings() const { |
563 | 3.70k | const DiagState &DS = *GetCurDiagState(); |
564 | 3.70k | return diag_mapping_range(DS.begin(), DS.end()); |
565 | 3.70k | } |
566 | | |
567 | 26.1M | DiagnosticConsumer *getClient() { return Client; } |
568 | 0 | const DiagnosticConsumer *getClient() const { return Client; } |
569 | | |
570 | | /// Determine whether this \c DiagnosticsEngine object own its client. |
571 | 18.0k | bool ownsClient() const { return Owner != nullptr; } |
572 | | |
573 | | /// Return the current diagnostic client along with ownership of that |
574 | | /// client. |
575 | 56.1k | std::unique_ptr<DiagnosticConsumer> takeClient() { return std::move(Owner); } |
576 | | |
577 | 460k | bool hasSourceManager() const { return SourceMgr != nullptr; } |
578 | | |
579 | 23.4M | SourceManager &getSourceManager() const { |
580 | 23.4M | assert(SourceMgr && "SourceManager not set!"); |
581 | 0 | return *SourceMgr; |
582 | 23.4M | } |
583 | | |
584 | 258k | void setSourceManager(SourceManager *SrcMgr) { |
585 | 258k | assert(DiagStatesByLoc.empty() && |
586 | 258k | "Leftover diag state from a different SourceManager."); |
587 | 0 | SourceMgr = SrcMgr; |
588 | 258k | } |
589 | | |
590 | | //===--------------------------------------------------------------------===// |
591 | | // DiagnosticsEngine characterization methods, used by a client to customize |
592 | | // how diagnostics are emitted. |
593 | | // |
594 | | |
595 | | /// Copies the current DiagMappings and pushes the new copy |
596 | | /// onto the top of the stack. |
597 | | void pushMappings(SourceLocation Loc); |
598 | | |
599 | | /// Pops the current DiagMappings off the top of the stack, |
600 | | /// causing the new top of the stack to be the active mappings. |
601 | | /// |
602 | | /// \returns \c true if the pop happens, \c false if there is only one |
603 | | /// DiagMapping on the stack. |
604 | | bool popMappings(SourceLocation Loc); |
605 | | |
606 | | /// Set the diagnostic client associated with this diagnostic object. |
607 | | /// |
608 | | /// \param ShouldOwnClient true if the diagnostic object should take |
609 | | /// ownership of \c client. |
610 | | void setClient(DiagnosticConsumer *client, bool ShouldOwnClient = true); |
611 | | |
612 | | /// Specify a limit for the number of errors we should |
613 | | /// emit before giving up. |
614 | | /// |
615 | | /// Zero disables the limit. |
616 | 60.8k | void setErrorLimit(unsigned Limit) { ErrorLimit = Limit; } |
617 | | |
618 | | /// Specify the maximum number of template instantiation |
619 | | /// notes to emit along with a given diagnostic. |
620 | 150k | void setTemplateBacktraceLimit(unsigned Limit) { |
621 | 150k | TemplateBacktraceLimit = Limit; |
622 | 150k | } |
623 | | |
624 | | /// Retrieve the maximum number of template instantiation |
625 | | /// notes to emit along with a given diagnostic. |
626 | 6.41k | unsigned getTemplateBacktraceLimit() const { |
627 | 6.41k | return TemplateBacktraceLimit; |
628 | 6.41k | } |
629 | | |
630 | | /// Specify the maximum number of constexpr evaluation |
631 | | /// notes to emit along with a given diagnostic. |
632 | 150k | void setConstexprBacktraceLimit(unsigned Limit) { |
633 | 150k | ConstexprBacktraceLimit = Limit; |
634 | 150k | } |
635 | | |
636 | | /// Retrieve the maximum number of constexpr evaluation |
637 | | /// notes to emit along with a given diagnostic. |
638 | 822k | unsigned getConstexprBacktraceLimit() const { |
639 | 822k | return ConstexprBacktraceLimit; |
640 | 822k | } |
641 | | |
642 | | /// When set to true, any unmapped warnings are ignored. |
643 | | /// |
644 | | /// If this and WarningsAsErrors are both set, then this one wins. |
645 | 200k | void setIgnoreAllWarnings(bool Val) { |
646 | 200k | GetCurDiagState()->IgnoreAllWarnings = Val; |
647 | 200k | } |
648 | 3.44M | bool getIgnoreAllWarnings() const { |
649 | 3.44M | return GetCurDiagState()->IgnoreAllWarnings; |
650 | 3.44M | } |
651 | | |
652 | | /// When set to true, any unmapped ignored warnings are no longer |
653 | | /// ignored. |
654 | | /// |
655 | | /// If this and IgnoreAllWarnings are both set, then that one wins. |
656 | 48 | void setEnableAllWarnings(bool Val) { |
657 | 48 | GetCurDiagState()->EnableAllWarnings = Val; |
658 | 48 | } |
659 | 43 | bool getEnableAllWarnings() const { |
660 | 43 | return GetCurDiagState()->EnableAllWarnings; |
661 | 43 | } |
662 | | |
663 | | /// When set to true, any warnings reported are issued as errors. |
664 | 4.97k | void setWarningsAsErrors(bool Val) { |
665 | 4.97k | GetCurDiagState()->WarningsAsErrors = Val; |
666 | 4.97k | } |
667 | 3.77k | bool getWarningsAsErrors() const { |
668 | 3.77k | return GetCurDiagState()->WarningsAsErrors; |
669 | 3.77k | } |
670 | | |
671 | | /// When set to true, any error reported is made a fatal error. |
672 | 2 | void setErrorsAsFatal(bool Val) { GetCurDiagState()->ErrorsAsFatal = Val; } |
673 | 0 | bool getErrorsAsFatal() const { return GetCurDiagState()->ErrorsAsFatal; } |
674 | | |
675 | | /// \brief When set to true, any fatal error reported is made an error. |
676 | | /// |
677 | | /// This setting takes precedence over the setErrorsAsFatal setting above. |
678 | 7 | void setFatalsAsError(bool Val) { FatalsAsError = Val; } |
679 | 0 | bool getFatalsAsError() const { return FatalsAsError; } |
680 | | |
681 | | /// When set to true mask warnings that come from system headers. |
682 | 150k | void setSuppressSystemWarnings(bool Val) { |
683 | 150k | GetCurDiagState()->SuppressSystemWarnings = Val; |
684 | 150k | } |
685 | 17.3M | bool getSuppressSystemWarnings() const { |
686 | 17.3M | return GetCurDiagState()->SuppressSystemWarnings; |
687 | 17.3M | } |
688 | | |
689 | | /// Suppress all diagnostics, to silence the front end when we |
690 | | /// know that we don't want any more diagnostics to be passed along to the |
691 | | /// client |
692 | 1.41k | void setSuppressAllDiagnostics(bool Val) { SuppressAllDiagnostics = Val; } |
693 | 4.01M | bool getSuppressAllDiagnostics() const { return SuppressAllDiagnostics; } |
694 | | |
695 | | /// Set type eliding, to skip outputting same types occurring in |
696 | | /// template types. |
697 | 150k | void setElideType(bool Val) { ElideType = Val; } |
698 | 0 | bool getElideType() { return ElideType; } |
699 | | |
700 | | /// Set tree printing, to outputting the template difference in a |
701 | | /// tree format. |
702 | 150k | void setPrintTemplateTree(bool Val) { PrintTemplateTree = Val; } |
703 | 0 | bool getPrintTemplateTree() { return PrintTemplateTree; } |
704 | | |
705 | | /// Set color printing, so the type diffing will inject color markers |
706 | | /// into the output. |
707 | 150k | void setShowColors(bool Val) { ShowColors = Val; } |
708 | 1.71k | bool getShowColors() { return ShowColors; } |
709 | | |
710 | | /// Specify which overload candidates to show when overload resolution |
711 | | /// fails. |
712 | | /// |
713 | | /// By default, we show all candidates. |
714 | 150k | void setShowOverloads(OverloadsShown Val) { |
715 | 150k | ShowOverloads = Val; |
716 | 150k | } |
717 | 39.4k | OverloadsShown getShowOverloads() const { return ShowOverloads; } |
718 | | |
719 | | /// When a call or operator fails, print out up to this many candidate |
720 | | /// overloads as suggestions. |
721 | | /// |
722 | | /// With Ovl_Best, we set a high limit for the first nontrivial overload set |
723 | | /// we print, and a lower limit for later sets. This way the user has a |
724 | | /// chance of diagnosing at least one callsite in their program without |
725 | | /// having to recompile with -fshow-overloads=all. |
726 | 18.9k | unsigned getNumOverloadCandidatesToShow() const { |
727 | 18.9k | switch (getShowOverloads()) { |
728 | 18.8k | case Ovl_All: |
729 | | // INT_MAX rather than UINT_MAX so that we don't have to think about the |
730 | | // effect of implicit conversions on this value. In practice we'll never |
731 | | // hit 2^31 candidates anyway. |
732 | 18.8k | return std::numeric_limits<int>::max(); |
733 | 74 | case Ovl_Best: |
734 | 74 | return NumOverloadsToShow; |
735 | 18.9k | } |
736 | 0 | llvm_unreachable("invalid OverloadsShown kind"); |
737 | 0 | } |
738 | | |
739 | | /// Call this after showing N overload candidates. This influences the value |
740 | | /// returned by later calls to getNumOverloadCandidatesToShow(). |
741 | 20.6k | void overloadCandidatesShown(unsigned N) { |
742 | | // Current heuristic: Start out with a large value for NumOverloadsToShow, |
743 | | // and then once we print one nontrivially-large overload set, decrease it |
744 | | // for future calls. |
745 | 20.6k | if (N > 4) { |
746 | 519 | NumOverloadsToShow = 4; |
747 | 519 | } |
748 | 20.6k | } |
749 | | |
750 | | /// Pretend that the last diagnostic issued was ignored, so any |
751 | | /// subsequent notes will be suppressed, or restore a prior ignoring |
752 | | /// state after ignoring some diagnostics and their notes, possibly in |
753 | | /// the middle of another diagnostic. |
754 | | /// |
755 | | /// This can be used by clients who suppress diagnostics themselves. |
756 | 3.03M | void setLastDiagnosticIgnored(bool Ignored) { |
757 | 3.03M | if (LastDiagLevel == DiagnosticIDs::Fatal) |
758 | 8 | FatalErrorOccurred = true; |
759 | 3.03M | LastDiagLevel = Ignored ? DiagnosticIDs::Ignored2.81M : DiagnosticIDs::Warning219k ; |
760 | 3.03M | } |
761 | | |
762 | | /// Determine whether the previous diagnostic was ignored. This can |
763 | | /// be used by clients that want to determine whether notes attached to a |
764 | | /// diagnostic will be suppressed. |
765 | 2.81M | bool isLastDiagnosticIgnored() const { |
766 | 2.81M | return LastDiagLevel == DiagnosticIDs::Ignored; |
767 | 2.81M | } |
768 | | |
769 | | /// Controls whether otherwise-unmapped extension diagnostics are |
770 | | /// mapped onto ignore/warning/error. |
771 | | /// |
772 | | /// This corresponds to the GCC -pedantic and -pedantic-errors option. |
773 | 150k | void setExtensionHandlingBehavior(diag::Severity H) { |
774 | 150k | GetCurDiagState()->ExtBehavior = H; |
775 | 150k | } |
776 | 9.75k | diag::Severity getExtensionHandlingBehavior() const { |
777 | 9.75k | return GetCurDiagState()->ExtBehavior; |
778 | 9.75k | } |
779 | | |
780 | | /// Counter bumped when an __extension__ block is/ encountered. |
781 | | /// |
782 | | /// When non-zero, all extension diagnostics are entirely silenced, no |
783 | | /// matter how they are mapped. |
784 | 36.7k | void IncrementAllExtensionsSilenced() { ++AllExtensionsSilenced; } |
785 | 36.7k | void DecrementAllExtensionsSilenced() { --AllExtensionsSilenced; } |
786 | 120M | bool hasAllExtensionsSilenced() { return AllExtensionsSilenced != 0; } |
787 | | |
788 | | /// This allows the client to specify that certain warnings are |
789 | | /// ignored. |
790 | | /// |
791 | | /// Notes can never be mapped, errors can only be mapped to fatal, and |
792 | | /// WARNINGs and EXTENSIONs can be mapped arbitrarily. |
793 | | /// |
794 | | /// \param Loc The source location that this change of diagnostic state should |
795 | | /// take affect. It can be null if we are setting the latest state. |
796 | | void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc); |
797 | | |
798 | | /// Change an entire diagnostic group (e.g. "unknown-pragmas") to |
799 | | /// have the specified mapping. |
800 | | /// |
801 | | /// \returns true (and ignores the request) if "Group" was unknown, false |
802 | | /// otherwise. |
803 | | /// |
804 | | /// \param Flavor The flavor of group to affect. -Rfoo does not affect the |
805 | | /// state of the -Wfoo group and vice versa. |
806 | | /// |
807 | | /// \param Loc The source location that this change of diagnostic state should |
808 | | /// take affect. It can be null if we are setting the state from command-line. |
809 | | bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group, |
810 | | diag::Severity Map, |
811 | | SourceLocation Loc = SourceLocation()); |
812 | | bool setSeverityForGroup(diag::Flavor Flavor, diag::Group Group, |
813 | | diag::Severity Map, |
814 | | SourceLocation Loc = SourceLocation()); |
815 | | |
816 | | /// Set the warning-as-error flag for the given diagnostic group. |
817 | | /// |
818 | | /// This function always only operates on the current diagnostic state. |
819 | | /// |
820 | | /// \returns True if the given group is unknown, false otherwise. |
821 | | bool setDiagnosticGroupWarningAsError(StringRef Group, bool Enabled); |
822 | | |
823 | | /// Set the error-as-fatal flag for the given diagnostic group. |
824 | | /// |
825 | | /// This function always only operates on the current diagnostic state. |
826 | | /// |
827 | | /// \returns True if the given group is unknown, false otherwise. |
828 | | bool setDiagnosticGroupErrorAsFatal(StringRef Group, bool Enabled); |
829 | | |
830 | | /// Add the specified mapping to all diagnostics of the specified |
831 | | /// flavor. |
832 | | /// |
833 | | /// Mainly to be used by -Wno-everything to disable all warnings but allow |
834 | | /// subsequent -W options to enable specific warnings. |
835 | | void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map, |
836 | | SourceLocation Loc = SourceLocation()); |
837 | | |
838 | 24.0M | bool hasErrorOccurred() const { return ErrorOccurred; } |
839 | | |
840 | | /// Errors that actually prevent compilation, not those that are |
841 | | /// upgraded from a warning by -Werror. |
842 | 12.5M | bool hasUncompilableErrorOccurred() const { |
843 | 12.5M | return UncompilableErrorOccurred; |
844 | 12.5M | } |
845 | 8.17M | bool hasFatalErrorOccurred() const { return FatalErrorOccurred; } |
846 | | |
847 | | /// Determine whether any kind of unrecoverable error has occurred. |
848 | 105 | bool hasUnrecoverableErrorOccurred() const { |
849 | 105 | return FatalErrorOccurred || UnrecoverableErrorOccurred103 ; |
850 | 105 | } |
851 | | |
852 | 4.12M | unsigned getNumErrors() const { return NumErrors; } |
853 | 72.3k | unsigned getNumWarnings() const { return NumWarnings; } |
854 | | |
855 | 501 | void setNumWarnings(unsigned NumWarnings) { |
856 | 501 | this->NumWarnings = NumWarnings; |
857 | 501 | } |
858 | | |
859 | | /// Return an ID for a diagnostic with the specified format string and |
860 | | /// level. |
861 | | /// |
862 | | /// If this is the first request for this diagnostic, it is registered and |
863 | | /// created, otherwise the existing ID is returned. |
864 | | /// |
865 | | /// \param FormatString A fixed diagnostic format string that will be hashed |
866 | | /// and mapped to a unique DiagID. |
867 | | template <unsigned N> |
868 | 4.59k | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { |
869 | 4.59k | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, |
870 | 4.59k | StringRef(FormatString, N - 1)); |
871 | 4.59k | } unsigned int clang::DiagnosticsEngine::getCustomDiagID<27u>(clang::DiagnosticsEngine::Level, char const (&) [27u]) Line | Count | Source | 868 | 37 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 37 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 37 | StringRef(FormatString, N - 1)); | 871 | 37 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<37u>(clang::DiagnosticsEngine::Level, char const (&) [37u]) Line | Count | Source | 868 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 2 | StringRef(FormatString, N - 1)); | 871 | 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 | 868 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 2 | StringRef(FormatString, N - 1)); | 871 | 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 | 868 | 1 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 1 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 1 | StringRef(FormatString, N - 1)); | 871 | 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 | 868 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 2 | StringRef(FormatString, N - 1)); | 871 | 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 | 868 | 164 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 164 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 164 | StringRef(FormatString, N - 1)); | 871 | 164 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<20u>(clang::DiagnosticsEngine::Level, char const (&) [20u]) Line | Count | Source | 868 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 2 | StringRef(FormatString, N - 1)); | 871 | 2 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<3u>(clang::DiagnosticsEngine::Level, char const (&) [3u]) Line | Count | Source | 868 | 3.85k | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 3.85k | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 3.85k | StringRef(FormatString, N - 1)); | 871 | 3.85k | } |
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 | 868 | 1 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 1 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 1 | StringRef(FormatString, N - 1)); | 871 | 1 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<133u>(clang::DiagnosticsEngine::Level, char const (&) [133u]) Line | Count | Source | 868 | 1 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 1 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 1 | StringRef(FormatString, N - 1)); | 871 | 1 | } |
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 | 868 | 250 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 250 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 250 | StringRef(FormatString, N - 1)); | 871 | 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 | 868 | 6 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 6 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 6 | StringRef(FormatString, N - 1)); | 871 | 6 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<141u>(clang::DiagnosticsEngine::Level, char const (&) [141u]) Line | Count | Source | 868 | 22 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 22 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 22 | StringRef(FormatString, N - 1)); | 871 | 22 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<96u>(clang::DiagnosticsEngine::Level, char const (&) [96u]) Line | Count | Source | 868 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 2 | StringRef(FormatString, N - 1)); | 871 | 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 | 868 | 1 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 1 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 1 | StringRef(FormatString, N - 1)); | 871 | 1 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<124u>(clang::DiagnosticsEngine::Level, char const (&) [124u]) Line | Count | Source | 868 | 10 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 10 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 10 | StringRef(FormatString, N - 1)); | 871 | 10 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<95u>(clang::DiagnosticsEngine::Level, char const (&) [95u]) Line | Count | Source | 868 | 2 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 2 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 2 | StringRef(FormatString, N - 1)); | 871 | 2 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<68u>(clang::DiagnosticsEngine::Level, char const (&) [68u]) Line | Count | Source | 868 | 78 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 78 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 78 | StringRef(FormatString, N - 1)); | 871 | 78 | } |
unsigned int clang::DiagnosticsEngine::getCustomDiagID<113u>(clang::DiagnosticsEngine::Level, char const (&) [113u]) Line | Count | Source | 868 | 164 | unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) { | 869 | 164 | return Diags->getCustomDiagID((DiagnosticIDs::Level)L, | 870 | 164 | StringRef(FormatString, N - 1)); | 871 | 164 | } |
|
872 | | |
873 | | /// Converts a diagnostic argument (as an intptr_t) into the string |
874 | | /// that represents it. |
875 | | void ConvertArgToString(ArgumentKind Kind, intptr_t Val, |
876 | | StringRef Modifier, StringRef Argument, |
877 | | ArrayRef<ArgumentValue> PrevArgs, |
878 | | SmallVectorImpl<char> &Output, |
879 | 177k | ArrayRef<intptr_t> QualTypeVals) const { |
880 | 177k | ArgToStringFn(Kind, Val, Modifier, Argument, PrevArgs, Output, |
881 | 177k | ArgToStringCookie, QualTypeVals); |
882 | 177k | } |
883 | | |
884 | 88.3k | void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie) { |
885 | 88.3k | ArgToStringFn = Fn; |
886 | 88.3k | ArgToStringCookie = Cookie; |
887 | 88.3k | } |
888 | | |
889 | | /// Note that the prior diagnostic was emitted by some other |
890 | | /// \c DiagnosticsEngine, and we may be attaching a note to that diagnostic. |
891 | 2.90M | void notePriorDiagnosticFrom(const DiagnosticsEngine &Other) { |
892 | 2.90M | LastDiagLevel = Other.LastDiagLevel; |
893 | 2.90M | } |
894 | | |
895 | | /// Reset the state of the diagnostic object to its initial configuration. |
896 | | /// \param[in] soft - if true, doesn't reset the diagnostic mappings and state |
897 | | void Reset(bool soft = false); |
898 | | |
899 | | //===--------------------------------------------------------------------===// |
900 | | // DiagnosticsEngine classification and reporting interfaces. |
901 | | // |
902 | | |
903 | | /// Determine whether the diagnostic is known to be ignored. |
904 | | /// |
905 | | /// This can be used to opportunistically avoid expensive checks when it's |
906 | | /// known for certain that the diagnostic has been suppressed at the |
907 | | /// specified location \p Loc. |
908 | | /// |
909 | | /// \param Loc The source location we are interested in finding out the |
910 | | /// diagnostic state. Can be null in order to query the latest state. |
911 | 177M | bool isIgnored(unsigned DiagID, SourceLocation Loc) const { |
912 | 177M | return Diags->getDiagnosticSeverity(DiagID, Loc, *this) == |
913 | 177M | diag::Severity::Ignored; |
914 | 177M | } |
915 | | |
916 | | /// Based on the way the client configured the DiagnosticsEngine |
917 | | /// object, classify the specified diagnostic ID into a Level, consumable by |
918 | | /// the DiagnosticConsumer. |
919 | | /// |
920 | | /// To preserve invariant assumptions, this function should not be used to |
921 | | /// influence parse or semantic analysis actions. Instead consider using |
922 | | /// \c isIgnored(). |
923 | | /// |
924 | | /// \param Loc The source location we are interested in finding out the |
925 | | /// diagnostic state. Can be null in order to query the latest state. |
926 | 3.42M | Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const { |
927 | 3.42M | return (Level)Diags->getDiagnosticLevel(DiagID, Loc, *this); |
928 | 3.42M | } |
929 | | |
930 | | /// Issue the message to the client. |
931 | | /// |
932 | | /// This actually returns an instance of DiagnosticBuilder which emits the |
933 | | /// diagnostics (through @c ProcessDiag) when it is destroyed. |
934 | | /// |
935 | | /// \param DiagID A member of the @c diag::kind enum. |
936 | | /// \param Loc Represents the source location associated with the diagnostic, |
937 | | /// which can be an invalid location if no position information is available. |
938 | | inline DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID); |
939 | | inline DiagnosticBuilder Report(unsigned DiagID); |
940 | | |
941 | | void Report(const StoredDiagnostic &storedDiag); |
942 | | |
943 | | /// Determine whethere there is already a diagnostic in flight. |
944 | 24 | bool isDiagnosticInFlight() const { |
945 | 24 | return CurDiagID != std::numeric_limits<unsigned>::max(); |
946 | 24 | } |
947 | | |
948 | | /// Set the "delayed" diagnostic that will be emitted once |
949 | | /// the current diagnostic completes. |
950 | | /// |
951 | | /// If a diagnostic is already in-flight but the front end must |
952 | | /// report a problem (e.g., with an inconsistent file system |
953 | | /// state), this routine sets a "delayed" diagnostic that will be |
954 | | /// emitted after the current diagnostic completes. This should |
955 | | /// only be used for fatal errors detected at inconvenient |
956 | | /// times. If emitting a delayed diagnostic causes a second delayed |
957 | | /// diagnostic to be introduced, that second delayed diagnostic |
958 | | /// will be ignored. |
959 | | /// |
960 | | /// \param DiagID The ID of the diagnostic being delayed. |
961 | | /// |
962 | | /// \param Arg1 A string argument that will be provided to the |
963 | | /// diagnostic. A copy of this string will be stored in the |
964 | | /// DiagnosticsEngine object itself. |
965 | | /// |
966 | | /// \param Arg2 A string argument that will be provided to the |
967 | | /// diagnostic. A copy of this string will be stored in the |
968 | | /// DiagnosticsEngine object itself. |
969 | | /// |
970 | | /// \param Arg3 A string argument that will be provided to the |
971 | | /// diagnostic. A copy of this string will be stored in the |
972 | | /// DiagnosticsEngine object itself. |
973 | | void SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1 = "", |
974 | | StringRef Arg2 = "", StringRef Arg3 = ""); |
975 | | |
976 | | /// Clear out the current diagnostic. |
977 | 12.9M | void Clear() { CurDiagID = std::numeric_limits<unsigned>::max(); } |
978 | | |
979 | | /// Return the value associated with this diagnostic flag. |
980 | 11.2k | StringRef getFlagValue() const { return FlagValue; } |
981 | | |
982 | | private: |
983 | | // This is private state used by DiagnosticBuilder. We put it here instead of |
984 | | // in DiagnosticBuilder in order to keep DiagnosticBuilder a small lightweight |
985 | | // object. This implementation choice means that we can only have one |
986 | | // diagnostic "in flight" at a time, but this seems to be a reasonable |
987 | | // tradeoff to keep these objects small. Assertions verify that only one |
988 | | // diagnostic is in flight at a time. |
989 | | friend class Diagnostic; |
990 | | friend class DiagnosticBuilder; |
991 | | friend class DiagnosticErrorTrap; |
992 | | friend class DiagnosticIDs; |
993 | | friend class PartialDiagnostic; |
994 | | |
995 | | /// Report the delayed diagnostic. |
996 | | void ReportDelayed(); |
997 | | |
998 | | /// The location of the current diagnostic that is in flight. |
999 | | SourceLocation CurDiagLoc; |
1000 | | |
1001 | | /// The ID of the current diagnostic that is in flight. |
1002 | | /// |
1003 | | /// This is set to std::numeric_limits<unsigned>::max() when there is no |
1004 | | /// diagnostic in flight. |
1005 | | unsigned CurDiagID; |
1006 | | |
1007 | | enum { |
1008 | | /// The maximum number of arguments we can hold. |
1009 | | /// |
1010 | | /// We currently only support up to 10 arguments (%0-%9). A single |
1011 | | /// diagnostic with more than that almost certainly has to be simplified |
1012 | | /// anyway. |
1013 | | MaxArguments = DiagnosticStorage::MaxArguments, |
1014 | | }; |
1015 | | |
1016 | | DiagnosticStorage DiagStorage; |
1017 | | |
1018 | 3.36M | DiagnosticMapping makeUserMapping(diag::Severity Map, SourceLocation L) { |
1019 | 3.36M | bool isPragma = L.isValid(); |
1020 | 3.36M | DiagnosticMapping Mapping = |
1021 | 3.36M | DiagnosticMapping::Make(Map, /*IsUser=*/true, isPragma); |
1022 | | |
1023 | | // If this is a pragma mapping, then set the diagnostic mapping flags so |
1024 | | // that we override command line options. |
1025 | 3.36M | if (isPragma) { |
1026 | 709k | Mapping.setNoWarningAsError(true); |
1027 | 709k | Mapping.setNoErrorAsFatal(true); |
1028 | 709k | } |
1029 | | |
1030 | 3.36M | return Mapping; |
1031 | 3.36M | } |
1032 | | |
1033 | | /// Used to report a diagnostic that is finally fully formed. |
1034 | | /// |
1035 | | /// \returns true if the diagnostic was emitted, false if it was suppressed. |
1036 | 12.7M | bool ProcessDiag() { |
1037 | 12.7M | return Diags->ProcessDiag(*this); |
1038 | 12.7M | } |
1039 | | |
1040 | | /// @name Diagnostic Emission |
1041 | | /// @{ |
1042 | | protected: |
1043 | | friend class ASTReader; |
1044 | | friend class ASTWriter; |
1045 | | |
1046 | | // Sema requires access to the following functions because the current design |
1047 | | // of SFINAE requires it to use its own SemaDiagnosticBuilder, which needs to |
1048 | | // access us directly to ensure we minimize the emitted code for the common |
1049 | | // Sema::Diag() patterns. |
1050 | | friend class Sema; |
1051 | | |
1052 | | /// Emit the current diagnostic and clear the diagnostic state. |
1053 | | /// |
1054 | | /// \param Force Emit the diagnostic regardless of suppression settings. |
1055 | | bool EmitCurrentDiagnostic(bool Force = false); |
1056 | | |
1057 | 224k | unsigned getCurrentDiagID() const { return CurDiagID; } |
1058 | | |
1059 | 92 | SourceLocation getCurrentDiagLoc() const { return CurDiagLoc; } |
1060 | | |
1061 | | /// @} |
1062 | | }; |
1063 | | |
1064 | | /// RAII class that determines when any errors have occurred |
1065 | | /// between the time the instance was created and the time it was |
1066 | | /// queried. |
1067 | | /// |
1068 | | /// Note that you almost certainly do not want to use this. It's usually |
1069 | | /// meaningless to ask whether a particular scope triggered an error message, |
1070 | | /// because error messages outside that scope can mark things invalid (or cause |
1071 | | /// us to reach an error limit), which can suppress errors within that scope. |
1072 | | class DiagnosticErrorTrap { |
1073 | | DiagnosticsEngine &Diag; |
1074 | | unsigned NumErrors; |
1075 | | unsigned NumUnrecoverableErrors; |
1076 | | |
1077 | | public: |
1078 | | explicit DiagnosticErrorTrap(DiagnosticsEngine &Diag) |
1079 | 1.20M | : Diag(Diag) { reset(); } |
1080 | | |
1081 | | /// Determine whether any errors have occurred since this |
1082 | | /// object instance was created. |
1083 | 187 | bool hasErrorOccurred() const { |
1084 | 187 | return Diag.TrapNumErrorsOccurred > NumErrors; |
1085 | 187 | } |
1086 | | |
1087 | | /// Determine whether any unrecoverable errors have occurred since this |
1088 | | /// object instance was created. |
1089 | 85.4M | bool hasUnrecoverableErrorOccurred() const { |
1090 | 85.4M | return Diag.TrapNumUnrecoverableErrorsOccurred > NumUnrecoverableErrors; |
1091 | 85.4M | } |
1092 | | |
1093 | | /// Set to initial state of "no errors occurred". |
1094 | 42.3M | void reset() { |
1095 | 42.3M | NumErrors = Diag.TrapNumErrorsOccurred; |
1096 | 42.3M | NumUnrecoverableErrors = Diag.TrapNumUnrecoverableErrorsOccurred; |
1097 | 42.3M | } |
1098 | | }; |
1099 | | |
1100 | | /// The streaming interface shared between DiagnosticBuilder and |
1101 | | /// PartialDiagnostic. This class is not intended to be constructed directly |
1102 | | /// but only as base class of DiagnosticBuilder and PartialDiagnostic builder. |
1103 | | /// |
1104 | | /// Any new type of argument accepted by DiagnosticBuilder and PartialDiagnostic |
1105 | | /// should be implemented as a '<<' operator of StreamingDiagnostic, e.g. |
1106 | | /// |
1107 | | /// const StreamingDiagnostic& |
1108 | | /// operator<<(const StreamingDiagnostic&, NewArgType); |
1109 | | /// |
1110 | | class StreamingDiagnostic { |
1111 | | public: |
1112 | | /// An allocator for DiagnosticStorage objects, which uses a small cache to |
1113 | | /// objects, used to reduce malloc()/free() traffic for partial diagnostics. |
1114 | | class DiagStorageAllocator { |
1115 | | static const unsigned NumCached = 16; |
1116 | | DiagnosticStorage Cached[NumCached]; |
1117 | | DiagnosticStorage *FreeList[NumCached]; |
1118 | | unsigned NumFreeListEntries; |
1119 | | |
1120 | | public: |
1121 | | DiagStorageAllocator(); |
1122 | | ~DiagStorageAllocator(); |
1123 | | |
1124 | | /// Allocate new storage. |
1125 | 1.72M | DiagnosticStorage *Allocate() { |
1126 | 1.72M | if (NumFreeListEntries == 0) |
1127 | 26.8k | return new DiagnosticStorage; |
1128 | | |
1129 | 1.70M | DiagnosticStorage *Result = FreeList[--NumFreeListEntries]; |
1130 | 1.70M | Result->NumDiagArgs = 0; |
1131 | 1.70M | Result->DiagRanges.clear(); |
1132 | 1.70M | Result->FixItHints.clear(); |
1133 | 1.70M | return Result; |
1134 | 1.72M | } |
1135 | | |
1136 | | /// Free the given storage object. |
1137 | 1.72M | void Deallocate(DiagnosticStorage *S) { |
1138 | 1.72M | if (S >= Cached && S <= Cached + NumCached1.70M ) { |
1139 | 1.69M | FreeList[NumFreeListEntries++] = S; |
1140 | 1.69M | return; |
1141 | 1.69M | } |
1142 | | |
1143 | 25.8k | delete S; |
1144 | 25.8k | } |
1145 | | }; |
1146 | | |
1147 | | protected: |
1148 | | mutable DiagnosticStorage *DiagStorage = nullptr; |
1149 | | |
1150 | | /// Allocator used to allocate storage for this diagnostic. |
1151 | | DiagStorageAllocator *Allocator = nullptr; |
1152 | | |
1153 | | public: |
1154 | | /// Retrieve storage for this particular diagnostic. |
1155 | 1.72M | DiagnosticStorage *getStorage() const { |
1156 | 1.72M | if (DiagStorage) |
1157 | 4 | return DiagStorage; |
1158 | | |
1159 | 1.72M | assert(Allocator); |
1160 | 0 | DiagStorage = Allocator->Allocate(); |
1161 | 1.72M | return DiagStorage; |
1162 | 1.72M | } |
1163 | | |
1164 | 30.1M | void freeStorage() { |
1165 | 30.1M | if (!DiagStorage) |
1166 | 8.83M | return; |
1167 | | |
1168 | | // The hot path for PartialDiagnostic is when we just used it to wrap an ID |
1169 | | // (typically so we have the flexibility of passing a more complex |
1170 | | // diagnostic into the callee, but that does not commonly occur). |
1171 | | // |
1172 | | // Split this out into a slow function for silly compilers (*cough*) which |
1173 | | // can't do decent partial inlining. |
1174 | 21.2M | freeStorageSlow(); |
1175 | 21.2M | } |
1176 | | |
1177 | 21.2M | void freeStorageSlow() { |
1178 | 21.2M | if (!Allocator) |
1179 | 19.5M | return; |
1180 | 1.72M | Allocator->Deallocate(DiagStorage); |
1181 | 1.72M | DiagStorage = nullptr; |
1182 | 1.72M | } |
1183 | | |
1184 | 7.31M | void AddTaggedVal(uint64_t V, DiagnosticsEngine::ArgumentKind Kind) const { |
1185 | 7.31M | if (!DiagStorage) |
1186 | 1.41M | DiagStorage = getStorage(); |
1187 | | |
1188 | 7.31M | assert(DiagStorage->NumDiagArgs < DiagnosticStorage::MaxArguments && |
1189 | 7.31M | "Too many arguments to diagnostic!"); |
1190 | 0 | DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] = Kind; |
1191 | 7.31M | DiagStorage->DiagArgumentsVal[DiagStorage->NumDiagArgs++] = V; |
1192 | 7.31M | } |
1193 | | |
1194 | 2.85M | void AddString(StringRef V) const { |
1195 | 2.85M | if (!DiagStorage) |
1196 | 134k | DiagStorage = getStorage(); |
1197 | | |
1198 | 2.85M | assert(DiagStorage->NumDiagArgs < DiagnosticStorage::MaxArguments && |
1199 | 2.85M | "Too many arguments to diagnostic!"); |
1200 | 0 | DiagStorage->DiagArgumentsKind[DiagStorage->NumDiagArgs] = |
1201 | 2.85M | DiagnosticsEngine::ak_std_string; |
1202 | 2.85M | DiagStorage->DiagArgumentsStr[DiagStorage->NumDiagArgs++] = std::string(V); |
1203 | 2.85M | } |
1204 | | |
1205 | 2.04M | void AddSourceRange(const CharSourceRange &R) const { |
1206 | 2.04M | if (!DiagStorage) |
1207 | 42.4k | DiagStorage = getStorage(); |
1208 | | |
1209 | 2.04M | DiagStorage->DiagRanges.push_back(R); |
1210 | 2.04M | } |
1211 | | |
1212 | 413k | void AddFixItHint(const FixItHint &Hint) const { |
1213 | 413k | if (Hint.isNull()) |
1214 | 53.8k | return; |
1215 | | |
1216 | 359k | if (!DiagStorage) |
1217 | 123 | DiagStorage = getStorage(); |
1218 | | |
1219 | 359k | DiagStorage->FixItHints.push_back(Hint); |
1220 | 359k | } |
1221 | | |
1222 | | /// Conversion of StreamingDiagnostic to bool always returns \c true. |
1223 | | /// |
1224 | | /// This allows is to be used in boolean error contexts (where \c true is |
1225 | | /// used to indicate that an error has occurred), like: |
1226 | | /// \code |
1227 | | /// return Diag(...); |
1228 | | /// \endcode |
1229 | 161 | operator bool() const { return true; } |
1230 | | |
1231 | | protected: |
1232 | 11.3M | StreamingDiagnostic() = default; |
1233 | | |
1234 | | /// Construct with an external storage not owned by itself. The allocator |
1235 | | /// is a null pointer in this case. |
1236 | | explicit StreamingDiagnostic(DiagnosticStorage *Storage) |
1237 | 12.9M | : DiagStorage(Storage) {} |
1238 | | |
1239 | | /// Construct with a storage allocator which will manage the storage. The |
1240 | | /// allocator is not a null pointer in this case. |
1241 | | explicit StreamingDiagnostic(DiagStorageAllocator &Alloc) |
1242 | 4.52M | : Allocator(&Alloc) {} |
1243 | | |
1244 | | StreamingDiagnostic(const StreamingDiagnostic &Diag) = default; |
1245 | | StreamingDiagnostic(StreamingDiagnostic &&Diag) = default; |
1246 | | |
1247 | 28.8M | ~StreamingDiagnostic() { freeStorage(); } |
1248 | | }; |
1249 | | |
1250 | | //===----------------------------------------------------------------------===// |
1251 | | // DiagnosticBuilder |
1252 | | //===----------------------------------------------------------------------===// |
1253 | | |
1254 | | /// A little helper class used to produce diagnostics. |
1255 | | /// |
1256 | | /// This is constructed by the DiagnosticsEngine::Report method, and |
1257 | | /// allows insertion of extra information (arguments and source ranges) into |
1258 | | /// the currently "in flight" diagnostic. When the temporary for the builder |
1259 | | /// is destroyed, the diagnostic is issued. |
1260 | | /// |
1261 | | /// Note that many of these will be created as temporary objects (many call |
1262 | | /// sites), so we want them to be small and we never want their address taken. |
1263 | | /// This ensures that compilers with somewhat reasonable optimizers will promote |
1264 | | /// the common fields to registers, eliminating increments of the NumArgs field, |
1265 | | /// for example. |
1266 | | class DiagnosticBuilder : public StreamingDiagnostic { |
1267 | | friend class DiagnosticsEngine; |
1268 | | friend class PartialDiagnostic; |
1269 | | |
1270 | | mutable DiagnosticsEngine *DiagObj = nullptr; |
1271 | | |
1272 | | /// Status variable indicating if this diagnostic is still active. |
1273 | | /// |
1274 | | // NOTE: This field is redundant with DiagObj (IsActive iff (DiagObj == 0)), |
1275 | | // but LLVM is not currently smart enough to eliminate the null check that |
1276 | | // Emit() would end up with if we used that as our status variable. |
1277 | | mutable bool IsActive = false; |
1278 | | |
1279 | | /// Flag indicating that this diagnostic is being emitted via a |
1280 | | /// call to ForceEmit. |
1281 | | mutable bool IsForceEmit = false; |
1282 | | |
1283 | | DiagnosticBuilder() = default; |
1284 | | |
1285 | | explicit DiagnosticBuilder(DiagnosticsEngine *diagObj) |
1286 | | : StreamingDiagnostic(&diagObj->DiagStorage), DiagObj(diagObj), |
1287 | 12.9M | IsActive(true) { |
1288 | 12.9M | assert(diagObj && "DiagnosticBuilder requires a valid DiagnosticsEngine!"); |
1289 | 0 | assert(DiagStorage && |
1290 | 12.9M | "DiagnosticBuilder requires a valid DiagnosticStorage!"); |
1291 | 0 | DiagStorage->NumDiagArgs = 0; |
1292 | 12.9M | DiagStorage->DiagRanges.clear(); |
1293 | 12.9M | DiagStorage->FixItHints.clear(); |
1294 | 12.9M | } |
1295 | | |
1296 | | protected: |
1297 | | /// Clear out the current diagnostic. |
1298 | 19.5M | void Clear() const { |
1299 | 19.5M | DiagObj = nullptr; |
1300 | 19.5M | IsActive = false; |
1301 | 19.5M | IsForceEmit = false; |
1302 | 19.5M | } |
1303 | | |
1304 | | /// Determine whether this diagnostic is still active. |
1305 | 36.0M | bool isActive() const { return IsActive; } |
1306 | | |
1307 | | /// Force the diagnostic builder to emit the diagnostic now. |
1308 | | /// |
1309 | | /// Once this function has been called, the DiagnosticBuilder object |
1310 | | /// should not be used again before it is destroyed. |
1311 | | /// |
1312 | | /// \returns true if a diagnostic was emitted, false if the |
1313 | | /// diagnostic was suppressed. |
1314 | 19.5M | bool Emit() { |
1315 | | // If this diagnostic is inactive, then its soul was stolen by the copy ctor |
1316 | | // (or by a subclass, as in SemaDiagnosticBuilder). |
1317 | 19.5M | if (!isActive()) return false9.86M ; |
1318 | | |
1319 | | // Process the diagnostic. |
1320 | 9.70M | bool Result = DiagObj->EmitCurrentDiagnostic(IsForceEmit); |
1321 | | |
1322 | | // This diagnostic is dead. |
1323 | 9.70M | Clear(); |
1324 | | |
1325 | 9.70M | return Result; |
1326 | 19.5M | } |
1327 | | |
1328 | | public: |
1329 | | /// Copy constructor. When copied, this "takes" the diagnostic info from the |
1330 | | /// input and neuters it. |
1331 | 6.61M | DiagnosticBuilder(const DiagnosticBuilder &D) : StreamingDiagnostic() { |
1332 | 6.61M | DiagObj = D.DiagObj; |
1333 | 6.61M | DiagStorage = D.DiagStorage; |
1334 | 6.61M | IsActive = D.IsActive; |
1335 | 6.61M | IsForceEmit = D.IsForceEmit; |
1336 | 6.61M | D.Clear(); |
1337 | 6.61M | } |
1338 | | |
1339 | 4.32M | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { |
1340 | 4.32M | assert(isActive() && "Clients must not add to cleared diagnostic!"); |
1341 | 0 | const StreamingDiagnostic &DB = *this; |
1342 | 4.32M | DB << V; |
1343 | 4.32M | return *this; |
1344 | 4.32M | } clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::comments::CommandMarkerKind>(clang::comments::CommandMarkerKind const&) const Line | Count | Source | 1339 | 81 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 81 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 81 | DB << V; | 1343 | 81 | return *this; | 1344 | 81 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<int>(int const&) const Line | Count | Source | 1339 | 24.9k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 24.9k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 24.9k | DB << V; | 1343 | 24.9k | return *this; | 1344 | 24.9k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SourceRange>(clang::SourceRange const&) const Line | Count | Source | 1339 | 315k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 315k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 315k | DB << V; | 1343 | 315k | return *this; | 1344 | 315k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned int>(unsigned int const&) const Line | Count | Source | 1339 | 107k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 107k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 107k | DB << V; | 1343 | 107k | return *this; | 1344 | 107k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXRecordDecl const*>(clang::CXXRecordDecl const* const&) const Line | Count | Source | 1339 | 198 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 198 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 198 | DB << V; | 1343 | 198 | return *this; | 1344 | 198 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXMethodDecl const*>(clang::CXXMethodDecl const* const&) const Line | Count | Source | 1339 | 47 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 47 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 47 | DB << V; | 1343 | 47 | return *this; | 1344 | 47 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char const*>(char const* const&) const Line | Count | Source | 1339 | 8.88k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 8.88k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 8.88k | DB << V; | 1343 | 8.88k | return *this; | 1344 | 8.88k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [21]>(char const (&) [21]) const Line | Count | Source | 1339 | 5.15k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5.15k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5.15k | DB << V; | 1343 | 5.15k | return *this; | 1344 | 5.15k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [17]>(char const (&) [17]) const Line | Count | Source | 1339 | 179 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 179 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 179 | DB << V; | 1343 | 179 | return *this; | 1344 | 179 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<256u> >(llvm::SmallString<256u> const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [9]>(char const (&) [9]) const Line | Count | Source | 1339 | 16.4k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 16.4k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 16.4k | DB << V; | 1343 | 16.4k | return *this; | 1344 | 16.4k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [16]>(char const (&) [16]) const Line | Count | Source | 1339 | 628 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 628 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 628 | DB << V; | 1343 | 628 | return *this; | 1344 | 628 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [36]>(char const (&) [36]) const Line | Count | Source | 1339 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 16 | DB << V; | 1343 | 16 | return *this; | 1344 | 16 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [10]>(char const (&) [10]) const Line | Count | Source | 1339 | 334 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 334 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 334 | DB << V; | 1343 | 334 | return *this; | 1344 | 334 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [12]>(char const (&) [12]) const Line | Count | Source | 1339 | 318 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 318 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 318 | DB << V; | 1343 | 318 | return *this; | 1344 | 318 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [38]>(char const (&) [38]) const Line | Count | Source | 1339 | 14 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 14 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 14 | DB << V; | 1343 | 14 | return *this; | 1344 | 14 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [11]>(char const (&) [11]) const Line | Count | Source | 1339 | 53 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 53 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 53 | DB << V; | 1343 | 53 | return *this; | 1344 | 53 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [84]>(char const (&) [84]) const Line | Count | Source | 1339 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 16 | DB << V; | 1343 | 16 | return *this; | 1344 | 16 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [14]>(char const (&) [14]) const Line | Count | Source | 1339 | 86 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 86 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 86 | DB << V; | 1343 | 86 | return *this; | 1344 | 86 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [15]>(char const (&) [15]) const Line | Count | Source | 1339 | 32 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 32 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 32 | DB << V; | 1343 | 32 | return *this; | 1344 | 32 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [23]>(char const (&) [23]) const Line | Count | Source | 1339 | 88 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 88 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 88 | DB << V; | 1343 | 88 | return *this; | 1344 | 88 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [8]>(char const (&) [8]) const Line | Count | Source | 1339 | 145 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 145 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 145 | DB << V; | 1343 | 145 | return *this; | 1344 | 145 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [3]>(char const (&) [3]) const Line | Count | Source | 1339 | 264 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 264 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 264 | DB << V; | 1343 | 264 | return *this; | 1344 | 264 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [6]>(char const (&) [6]) const Line | Count | Source | 1339 | 1.81k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1.81k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1.81k | DB << V; | 1343 | 1.81k | return *this; | 1344 | 1.81k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [27]>(char const (&) [27]) const Line | Count | Source | 1339 | 13 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 13 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 13 | DB << V; | 1343 | 13 | return *this; | 1344 | 13 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [33]>(char const (&) [33]) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [35]>(char const (&) [35]) const Line | Count | Source | 1339 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 24 | DB << V; | 1343 | 24 | return *this; | 1344 | 24 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [13]>(char const (&) [13]) const Line | Count | Source | 1339 | 58 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 58 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 58 | DB << V; | 1343 | 58 | return *this; | 1344 | 58 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [4]>(char const (&) [4]) const Line | Count | Source | 1339 | 247 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 247 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 247 | DB << V; | 1343 | 247 | return *this; | 1344 | 247 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<bool>(bool const&) const Line | Count | Source | 1339 | 39.7k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 39.7k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 39.7k | DB << V; | 1343 | 39.7k | return *this; | 1344 | 39.7k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamedDecl const*>(clang::NamedDecl const* const&) const Line | Count | Source | 1339 | 212k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 212k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 212k | DB << V; | 1343 | 212k | return *this; | 1344 | 212k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::StringRef>(llvm::StringRef const&) const Line | Count | Source | 1339 | 76.1k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 76.1k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 76.1k | DB << V; | 1343 | 76.1k | return *this; | 1344 | 76.1k | } |
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 | 1339 | 2.25M | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2.25M | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2.25M | DB << V; | 1343 | 2.25M | return *this; | 1344 | 2.25M | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CharSourceRange>(clang::CharSourceRange const&) const Line | Count | Source | 1339 | 5.91k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5.91k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5.91k | DB << V; | 1343 | 5.91k | return *this; | 1344 | 5.91k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<5u> >(llvm::SmallString<5u> const&) const Line | Count | Source | 1339 | 78 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 78 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 78 | DB << V; | 1343 | 78 | return *this; | 1344 | 78 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [2]>(char const (&) [2]) const Line | Count | Source | 1339 | 394 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 394 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 394 | DB << V; | 1343 | 394 | return *this; | 1344 | 394 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NumericLiteralParser::CheckSeparatorKind>(clang::NumericLiteralParser::CheckSeparatorKind const&) const Line | Count | Source | 1339 | 38 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 38 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 38 | DB << V; | 1343 | 38 | return *this; | 1344 | 38 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<32u> >(llvm::SmallString<32u> const&) const Line | Count | Source | 1339 | 413 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 413 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 413 | DB << V; | 1343 | 413 | return *this; | 1344 | 413 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::IdentifierInfo*>(clang::IdentifierInfo* const&) const Line | Count | Source | 1339 | 104k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 104k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 104k | DB << V; | 1343 | 104k | return *this; | 1344 | 104k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FixItHint>(clang::FixItHint const&) const Line | Count | Source | 1339 | 79.2k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 79.2k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 79.2k | DB << V; | 1343 | 79.2k | return *this; | 1344 | 79.2k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<128u> >(llvm::SmallString<128u> const&) const Line | Count | Source | 1339 | 13.8k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 13.8k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 13.8k | DB << V; | 1343 | 13.8k | return *this; | 1344 | 13.8k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<PPElifDiag>(PPElifDiag const&) const Line | Count | Source | 1339 | 34 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 34 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 34 | DB << V; | 1343 | 34 | return *this; | 1344 | 34 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [1]>(char const (&) [1]) const Line | Count | Source | 1339 | 114 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 114 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 114 | DB << V; | 1343 | 114 | return *this; | 1344 | 114 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::IdentifierInfo const*>(clang::IdentifierInfo const* const&) const Line | Count | Source | 1339 | 1.06k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1.06k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1.06k | DB << V; | 1343 | 1.06k | return *this; | 1344 | 1.06k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::PPCallbacks::PragmaMessageKind>(clang::PPCallbacks::PragmaMessageKind const&) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [45]>(char const (&) [45]) const Line | Count | Source | 1339 | 90 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 90 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 90 | DB << V; | 1343 | 90 | return *this; | 1344 | 90 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [25]>(char const (&) [25]) const Line | Count | Source | 1339 | 28 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 28 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 28 | DB << V; | 1343 | 28 | return *this; | 1344 | 28 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [28]>(char const (&) [28]) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [19]>(char const (&) [19]) const Line | Count | Source | 1339 | 161 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 161 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 161 | DB << V; | 1343 | 161 | return *this; | 1344 | 161 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [26]>(char const (&) [26]) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [31]>(char const (&) [31]) const Line | Count | Source | 1339 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 16 | DB << V; | 1343 | 16 | return *this; | 1344 | 16 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [18]>(char const (&) [18]) const Line | Count | Source | 1339 | 73 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 73 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 73 | DB << V; | 1343 | 73 | return *this; | 1344 | 73 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [43]>(char const (&) [43]) const Line | Count | Source | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [24]>(char const (&) [24]) const Line | Count | Source | 1339 | 45 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 45 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 45 | DB << V; | 1343 | 45 | return *this; | 1344 | 45 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [29]>(char const (&) [29]) const Line | Count | Source | 1339 | 51 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 51 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 51 | DB << V; | 1343 | 51 | return *this; | 1344 | 51 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [34]>(char const (&) [34]) const Line | Count | Source | 1339 | 47 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 47 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 47 | DB << V; | 1343 | 47 | return *this; | 1344 | 47 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [39]>(char const (&) [39]) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [54]>(char const (&) [54]) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [42]>(char const (&) [42]) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 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 | 1339 | 42 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 42 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 42 | DB << V; | 1343 | 42 | return *this; | 1344 | 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 | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [7]>(char const (&) [7]) const Line | Count | Source | 1339 | 355 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 355 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 355 | DB << V; | 1343 | 355 | return *this; | 1344 | 355 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [32]>(char const (&) [32]) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 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 | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [37]>(char const (&) [37]) const Line | Count | Source | 1339 | 14 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 14 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 14 | DB << V; | 1343 | 14 | return *this; | 1344 | 14 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [47]>(char const (&) [47]) const Line | Count | Source | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 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 | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [48]>(char const (&) [48]) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 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 | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [50]>(char const (&) [50]) const Line | Count | Source | 1339 | 20 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 20 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 20 | DB << V; | 1343 | 20 | return *this; | 1344 | 20 | } |
Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [141]>(char const (&) [141]) const Unexecuted instantiation: clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [87]>(char const (&) [87]) const 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 | 1339 | 17 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 17 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 17 | DB << V; | 1343 | 17 | return *this; | 1344 | 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 | 1339 | 207 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 207 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 207 | DB << V; | 1343 | 207 | return *this; | 1344 | 207 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRDefinitionDataDifference>(clang::ASTReader::diagnoseOdrViolations()::ODRDefinitionDataDifference const&) const Line | Count | Source | 1339 | 20 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 20 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 20 | DB << V; | 1343 | 20 | return *this; | 1344 | 20 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRCXXRecordDifference>(clang::ASTReader::diagnoseOdrViolations()::ODRCXXRecordDifference const&) const Line | Count | Source | 1339 | 122 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 122 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 122 | DB << V; | 1343 | 122 | return *this; | 1344 | 122 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::$_10::operator()(clang::NamedDecl*, llvm::StringRef, llvm::StringRef, clang::FieldDecl*, clang::FieldDecl*) const::ODRFieldDifference>(clang::ASTReader::diagnoseOdrViolations()::$_10::operator()(clang::NamedDecl*, llvm::StringRef, llvm::StringRef, clang::FieldDecl*, clang::FieldDecl*) const::ODRFieldDifference const&) const Line | Count | Source | 1339 | 48 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 48 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 48 | DB << V; | 1343 | 48 | return *this; | 1344 | 48 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::$_13>(clang::ASTReader::diagnoseOdrViolations()::$_13 const&) const Line | Count | Source | 1339 | 68 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 68 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 68 | DB << V; | 1343 | 68 | return *this; | 1344 | 68 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::$_11::operator()(clang::NamedDecl*, llvm::StringRef, llvm::StringRef, clang::TypedefNameDecl*, clang::TypedefNameDecl*, bool) const::ODRTypedefDifference>(clang::ASTReader::diagnoseOdrViolations()::$_11::operator()(clang::NamedDecl*, llvm::StringRef, llvm::StringRef, clang::TypedefNameDecl*, clang::TypedefNameDecl*, bool) const::ODRTypedefDifference const&) const Line | Count | Source | 1339 | 14 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 14 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 14 | DB << V; | 1343 | 14 | return *this; | 1344 | 14 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::$_12::operator()(clang::NamedDecl*, llvm::StringRef, llvm::StringRef, clang::VarDecl*, clang::VarDecl*) const::ODRVarDifference>(clang::ASTReader::diagnoseOdrViolations()::$_12::operator()(clang::NamedDecl*, llvm::StringRef, llvm::StringRef, clang::VarDecl*, clang::VarDecl*) const::ODRVarDifference const&) const Line | Count | Source | 1339 | 10 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 10 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 10 | DB << V; | 1343 | 10 | return *this; | 1344 | 10 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FunctionTemplateDecl*>(clang::FunctionTemplateDecl* const&) const Line | Count | Source | 1339 | 123 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 123 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 123 | DB << V; | 1343 | 123 | return *this; | 1344 | 123 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FunctionDecl*>(clang::FunctionDecl* const&) const Line | Count | Source | 1339 | 224k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 224k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 224k | DB << V; | 1343 | 224k | return *this; | 1344 | 224k | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRFunctionDifference>(clang::ASTReader::diagnoseOdrViolations()::ODRFunctionDifference const&) const Line | Count | Source | 1339 | 72 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 72 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 72 | DB << V; | 1343 | 72 | return *this; | 1344 | 72 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::EnumDecl*>(clang::EnumDecl* const&) const Line | Count | Source | 1339 | 65 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 65 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 65 | DB << V; | 1343 | 65 | return *this; | 1344 | 65 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODREnumDifference>(clang::ASTReader::diagnoseOdrViolations()::ODREnumDifference const&) const Line | Count | Source | 1339 | 26 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 26 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 26 | DB << V; | 1343 | 26 | return *this; | 1344 | 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 | 1339 | 10 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 10 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 10 | DB << V; | 1343 | 10 | return *this; | 1344 | 10 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamedDecl*>(clang::NamedDecl* const&) const Line | Count | Source | 1339 | 120k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 120k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 120k | DB << V; | 1343 | 120k | return *this; | 1344 | 120k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclContext*>(clang::DeclContext* const&) const Line | Count | Source | 1339 | 71.9k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 71.9k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 71.9k | DB << V; | 1343 | 71.9k | return *this; | 1344 | 71.9k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::QualType>(clang::QualType const&) const Line | Count | Source | 1339 | 333k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 333k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 333k | DB << V; | 1343 | 333k | return *this; | 1344 | 333k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclarationName>(clang::DeclarationName const&) const Line | Count | Source | 1339 | 29.9k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 29.9k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 29.9k | DB << V; | 1343 | 29.9k | return *this; | 1344 | 29.9k | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRMismatchDecl>(clang::ASTReader::diagnoseOdrViolations()::ODRMismatchDecl const&) const Line | Count | Source | 1339 | 88 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 88 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 88 | DB << V; | 1343 | 88 | return *this; | 1344 | 88 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXRecordDecl*>(clang::CXXRecordDecl* const&) const Line | Count | Source | 1339 | 8.74k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 8.74k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 8.74k | DB << V; | 1343 | 8.74k | return *this; | 1344 | 8.74k | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::ODRTemplateDifference>(clang::ASTReader::diagnoseOdrViolations()::ODRTemplateDifference const&) const Line | Count | Source | 1339 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 16 | DB << V; | 1343 | 16 | return *this; | 1344 | 16 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateArgument>(clang::TemplateArgument const&) const Line | Count | Source | 1339 | 766 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 766 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 766 | DB << V; | 1343 | 766 | return *this; | 1344 | 766 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Expr*>(clang::Expr* const&) const Line | Count | Source | 1339 | 344 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 344 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 344 | DB << V; | 1343 | 344 | return *this; | 1344 | 344 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::EnumConstantDecl const*>(clang::EnumConstantDecl const* const&) const Line | Count | Source | 1339 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 8 | DB << V; | 1343 | 8 | return *this; | 1344 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [5]>(char const (&) [5]) const Line | Count | Source | 1339 | 2.27k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2.27k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2.27k | DB << V; | 1343 | 2.27k | return *this; | 1344 | 2.27k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [69]>(char const (&) [69]) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [68]>(char const (&) [68]) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 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 | 1339 | 12 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 12 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 12 | DB << V; | 1343 | 12 | return *this; | 1344 | 12 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [144]>(char const (&) [144]) const Line | Count | Source | 1339 | 38 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 38 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 38 | DB << V; | 1343 | 38 | return *this; | 1344 | 38 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [30]>(char const (&) [30]) const Line | Count | Source | 1339 | 40 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 40 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 40 | DB << V; | 1343 | 40 | return *this; | 1344 | 40 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [56]>(char const (&) [56]) const Line | Count | Source | 1339 | 55 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 55 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 55 | DB << V; | 1343 | 55 | return *this; | 1344 | 55 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<64u> >(llvm::SmallString<64u> const&) const Line | Count | Source | 1339 | 48 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 48 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 48 | DB << V; | 1343 | 48 | return *this; | 1344 | 48 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<512u> >(llvm::SmallString<512u> const&) const Line | Count | Source | 1339 | 339 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 339 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 339 | DB << V; | 1343 | 339 | return *this; | 1344 | 339 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MSPropertyDecl const*>(clang::MSPropertyDecl const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
ParseOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::OMPContextLvl>((anonymous namespace)::OMPContextLvl const&) const Line | Count | Source | 1339 | 172 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 172 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 172 | DB << V; | 1343 | 172 | return *this; | 1344 | 172 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::PragmaClangSectionKind>(clang::Sema::PragmaClangSectionKind const&) const Line | Count | Source | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
ParsePragma.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::TokFPAnnotValue::FlagKinds>((anonymous namespace)::TokFPAnnotValue::FlagKinds const&) const Line | Count | Source | 1339 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6 | DB << V; | 1343 | 6 | return *this; | 1344 | 6 | } |
ParseStmt.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::MisleadingStatementKind>((anonymous namespace)::MisleadingStatementKind const&) const Line | Count | Source | 1339 | 46 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 46 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 46 | DB << V; | 1343 | 46 | return *this; | 1344 | 46 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::tok::TokenKind>(clang::tok::TokenKind const&) const Line | Count | Source | 1339 | 47.7k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 47.7k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 47.7k | DB << V; | 1343 | 47.7k | return *this; | 1344 | 47.7k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Parser::ExtraSemiKind>(clang::Parser::ExtraSemiKind const&) const Line | Count | Source | 1339 | 1.39k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1.39k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1.39k | DB << V; | 1343 | 1.39k | return *this; | 1344 | 1.39k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCMethodDecl const*>(clang::ObjCMethodDecl const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 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 | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NotTailCalledAttr const*>(clang::NotTailCalledAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [86]>(char const (&) [86]) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 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 | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TargetAttr const*>(clang::TargetAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CPUSpecificAttr const*>(clang::CPUSpecificAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 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 | 1339 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6 | DB << V; | 1343 | 6 | return *this; | 1344 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::HIPManagedAttr const*>(clang::HIPManagedAttr const* const&) const Line | Count | Source | 1339 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 8 | DB << V; | 1343 | 8 | return *this; | 1344 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDAGlobalAttr const*>(clang::CUDAGlobalAttr const* const&) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 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 | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDAHostAttr const*>(clang::CUDAHostAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDAConstantAttr const*>(clang::CUDAConstantAttr const* const&) const Line | Count | Source | 1339 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 8 | DB << V; | 1343 | 8 | return *this; | 1344 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::HotAttr const*>(clang::HotAttr const* const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::InternalLinkageAttr const*>(clang::InternalLinkageAttr const* const&) const Line | Count | Source | 1339 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6 | DB << V; | 1343 | 6 | return *this; | 1344 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [58]>(char const (&) [58]) const Line | Count | Source | 1339 | 252 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 252 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 252 | DB << V; | 1343 | 252 | return *this; | 1344 | 252 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NakedAttr const*>(clang::NakedAttr const* const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ColdAttr const*>(clang::ColdAttr const* const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CommonAttr const*>(clang::CommonAttr const* const&) const Line | Count | Source | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Mips16Attr const*>(clang::Mips16Attr const* const&) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MipsInterruptAttr const*>(clang::MipsInterruptAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MicroMipsAttr const*>(clang::MicroMipsAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MipsShortCallAttr const*>(clang::MipsShortCallAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MipsLongCallAttr const*>(clang::MipsLongCallAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DisableTailCallsAttr const*>(clang::DisableTailCallsAttr const* const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlwaysDestroyAttr const*>(clang::AlwaysDestroyAttr const* const&) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RandomizeLayoutAttr const*>(clang::RandomizeLayoutAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SpeculativeLoadHardeningAttr const*>(clang::SpeculativeLoadHardeningAttr const* const&) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlwaysInlineAttr const*>(clang::AlwaysInlineAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 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 | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::PointerAttr const*>(clang::PointerAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::OwnerAttr const*>(clang::OwnerAttr const* const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NoRandomizeLayoutAttr const*>(clang::NoRandomizeLayoutAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [77]>(char const (&) [77]) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NoSpeculativeLoadHardeningAttr const*>(clang::NoSpeculativeLoadHardeningAttr const* const&) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [150]>(char const (&) [150]) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char [97]>(char const (&) [97]) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ValueDecl*>(clang::ValueDecl* const&) const Line | Count | Source | 1339 | 9.07k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 9.07k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 9.07k | DB << V; | 1343 | 9.07k | return *this; | 1344 | 9.07k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CanonicalDeclPtr<clang::FunctionDecl> >(clang::CanonicalDeclPtr<clang::FunctionDecl> const&) const Line | Count | Source | 1339 | 118 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 118 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 118 | DB << V; | 1343 | 118 | return *this; | 1344 | 118 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FunctionDecl const*>(clang::FunctionDecl const* const&) const Line | Count | Source | 1339 | 10.4k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 10.4k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 10.4k | DB << V; | 1343 | 10.4k | return *this; | 1344 | 10.4k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarDecl const*>(clang::VarDecl const* const&) const Line | Count | Source | 1339 | 6.07k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6.07k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6.07k | DB << V; | 1343 | 6.07k | return *this; | 1344 | 6.07k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeCommonInfo>(clang::AttributeCommonInfo const&) const Line | Count | Source | 1339 | 66 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 66 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 66 | DB << V; | 1343 | 66 | return *this; | 1344 | 66 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTContext::SectionInfo>(clang::ASTContext::SectionInfo const&) const Line | Count | Source | 1339 | 23 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 23 | DB << V; | 1343 | 23 | return *this; | 1344 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParsedAttr>(clang::ParsedAttr const&) const Line | Count | Source | 1339 | 21.1k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 21.1k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 21.1k | DB << V; | 1343 | 21.1k | return *this; | 1344 | 21.1k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallVector<clang::FixItHint, 12u> >(llvm::SmallVector<clang::FixItHint, 12u> const&) const Line | Count | Source | 1339 | 40.1k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 40.1k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 40.1k | DB << V; | 1343 | 40.1k | return *this; | 1344 | 40.1k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<CastType>(CastType const&) const Line | Count | Source | 1339 | 400 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 400 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 400 | DB << V; | 1343 | 400 | return *this; | 1344 | 400 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::ArrayRef<clang::FixItHint> >(llvm::ArrayRef<clang::FixItHint> const&) const Line | Count | Source | 1339 | 31.6k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 31.6k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 31.6k | DB << V; | 1343 | 31.6k | return *this; | 1344 | 31.6k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned long long>(unsigned long long const&) const Line | Count | Source | 1339 | 22 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 22 | DB << V; | 1343 | 22 | return *this; | 1344 | 22 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<AbsoluteValueKind>(AbsoluteValueKind const&) const Line | Count | Source | 1339 | 768 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 768 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 768 | DB << V; | 1343 | 768 | return *this; | 1344 | 768 | } |
SemaChecking.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_20>(clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_20 const&) const Line | Count | Source | 1339 | 253 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 253 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 253 | DB << V; | 1343 | 253 | return *this; | 1344 | 253 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCIvarDecl*>(clang::ObjCIvarDecl* const&) const Line | Count | Source | 1339 | 46 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 46 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 46 | DB << V; | 1343 | 46 | return *this; | 1344 | 46 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ConceptSpecializationExpr*>(clang::ConceptSpecializationExpr* const&) const Line | Count | Source | 1339 | 36 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 36 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 36 | DB << V; | 1343 | 36 | return *this; | 1344 | 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 | 1339 | 42 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 42 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 42 | DB << V; | 1343 | 42 | return *this; | 1344 | 42 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXMethodDecl*>(clang::CXXMethodDecl* const&) const Line | Count | Source | 1339 | 23 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 23 | DB << V; | 1343 | 23 | return *this; | 1344 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ClassTemplateDecl*>(clang::ClassTemplateDecl* const&) const Line | Count | Source | 1339 | 62 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 62 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 62 | DB << V; | 1343 | 62 | return *this; | 1344 | 62 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlignedAttr const*>(clang::AlignedAttr const* const&) const Line | Count | Source | 1339 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6 | DB << V; | 1343 | 6 | return *this; | 1344 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlignedAttr*>(clang::AlignedAttr* const&) const Line | Count | Source | 1339 | 25 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 25 | DB << V; | 1343 | 25 | return *this; | 1344 | 25 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DLLImportAttr const*>(clang::DLLImportAttr const* const&) const Line | Count | Source | 1339 | 537 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 537 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 537 | DB << V; | 1343 | 537 | return *this; | 1344 | 537 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ErrorAttr*>(clang::ErrorAttr* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AnyX86NoCallerSavedRegistersAttr*>(clang::AnyX86NoCallerSavedRegistersAttr* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXX11NoReturnAttr const*>(clang::CXX11NoReturnAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypedefNameDecl*>(clang::TypedefNameDecl* const&) const Line | Count | Source | 1339 | 79 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 79 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 79 | DB << V; | 1343 | 79 | return *this; | 1344 | 79 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::InheritableAttr const*>(clang::InheritableAttr const* const&) const Line | Count | Source | 1339 | 484 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 484 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 484 | DB << V; | 1343 | 484 | return *this; | 1344 | 484 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<ShadowedDeclKind>(ShadowedDeclKind const&) const Line | Count | Source | 1339 | 158 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 158 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 158 | DB << V; | 1343 | 158 | return *this; | 1344 | 158 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclContext const*>(clang::DeclContext const* const&) const Line | Count | Source | 1339 | 52 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 52 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 52 | DB << V; | 1343 | 52 | return *this; | 1344 | 52 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::StorageClass>(clang::StorageClass const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::NonTrivialCUnionContext>(clang::Sema::NonTrivialCUnionContext const&) const Line | Count | Source | 1339 | 81 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 81 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 81 | DB << V; | 1343 | 81 | return *this; | 1344 | 81 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallVector<clang::FixItHint, 1u> >(llvm::SmallVector<clang::FixItHint, 1u> const&) const Line | Count | Source | 1339 | 17 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 17 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 17 | DB << V; | 1343 | 17 | return *this; | 1344 | 17 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::UsedAttr*>(clang::UsedAttr* const&) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RetainAttr*>(clang::RetainAttr* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParmVarDecl const*>(clang::ParmVarDecl const* const&) const Line | Count | Source | 1339 | 53 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 53 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 53 | DB << V; | 1343 | 53 | return *this; | 1344 | 53 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypedefDecl*>(clang::TypedefDecl* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TagDecl*>(clang::TagDecl* const&) const Line | Count | Source | 1339 | 12 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 12 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 12 | DB << V; | 1343 | 12 | return *this; | 1344 | 12 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CXXSpecialMember>(clang::Sema::CXXSpecialMember const&) const Line | Count | Source | 1339 | 646 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 646 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 646 | DB << V; | 1343 | 646 | return *this; | 1344 | 646 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::EnumConstantDecl*>(clang::EnumConstantDecl* const&) const Line | Count | Source | 1339 | 25 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 25 | DB << V; | 1343 | 25 | return *this; | 1344 | 25 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeArgumentNType>(clang::AttributeArgumentNType const&) const Line | Count | Source | 1339 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 7 | DB << V; | 1343 | 7 | return *this; | 1344 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::OwnershipAttr const*>(clang::OwnershipAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VecReturnAttr*>(clang::VecReturnAttr* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeDeclKind>(clang::AttributeDeclKind const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 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 | 1339 | 13 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 13 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 13 | DB << V; | 1343 | 13 | return *this; | 1344 | 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 | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ErrorAttr const*>(clang::ErrorAttr const* const&) const Line | Count | Source | 1339 | 11 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 11 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 11 | DB << V; | 1343 | 11 | return *this; | 1344 | 11 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SwiftNameAttr const*>(clang::SwiftNameAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlwaysInlineAttr*>(clang::AlwaysInlineAttr* const&) const Line | Count | Source | 1339 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 7 | DB << V; | 1343 | 7 | return *this; | 1344 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MinSizeAttr*>(clang::MinSizeAttr* const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 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 | 1339 | 178 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 178 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 178 | DB << V; | 1343 | 178 | return *this; | 1344 | 178 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ReqdWorkGroupSizeAttr const*>(clang::ReqdWorkGroupSizeAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::WorkGroupSizeHintAttr const*>(clang::WorkGroupSizeHintAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VecTypeHintAttr const*>(clang::VecTypeHintAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::OpenCLIntelReqdSubGroupSizeAttr const*>(clang::OpenCLIntelReqdSubGroupSizeAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUFlatWorkGroupSizeAttr const*>(clang::AMDGPUFlatWorkGroupSizeAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUWavesPerEUAttr const*>(clang::AMDGPUWavesPerEUAttr const* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUNumSGPRAttr const*>(clang::AMDGPUNumSGPRAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUNumVGPRAttr const*>(clang::AMDGPUNumVGPRAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::AbstractDiagSelID>(clang::Sema::AbstractDiagSelID const&) const Line | Count | Source | 1339 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 16 | DB << V; | 1343 | 16 | return *this; | 1344 | 16 | } |
SemaDeclCXX.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::DefaultedComparisonSubobject::$_8>((anonymous namespace)::DefaultedComparisonSubobject::$_8 const&) const Line | Count | Source | 1339 | 40 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 40 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 40 | DB << V; | 1343 | 40 | return *this; | 1344 | 40 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<TrivialSubobjectKind>(TrivialSubobjectKind const&) const Line | Count | Source | 1339 | 226 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 226 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 226 | DB << V; | 1343 | 226 | return *this; | 1344 | 226 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXConstructorDecl*>(clang::CXXConstructorDecl* const&) const Line | Count | Source | 1339 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 7 | DB << V; | 1343 | 7 | return *this; | 1344 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DecompositionDecl*>(clang::DecompositionDecl* const&) const Line | Count | Source | 1339 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 7 | DB << V; | 1343 | 7 | return *this; | 1344 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AccessSpecifier>(clang::AccessSpecifier const&) const Line | Count | Source | 1339 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 8 | DB << V; | 1343 | 8 | return *this; | 1344 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Attr*>(clang::Attr* const&) const Line | Count | Source | 1339 | 46 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 46 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 46 | DB << V; | 1343 | 46 | return *this; | 1344 | 46 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::InheritableAttr*>(clang::InheritableAttr* const&) const Line | Count | Source | 1339 | 28 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 28 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 28 | DB << V; | 1343 | 28 | return *this; | 1344 | 28 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ClassTemplateSpecializationDecl*>(clang::ClassTemplateSpecializationDecl* const&) const Line | Count | Source | 1339 | 80 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 80 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 80 | DB << V; | 1343 | 80 | return *this; | 1344 | 80 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateDecl*>(clang::TemplateDecl* const&) const Line | Count | Source | 1339 | 1.26k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1.26k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1.26k | DB << V; | 1343 | 1.26k | return *this; | 1344 | 1.26k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCMethodDecl*>(clang::ObjCMethodDecl* const&) const Line | Count | Source | 1339 | 2.65k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2.65k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2.65k | DB << V; | 1343 | 2.65k | return *this; | 1344 | 2.65k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCInterfaceDecl const*>(clang::ObjCInterfaceDecl const* const&) const Line | Count | Source | 1339 | 8 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 8 | DB << V; | 1343 | 8 | return *this; | 1344 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCCategoryDecl*>(clang::ObjCCategoryDecl* const&) const Line | Count | Source | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCProtocolDecl const*>(clang::ObjCProtocolDecl const* const&) const Line | Count | Source | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCMethodFamily>(clang::ObjCMethodFamily const&) const Line | Count | Source | 1339 | 48 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 48 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 48 | DB << V; | 1343 | 48 | return *this; | 1344 | 48 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCProtocolDecl*>(clang::ObjCProtocolDecl* const&) const Line | Count | Source | 1339 | 41 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 41 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 41 | DB << V; | 1343 | 41 | return *this; | 1344 | 41 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Selector>(clang::Selector const&) const Line | Count | Source | 1339 | 3.65k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3.65k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3.65k | DB << V; | 1343 | 3.65k | return *this; | 1344 | 3.65k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCIvarDecl const*>(clang::ObjCIvarDecl const* const&) const Line | Count | Source | 1339 | 10 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 10 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 10 | DB << V; | 1343 | 10 | return *this; | 1344 | 10 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ValueDecl const*>(clang::ValueDecl const* const&) const Line | Count | Source | 1339 | 12.7k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 12.7k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 12.7k | DB << V; | 1343 | 12.7k | return *this; | 1344 | 12.7k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CanQual<clang::Type> >(clang::CanQual<clang::Type> const&) const Line | Count | Source | 1339 | 96 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 96 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 96 | DB << V; | 1343 | 96 | return *this; | 1344 | 96 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<40u> >(llvm::SmallString<40u> const&) const Line | Count | Source | 1339 | 9.21k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 9.21k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 9.21k | DB << V; | 1343 | 9.21k | return *this; | 1344 | 9.21k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SourceLocation>(clang::SourceLocation const&) const Line | Count | Source | 1339 | 658 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 658 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 658 | DB << V; | 1343 | 658 | return *this; | 1344 | 658 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ObjCLiteralKind>(clang::Sema::ObjCLiteralKind const&) const Line | Count | Source | 1339 | 79 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 79 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 79 | DB << V; | 1343 | 79 | return *this; | 1344 | 79 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FieldDecl const*>(clang::FieldDecl const* const&) const Line | Count | Source | 1339 | 175 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 175 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 175 | DB << V; | 1343 | 175 | return *this; | 1344 | 175 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<OriginalExprKind>(OriginalExprKind const&) const Line | Count | Source | 1339 | 16 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 16 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 16 | DB << V; | 1343 | 16 | return *this; | 1344 | 16 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TagTypeKind>(clang::TagTypeKind const&) const Line | Count | Source | 1339 | 82 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 82 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 82 | DB << V; | 1343 | 82 | return *this; | 1344 | 82 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::NonTagKind>(clang::Sema::NonTagKind const&) const Line | Count | Source | 1339 | 28 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 28 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 28 | DB << V; | 1343 | 28 | return *this; | 1344 | 28 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypeAliasTemplateDecl*>(clang::TypeAliasTemplateDecl* const&) const Line | Count | Source | 1339 | 7 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 7 | DB << V; | 1343 | 7 | return *this; | 1344 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::UsingPackDecl*>(clang::UsingPackDecl* const&) const Line | Count | Source | 1339 | 2 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 2 | DB << V; | 1343 | 2 | return *this; | 1344 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CUDAFunctionTarget>(clang::Sema::CUDAFunctionTarget const&) const Line | Count | Source | 1339 | 263 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 263 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 263 | DB << V; | 1343 | 263 | return *this; | 1344 | 263 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::VariadicCallType>(clang::Sema::VariadicCallType const&) const Line | Count | Source | 1339 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6 | DB << V; | 1343 | 6 | return *this; | 1344 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RecordDecl*>(clang::RecordDecl* const&) const Line | Count | Source | 1339 | 23 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 23 | DB << V; | 1343 | 23 | return *this; | 1344 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarDecl*>(clang::VarDecl* const&) const Line | Count | Source | 1339 | 8.21k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 8.21k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 8.21k | DB << V; | 1343 | 8.21k | return *this; | 1344 | 8.21k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::AssignmentAction>(clang::Sema::AssignmentAction const&) const Line | Count | Source | 1339 | 13 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 13 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 13 | DB << V; | 1343 | 13 | return *this; | 1344 | 13 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCBridgeCastKind>(clang::ObjCBridgeCastKind const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FieldDecl*>(clang::FieldDecl* const&) const Line | Count | Source | 1339 | 619 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 619 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 619 | DB << V; | 1343 | 619 | return *this; | 1344 | 619 | } |
SemaInit.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::ReferenceKind>((anonymous namespace)::ReferenceKind const&) const Line | Count | Source | 1339 | 126 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 126 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 126 | DB << V; | 1343 | 126 | return *this; | 1344 | 126 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateName>(clang::TemplateName const&) const Line | Count | Source | 1339 | 467 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 467 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 467 | DB << V; | 1343 | 467 | return *this; | 1344 | 467 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers::ObjCLifetime>(clang::Qualifiers::ObjCLifetime const&) const Line | Count | Source | 1339 | 251 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 251 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 251 | DB << V; | 1343 | 251 | return *this; | 1344 | 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 | 1339 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 24 | DB << V; | 1343 | 24 | return *this; | 1344 | 24 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCPropertyDecl*>(clang::ObjCPropertyDecl* const&) const Line | Count | Source | 1339 | 31 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 31 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 31 | DB << V; | 1343 | 31 | return *this; | 1344 | 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)::$_46>(reportOriginalDsa(clang::Sema&, (anonymous namespace)::DSAStackTy const*, clang::ValueDecl const*, (anonymous namespace)::DSAStackTy::DSAVarData const&, bool)::$_46 const&) const Line | Count | Source | 1339 | 1.21k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1.21k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1.21k | DB << V; | 1343 | 1.21k | return *this; | 1344 | 1.21k | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<getPrivateItem(clang::Sema&, clang::Expr*&, clang::SourceLocation&, clang::SourceRange&, bool)::$_50>(getPrivateItem(clang::Sema&, clang::Expr*&, clang::SourceLocation&, clang::SourceRange&, bool)::$_50 const&) const Line | Count | Source | 1339 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 24 | DB << V; | 1343 | 24 | return *this; | 1344 | 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)::$_49>(checkNestingOfRegions(clang::Sema&, (anonymous namespace)::DSAStackTy const*, llvm::omp::Directive, clang::DeclarationNameInfo const&, llvm::omp::Directive, clang::OpenMPBindClauseKind, clang::SourceLocation)::$_49 const&) const Line | Count | Source | 1339 | 7.28k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 7.28k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 7.28k | DB << V; | 1343 | 7.28k | return *this; | 1344 | 7.28k | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::OpenMPAtomicUpdateChecker::ExprAnalysisErrorCode>((anonymous namespace)::OpenMPAtomicUpdateChecker::ExprAnalysisErrorCode const&) const Line | Count | Source | 1339 | 1.03k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1.03k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1.03k | DB << V; | 1343 | 1.03k | return *this; | 1344 | 1.03k | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_26>(clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_26 const&) const Line | Count | Source | 1339 | 108 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 108 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 108 | DB << V; | 1343 | 108 | return *this; | 1344 | 108 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_27>(clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_27 const&) const Line | Count | Source | 1339 | 72 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 72 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 72 | DB << V; | 1343 | 72 | return *this; | 1344 | 72 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_28>(clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_28 const&) const Line | Count | Source | 1339 | 108 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 108 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 108 | DB << V; | 1343 | 108 | return *this; | 1344 | 108 | } |
SemaOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::OpenMPAtomicCompareChecker::ErrorTy>((anonymous namespace)::OpenMPAtomicCompareChecker::ErrorTy const&) const Line | Count | Source | 1339 | 96 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 96 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 96 | DB << V; | 1343 | 96 | return *this; | 1344 | 96 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CCEKind>(clang::Sema::CCEKind const&) const Line | Count | Source | 1339 | 139 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 139 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 139 | DB << V; | 1343 | 139 | return *this; | 1344 | 139 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers>(clang::Qualifiers const&) const Line | Count | Source | 1339 | 9 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 9 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 9 | DB << V; | 1343 | 9 | return *this; | 1344 | 9 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::WarnUnusedResultAttr const*>(clang::WarnUnusedResultAttr const* const&) const Line | Count | Source | 1339 | 130 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 130 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 130 | DB << V; | 1343 | 130 | return *this; | 1344 | 130 | } |
SemaStmt.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::BeginEndFunction>((anonymous namespace)::BeginEndFunction const&) const Line | Count | Source | 1339 | 40 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 40 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 40 | DB << V; | 1343 | 40 | return *this; | 1344 | 40 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::LabelDecl*>(clang::LabelDecl* const&) const Line | Count | Source | 1339 | 380 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 380 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 380 | DB << V; | 1343 | 380 | return *this; | 1344 | 380 | } |
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 | 1339 | 12 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 12 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 12 | DB << V; | 1343 | 12 | return *this; | 1344 | 12 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Attr const*>(clang::Attr const* const&) const Line | Count | Source | 1339 | 38 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 38 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 38 | DB << V; | 1343 | 38 | return *this; | 1344 | 38 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::SmallString<16u> >(llvm::SmallString<16u> const&) const Line | Count | Source | 1339 | 233 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 233 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 233 | DB << V; | 1343 | 233 | return *this; | 1344 | 233 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParmVarDecl*>(clang::ParmVarDecl* const&) const Line | Count | Source | 1339 | 23 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 23 | DB << V; | 1343 | 23 | return *this; | 1344 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::sema::FunctionScopeInfo::'unnamed'>(clang::sema::FunctionScopeInfo::'unnamed' const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
SemaStmtAsm.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<checkExprMemoryConstraintCompat(clang::Sema&, clang::Expr*, clang::TargetInfo::ConstraintInfo&, bool)::$_1>(checkExprMemoryConstraintCompat(clang::Sema&, clang::Expr*, clang::TargetInfo::ConstraintInfo&, bool)::$_1 const&) const Line | Count | Source | 1339 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6 | DB << V; | 1343 | 6 | return *this; | 1344 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::LikelyAttr const*>(clang::LikelyAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::UnlikelyAttr const*>(clang::UnlikelyAttr const* const&) const Line | Count | Source | 1339 | 1 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 1 | DB << V; | 1343 | 1 | return *this; | 1344 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamespaceDecl*>(clang::NamespaceDecl* const&) const Line | Count | Source | 1339 | 39 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 39 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 39 | DB << V; | 1343 | 39 | return *this; | 1344 | 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 | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarTemplateSpecializationDecl*>(clang::VarTemplateSpecializationDecl* const&) const Line | Count | Source | 1339 | 3 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 3 | DB << V; | 1343 | 3 | return *this; | 1344 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateTemplateParmDecl*>(clang::TemplateTemplateParmDecl* const&) const Line | Count | Source | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 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 | 1339 | 4 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 4 | DB << V; | 1343 | 4 | return *this; | 1344 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarTemplateDecl*>(clang::VarTemplateDecl* const&) const Line | Count | Source | 1339 | 21 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 21 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 21 | DB << V; | 1343 | 21 | return *this; | 1344 | 21 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeducedTemplateArgument>(clang::DeducedTemplateArgument const&) const Line | Count | Source | 1339 | 25 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 25 | DB << V; | 1343 | 25 | return *this; | 1344 | 25 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AnnotateAttr const*>(clang::AnnotateAttr const* const&) const Line | Count | Source | 1339 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6 | DB << V; | 1343 | 6 | return *this; | 1344 | 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 | 1339 | 5 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 5 | DB << V; | 1343 | 5 | return *this; | 1344 | 5 | } |
SemaType.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::QualifiedFunctionKind>((anonymous namespace)::QualifiedFunctionKind const&) const Line | Count | Source | 1339 | 24 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 24 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 24 | DB << V; | 1343 | 24 | return *this; | 1344 | 24 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<TypeDiagSelector>(TypeDiagSelector const&) const Line | Count | Source | 1339 | 34 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 34 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 34 | DB << V; | 1343 | 34 | return *this; | 1344 | 34 | } |
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 | 1339 | 50 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 50 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 50 | DB << V; | 1343 | 50 | return *this; | 1344 | 50 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ArrayType::ArraySizeModifier>(clang::ArrayType::ArraySizeModifier const&) const Line | Count | Source | 1339 | 6 | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 6 | DB << V; | 1343 | 6 | return *this; | 1344 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::ArrayRef<clang::SourceRange> >(llvm::ArrayRef<clang::SourceRange> const&) const Line | Count | Source | 1339 | 25.7k | template <typename T> const DiagnosticBuilder &operator<<(const T &V) const { | 1340 | 25.7k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1341 | 0 | const StreamingDiagnostic &DB = *this; | 1342 | 25.7k | DB << V; | 1343 | 25.7k | return *this; | 1344 | 25.7k | } |
|
1345 | | |
1346 | | // It is necessary to limit this to rvalue reference to avoid calling this |
1347 | | // function with a bitfield lvalue argument since non-const reference to |
1348 | | // bitfield is not allowed. |
1349 | | template <typename T, typename = typename std::enable_if< |
1350 | | !std::is_lvalue_reference<T>::value>::type> |
1351 | 5.56M | const DiagnosticBuilder &operator<<(T &&V) const { |
1352 | 5.56M | assert(isActive() && "Clients must not add to cleared diagnostic!"); |
1353 | 0 | const StreamingDiagnostic &DB = *this; |
1354 | 5.56M | DB << std::move(V); |
1355 | 5.56M | return *this; |
1356 | 5.56M | } clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned long, void>(unsigned long&&) const Line | Count | Source | 1351 | 23 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 23 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 23 | DB << std::move(V); | 1355 | 23 | return *this; | 1356 | 23 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::comments::CommandMarkerKind, void>(clang::comments::CommandMarkerKind&&) const Line | Count | Source | 1351 | 501 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 501 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 501 | DB << std::move(V); | 1355 | 501 | return *this; | 1356 | 501 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned int, void>(unsigned int&&) const Line | Count | Source | 1351 | 2.73M | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 2.73M | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 2.73M | DB << std::move(V); | 1355 | 2.73M | return *this; | 1356 | 2.73M | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::IdentifierInfo*, void>(clang::IdentifierInfo*&&) const Line | Count | Source | 1351 | 153k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 153k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 153k | DB << std::move(V); | 1355 | 153k | return *this; | 1356 | 153k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::QualType, void>(clang::QualType&&) const Line | Count | Source | 1351 | 121k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 121k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 121k | DB << std::move(V); | 1355 | 121k | return *this; | 1356 | 121k | } |
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 | 1351 | 6 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 6 | DB << std::move(V); | 1355 | 6 | return *this; | 1356 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SourceRange, void>(clang::SourceRange&&) const Line | Count | Source | 1351 | 1.14M | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 1.14M | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 1.14M | DB << std::move(V); | 1355 | 1.14M | return *this; | 1356 | 1.14M | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<char const*, void>(char const*&&) const Line | Count | Source | 1351 | 17.3k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 17.3k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 17.3k | DB << std::move(V); | 1355 | 17.3k | return *this; | 1356 | 17.3k | } |
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 | 1351 | 173k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 173k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 173k | DB << std::move(V); | 1355 | 173k | return *this; | 1356 | 173k | } |
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 | 1351 | 7 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 7 | DB << std::move(V); | 1355 | 7 | return *this; | 1356 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<llvm::StringRef, void>(llvm::StringRef&&) const Line | Count | Source | 1351 | 129k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 129k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 129k | DB << std::move(V); | 1355 | 129k | return *this; | 1356 | 129k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<int, void>(int&&) const Line | Count | Source | 1351 | 591k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 591k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 591k | DB << std::move(V); | 1355 | 591k | return *this; | 1356 | 591k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FixItHint, void>(clang::FixItHint&&) const Line | Count | Source | 1351 | 330k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 330k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 330k | DB << std::move(V); | 1355 | 330k | return *this; | 1356 | 330k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CharSourceRange, void>(clang::CharSourceRange&&) const Line | Count | Source | 1351 | 797 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 797 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 797 | DB << std::move(V); | 1355 | 797 | return *this; | 1356 | 797 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<PPElifDiag, void>(PPElifDiag&&) const Line | Count | Source | 1351 | 46 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 46 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 46 | DB << std::move(V); | 1355 | 46 | return *this; | 1356 | 46 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<bool, void>(bool&&) const Line | Count | Source | 1351 | 95.8k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 95.8k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 95.8k | DB << std::move(V); | 1355 | 95.8k | return *this; | 1356 | 95.8k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::SourceLocation, void>(clang::SourceLocation&&) const Line | Count | Source | 1351 | 399 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 399 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 399 | DB << std::move(V); | 1355 | 399 | return *this; | 1356 | 399 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::tok::TokenKind, void>(clang::tok::TokenKind&&) const Line | Count | Source | 1351 | 1.01k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 1.01k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 1.01k | DB << std::move(V); | 1355 | 1.01k | return *this; | 1356 | 1.01k | } |
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 | 1351 | 3 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 3 | DB << std::move(V); | 1355 | 3 | return *this; | 1356 | 3 | } |
ASTReader.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ASTReader::diagnoseOdrViolations()::$_14, void>(clang::ASTReader::diagnoseOdrViolations()::$_14&&) const Line | Count | Source | 1351 | 6 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 6 | DB << std::move(V); | 1355 | 6 | return *this; | 1356 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclarationName, void>(clang::DeclarationName&&) const Line | Count | Source | 1351 | 62.0k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 62.0k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 62.0k | DB << std::move(V); | 1355 | 62.0k | return *this; | 1356 | 62.0k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::ObjCContainerKind, void>(clang::Sema::ObjCContainerKind&&) const Line | Count | Source | 1351 | 37 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 37 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 37 | DB << std::move(V); | 1355 | 37 | return *this; | 1356 | 37 | } |
ParseOpenMP.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::OMPContextLvl, void>((anonymous namespace)::OMPContextLvl&&) const Line | Count | Source | 1351 | 606 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 606 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 606 | DB << std::move(V); | 1355 | 606 | return *this; | 1356 | 606 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeDeclKind, void>(clang::AttributeDeclKind&&) const Line | Count | Source | 1351 | 69 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 69 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 69 | DB << std::move(V); | 1355 | 69 | return *this; | 1356 | 69 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AttributeArgumentNType, void>(clang::AttributeArgumentNType&&) const Line | Count | Source | 1351 | 189 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 189 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 189 | DB << std::move(V); | 1355 | 189 | return *this; | 1356 | 189 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<CastType, void>(CastType&&) const Line | Count | Source | 1351 | 138 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 138 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 138 | DB << std::move(V); | 1355 | 138 | return *this; | 1356 | 138 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Expr*, void>(clang::Expr*&&) const Line | Count | Source | 1351 | 62 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 62 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 62 | DB << std::move(V); | 1355 | 62 | return *this; | 1356 | 62 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::AssignmentAction, void>(clang::Sema::AssignmentAction&&) const Line | Count | Source | 1351 | 114 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 114 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 114 | DB << std::move(V); | 1355 | 114 | return *this; | 1356 | 114 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ConceptDecl*, void>(clang::ConceptDecl*&&) const Line | Count | Source | 1351 | 62 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 62 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 62 | DB << std::move(V); | 1355 | 62 | return *this; | 1356 | 62 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FunctionDecl*, void>(clang::FunctionDecl*&&) const Line | Count | Source | 1351 | 379 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 379 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 379 | DB << std::move(V); | 1355 | 379 | return *this; | 1356 | 379 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::VarDecl*, void>(clang::VarDecl*&&) const Line | Count | Source | 1351 | 516 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 516 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 516 | DB << std::move(V); | 1355 | 516 | return *this; | 1356 | 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 | 1351 | 1 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 1 | DB << std::move(V); | 1355 | 1 | return *this; | 1356 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RecordDecl const*, void>(clang::RecordDecl const*&&) const Line | Count | Source | 1351 | 4 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 4 | DB << std::move(V); | 1355 | 4 | return *this; | 1356 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<ShadowedDeclKind, void>(ShadowedDeclKind&&) const Line | Count | Source | 1351 | 48 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 48 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 48 | DB << std::move(V); | 1355 | 48 | return *this; | 1356 | 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 | 1351 | 28 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 28 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 28 | DB << std::move(V); | 1355 | 28 | return *this; | 1356 | 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 | 1351 | 27 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 27 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 27 | DB << std::move(V); | 1355 | 27 | return *this; | 1356 | 27 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamedDecl const*, void>(clang::NamedDecl const*&&) const Line | Count | Source | 1351 | 44 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 44 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 44 | DB << std::move(V); | 1355 | 44 | return *this; | 1356 | 44 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CUDALaunchBoundsAttr const*, void>(clang::CUDALaunchBoundsAttr const*&&) const Line | Count | Source | 1351 | 7 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 7 | DB << std::move(V); | 1355 | 7 | return *this; | 1356 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUFlatWorkGroupSizeAttr const*, void>(clang::AMDGPUFlatWorkGroupSizeAttr const*&&) const Line | Count | Source | 1351 | 11 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 11 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 11 | DB << std::move(V); | 1355 | 11 | return *this; | 1356 | 11 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AMDGPUWavesPerEUAttr const*, void>(clang::AMDGPUWavesPerEUAttr const*&&) const Line | Count | Source | 1351 | 11 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 11 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 11 | DB << std::move(V); | 1355 | 11 | return *this; | 1356 | 11 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParsedAttr const*, void>(clang::ParsedAttr const*&&) const Line | Count | Source | 1351 | 86 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 86 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 86 | DB << std::move(V); | 1355 | 86 | return *this; | 1356 | 86 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<AttributeLangSupport::LANG, void>(AttributeLangSupport::LANG&&) const Line | Count | Source | 1351 | 3 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 3 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 3 | DB << std::move(V); | 1355 | 3 | return *this; | 1356 | 3 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypedefNameDecl*, void>(clang::TypedefNameDecl*&&) const Line | Count | Source | 1351 | 30 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 30 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 30 | DB << std::move(V); | 1355 | 30 | return *this; | 1356 | 30 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AssumeAlignedAttr*, void>(clang::AssumeAlignedAttr*&&) const Line | Count | Source | 1351 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 5 | DB << std::move(V); | 1355 | 5 | return *this; | 1356 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AllocAlignAttr*, void>(clang::AllocAlignAttr*&&) const Line | Count | Source | 1351 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 5 | DB << std::move(V); | 1355 | 5 | return *this; | 1356 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AllocAlignAttr const*, void>(clang::AllocAlignAttr const*&&) const Line | Count | Source | 1351 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 5 | DB << std::move(V); | 1355 | 5 | return *this; | 1356 | 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 | 1351 | 22 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 22 | DB << std::move(V); | 1355 | 22 | return *this; | 1356 | 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 | 1351 | 22 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 22 | DB << std::move(V); | 1355 | 22 | return *this; | 1356 | 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 | 1351 | 22 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 22 | DB << std::move(V); | 1355 | 22 | return *this; | 1356 | 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 | 1351 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 5 | DB << std::move(V); | 1355 | 5 | return *this; | 1356 | 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 | 1351 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 5 | DB << std::move(V); | 1355 | 5 | return *this; | 1356 | 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 | 1351 | 5 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 5 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 5 | DB << std::move(V); | 1355 | 5 | return *this; | 1356 | 5 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlignValueAttr*, void>(clang::AlignValueAttr*&&) const Line | Count | Source | 1351 | 1 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 1 | DB << std::move(V); | 1355 | 1 | return *this; | 1356 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AlignedAttr*, void>(clang::AlignedAttr*&&) const Line | Count | Source | 1351 | 20 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 20 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 20 | DB << std::move(V); | 1355 | 20 | return *this; | 1356 | 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 | 1351 | 1 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 1 | DB << std::move(V); | 1355 | 1 | return *this; | 1356 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::AccessSpecifier, void>(clang::AccessSpecifier&&) const Line | Count | Source | 1351 | 8 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 8 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 8 | DB << std::move(V); | 1355 | 8 | return *this; | 1356 | 8 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamespaceDecl*, void>(clang::NamespaceDecl*&&) const Line | Count | Source | 1351 | 1 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 1 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 1 | DB << std::move(V); | 1355 | 1 | return *this; | 1356 | 1 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CanQual<clang::Type>, void>(clang::CanQual<clang::Type>&&) const Line | Count | Source | 1351 | 21 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 21 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 21 | DB << std::move(V); | 1355 | 21 | return *this; | 1356 | 21 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<std::__1::pair<clang::NullabilityKind, bool>, void>(std::__1::pair<clang::NullabilityKind, bool>&&) const Line | Count | Source | 1351 | 144 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 144 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 144 | DB << std::move(V); | 1355 | 144 | return *this; | 1356 | 144 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TagTypeKind, void>(clang::TagTypeKind&&) const Line | Count | Source | 1351 | 280 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 280 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 280 | DB << std::move(V); | 1355 | 280 | return *this; | 1356 | 280 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ObjCMethodDecl const*, void>(clang::ObjCMethodDecl const*&&) const Line | Count | Source | 1351 | 2 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 2 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 2 | DB << std::move(V); | 1355 | 2 | return *this; | 1356 | 2 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Selector, void>(clang::Selector&&) const Line | Count | Source | 1351 | 170 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 170 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 170 | DB << std::move(V); | 1355 | 170 | return *this; | 1356 | 170 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::IdentifierInfo const*, void>(clang::IdentifierInfo const*&&) const Line | Count | Source | 1351 | 140 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 140 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 140 | DB << std::move(V); | 1355 | 140 | return *this; | 1356 | 140 | } |
SemaExpr.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<$_15, void>($_15&&) const Line | Count | Source | 1351 | 387 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 387 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 387 | DB << std::move(V); | 1355 | 387 | return *this; | 1356 | 387 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::NonTagKind, void>(clang::Sema::NonTagKind&&) const Line | Count | Source | 1351 | 7 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 7 | DB << std::move(V); | 1355 | 7 | return *this; | 1356 | 7 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXRecordDecl*, void>(clang::CXXRecordDecl*&&) const Line | Count | Source | 1351 | 681 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 681 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 681 | DB << std::move(V); | 1355 | 681 | return *this; | 1356 | 681 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ValueDecl const*, void>(clang::ValueDecl const*&&) const Line | Count | Source | 1351 | 64 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 64 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 64 | DB << std::move(V); | 1355 | 64 | return *this; | 1356 | 64 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::DeclContext*, void>(clang::DeclContext*&&) const Line | Count | Source | 1351 | 169 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 169 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 169 | DB << std::move(V); | 1355 | 169 | return *this; | 1356 | 169 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NestedNameSpecifier*, void>(clang::NestedNameSpecifier*&&) const Line | Count | Source | 1351 | 388 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 388 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 388 | DB << std::move(V); | 1355 | 388 | return *this; | 1356 | 388 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ParmVarDecl*, void>(clang::ParmVarDecl*&&) const Line | Count | Source | 1351 | 436 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 436 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 436 | DB << std::move(V); | 1355 | 436 | return *this; | 1356 | 436 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::ValueDecl*, void>(clang::ValueDecl*&&) const Line | Count | Source | 1351 | 242 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 242 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 242 | DB << std::move(V); | 1355 | 242 | return *this; | 1356 | 242 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::FieldDecl*, void>(clang::FieldDecl*&&) const Line | Count | Source | 1351 | 388 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 388 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 388 | DB << std::move(V); | 1355 | 388 | return *this; | 1356 | 388 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers, void>(clang::Qualifiers&&) const Line | Count | Source | 1351 | 72 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 72 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 72 | DB << std::move(V); | 1355 | 72 | return *this; | 1356 | 72 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::QualType const, void>(clang::QualType const&&) const Line | Count | Source | 1351 | 42 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 42 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 42 | DB << std::move(V); | 1355 | 42 | return *this; | 1356 | 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 | 1351 | 12 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 12 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 12 | DB << std::move(V); | 1355 | 12 | return *this; | 1356 | 12 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::LangAS, void>(clang::LangAS&&) const Line | Count | Source | 1351 | 112 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 112 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 112 | DB << std::move(V); | 1355 | 112 | return *this; | 1356 | 112 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers::ObjCLifetime, void>(clang::Qualifiers::ObjCLifetime&&) const Line | Count | Source | 1351 | 34 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 34 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 34 | DB << std::move(V); | 1355 | 34 | return *this; | 1356 | 34 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Qualifiers::GC, void>(clang::Qualifiers::GC&&) const Line | Count | Source | 1351 | 4 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 4 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 4 | DB << std::move(V); | 1355 | 4 | return *this; | 1356 | 4 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TemplateDecl*, void>(clang::TemplateDecl*&&) const Line | Count | Source | 1351 | 6 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 6 | DB << std::move(V); | 1355 | 6 | return *this; | 1356 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::RefQualifierKind, void>(clang::RefQualifierKind&&) const Line | Count | Source | 1351 | 22 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 22 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 22 | DB << std::move(V); | 1355 | 22 | return *this; | 1356 | 22 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::NamedDecl*, void>(clang::NamedDecl*&&) const Line | Count | Source | 1351 | 522 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 522 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 522 | DB << std::move(V); | 1355 | 522 | return *this; | 1356 | 522 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CXXSpecialMember, void>(clang::Sema::CXXSpecialMember&&) const Line | Count | Source | 1351 | 1.05k | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 1.05k | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 1.05k | DB << std::move(V); | 1355 | 1.05k | return *this; | 1356 | 1.05k | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::CXXRecordDecl const*, void>(clang::CXXRecordDecl const*&&) const Line | Count | Source | 1351 | 52 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 52 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 52 | DB << std::move(V); | 1355 | 52 | return *this; | 1356 | 52 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::MSPropertyDecl*, void>(clang::MSPropertyDecl*&&) const Line | Count | Source | 1351 | 25 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 25 | DB << std::move(V); | 1355 | 25 | return *this; | 1356 | 25 | } |
SemaStmt.cpp:clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<(anonymous namespace)::BeginEndFunction, void>((anonymous namespace)::BeginEndFunction&&) const Line | Count | Source | 1351 | 6 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 6 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 6 | DB << std::move(V); | 1355 | 6 | return *this; | 1356 | 6 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Attr const*, void>(clang::Attr const*&&) const Line | Count | Source | 1351 | 941 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 941 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 941 | DB << std::move(V); | 1355 | 941 | return *this; | 1356 | 941 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::Sema::CUDAFunctionTarget, void>(clang::Sema::CUDAFunctionTarget&&) const Line | Count | Source | 1351 | 107 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 107 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 107 | DB << std::move(V); | 1355 | 107 | return *this; | 1356 | 107 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::TypeAliasTemplateDecl*, void>(clang::TypeAliasTemplateDecl*&&) const Line | Count | Source | 1351 | 14 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 14 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 14 | DB << std::move(V); | 1355 | 14 | return *this; | 1356 | 14 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<clang::BindingDecl*, void>(clang::BindingDecl*&&) const Line | Count | Source | 1351 | 10 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 10 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 10 | DB << std::move(V); | 1355 | 10 | return *this; | 1356 | 10 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<TypeDiagSelector, void>(TypeDiagSelector&&) const Line | Count | Source | 1351 | 25 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 25 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 25 | DB << std::move(V); | 1355 | 25 | return *this; | 1356 | 25 | } |
clang::DiagnosticBuilder const& clang::DiagnosticBuilder::operator<<<unsigned long long, void>(unsigned long long&&) const Line | Count | Source | 1351 | 7 | const DiagnosticBuilder &operator<<(T &&V) const { | 1352 | 7 | assert(isActive() && "Clients must not add to cleared diagnostic!"); | 1353 | 0 | const StreamingDiagnostic &DB = *this; | 1354 | 7 | DB << std::move(V); | 1355 | 7 | return *this; | 1356 | 7 | } |
|
1357 | | |
1358 | | DiagnosticBuilder &operator=(const DiagnosticBuilder &) = delete; |
1359 | | |
1360 | | /// Emits the diagnostic. |
1361 | 19.5M | ~DiagnosticBuilder() { Emit(); } |
1362 | | |
1363 | | /// Forces the diagnostic to be emitted. |
1364 | 164 | const DiagnosticBuilder &setForceEmit() const { |
1365 | 164 | IsForceEmit = true; |
1366 | 164 | return *this; |
1367 | 164 | } |
1368 | | |
1369 | 2.65k | void addFlagValue(StringRef V) const { DiagObj->FlagValue = std::string(V); } |
1370 | | }; |
1371 | | |
1372 | | struct AddFlagValue { |
1373 | | StringRef Val; |
1374 | | |
1375 | 2.65k | explicit AddFlagValue(StringRef V) : Val(V) {} |
1376 | | }; |
1377 | | |
1378 | | /// Register a value for the flag in the current diagnostic. This |
1379 | | /// value will be shown as the suffix "=value" after the flag name. It is |
1380 | | /// useful in cases where the diagnostic flag accepts values (e.g., |
1381 | | /// -Rpass or -Wframe-larger-than). |
1382 | | inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, |
1383 | 2.65k | const AddFlagValue V) { |
1384 | 2.65k | DB.addFlagValue(V.Val); |
1385 | 2.65k | return DB; |
1386 | 2.65k | } |
1387 | | |
1388 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1389 | 2.74M | StringRef S) { |
1390 | 2.74M | DB.AddString(S); |
1391 | 2.74M | return DB; |
1392 | 2.74M | } |
1393 | | |
1394 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1395 | 57.9k | const char *Str) { |
1396 | 57.9k | DB.AddTaggedVal(reinterpret_cast<intptr_t>(Str), |
1397 | 57.9k | DiagnosticsEngine::ak_c_string); |
1398 | 57.9k | return DB; |
1399 | 57.9k | } |
1400 | | |
1401 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1402 | 720k | int I) { |
1403 | 720k | DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint); |
1404 | 720k | return DB; |
1405 | 720k | } |
1406 | | |
1407 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1408 | 0 | long I) { |
1409 | 0 | DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint); |
1410 | 0 | return DB; |
1411 | 0 | } |
1412 | | |
1413 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1414 | 0 | long long I) { |
1415 | 0 | DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint); |
1416 | 0 | return DB; |
1417 | 0 | } |
1418 | | |
1419 | | // We use enable_if here to prevent that this overload is selected for |
1420 | | // pointers or other arguments that are implicitly convertible to bool. |
1421 | | template <typename T> |
1422 | | inline std::enable_if_t<std::is_same<T, bool>::value, |
1423 | | const StreamingDiagnostic &> |
1424 | 339k | operator<<(const StreamingDiagnostic &DB, T I) { |
1425 | 339k | DB.AddTaggedVal(I, DiagnosticsEngine::ak_sint); |
1426 | 339k | return DB; |
1427 | 339k | } |
1428 | | |
1429 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1430 | 2.89M | unsigned I) { |
1431 | 2.89M | DB.AddTaggedVal(I, DiagnosticsEngine::ak_uint); |
1432 | 2.89M | return DB; |
1433 | 2.89M | } |
1434 | | |
1435 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1436 | 23 | unsigned long I) { |
1437 | 23 | DB.AddTaggedVal(I, DiagnosticsEngine::ak_uint); |
1438 | 23 | return DB; |
1439 | 23 | } |
1440 | | |
1441 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1442 | 29 | unsigned long long I) { |
1443 | 29 | DB.AddTaggedVal(I, DiagnosticsEngine::ak_uint); |
1444 | 29 | return DB; |
1445 | 29 | } |
1446 | | |
1447 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1448 | 48.7k | tok::TokenKind I) { |
1449 | 48.7k | DB.AddTaggedVal(static_cast<unsigned>(I), DiagnosticsEngine::ak_tokenkind); |
1450 | 48.7k | return DB; |
1451 | 48.7k | } |
1452 | | |
1453 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1454 | 259k | const IdentifierInfo *II) { |
1455 | 259k | DB.AddTaggedVal(reinterpret_cast<intptr_t>(II), |
1456 | 259k | DiagnosticsEngine::ak_identifierinfo); |
1457 | 259k | return DB; |
1458 | 259k | } |
1459 | | |
1460 | | // Adds a DeclContext to the diagnostic. The enable_if template magic is here |
1461 | | // so that we only match those arguments that are (statically) DeclContexts; |
1462 | | // other arguments that derive from DeclContext (e.g., RecordDecls) will not |
1463 | | // match. |
1464 | | template <typename T> |
1465 | | inline std::enable_if_t< |
1466 | | std::is_same<std::remove_const_t<T>, DeclContext>::value, |
1467 | | const StreamingDiagnostic &> |
1468 | 72.5k | operator<<(const StreamingDiagnostic &DB, T *DC) { |
1469 | 72.5k | DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC), |
1470 | 72.5k | DiagnosticsEngine::ak_declcontext); |
1471 | 72.5k | return DB; |
1472 | 72.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 | 1468 | 72.4k | operator<<(const StreamingDiagnostic &DB, T *DC) { | 1469 | 72.4k | DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC), | 1470 | 72.4k | DiagnosticsEngine::ak_declcontext); | 1471 | 72.4k | return DB; | 1472 | 72.4k | } |
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 | 1468 | 52 | operator<<(const StreamingDiagnostic &DB, T *DC) { | 1469 | 52 | DB.AddTaggedVal(reinterpret_cast<intptr_t>(DC), | 1470 | 52 | DiagnosticsEngine::ak_declcontext); | 1471 | 52 | return DB; | 1472 | 52 | } |
|
1473 | | |
1474 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1475 | 1.68M | SourceRange R) { |
1476 | 1.68M | DB.AddSourceRange(CharSourceRange::getTokenRange(R)); |
1477 | 1.68M | return DB; |
1478 | 1.68M | } |
1479 | | |
1480 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1481 | 25.7k | ArrayRef<SourceRange> Ranges) { |
1482 | 25.7k | for (SourceRange R : Ranges) |
1483 | 40.4k | DB.AddSourceRange(CharSourceRange::getTokenRange(R)); |
1484 | 25.7k | return DB; |
1485 | 25.7k | } |
1486 | | |
1487 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1488 | 10.3k | const CharSourceRange &R) { |
1489 | 10.3k | DB.AddSourceRange(R); |
1490 | 10.3k | return DB; |
1491 | 10.3k | } |
1492 | | |
1493 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1494 | 410k | const FixItHint &Hint) { |
1495 | 410k | DB.AddFixItHint(Hint); |
1496 | 410k | return DB; |
1497 | 410k | } |
1498 | | |
1499 | | inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1500 | 71.8k | ArrayRef<FixItHint> Hints) { |
1501 | 71.8k | for (const FixItHint &Hint : Hints) |
1502 | 1.47k | DB.AddFixItHint(Hint); |
1503 | 71.8k | return DB; |
1504 | 71.8k | } |
1505 | | |
1506 | | inline const StreamingDiagnostic & |
1507 | | operator<<(const StreamingDiagnostic &DB, |
1508 | 0 | const llvm::Optional<SourceRange> &Opt) { |
1509 | 0 | if (Opt) |
1510 | 0 | DB << *Opt; |
1511 | 0 | return DB; |
1512 | 0 | } |
1513 | | |
1514 | | inline const StreamingDiagnostic & |
1515 | | operator<<(const StreamingDiagnostic &DB, |
1516 | 0 | const llvm::Optional<CharSourceRange> &Opt) { |
1517 | 0 | if (Opt) |
1518 | 0 | DB << *Opt; |
1519 | 0 | return DB; |
1520 | 0 | } |
1521 | | |
1522 | | inline const StreamingDiagnostic & |
1523 | | operator<<(const StreamingDiagnostic &DB, |
1524 | 0 | const llvm::Optional<FixItHint> &Opt) { |
1525 | 0 | if (Opt) |
1526 | 0 | DB << *Opt; |
1527 | 0 | return DB; |
1528 | 0 | } |
1529 | | |
1530 | | /// A nullability kind paired with a bit indicating whether it used a |
1531 | | /// context-sensitive keyword. |
1532 | | using DiagNullabilityKind = std::pair<NullabilityKind, bool>; |
1533 | | |
1534 | | const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1535 | | DiagNullabilityKind nullability); |
1536 | | |
1537 | | inline DiagnosticBuilder DiagnosticsEngine::Report(SourceLocation Loc, |
1538 | 12.9M | unsigned DiagID) { |
1539 | 12.9M | assert(CurDiagID == std::numeric_limits<unsigned>::max() && |
1540 | 12.9M | "Multiple diagnostics in flight at once!"); |
1541 | 0 | CurDiagLoc = Loc; |
1542 | 12.9M | CurDiagID = DiagID; |
1543 | 12.9M | FlagValue.clear(); |
1544 | 12.9M | return DiagnosticBuilder(this); |
1545 | 12.9M | } |
1546 | | |
1547 | | const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB, |
1548 | | llvm::Error &&E); |
1549 | | |
1550 | 155k | inline DiagnosticBuilder DiagnosticsEngine::Report(unsigned DiagID) { |
1551 | 155k | return Report(SourceLocation(), DiagID); |
1552 | 155k | } |
1553 | | |
1554 | | //===----------------------------------------------------------------------===// |
1555 | | // Diagnostic |
1556 | | //===----------------------------------------------------------------------===// |
1557 | | |
1558 | | /// A little helper class (which is basically a smart pointer that forwards |
1559 | | /// info from DiagnosticsEngine) that allows clients to enquire about the |
1560 | | /// currently in-flight diagnostic. |
1561 | | class Diagnostic { |
1562 | | const DiagnosticsEngine *DiagObj; |
1563 | | StringRef StoredDiagMessage; |
1564 | | |
1565 | | public: |
1566 | 16.2M | explicit Diagnostic(const DiagnosticsEngine *DO) : DiagObj(DO) {} |
1567 | | Diagnostic(const DiagnosticsEngine *DO, StringRef storedDiagMessage) |
1568 | 150 | : DiagObj(DO), StoredDiagMessage(storedDiagMessage) {} |
1569 | | |
1570 | 670k | const DiagnosticsEngine *getDiags() const { return DiagObj; } |
1571 | 13.4M | unsigned getID() const { return DiagObj->CurDiagID; } |
1572 | 13.8M | const SourceLocation &getLocation() const { return DiagObj->CurDiagLoc; } |
1573 | 442k | bool hasSourceManager() const { return DiagObj->hasSourceManager(); } |
1574 | 841k | SourceManager &getSourceManager() const { return DiagObj->getSourceManager();} |
1575 | | |
1576 | 4.99M | unsigned getNumArgs() const { return DiagObj->DiagStorage.NumDiagArgs; } |
1577 | | |
1578 | | /// Return the kind of the specified index. |
1579 | | /// |
1580 | | /// Based on the kind of argument, the accessors below can be used to get |
1581 | | /// the value. |
1582 | | /// |
1583 | | /// \pre Idx < getNumArgs() |
1584 | 4.15M | DiagnosticsEngine::ArgumentKind getArgKind(unsigned Idx) const { |
1585 | 4.15M | assert(Idx < getNumArgs() && "Argument index out of range!"); |
1586 | 0 | return (DiagnosticsEngine::ArgumentKind) |
1587 | 4.15M | DiagObj->DiagStorage.DiagArgumentsKind[Idx]; |
1588 | 4.15M | } |
1589 | | |
1590 | | /// Return the provided argument string specified by \p Idx. |
1591 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_std_string |
1592 | 353k | const std::string &getArgStdStr(unsigned Idx) const { |
1593 | 353k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_std_string && |
1594 | 353k | "invalid argument accessor!"); |
1595 | 0 | return DiagObj->DiagStorage.DiagArgumentsStr[Idx]; |
1596 | 353k | } |
1597 | | |
1598 | | /// Return the specified C string argument. |
1599 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_c_string |
1600 | 18.0k | const char *getArgCStr(unsigned Idx) const { |
1601 | 18.0k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_c_string && |
1602 | 18.0k | "invalid argument accessor!"); |
1603 | 0 | return reinterpret_cast<const char *>( |
1604 | 18.0k | DiagObj->DiagStorage.DiagArgumentsVal[Idx]); |
1605 | 18.0k | } |
1606 | | |
1607 | | /// Return the specified signed integer argument. |
1608 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_sint |
1609 | 123k | int64_t getArgSInt(unsigned Idx) const { |
1610 | 123k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_sint && |
1611 | 123k | "invalid argument accessor!"); |
1612 | 0 | return (int64_t)DiagObj->DiagStorage.DiagArgumentsVal[Idx]; |
1613 | 123k | } |
1614 | | |
1615 | | /// Return the specified unsigned integer argument. |
1616 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_uint |
1617 | 82.6k | uint64_t getArgUInt(unsigned Idx) const { |
1618 | 82.6k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_uint && |
1619 | 82.6k | "invalid argument accessor!"); |
1620 | 0 | return DiagObj->DiagStorage.DiagArgumentsVal[Idx]; |
1621 | 82.6k | } |
1622 | | |
1623 | | /// Return the specified IdentifierInfo argument. |
1624 | | /// \pre getArgKind(Idx) == DiagnosticsEngine::ak_identifierinfo |
1625 | 9.80k | const IdentifierInfo *getArgIdentifier(unsigned Idx) const { |
1626 | 9.80k | assert(getArgKind(Idx) == DiagnosticsEngine::ak_identifierinfo && |
1627 | 9.80k | "invalid argument accessor!"); |
1628 | 0 | return reinterpret_cast<IdentifierInfo *>( |
1629 | 9.80k | DiagObj->DiagStorage.DiagArgumentsVal[Idx]); |
1630 | 9.80k | } |
1631 | | |
1632 | | /// Return the specified non-string argument in an opaque form. |
1633 | | /// \pre getArgKind(Idx) != DiagnosticsEngine::ak_std_string |
1634 | 1.07M | uint64_t getRawArg(unsigned Idx) const { |
1635 | 1.07M | assert(getArgKind(Idx) != DiagnosticsEngine::ak_std_string && |
1636 | 1.07M | "invalid argument accessor!"); |
1637 | 0 | return DiagObj->DiagStorage.DiagArgumentsVal[Idx]; |
1638 | 1.07M | } |
1639 | | |
1640 | | /// Return the number of source ranges associated with this diagnostic. |
1641 | 377k | unsigned getNumRanges() const { |
1642 | 377k | return DiagObj->DiagStorage.DiagRanges.size(); |
1643 | 377k | } |
1644 | | |
1645 | | /// \pre Idx < getNumRanges() |
1646 | 172k | const CharSourceRange &getRange(unsigned Idx) const { |
1647 | 172k | assert(Idx < getNumRanges() && "Invalid diagnostic range index!"); |
1648 | 0 | return DiagObj->DiagStorage.DiagRanges[Idx]; |
1649 | 172k | } |
1650 | | |
1651 | | /// Return an array reference for this diagnostic's ranges. |
1652 | 43.8k | ArrayRef<CharSourceRange> getRanges() const { |
1653 | 43.8k | return DiagObj->DiagStorage.DiagRanges; |
1654 | 43.8k | } |
1655 | | |
1656 | 207k | unsigned getNumFixItHints() const { |
1657 | 207k | return DiagObj->DiagStorage.FixItHints.size(); |
1658 | 207k | } |
1659 | | |
1660 | 1.05k | const FixItHint &getFixItHint(unsigned Idx) const { |
1661 | 1.05k | assert(Idx < getNumFixItHints() && "Invalid index!"); |
1662 | 0 | return DiagObj->DiagStorage.FixItHints[Idx]; |
1663 | 1.05k | } |
1664 | | |
1665 | 44.2k | ArrayRef<FixItHint> getFixItHints() const { |
1666 | 44.2k | return DiagObj->DiagStorage.FixItHints; |
1667 | 44.2k | } |
1668 | | |
1669 | | /// Format this diagnostic into a string, substituting the |
1670 | | /// formal arguments into the %0 slots. |
1671 | | /// |
1672 | | /// The result is appended onto the \p OutStr array. |
1673 | | void FormatDiagnostic(SmallVectorImpl<char> &OutStr) const; |
1674 | | |
1675 | | /// Format the given format-string into the output buffer using the |
1676 | | /// arguments stored in this diagnostic. |
1677 | | void FormatDiagnostic(const char *DiagStr, const char *DiagEnd, |
1678 | | SmallVectorImpl<char> &OutStr) const; |
1679 | | }; |
1680 | | |
1681 | | /** |
1682 | | * Represents a diagnostic in a form that can be retained until its |
1683 | | * corresponding source manager is destroyed. |
1684 | | */ |
1685 | | class StoredDiagnostic { |
1686 | | unsigned ID; |
1687 | | DiagnosticsEngine::Level Level; |
1688 | | FullSourceLoc Loc; |
1689 | | std::string Message; |
1690 | | std::vector<CharSourceRange> Ranges; |
1691 | | std::vector<FixItHint> FixIts; |
1692 | | |
1693 | | public: |
1694 | | StoredDiagnostic() = default; |
1695 | | StoredDiagnostic(DiagnosticsEngine::Level Level, const Diagnostic &Info); |
1696 | | StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID, |
1697 | | StringRef Message); |
1698 | | StoredDiagnostic(DiagnosticsEngine::Level Level, unsigned ID, |
1699 | | StringRef Message, FullSourceLoc Loc, |
1700 | | ArrayRef<CharSourceRange> Ranges, |
1701 | | ArrayRef<FixItHint> Fixits); |
1702 | | |
1703 | | /// Evaluates true when this object stores a diagnostic. |
1704 | 0 | explicit operator bool() const { return !Message.empty(); } |
1705 | | |
1706 | 22.6k | unsigned getID() const { return ID; } |
1707 | 9.53k | DiagnosticsEngine::Level getLevel() const { return Level; } |
1708 | 27.5k | const FullSourceLoc &getLocation() const { return Loc; } |
1709 | 2.07k | StringRef getMessage() const { return Message; } |
1710 | | |
1711 | 97 | void setLocation(FullSourceLoc Loc) { this->Loc = Loc; } |
1712 | | |
1713 | | using range_iterator = std::vector<CharSourceRange>::const_iterator; |
1714 | | |
1715 | 253 | range_iterator range_begin() const { return Ranges.begin(); } |
1716 | 151 | range_iterator range_end() const { return Ranges.end(); } |
1717 | 884 | unsigned range_size() const { return Ranges.size(); } |
1718 | | |
1719 | 667 | ArrayRef<CharSourceRange> getRanges() const { |
1720 | 667 | return llvm::makeArrayRef(Ranges); |
1721 | 667 | } |
1722 | | |
1723 | | using fixit_iterator = std::vector<FixItHint>::const_iterator; |
1724 | | |
1725 | 192 | fixit_iterator fixit_begin() const { return FixIts.begin(); } |
1726 | 150 | fixit_iterator fixit_end() const { return FixIts.end(); } |
1727 | 824 | unsigned fixit_size() const { return FixIts.size(); } |
1728 | | |
1729 | 665 | ArrayRef<FixItHint> getFixIts() const { |
1730 | 665 | return llvm::makeArrayRef(FixIts); |
1731 | 665 | } |
1732 | | }; |
1733 | | |
1734 | | // Simple debug printing of StoredDiagnostic. |
1735 | | llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const StoredDiagnostic &); |
1736 | | |
1737 | | /// Abstract interface, implemented by clients of the front-end, which |
1738 | | /// formats and prints fully processed diagnostics. |
1739 | | class DiagnosticConsumer { |
1740 | | protected: |
1741 | | unsigned NumWarnings = 0; ///< Number of warnings reported |
1742 | | unsigned NumErrors = 0; ///< Number of errors reported |
1743 | | |
1744 | | public: |
1745 | 476k | DiagnosticConsumer() = default; |
1746 | | virtual ~DiagnosticConsumer(); |
1747 | | |
1748 | 146k | unsigned getNumErrors() const { return NumErrors; } |
1749 | 63.1k | unsigned getNumWarnings() const { return NumWarnings; } |
1750 | 212 | virtual void clear() { NumWarnings = NumErrors = 0; } |
1751 | | |
1752 | | /// Callback to inform the diagnostic client that processing |
1753 | | /// of a source file is beginning. |
1754 | | /// |
1755 | | /// Note that diagnostics may be emitted outside the processing of a source |
1756 | | /// file, for example during the parsing of command line options. However, |
1757 | | /// diagnostics with source range information are required to only be emitted |
1758 | | /// in between BeginSourceFile() and EndSourceFile(). |
1759 | | /// |
1760 | | /// \param LangOpts The language options for the source file being processed. |
1761 | | /// \param PP The preprocessor object being used for the source; this is |
1762 | | /// optional, e.g., it may not be present when processing AST source files. |
1763 | | virtual void BeginSourceFile(const LangOptions &LangOpts, |
1764 | 2.09k | const Preprocessor *PP = nullptr) {} |
1765 | | |
1766 | | /// Callback to inform the diagnostic client that processing |
1767 | | /// of a source file has ended. |
1768 | | /// |
1769 | | /// The diagnostic client should assume that any objects made available via |
1770 | | /// BeginSourceFile() are inaccessible. |
1771 | 5.01k | virtual void EndSourceFile() {} |
1772 | | |
1773 | | /// Callback to inform the diagnostic client that processing of all |
1774 | | /// source files has ended. |
1775 | 83.5k | virtual void finish() {} |
1776 | | |
1777 | | /// Indicates whether the diagnostics handled by this |
1778 | | /// DiagnosticConsumer should be included in the number of diagnostics |
1779 | | /// reported by DiagnosticsEngine. |
1780 | | /// |
1781 | | /// The default implementation returns true. |
1782 | | virtual bool IncludeInDiagnosticCounts() const; |
1783 | | |
1784 | | /// Handle this diagnostic, reporting it to the user or |
1785 | | /// capturing it to a log as needed. |
1786 | | /// |
1787 | | /// The default implementation just keeps track of the total number of |
1788 | | /// warnings and errors. |
1789 | | virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
1790 | | const Diagnostic &Info); |
1791 | | }; |
1792 | | |
1793 | | /// A diagnostic client that ignores all diagnostics. |
1794 | | class IgnoringDiagConsumer : public DiagnosticConsumer { |
1795 | | virtual void anchor(); |
1796 | | |
1797 | | void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
1798 | 72 | const Diagnostic &Info) override { |
1799 | | // Just ignore it. |
1800 | 72 | } |
1801 | | }; |
1802 | | |
1803 | | /// Diagnostic consumer that forwards diagnostics along to an |
1804 | | /// existing, already-initialized diagnostic consumer. |
1805 | | /// |
1806 | | class ForwardingDiagnosticConsumer : public DiagnosticConsumer { |
1807 | | DiagnosticConsumer &Target; |
1808 | | |
1809 | | public: |
1810 | 1.85k | ForwardingDiagnosticConsumer(DiagnosticConsumer &Target) : Target(Target) {} |
1811 | | ~ForwardingDiagnosticConsumer() override; |
1812 | | |
1813 | | void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, |
1814 | | const Diagnostic &Info) override; |
1815 | | void clear() override; |
1816 | | |
1817 | | bool IncludeInDiagnosticCounts() const override; |
1818 | | }; |
1819 | | |
1820 | | // Struct used for sending info about how a type should be printed. |
1821 | | struct TemplateDiffTypes { |
1822 | | intptr_t FromType; |
1823 | | intptr_t ToType; |
1824 | | unsigned PrintTree : 1; |
1825 | | unsigned PrintFromType : 1; |
1826 | | unsigned ElideType : 1; |
1827 | | unsigned ShowColors : 1; |
1828 | | |
1829 | | // The printer sets this variable to true if the template diff was used. |
1830 | | unsigned TemplateDiffUsed : 1; |
1831 | | }; |
1832 | | |
1833 | | /// Special character that the diagnostic printer will use to toggle the bold |
1834 | | /// attribute. The character itself will be not be printed. |
1835 | | const char ToggleHighlight = 127; |
1836 | | |
1837 | | /// ProcessWarningOptions - Initialize the diagnostic client and process the |
1838 | | /// warning options specified on the command line. |
1839 | | void ProcessWarningOptions(DiagnosticsEngine &Diags, |
1840 | | const DiagnosticOptions &Opts, |
1841 | | bool ReportDiags = true); |
1842 | | |
1843 | | } // namespace clang |
1844 | | |
1845 | | #endif // LLVM_CLANG_BASIC_DIAGNOSTIC_H |