/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Sema/Sema.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- Sema.h - Semantic Analysis & AST Building --------------*- 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 | | // This file defines the Sema class, which performs semantic analysis and |
10 | | // builds ASTs. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #ifndef LLVM_CLANG_SEMA_SEMA_H |
15 | | #define LLVM_CLANG_SEMA_SEMA_H |
16 | | |
17 | | #include "clang/AST/ASTConcept.h" |
18 | | #include "clang/AST/ASTFwd.h" |
19 | | #include "clang/AST/Attr.h" |
20 | | #include "clang/AST/Availability.h" |
21 | | #include "clang/AST/ComparisonCategories.h" |
22 | | #include "clang/AST/DeclTemplate.h" |
23 | | #include "clang/AST/DeclarationName.h" |
24 | | #include "clang/AST/Expr.h" |
25 | | #include "clang/AST/ExprCXX.h" |
26 | | #include "clang/AST/ExprConcepts.h" |
27 | | #include "clang/AST/ExprObjC.h" |
28 | | #include "clang/AST/ExprOpenMP.h" |
29 | | #include "clang/AST/ExternalASTSource.h" |
30 | | #include "clang/AST/LocInfoType.h" |
31 | | #include "clang/AST/MangleNumberingContext.h" |
32 | | #include "clang/AST/NSAPI.h" |
33 | | #include "clang/AST/PrettyPrinter.h" |
34 | | #include "clang/AST/StmtCXX.h" |
35 | | #include "clang/AST/TypeLoc.h" |
36 | | #include "clang/AST/TypeOrdering.h" |
37 | | #include "clang/Basic/BitmaskEnum.h" |
38 | | #include "clang/Basic/ExpressionTraits.h" |
39 | | #include "clang/Basic/Module.h" |
40 | | #include "clang/Basic/OpenCLOptions.h" |
41 | | #include "clang/Basic/OpenMPKinds.h" |
42 | | #include "clang/Basic/PragmaKinds.h" |
43 | | #include "clang/Basic/Specifiers.h" |
44 | | #include "clang/Basic/TemplateKinds.h" |
45 | | #include "clang/Basic/TypeTraits.h" |
46 | | #include "clang/Sema/AnalysisBasedWarnings.h" |
47 | | #include "clang/Sema/CleanupInfo.h" |
48 | | #include "clang/Sema/DeclSpec.h" |
49 | | #include "clang/Sema/ExternalSemaSource.h" |
50 | | #include "clang/Sema/IdentifierResolver.h" |
51 | | #include "clang/Sema/ObjCMethodList.h" |
52 | | #include "clang/Sema/Ownership.h" |
53 | | #include "clang/Sema/Scope.h" |
54 | | #include "clang/Sema/SemaConcept.h" |
55 | | #include "clang/Sema/TypoCorrection.h" |
56 | | #include "clang/Sema/Weak.h" |
57 | | #include "llvm/ADT/ArrayRef.h" |
58 | | #include "llvm/ADT/Optional.h" |
59 | | #include "llvm/ADT/SetVector.h" |
60 | | #include "llvm/ADT/SmallBitVector.h" |
61 | | #include "llvm/ADT/SmallPtrSet.h" |
62 | | #include "llvm/ADT/SmallSet.h" |
63 | | #include "llvm/ADT/SmallVector.h" |
64 | | #include "llvm/ADT/TinyPtrVector.h" |
65 | | #include "llvm/Frontend/OpenMP/OMPConstants.h" |
66 | | #include <deque> |
67 | | #include <memory> |
68 | | #include <string> |
69 | | #include <tuple> |
70 | | #include <vector> |
71 | | |
72 | | namespace llvm { |
73 | | class APSInt; |
74 | | template <typename ValueT> struct DenseMapInfo; |
75 | | template <typename ValueT, typename ValueInfoT> class DenseSet; |
76 | | class SmallBitVector; |
77 | | struct InlineAsmIdentifierInfo; |
78 | | } |
79 | | |
80 | | namespace clang { |
81 | | class ADLResult; |
82 | | class ASTConsumer; |
83 | | class ASTContext; |
84 | | class ASTMutationListener; |
85 | | class ASTReader; |
86 | | class ASTWriter; |
87 | | class ArrayType; |
88 | | class ParsedAttr; |
89 | | class BindingDecl; |
90 | | class BlockDecl; |
91 | | class CapturedDecl; |
92 | | class CXXBasePath; |
93 | | class CXXBasePaths; |
94 | | class CXXBindTemporaryExpr; |
95 | | typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath; |
96 | | class CXXConstructorDecl; |
97 | | class CXXConversionDecl; |
98 | | class CXXDeleteExpr; |
99 | | class CXXDestructorDecl; |
100 | | class CXXFieldCollector; |
101 | | class CXXMemberCallExpr; |
102 | | class CXXMethodDecl; |
103 | | class CXXScopeSpec; |
104 | | class CXXTemporary; |
105 | | class CXXTryStmt; |
106 | | class CallExpr; |
107 | | class ClassTemplateDecl; |
108 | | class ClassTemplatePartialSpecializationDecl; |
109 | | class ClassTemplateSpecializationDecl; |
110 | | class VarTemplatePartialSpecializationDecl; |
111 | | class CodeCompleteConsumer; |
112 | | class CodeCompletionAllocator; |
113 | | class CodeCompletionTUInfo; |
114 | | class CodeCompletionResult; |
115 | | class CoroutineBodyStmt; |
116 | | class Decl; |
117 | | class DeclAccessPair; |
118 | | class DeclContext; |
119 | | class DeclRefExpr; |
120 | | class DeclaratorDecl; |
121 | | class DeducedTemplateArgument; |
122 | | class DependentDiagnostic; |
123 | | class DesignatedInitExpr; |
124 | | class Designation; |
125 | | class EnableIfAttr; |
126 | | class EnumConstantDecl; |
127 | | class Expr; |
128 | | class ExtVectorType; |
129 | | class FormatAttr; |
130 | | class FriendDecl; |
131 | | class FunctionDecl; |
132 | | class FunctionProtoType; |
133 | | class FunctionTemplateDecl; |
134 | | class ImplicitConversionSequence; |
135 | | typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList; |
136 | | class InitListExpr; |
137 | | class InitializationKind; |
138 | | class InitializationSequence; |
139 | | class InitializedEntity; |
140 | | class IntegerLiteral; |
141 | | class LabelStmt; |
142 | | class LambdaExpr; |
143 | | class LangOptions; |
144 | | class LocalInstantiationScope; |
145 | | class LookupResult; |
146 | | class MacroInfo; |
147 | | typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath; |
148 | | class ModuleLoader; |
149 | | class MultiLevelTemplateArgumentList; |
150 | | class NamedDecl; |
151 | | class ObjCCategoryDecl; |
152 | | class ObjCCategoryImplDecl; |
153 | | class ObjCCompatibleAliasDecl; |
154 | | class ObjCContainerDecl; |
155 | | class ObjCImplDecl; |
156 | | class ObjCImplementationDecl; |
157 | | class ObjCInterfaceDecl; |
158 | | class ObjCIvarDecl; |
159 | | template <class T> class ObjCList; |
160 | | class ObjCMessageExpr; |
161 | | class ObjCMethodDecl; |
162 | | class ObjCPropertyDecl; |
163 | | class ObjCProtocolDecl; |
164 | | class OMPThreadPrivateDecl; |
165 | | class OMPRequiresDecl; |
166 | | class OMPDeclareReductionDecl; |
167 | | class OMPDeclareSimdDecl; |
168 | | class OMPClause; |
169 | | struct OMPVarListLocTy; |
170 | | struct OverloadCandidate; |
171 | | enum class OverloadCandidateParamOrder : char; |
172 | | enum OverloadCandidateRewriteKind : unsigned; |
173 | | class OverloadCandidateSet; |
174 | | class OverloadExpr; |
175 | | class ParenListExpr; |
176 | | class ParmVarDecl; |
177 | | class Preprocessor; |
178 | | class PseudoDestructorTypeStorage; |
179 | | class PseudoObjectExpr; |
180 | | class QualType; |
181 | | class StandardConversionSequence; |
182 | | class Stmt; |
183 | | class StringLiteral; |
184 | | class SwitchStmt; |
185 | | class TemplateArgument; |
186 | | class TemplateArgumentList; |
187 | | class TemplateArgumentLoc; |
188 | | class TemplateDecl; |
189 | | class TemplateInstantiationCallback; |
190 | | class TemplateParameterList; |
191 | | class TemplatePartialOrderingContext; |
192 | | class TemplateTemplateParmDecl; |
193 | | class Token; |
194 | | class TypeAliasDecl; |
195 | | class TypedefDecl; |
196 | | class TypedefNameDecl; |
197 | | class TypeLoc; |
198 | | class TypoCorrectionConsumer; |
199 | | class UnqualifiedId; |
200 | | class UnresolvedLookupExpr; |
201 | | class UnresolvedMemberExpr; |
202 | | class UnresolvedSetImpl; |
203 | | class UnresolvedSetIterator; |
204 | | class UsingDecl; |
205 | | class UsingShadowDecl; |
206 | | class ValueDecl; |
207 | | class VarDecl; |
208 | | class VarTemplateSpecializationDecl; |
209 | | class VisibilityAttr; |
210 | | class VisibleDeclConsumer; |
211 | | class IndirectFieldDecl; |
212 | | struct DeductionFailureInfo; |
213 | | class TemplateSpecCandidateSet; |
214 | | |
215 | | namespace sema { |
216 | | class AccessedEntity; |
217 | | class BlockScopeInfo; |
218 | | class Capture; |
219 | | class CapturedRegionScopeInfo; |
220 | | class CapturingScopeInfo; |
221 | | class CompoundScopeInfo; |
222 | | class DelayedDiagnostic; |
223 | | class DelayedDiagnosticPool; |
224 | | class FunctionScopeInfo; |
225 | | class LambdaScopeInfo; |
226 | | class PossiblyUnreachableDiag; |
227 | | class SemaPPCallbacks; |
228 | | class TemplateDeductionInfo; |
229 | | } |
230 | | |
231 | | namespace threadSafety { |
232 | | class BeforeSet; |
233 | | void threadSafetyCleanup(BeforeSet* Cache); |
234 | | } |
235 | | |
236 | | // FIXME: No way to easily map from TemplateTypeParmTypes to |
237 | | // TemplateTypeParmDecls, so we have this horrible PointerUnion. |
238 | | typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>, |
239 | | SourceLocation> UnexpandedParameterPack; |
240 | | |
241 | | /// Describes whether we've seen any nullability information for the given |
242 | | /// file. |
243 | | struct FileNullability { |
244 | | /// The first pointer declarator (of any pointer kind) in the file that does |
245 | | /// not have a corresponding nullability annotation. |
246 | | SourceLocation PointerLoc; |
247 | | |
248 | | /// The end location for the first pointer declarator in the file. Used for |
249 | | /// placing fix-its. |
250 | | SourceLocation PointerEndLoc; |
251 | | |
252 | | /// Which kind of pointer declarator we saw. |
253 | | uint8_t PointerKind; |
254 | | |
255 | | /// Whether we saw any type nullability annotations in the given file. |
256 | | bool SawTypeNullability = false; |
257 | | }; |
258 | | |
259 | | /// A mapping from file IDs to a record of whether we've seen nullability |
260 | | /// information in that file. |
261 | | class FileNullabilityMap { |
262 | | /// A mapping from file IDs to the nullability information for each file ID. |
263 | | llvm::DenseMap<FileID, FileNullability> Map; |
264 | | |
265 | | /// A single-element cache based on the file ID. |
266 | | struct { |
267 | | FileID File; |
268 | | FileNullability Nullability; |
269 | | } Cache; |
270 | | |
271 | | public: |
272 | 36.1k | FileNullability &operator[](FileID file) { |
273 | | // Check the single-element cache. |
274 | 36.1k | if (file == Cache.File) |
275 | 33.0k | return Cache.Nullability; |
276 | | |
277 | | // It's not in the single-element cache; flush the cache if we have one. |
278 | 3.07k | if (!Cache.File.isInvalid()) { |
279 | 1.63k | Map[Cache.File] = Cache.Nullability; |
280 | 1.63k | } |
281 | | |
282 | | // Pull this entry into the cache. |
283 | 3.07k | Cache.File = file; |
284 | 3.07k | Cache.Nullability = Map[file]; |
285 | 3.07k | return Cache.Nullability; |
286 | 3.07k | } |
287 | | }; |
288 | | |
289 | | /// Keeps track of expected type during expression parsing. The type is tied to |
290 | | /// a particular token, all functions that update or consume the type take a |
291 | | /// start location of the token they are looking at as a parameter. This allows |
292 | | /// to avoid updating the type on hot paths in the parser. |
293 | | class PreferredTypeBuilder { |
294 | | public: |
295 | 3.30M | PreferredTypeBuilder() = default; |
296 | 0 | explicit PreferredTypeBuilder(QualType Type) : Type(Type) {} |
297 | | |
298 | | void enterCondition(Sema &S, SourceLocation Tok); |
299 | | void enterReturn(Sema &S, SourceLocation Tok); |
300 | | void enterVariableInit(SourceLocation Tok, Decl *D); |
301 | | /// Computing a type for the function argument may require running |
302 | | /// overloading, so we postpone its computation until it is actually needed. |
303 | | /// |
304 | | /// Clients should be very careful when using this funciton, as it stores a |
305 | | /// function_ref, clients should make sure all calls to get() with the same |
306 | | /// location happen while function_ref is alive. |
307 | | void enterFunctionArgument(SourceLocation Tok, |
308 | | llvm::function_ref<QualType()> ComputeType); |
309 | | |
310 | | void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc); |
311 | | void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind, |
312 | | SourceLocation OpLoc); |
313 | | void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op); |
314 | | void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base); |
315 | | void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS); |
316 | | /// Handles all type casts, including C-style cast, C++ casts, etc. |
317 | | void enterTypeCast(SourceLocation Tok, QualType CastType); |
318 | | |
319 | 2.37M | QualType get(SourceLocation Tok) const { |
320 | 2.37M | if (Tok != ExpectedLoc) |
321 | 1.46M | return QualType(); |
322 | 907k | if (!Type.isNull()) |
323 | 361k | return Type; |
324 | 545k | if (ComputeType) |
325 | 199 | return ComputeType(); |
326 | 545k | return QualType(); |
327 | 545k | } |
328 | | |
329 | | private: |
330 | | /// Start position of a token for which we store expected type. |
331 | | SourceLocation ExpectedLoc; |
332 | | /// Expected type for a token starting at ExpectedLoc. |
333 | | QualType Type; |
334 | | /// A function to compute expected type at ExpectedLoc. It is only considered |
335 | | /// if Type is null. |
336 | | llvm::function_ref<QualType()> ComputeType; |
337 | | }; |
338 | | |
339 | | /// Sema - This implements semantic analysis and AST building for C. |
340 | | class Sema final { |
341 | | Sema(const Sema &) = delete; |
342 | | void operator=(const Sema &) = delete; |
343 | | |
344 | | /// A key method to reduce duplicate debug info from Sema. |
345 | | virtual void anchor(); |
346 | | |
347 | | ///Source of additional semantic information. |
348 | | ExternalSemaSource *ExternalSource; |
349 | | |
350 | | ///Whether Sema has generated a multiplexer and has to delete it. |
351 | | bool isMultiplexExternalSource; |
352 | | |
353 | | static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD); |
354 | | |
355 | | bool isVisibleSlow(const NamedDecl *D); |
356 | | |
357 | | /// Determine whether two declarations should be linked together, given that |
358 | | /// the old declaration might not be visible and the new declaration might |
359 | | /// not have external linkage. |
360 | | bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old, |
361 | 185k | const NamedDecl *New) { |
362 | 185k | if (isVisible(Old)) |
363 | 185k | return true; |
364 | | // See comment in below overload for why it's safe to compute the linkage |
365 | | // of the new declaration here. |
366 | 157 | if (New->isExternallyDeclarable()) { |
367 | 156 | assert(Old->isExternallyDeclarable() && |
368 | 156 | "should not have found a non-externally-declarable previous decl"); |
369 | 156 | return true; |
370 | 156 | } |
371 | 1 | return false; |
372 | 1 | } |
373 | | bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New); |
374 | | |
375 | | void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem, |
376 | | QualType ResultTy, |
377 | | ArrayRef<QualType> Args); |
378 | | |
379 | | public: |
380 | | /// The maximum alignment, same as in llvm::Value. We duplicate them here |
381 | | /// because that allows us not to duplicate the constants in clang code, |
382 | | /// which we must to since we can't directly use the llvm constants. |
383 | | /// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp |
384 | | /// |
385 | | /// This is the greatest alignment value supported by load, store, and alloca |
386 | | /// instructions, and global values. |
387 | | static const unsigned MaxAlignmentExponent = 29; |
388 | | static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent; |
389 | | |
390 | | typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy; |
391 | | typedef OpaquePtr<TemplateName> TemplateTy; |
392 | | typedef OpaquePtr<QualType> TypeTy; |
393 | | |
394 | | OpenCLOptions OpenCLFeatures; |
395 | | FPOptions CurFPFeatures; |
396 | | |
397 | | const LangOptions &LangOpts; |
398 | | Preprocessor &PP; |
399 | | ASTContext &Context; |
400 | | ASTConsumer &Consumer; |
401 | | DiagnosticsEngine &Diags; |
402 | | SourceManager &SourceMgr; |
403 | | |
404 | | /// Flag indicating whether or not to collect detailed statistics. |
405 | | bool CollectStats; |
406 | | |
407 | | /// Code-completion consumer. |
408 | | CodeCompleteConsumer *CodeCompleter; |
409 | | |
410 | | /// CurContext - This is the current declaration context of parsing. |
411 | | DeclContext *CurContext; |
412 | | |
413 | | /// Generally null except when we temporarily switch decl contexts, |
414 | | /// like in \see ActOnObjCTemporaryExitContainerContext. |
415 | | DeclContext *OriginalLexicalContext; |
416 | | |
417 | | /// VAListTagName - The declaration name corresponding to __va_list_tag. |
418 | | /// This is used as part of a hack to omit that class from ADL results. |
419 | | DeclarationName VAListTagName; |
420 | | |
421 | | bool MSStructPragmaOn; // True when \#pragma ms_struct on |
422 | | |
423 | | /// Controls member pointer representation format under the MS ABI. |
424 | | LangOptions::PragmaMSPointersToMembersKind |
425 | | MSPointerToMemberRepresentationMethod; |
426 | | |
427 | | /// Stack of active SEH __finally scopes. Can be empty. |
428 | | SmallVector<Scope*, 2> CurrentSEHFinally; |
429 | | |
430 | | /// Source location for newly created implicit MSInheritanceAttrs |
431 | | SourceLocation ImplicitMSInheritanceAttrLoc; |
432 | | |
433 | | /// Holds TypoExprs that are created from `createDelayedTypo`. This is used by |
434 | | /// `TransformTypos` in order to keep track of any TypoExprs that are created |
435 | | /// recursively during typo correction and wipe them away if the correction |
436 | | /// fails. |
437 | | llvm::SmallVector<TypoExpr *, 2> TypoExprs; |
438 | | |
439 | | /// pragma clang section kind |
440 | | enum PragmaClangSectionKind { |
441 | | PCSK_Invalid = 0, |
442 | | PCSK_BSS = 1, |
443 | | PCSK_Data = 2, |
444 | | PCSK_Rodata = 3, |
445 | | PCSK_Text = 4, |
446 | | PCSK_Relro = 5 |
447 | | }; |
448 | | |
449 | | enum PragmaClangSectionAction { |
450 | | PCSA_Set = 0, |
451 | | PCSA_Clear = 1 |
452 | | }; |
453 | | |
454 | | struct PragmaClangSection { |
455 | | std::string SectionName; |
456 | | bool Valid = false; |
457 | | SourceLocation PragmaLocation; |
458 | | }; |
459 | | |
460 | | PragmaClangSection PragmaClangBSSSection; |
461 | | PragmaClangSection PragmaClangDataSection; |
462 | | PragmaClangSection PragmaClangRodataSection; |
463 | | PragmaClangSection PragmaClangRelroSection; |
464 | | PragmaClangSection PragmaClangTextSection; |
465 | | |
466 | | enum PragmaMsStackAction { |
467 | | PSK_Reset = 0x0, // #pragma () |
468 | | PSK_Set = 0x1, // #pragma (value) |
469 | | PSK_Push = 0x2, // #pragma (push[, id]) |
470 | | PSK_Pop = 0x4, // #pragma (pop[, id]) |
471 | | PSK_Show = 0x8, // #pragma (show) -- only for "pack"! |
472 | | PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value) |
473 | | PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value) |
474 | | }; |
475 | | |
476 | | // #pragma pack and align. |
477 | | class AlignPackInfo { |
478 | | public: |
479 | | // `Native` represents default align mode, which may vary based on the |
480 | | // platform. |
481 | | enum Mode : unsigned char { Native, Natural, Packed, Mac68k }; |
482 | | |
483 | | // #pragma pack info constructor |
484 | | AlignPackInfo(AlignPackInfo::Mode M, unsigned Num, bool IsXL) |
485 | 331k | : PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) { |
486 | 331k | assert(Num == PackNumber && "The pack number has been truncated."); |
487 | 331k | } |
488 | | |
489 | | // #pragma align info constructor |
490 | | AlignPackInfo(AlignPackInfo::Mode M, bool IsXL) |
491 | | : PackAttr(false), AlignMode(M), |
492 | 86.4k | PackNumber(M == Packed ? 1 : UninitPackVal), XLStack(IsXL) {} |
493 | | |
494 | 79.0k | explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {} Unexecuted instantiation: clang::Sema::AlignPackInfo::AlignPackInfo(bool) clang::Sema::AlignPackInfo::AlignPackInfo(bool) Line | Count | Source | 494 | 79.0k | explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {} |
|
495 | | |
496 | 14 | AlignPackInfo() : AlignPackInfo(Native, false) {} Unexecuted instantiation: clang::Sema::AlignPackInfo::AlignPackInfo() clang::Sema::AlignPackInfo::AlignPackInfo() Line | Count | Source | 496 | 14 | AlignPackInfo() : AlignPackInfo(Native, false) {} |
|
497 | | |
498 | | // When a AlignPackInfo itself cannot be used, this returns an 32-bit |
499 | | // integer encoding for it. This should only be passed to |
500 | | // AlignPackInfo::getFromRawEncoding, it should not be inspected directly. |
501 | 3.31k | static uint32_t getRawEncoding(const AlignPackInfo &Info) { |
502 | 3.31k | std::uint32_t Encoding{}; |
503 | 3.31k | if (Info.IsXLStack()) |
504 | 20 | Encoding |= IsXLMask; |
505 | | |
506 | 3.31k | Encoding |= static_cast<uint32_t>(Info.getAlignMode()) << 1; |
507 | | |
508 | 3.31k | if (Info.IsPackAttr()) |
509 | 14 | Encoding |= PackAttrMask; |
510 | | |
511 | 3.31k | Encoding |= static_cast<uint32_t>(Info.getPackNumber()) << 4; |
512 | | |
513 | 3.31k | return Encoding; |
514 | 3.31k | } |
515 | | |
516 | 3.82k | static AlignPackInfo getFromRawEncoding(unsigned Encoding) { |
517 | 3.82k | bool IsXL = static_cast<bool>(Encoding & IsXLMask); |
518 | 3.82k | AlignPackInfo::Mode M = |
519 | 3.82k | static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> 1); |
520 | 3.82k | int PackNumber = (Encoding & PackNumMask) >> 4; |
521 | | |
522 | 3.82k | if (Encoding & PackAttrMask) |
523 | 14 | return AlignPackInfo(M, PackNumber, IsXL); |
524 | | |
525 | 3.81k | return AlignPackInfo(M, IsXL); |
526 | 3.81k | } |
527 | | |
528 | 3.41k | bool IsPackAttr() const { return PackAttr; } |
529 | | |
530 | 146 | bool IsAlignAttr() const { return !PackAttr; } |
531 | | |
532 | 1.48M | Mode getAlignMode() const { return AlignMode; } |
533 | | |
534 | 311k | unsigned getPackNumber() const { return PackNumber; } |
535 | | |
536 | 1.15M | bool IsPackSet() const { |
537 | | // #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack |
538 | | // attriute on a decl. |
539 | 1.15M | return PackNumber != UninitPackVal && PackNumber != 0308k ; |
540 | 1.15M | } |
541 | | |
542 | 333k | bool IsXLStack() const { return XLStack; } |
543 | | |
544 | 1.60M | bool operator==(const AlignPackInfo &Info) const { |
545 | 1.60M | return std::tie(AlignMode, PackNumber, PackAttr, XLStack) == |
546 | 1.60M | std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr, |
547 | 1.60M | Info.XLStack); |
548 | 1.60M | } |
549 | | |
550 | 1.60M | bool operator!=(const AlignPackInfo &Info) const { |
551 | 1.60M | return !(*this == Info); |
552 | 1.60M | } |
553 | | |
554 | | private: |
555 | | /// \brief True if this is a pragma pack attribute, |
556 | | /// not a pragma align attribute. |
557 | | bool PackAttr; |
558 | | |
559 | | /// \brief The alignment mode that is in effect. |
560 | | Mode AlignMode; |
561 | | |
562 | | /// \brief The pack number of the stack. |
563 | | unsigned char PackNumber; |
564 | | |
565 | | /// \brief True if it is a XL #pragma align/pack stack. |
566 | | bool XLStack; |
567 | | |
568 | | /// \brief Uninitialized pack value. |
569 | | static constexpr unsigned char UninitPackVal = -1; |
570 | | |
571 | | // Masks to encode and decode an AlignPackInfo. |
572 | | static constexpr uint32_t IsXLMask{0x0000'0001}; |
573 | | static constexpr uint32_t AlignModeMask{0x0000'0006}; |
574 | | static constexpr uint32_t PackAttrMask{0x00000'0008}; |
575 | | static constexpr uint32_t PackNumMask{0x0000'01F0}; |
576 | | }; |
577 | | |
578 | | template<typename ValueType> |
579 | | struct PragmaStack { |
580 | | struct Slot { |
581 | | llvm::StringRef StackSlotLabel; |
582 | | ValueType Value; |
583 | | SourceLocation PragmaLocation; |
584 | | SourceLocation PragmaPushLocation; |
585 | | Slot(llvm::StringRef StackSlotLabel, ValueType Value, |
586 | | SourceLocation PragmaLocation, SourceLocation PragmaPushLocation) |
587 | | : StackSlotLabel(StackSlotLabel), Value(Value), |
588 | | PragmaLocation(PragmaLocation), |
589 | 3.29M | PragmaPushLocation(PragmaPushLocation) {} clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::Slot::Slot(llvm::StringRef, clang::Sema::AlignPackInfo, clang::SourceLocation, clang::SourceLocation) Line | Count | Source | 589 | 165k | PragmaPushLocation(PragmaPushLocation) {} |
clang::Sema::PragmaStack<clang::FPOptionsOverride>::Slot::Slot(llvm::StringRef, clang::FPOptionsOverride, clang::SourceLocation, clang::SourceLocation) Line | Count | Source | 589 | 36 | PragmaPushLocation(PragmaPushLocation) {} |
clang::Sema::PragmaStack<clang::MSVtorDispMode>::Slot::Slot(llvm::StringRef, clang::MSVtorDispMode, clang::SourceLocation, clang::SourceLocation) Line | Count | Source | 589 | 625k | PragmaPushLocation(PragmaPushLocation) {} |
clang::Sema::PragmaStack<clang::StringLiteral*>::Slot::Slot(llvm::StringRef, clang::StringLiteral*, clang::SourceLocation, clang::SourceLocation) Line | Count | Source | 589 | 2.50M | PragmaPushLocation(PragmaPushLocation) {} |
|
590 | | }; |
591 | | |
592 | | void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action, |
593 | 6.86M | llvm::StringRef StackSlotLabel, ValueType Value) { |
594 | 6.86M | if (Action == PSK_Reset) { |
595 | 604k | CurrentValue = DefaultValue; |
596 | 604k | CurrentPragmaLocation = PragmaLocation; |
597 | 604k | return; |
598 | 604k | } |
599 | 6.25M | if (Action & PSK_Push) |
600 | 3.12M | Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, |
601 | 3.12M | PragmaLocation); |
602 | 3.12M | else if (Action & PSK_Pop) { |
603 | 3.12M | if (!StackSlotLabel.empty()) { |
604 | | // If we've got a label, try to find it and jump there. |
605 | 3.12M | auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { |
606 | 3.12M | return x.StackSlotLabel == StackSlotLabel; |
607 | 3.12M | }); Unexecuted instantiation: clang::Sema::PragmaStack<clang::FPOptionsOverride>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::FPOptionsOverride)::'lambda'(clang::Sema::PragmaStack<clang::FPOptionsOverride>::Slot const&)::operator()(clang::Sema::PragmaStack<clang::FPOptionsOverride>::Slot const&) const clang::Sema::PragmaStack<clang::MSVtorDispMode>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::MSVtorDispMode)::'lambda'(clang::Sema::PragmaStack<clang::MSVtorDispMode>::Slot const&)::operator()(clang::Sema::PragmaStack<clang::MSVtorDispMode>::Slot const&) const Line | Count | Source | 605 | 625k | auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { | 606 | 625k | return x.StackSlotLabel == StackSlotLabel; | 607 | 625k | }); |
clang::Sema::PragmaStack<clang::StringLiteral*>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::StringLiteral*)::'lambda'(clang::Sema::PragmaStack<clang::StringLiteral*>::Slot const&)::operator()(clang::Sema::PragmaStack<clang::StringLiteral*>::Slot const&) const Line | Count | Source | 605 | 2.50M | auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { | 606 | 2.50M | return x.StackSlotLabel == StackSlotLabel; | 607 | 2.50M | }); |
|
608 | | // If we found the label so pop from there. |
609 | 3.12M | if (I != Stack.rend()) { |
610 | 3.12M | CurrentValue = I->Value; |
611 | 3.12M | CurrentPragmaLocation = I->PragmaLocation; |
612 | 3.12M | Stack.erase(std::prev(I.base()), Stack.end()); |
613 | 3.12M | } |
614 | 59 | } else if (!Stack.empty()) { |
615 | | // We do not have a label, just pop the last entry. |
616 | 55 | CurrentValue = Stack.back().Value; |
617 | 55 | CurrentPragmaLocation = Stack.back().PragmaLocation; |
618 | 55 | Stack.pop_back(); |
619 | 55 | } |
620 | 3.12M | } |
621 | 6.25M | if (Action & PSK_Set) { |
622 | 396 | CurrentValue = Value; |
623 | 396 | CurrentPragmaLocation = PragmaLocation; |
624 | 396 | } |
625 | 6.25M | } clang::Sema::PragmaStack<clang::FPOptionsOverride>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::FPOptionsOverride) Line | Count | Source | 593 | 605k | llvm::StringRef StackSlotLabel, ValueType Value) { | 594 | 605k | if (Action == PSK_Reset) { | 595 | 604k | CurrentValue = DefaultValue; | 596 | 604k | CurrentPragmaLocation = PragmaLocation; | 597 | 604k | return; | 598 | 604k | } | 599 | 363 | if (Action & PSK_Push) | 600 | 34 | Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, | 601 | 34 | PragmaLocation); | 602 | 329 | else if (Action & PSK_Pop) { | 603 | 33 | if (!StackSlotLabel.empty()) { | 604 | | // If we've got a label, try to find it and jump there. | 605 | 0 | auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { | 606 | 0 | return x.StackSlotLabel == StackSlotLabel; | 607 | 0 | }); | 608 | | // If we found the label so pop from there. | 609 | 0 | if (I != Stack.rend()) { | 610 | 0 | CurrentValue = I->Value; | 611 | 0 | CurrentPragmaLocation = I->PragmaLocation; | 612 | 0 | Stack.erase(std::prev(I.base()), Stack.end()); | 613 | 0 | } | 614 | 33 | } else if (!Stack.empty()) { | 615 | | // We do not have a label, just pop the last entry. | 616 | 33 | CurrentValue = Stack.back().Value; | 617 | 33 | CurrentPragmaLocation = Stack.back().PragmaLocation; | 618 | 33 | Stack.pop_back(); | 619 | 33 | } | 620 | 33 | } | 621 | 363 | if (Action & PSK_Set) { | 622 | 330 | CurrentValue = Value; | 623 | 330 | CurrentPragmaLocation = PragmaLocation; | 624 | 330 | } | 625 | 363 | } |
clang::Sema::PragmaStack<clang::MSVtorDispMode>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::MSVtorDispMode) Line | Count | Source | 593 | 1.25M | llvm::StringRef StackSlotLabel, ValueType Value) { | 594 | 1.25M | if (Action == PSK_Reset) { | 595 | 3 | CurrentValue = DefaultValue; | 596 | 3 | CurrentPragmaLocation = PragmaLocation; | 597 | 3 | return; | 598 | 3 | } | 599 | 1.25M | if (Action & PSK_Push) | 600 | 625k | Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, | 601 | 625k | PragmaLocation); | 602 | 625k | else if (Action & PSK_Pop) { | 603 | 625k | if (!StackSlotLabel.empty()) { | 604 | | // If we've got a label, try to find it and jump there. | 605 | 625k | auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { | 606 | 625k | return x.StackSlotLabel == StackSlotLabel; | 607 | 625k | }); | 608 | | // If we found the label so pop from there. | 609 | 625k | if (I != Stack.rend()) { | 610 | 625k | CurrentValue = I->Value; | 611 | 625k | CurrentPragmaLocation = I->PragmaLocation; | 612 | 625k | Stack.erase(std::prev(I.base()), Stack.end()); | 613 | 625k | } | 614 | 20 | } else if (!Stack.empty()) { | 615 | | // We do not have a label, just pop the last entry. | 616 | 16 | CurrentValue = Stack.back().Value; | 617 | 16 | CurrentPragmaLocation = Stack.back().PragmaLocation; | 618 | 16 | Stack.pop_back(); | 619 | 16 | } | 620 | 625k | } | 621 | 1.25M | if (Action & PSK_Set) { | 622 | 22 | CurrentValue = Value; | 623 | 22 | CurrentPragmaLocation = PragmaLocation; | 624 | 22 | } | 625 | 1.25M | } |
clang::Sema::PragmaStack<clang::StringLiteral*>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::StringLiteral*) Line | Count | Source | 593 | 5.00M | llvm::StringRef StackSlotLabel, ValueType Value) { | 594 | 5.00M | if (Action == PSK_Reset) { | 595 | 4 | CurrentValue = DefaultValue; | 596 | 4 | CurrentPragmaLocation = PragmaLocation; | 597 | 4 | return; | 598 | 4 | } | 599 | 5.00M | if (Action & PSK_Push) | 600 | 2.50M | Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation, | 601 | 2.50M | PragmaLocation); | 602 | 2.50M | else if (Action & PSK_Pop) { | 603 | 2.50M | if (!StackSlotLabel.empty()) { | 604 | | // If we've got a label, try to find it and jump there. | 605 | 2.50M | auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) { | 606 | 2.50M | return x.StackSlotLabel == StackSlotLabel; | 607 | 2.50M | }); | 608 | | // If we found the label so pop from there. | 609 | 2.50M | if (I != Stack.rend()) { | 610 | 2.50M | CurrentValue = I->Value; | 611 | 2.50M | CurrentPragmaLocation = I->PragmaLocation; | 612 | 2.50M | Stack.erase(std::prev(I.base()), Stack.end()); | 613 | 2.50M | } | 614 | 6 | } else if (!Stack.empty()) { | 615 | | // We do not have a label, just pop the last entry. | 616 | 6 | CurrentValue = Stack.back().Value; | 617 | 6 | CurrentPragmaLocation = Stack.back().PragmaLocation; | 618 | 6 | Stack.pop_back(); | 619 | 6 | } | 620 | 2.50M | } | 621 | 5.00M | if (Action & PSK_Set) { | 622 | 44 | CurrentValue = Value; | 623 | 44 | CurrentPragmaLocation = PragmaLocation; | 624 | 44 | } | 625 | 5.00M | } |
|
626 | | |
627 | | // MSVC seems to add artificial slots to #pragma stacks on entering a C++ |
628 | | // method body to restore the stacks on exit, so it works like this: |
629 | | // |
630 | | // struct S { |
631 | | // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>) |
632 | | // void Method {} |
633 | | // #pragma <name>(pop, InternalPragmaSlot) |
634 | | // }; |
635 | | // |
636 | | // It works even with #pragma vtordisp, although MSVC doesn't support |
637 | | // #pragma vtordisp(push [, id], n) |
638 | | // syntax. |
639 | | // |
640 | | // Push / pop a named sentinel slot. |
641 | 6.25M | void SentinelAction(PragmaMsStackAction Action, StringRef Label) { |
642 | 6.25M | assert((Action == PSK_Push || Action == PSK_Pop) && |
643 | 6.25M | "Can only push / pop #pragma stack sentinels!"); |
644 | 6.25M | Act(CurrentPragmaLocation, Action, Label, CurrentValue); |
645 | 6.25M | } clang::Sema::PragmaStack<clang::MSVtorDispMode>::SentinelAction(clang::Sema::PragmaMsStackAction, llvm::StringRef) Line | Count | Source | 641 | 1.25M | void SentinelAction(PragmaMsStackAction Action, StringRef Label) { | 642 | 1.25M | assert((Action == PSK_Push || Action == PSK_Pop) && | 643 | 1.25M | "Can only push / pop #pragma stack sentinels!"); | 644 | 1.25M | Act(CurrentPragmaLocation, Action, Label, CurrentValue); | 645 | 1.25M | } |
clang::Sema::PragmaStack<clang::StringLiteral*>::SentinelAction(clang::Sema::PragmaMsStackAction, llvm::StringRef) Line | Count | Source | 641 | 5.00M | void SentinelAction(PragmaMsStackAction Action, StringRef Label) { | 642 | 5.00M | assert((Action == PSK_Push || Action == PSK_Pop) && | 643 | 5.00M | "Can only push / pop #pragma stack sentinels!"); | 644 | 5.00M | Act(CurrentPragmaLocation, Action, Label, CurrentValue); | 645 | 5.00M | } |
|
646 | | |
647 | | // Constructors. |
648 | | explicit PragmaStack(const ValueType &Default) |
649 | 553k | : DefaultValue(Default), CurrentValue(Default) {} clang::Sema::PragmaStack<clang::MSVtorDispMode>::PragmaStack(clang::MSVtorDispMode const&) Line | Count | Source | 649 | 79.0k | : DefaultValue(Default), CurrentValue(Default) {} |
clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::PragmaStack(clang::Sema::AlignPackInfo const&) Line | Count | Source | 649 | 79.0k | : DefaultValue(Default), CurrentValue(Default) {} |
clang::Sema::PragmaStack<clang::StringLiteral*>::PragmaStack(clang::StringLiteral* const&) Line | Count | Source | 649 | 316k | : DefaultValue(Default), CurrentValue(Default) {} |
clang::Sema::PragmaStack<clang::FPOptionsOverride>::PragmaStack(clang::FPOptionsOverride const&) Line | Count | Source | 649 | 79.0k | : DefaultValue(Default), CurrentValue(Default) {} |
|
650 | | |
651 | 39.1M | bool hasValue() const { return CurrentValue != DefaultValue; } clang::Sema::PragmaStack<clang::FPOptionsOverride>::hasValue() const Line | Count | Source | 651 | 38.0M | bool hasValue() const { return CurrentValue != DefaultValue; } |
clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::hasValue() const Line | Count | Source | 651 | 1.06M | bool hasValue() const { return CurrentValue != DefaultValue; } |
|
652 | | |
653 | | SmallVector<Slot, 2> Stack; |
654 | | ValueType DefaultValue; // Value used for PSK_Reset action. |
655 | | ValueType CurrentValue; |
656 | | SourceLocation CurrentPragmaLocation; |
657 | | }; |
658 | | // FIXME: We should serialize / deserialize these if they occur in a PCH (but |
659 | | // we shouldn't do so if they're in a module). |
660 | | |
661 | | /// Whether to insert vtordisps prior to virtual bases in the Microsoft |
662 | | /// C++ ABI. Possible values are 0, 1, and 2, which mean: |
663 | | /// |
664 | | /// 0: Suppress all vtordisps |
665 | | /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial |
666 | | /// structors |
667 | | /// 2: Always insert vtordisps to support RTTI on partially constructed |
668 | | /// objects |
669 | | PragmaStack<MSVtorDispMode> VtorDispStack; |
670 | | PragmaStack<AlignPackInfo> AlignPackStack; |
671 | | // The current #pragma align/pack values and locations at each #include. |
672 | | struct AlignPackIncludeState { |
673 | | AlignPackInfo CurrentValue; |
674 | | SourceLocation CurrentPragmaLocation; |
675 | | bool HasNonDefaultValue, ShouldWarnOnInclude; |
676 | | }; |
677 | | SmallVector<AlignPackIncludeState, 8> AlignPackIncludeStack; |
678 | | // Segment #pragmas. |
679 | | PragmaStack<StringLiteral *> DataSegStack; |
680 | | PragmaStack<StringLiteral *> BSSSegStack; |
681 | | PragmaStack<StringLiteral *> ConstSegStack; |
682 | | PragmaStack<StringLiteral *> CodeSegStack; |
683 | | |
684 | | // This stack tracks the current state of Sema.CurFPFeatures. |
685 | | PragmaStack<FPOptionsOverride> FpPragmaStack; |
686 | 38.0M | FPOptionsOverride CurFPFeatureOverrides() { |
687 | 38.0M | FPOptionsOverride result; |
688 | 38.0M | if (!FpPragmaStack.hasValue()) { |
689 | 38.0M | result = FPOptionsOverride(); |
690 | 42.9k | } else { |
691 | 42.9k | result = FpPragmaStack.CurrentValue; |
692 | 42.9k | } |
693 | 38.0M | return result; |
694 | 38.0M | } |
695 | | |
696 | | // RAII object to push / pop sentinel slots for all MS #pragma stacks. |
697 | | // Actions should be performed only if we enter / exit a C++ method body. |
698 | | class PragmaStackSentinelRAII { |
699 | | public: |
700 | | PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct); |
701 | | ~PragmaStackSentinelRAII(); |
702 | | |
703 | | private: |
704 | | Sema &S; |
705 | | StringRef SlotLabel; |
706 | | bool ShouldAct; |
707 | | }; |
708 | | |
709 | | /// A mapping that describes the nullability we've seen in each header file. |
710 | | FileNullabilityMap NullabilityMap; |
711 | | |
712 | | /// Last section used with #pragma init_seg. |
713 | | StringLiteral *CurInitSeg; |
714 | | SourceLocation CurInitSegLoc; |
715 | | |
716 | | /// VisContext - Manages the stack for \#pragma GCC visibility. |
717 | | void *VisContext; // Really a "PragmaVisStack*" |
718 | | |
719 | | /// This an attribute introduced by \#pragma clang attribute. |
720 | | struct PragmaAttributeEntry { |
721 | | SourceLocation Loc; |
722 | | ParsedAttr *Attribute; |
723 | | SmallVector<attr::SubjectMatchRule, 4> MatchRules; |
724 | | bool IsUsed; |
725 | | }; |
726 | | |
727 | | /// A push'd group of PragmaAttributeEntries. |
728 | | struct PragmaAttributeGroup { |
729 | | /// The location of the push attribute. |
730 | | SourceLocation Loc; |
731 | | /// The namespace of this push group. |
732 | | const IdentifierInfo *Namespace; |
733 | | SmallVector<PragmaAttributeEntry, 2> Entries; |
734 | | }; |
735 | | |
736 | | SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack; |
737 | | |
738 | | /// The declaration that is currently receiving an attribute from the |
739 | | /// #pragma attribute stack. |
740 | | const Decl *PragmaAttributeCurrentTargetDecl; |
741 | | |
742 | | /// This represents the last location of a "#pragma clang optimize off" |
743 | | /// directive if such a directive has not been closed by an "on" yet. If |
744 | | /// optimizations are currently "on", this is set to an invalid location. |
745 | | SourceLocation OptimizeOffPragmaLocation; |
746 | | |
747 | | /// Flag indicating if Sema is building a recovery call expression. |
748 | | /// |
749 | | /// This flag is used to avoid building recovery call expressions |
750 | | /// if Sema is already doing so, which would cause infinite recursions. |
751 | | bool IsBuildingRecoveryCallExpr; |
752 | | |
753 | | /// Used to control the generation of ExprWithCleanups. |
754 | | CleanupInfo Cleanup; |
755 | | |
756 | | /// ExprCleanupObjects - This is the stack of objects requiring |
757 | | /// cleanup that are created by the current full expression. |
758 | | SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects; |
759 | | |
760 | | /// Store a set of either DeclRefExprs or MemberExprs that contain a reference |
761 | | /// to a variable (constant) that may or may not be odr-used in this Expr, and |
762 | | /// we won't know until all lvalue-to-rvalue and discarded value conversions |
763 | | /// have been applied to all subexpressions of the enclosing full expression. |
764 | | /// This is cleared at the end of each full expression. |
765 | | using MaybeODRUseExprSet = llvm::SetVector<Expr *, SmallVector<Expr *, 4>, |
766 | | llvm::SmallPtrSet<Expr *, 4>>; |
767 | | MaybeODRUseExprSet MaybeODRUseExprs; |
768 | | |
769 | | std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope; |
770 | | |
771 | | /// Stack containing information about each of the nested |
772 | | /// function, block, and method scopes that are currently active. |
773 | | SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes; |
774 | | |
775 | | /// The index of the first FunctionScope that corresponds to the current |
776 | | /// context. |
777 | | unsigned FunctionScopesStart = 0; |
778 | | |
779 | 352k | ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const { |
780 | 352k | return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart, |
781 | 352k | FunctionScopes.end()); |
782 | 352k | } |
783 | | |
784 | | /// Stack containing information needed when in C++2a an 'auto' is encountered |
785 | | /// in a function declaration parameter type specifier in order to invent a |
786 | | /// corresponding template parameter in the enclosing abbreviated function |
787 | | /// template. This information is also present in LambdaScopeInfo, stored in |
788 | | /// the FunctionScopes stack. |
789 | | SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos; |
790 | | |
791 | | /// The index of the first InventedParameterInfo that refers to the current |
792 | | /// context. |
793 | | unsigned InventedParameterInfosStart = 0; |
794 | | |
795 | 352k | ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const { |
796 | 352k | return llvm::makeArrayRef(InventedParameterInfos.begin() + |
797 | 352k | InventedParameterInfosStart, |
798 | 352k | InventedParameterInfos.end()); |
799 | 352k | } |
800 | | |
801 | | typedef LazyVector<TypedefNameDecl *, ExternalSemaSource, |
802 | | &ExternalSemaSource::ReadExtVectorDecls, 2, 2> |
803 | | ExtVectorDeclsType; |
804 | | |
805 | | /// ExtVectorDecls - This is a list all the extended vector types. This allows |
806 | | /// us to associate a raw vector type with one of the ext_vector type names. |
807 | | /// This is only necessary for issuing pretty diagnostics. |
808 | | ExtVectorDeclsType ExtVectorDecls; |
809 | | |
810 | | /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes. |
811 | | std::unique_ptr<CXXFieldCollector> FieldCollector; |
812 | | |
813 | | typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType; |
814 | | |
815 | | /// Set containing all declared private fields that are not used. |
816 | | NamedDeclSetType UnusedPrivateFields; |
817 | | |
818 | | /// Set containing all typedefs that are likely unused. |
819 | | llvm::SmallSetVector<const TypedefNameDecl *, 4> |
820 | | UnusedLocalTypedefNameCandidates; |
821 | | |
822 | | /// Delete-expressions to be analyzed at the end of translation unit |
823 | | /// |
824 | | /// This list contains class members, and locations of delete-expressions |
825 | | /// that could not be proven as to whether they mismatch with new-expression |
826 | | /// used in initializer of the field. |
827 | | typedef std::pair<SourceLocation, bool> DeleteExprLoc; |
828 | | typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs; |
829 | | llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs; |
830 | | |
831 | | typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy; |
832 | | |
833 | | /// PureVirtualClassDiagSet - a set of class declarations which we have |
834 | | /// emitted a list of pure virtual functions. Used to prevent emitting the |
835 | | /// same list more than once. |
836 | | std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet; |
837 | | |
838 | | /// ParsingInitForAutoVars - a set of declarations with auto types for which |
839 | | /// we are currently parsing the initializer. |
840 | | llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars; |
841 | | |
842 | | /// Look for a locally scoped extern "C" declaration by the given name. |
843 | | NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name); |
844 | | |
845 | | typedef LazyVector<VarDecl *, ExternalSemaSource, |
846 | | &ExternalSemaSource::ReadTentativeDefinitions, 2, 2> |
847 | | TentativeDefinitionsType; |
848 | | |
849 | | /// All the tentative definitions encountered in the TU. |
850 | | TentativeDefinitionsType TentativeDefinitions; |
851 | | |
852 | | /// All the external declarations encoutered and used in the TU. |
853 | | SmallVector<VarDecl *, 4> ExternalDeclarations; |
854 | | |
855 | | typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource, |
856 | | &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2> |
857 | | UnusedFileScopedDeclsType; |
858 | | |
859 | | /// The set of file scoped decls seen so far that have not been used |
860 | | /// and must warn if not used. Only contains the first declaration. |
861 | | UnusedFileScopedDeclsType UnusedFileScopedDecls; |
862 | | |
863 | | typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource, |
864 | | &ExternalSemaSource::ReadDelegatingConstructors, 2, 2> |
865 | | DelegatingCtorDeclsType; |
866 | | |
867 | | /// All the delegating constructors seen so far in the file, used for |
868 | | /// cycle detection at the end of the TU. |
869 | | DelegatingCtorDeclsType DelegatingCtorDecls; |
870 | | |
871 | | /// All the overriding functions seen during a class definition |
872 | | /// that had their exception spec checks delayed, plus the overridden |
873 | | /// function. |
874 | | SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2> |
875 | | DelayedOverridingExceptionSpecChecks; |
876 | | |
877 | | /// All the function redeclarations seen during a class definition that had |
878 | | /// their exception spec checks delayed, plus the prior declaration they |
879 | | /// should be checked against. Except during error recovery, the new decl |
880 | | /// should always be a friend declaration, as that's the only valid way to |
881 | | /// redeclare a special member before its class is complete. |
882 | | SmallVector<std::pair<FunctionDecl*, FunctionDecl*>, 2> |
883 | | DelayedEquivalentExceptionSpecChecks; |
884 | | |
885 | | typedef llvm::MapVector<const FunctionDecl *, |
886 | | std::unique_ptr<LateParsedTemplate>> |
887 | | LateParsedTemplateMapT; |
888 | | LateParsedTemplateMapT LateParsedTemplateMap; |
889 | | |
890 | | /// Callback to the parser to parse templated functions when needed. |
891 | | typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT); |
892 | | typedef void LateTemplateParserCleanupCB(void *P); |
893 | | LateTemplateParserCB *LateTemplateParser; |
894 | | LateTemplateParserCleanupCB *LateTemplateParserCleanup; |
895 | | void *OpaqueParser; |
896 | | |
897 | | void SetLateTemplateParser(LateTemplateParserCB *LTP, |
898 | | LateTemplateParserCleanupCB *LTPCleanup, |
899 | 78.8k | void *P) { |
900 | 78.8k | LateTemplateParser = LTP; |
901 | 78.8k | LateTemplateParserCleanup = LTPCleanup; |
902 | 78.8k | OpaqueParser = P; |
903 | 78.8k | } |
904 | | |
905 | | class DelayedDiagnostics; |
906 | | |
907 | | class DelayedDiagnosticsState { |
908 | | sema::DelayedDiagnosticPool *SavedPool; |
909 | | friend class Sema::DelayedDiagnostics; |
910 | | }; |
911 | | typedef DelayedDiagnosticsState ParsingDeclState; |
912 | | typedef DelayedDiagnosticsState ProcessingContextState; |
913 | | |
914 | | /// A class which encapsulates the logic for delaying diagnostics |
915 | | /// during parsing and other processing. |
916 | | class DelayedDiagnostics { |
917 | | /// The current pool of diagnostics into which delayed |
918 | | /// diagnostics should go. |
919 | | sema::DelayedDiagnosticPool *CurPool; |
920 | | |
921 | | public: |
922 | 79.0k | DelayedDiagnostics() : CurPool(nullptr) {} |
923 | | |
924 | | /// Adds a delayed diagnostic. |
925 | | void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h |
926 | | |
927 | | /// Determines whether diagnostics should be delayed. |
928 | 1.88M | bool shouldDelayDiagnostics() { return CurPool != nullptr; } |
929 | | |
930 | | /// Returns the current delayed-diagnostics pool. |
931 | 118M | sema::DelayedDiagnosticPool *getCurrentPool() const { |
932 | 118M | return CurPool; |
933 | 118M | } |
934 | | |
935 | | /// Enter a new scope. Access and deprecation diagnostics will be |
936 | | /// collected in this pool. |
937 | 59.4M | DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) { |
938 | 59.4M | DelayedDiagnosticsState state; |
939 | 59.4M | state.SavedPool = CurPool; |
940 | 59.4M | CurPool = &pool; |
941 | 59.4M | return state; |
942 | 59.4M | } |
943 | | |
944 | | /// Leave a delayed-diagnostic state that was previously pushed. |
945 | | /// Do not emit any of the diagnostics. This is performed as part |
946 | | /// of the bookkeeping of popping a pool "properly". |
947 | 59.4M | void popWithoutEmitting(DelayedDiagnosticsState state) { |
948 | 59.4M | CurPool = state.SavedPool; |
949 | 59.4M | } |
950 | | |
951 | | /// Enter a new scope where access and deprecation diagnostics are |
952 | | /// not delayed. |
953 | 5.85M | DelayedDiagnosticsState pushUndelayed() { |
954 | 5.85M | DelayedDiagnosticsState state; |
955 | 5.85M | state.SavedPool = CurPool; |
956 | 5.85M | CurPool = nullptr; |
957 | 5.85M | return state; |
958 | 5.85M | } |
959 | | |
960 | | /// Undo a previous pushUndelayed(). |
961 | 5.85M | void popUndelayed(DelayedDiagnosticsState state) { |
962 | 5.85M | assert(CurPool == nullptr); |
963 | 5.85M | CurPool = state.SavedPool; |
964 | 5.85M | } |
965 | | } DelayedDiagnostics; |
966 | | |
967 | | /// A RAII object to temporarily push a declaration context. |
968 | | class ContextRAII { |
969 | | private: |
970 | | Sema &S; |
971 | | DeclContext *SavedContext; |
972 | | ProcessingContextState SavedContextState; |
973 | | QualType SavedCXXThisTypeOverride; |
974 | | unsigned SavedFunctionScopesStart; |
975 | | unsigned SavedInventedParameterInfosStart; |
976 | | |
977 | | public: |
978 | | ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true) |
979 | | : S(S), SavedContext(S.CurContext), |
980 | | SavedContextState(S.DelayedDiagnostics.pushUndelayed()), |
981 | | SavedCXXThisTypeOverride(S.CXXThisTypeOverride), |
982 | | SavedFunctionScopesStart(S.FunctionScopesStart), |
983 | | SavedInventedParameterInfosStart(S.InventedParameterInfosStart) |
984 | 5.20M | { |
985 | 5.20M | assert(ContextToPush && "pushing null context"); |
986 | 5.20M | S.CurContext = ContextToPush; |
987 | 5.20M | if (NewThisContext) |
988 | 5.19M | S.CXXThisTypeOverride = QualType(); |
989 | | // Any saved FunctionScopes do not refer to this context. |
990 | 5.20M | S.FunctionScopesStart = S.FunctionScopes.size(); |
991 | 5.20M | S.InventedParameterInfosStart = S.InventedParameterInfos.size(); |
992 | 5.20M | } |
993 | | |
994 | 6.12M | void pop() { |
995 | 6.12M | if (!SavedContext) return915k ; |
996 | 5.20M | S.CurContext = SavedContext; |
997 | 5.20M | S.DelayedDiagnostics.popUndelayed(SavedContextState); |
998 | 5.20M | S.CXXThisTypeOverride = SavedCXXThisTypeOverride; |
999 | 5.20M | S.FunctionScopesStart = SavedFunctionScopesStart; |
1000 | 5.20M | S.InventedParameterInfosStart = SavedInventedParameterInfosStart; |
1001 | 5.20M | SavedContext = nullptr; |
1002 | 5.20M | } |
1003 | | |
1004 | 5.20M | ~ContextRAII() { |
1005 | 5.20M | pop(); |
1006 | 5.20M | } |
1007 | | }; |
1008 | | |
1009 | | /// Whether the AST is currently being rebuilt to correct immediate |
1010 | | /// invocations. Immediate invocation candidates and references to consteval |
1011 | | /// functions aren't tracked when this is set. |
1012 | | bool RebuildingImmediateInvocation = false; |
1013 | | |
1014 | | /// Used to change context to isConstantEvaluated without pushing a heavy |
1015 | | /// ExpressionEvaluationContextRecord object. |
1016 | | bool isConstantEvaluatedOverride; |
1017 | | |
1018 | 11.5M | bool isConstantEvaluated() { |
1019 | 11.5M | return ExprEvalContexts.back().isConstantEvaluated() || |
1020 | 11.1M | isConstantEvaluatedOverride; |
1021 | 11.5M | } |
1022 | | |
1023 | | /// RAII object to handle the state changes required to synthesize |
1024 | | /// a function body. |
1025 | | class SynthesizedFunctionScope { |
1026 | | Sema &S; |
1027 | | Sema::ContextRAII SavedContext; |
1028 | | bool PushedCodeSynthesisContext = false; |
1029 | | |
1030 | | public: |
1031 | | SynthesizedFunctionScope(Sema &S, DeclContext *DC) |
1032 | 72.6k | : S(S), SavedContext(S, DC) { |
1033 | 72.6k | S.PushFunctionScope(); |
1034 | 72.6k | S.PushExpressionEvaluationContext( |
1035 | 72.6k | Sema::ExpressionEvaluationContext::PotentiallyEvaluated); |
1036 | 72.6k | if (auto *FD = dyn_cast<FunctionDecl>(DC)) |
1037 | 72.5k | FD->setWillHaveBody(true); |
1038 | 72.6k | else |
1039 | 72.6k | assert(isa<ObjCMethodDecl>(DC)); |
1040 | 72.6k | } |
1041 | | |
1042 | 71.7k | void addContextNote(SourceLocation UseLoc) { |
1043 | 71.7k | assert(!PushedCodeSynthesisContext); |
1044 | | |
1045 | 71.7k | Sema::CodeSynthesisContext Ctx; |
1046 | 71.7k | Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction; |
1047 | 71.7k | Ctx.PointOfInstantiation = UseLoc; |
1048 | 71.7k | Ctx.Entity = cast<Decl>(S.CurContext); |
1049 | 71.7k | S.pushCodeSynthesisContext(Ctx); |
1050 | | |
1051 | 71.7k | PushedCodeSynthesisContext = true; |
1052 | 71.7k | } |
1053 | | |
1054 | 72.6k | ~SynthesizedFunctionScope() { |
1055 | 72.6k | if (PushedCodeSynthesisContext) |
1056 | 71.7k | S.popCodeSynthesisContext(); |
1057 | 72.6k | if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext)) |
1058 | 72.5k | FD->setWillHaveBody(false); |
1059 | 72.6k | S.PopExpressionEvaluationContext(); |
1060 | 72.6k | S.PopFunctionScopeInfo(); |
1061 | 72.6k | } |
1062 | | }; |
1063 | | |
1064 | | /// WeakUndeclaredIdentifiers - Identifiers contained in |
1065 | | /// \#pragma weak before declared. rare. may alias another |
1066 | | /// identifier, declared or undeclared |
1067 | | llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers; |
1068 | | |
1069 | | /// ExtnameUndeclaredIdentifiers - Identifiers contained in |
1070 | | /// \#pragma redefine_extname before declared. Used in Solaris system headers |
1071 | | /// to define functions that occur in multiple standards to call the version |
1072 | | /// in the currently selected standard. |
1073 | | llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers; |
1074 | | |
1075 | | |
1076 | | /// Load weak undeclared identifiers from the external source. |
1077 | | void LoadExternalWeakUndeclaredIdentifiers(); |
1078 | | |
1079 | | /// WeakTopLevelDecl - Translation-unit scoped declarations generated by |
1080 | | /// \#pragma weak during processing of other Decls. |
1081 | | /// I couldn't figure out a clean way to generate these in-line, so |
1082 | | /// we store them here and handle separately -- which is a hack. |
1083 | | /// It would be best to refactor this. |
1084 | | SmallVector<Decl*,2> WeakTopLevelDecl; |
1085 | | |
1086 | | IdentifierResolver IdResolver; |
1087 | | |
1088 | | /// Translation Unit Scope - useful to Objective-C actions that need |
1089 | | /// to lookup file scope declarations in the "ordinary" C decl namespace. |
1090 | | /// For example, user-defined classes, built-in "id" type, etc. |
1091 | | Scope *TUScope; |
1092 | | |
1093 | | /// The C++ "std" namespace, where the standard library resides. |
1094 | | LazyDeclPtr StdNamespace; |
1095 | | |
1096 | | /// The C++ "std::bad_alloc" class, which is defined by the C++ |
1097 | | /// standard library. |
1098 | | LazyDeclPtr StdBadAlloc; |
1099 | | |
1100 | | /// The C++ "std::align_val_t" enum class, which is defined by the C++ |
1101 | | /// standard library. |
1102 | | LazyDeclPtr StdAlignValT; |
1103 | | |
1104 | | /// The C++ "std::experimental" namespace, where the experimental parts |
1105 | | /// of the standard library resides. |
1106 | | NamespaceDecl *StdExperimentalNamespaceCache; |
1107 | | |
1108 | | /// The C++ "std::initializer_list" template, which is defined in |
1109 | | /// \<initializer_list>. |
1110 | | ClassTemplateDecl *StdInitializerList; |
1111 | | |
1112 | | /// The C++ "std::coroutine_traits" template, which is defined in |
1113 | | /// \<coroutine_traits> |
1114 | | ClassTemplateDecl *StdCoroutineTraitsCache; |
1115 | | |
1116 | | /// The C++ "type_info" declaration, which is defined in \<typeinfo>. |
1117 | | RecordDecl *CXXTypeInfoDecl; |
1118 | | |
1119 | | /// The MSVC "_GUID" struct, which is defined in MSVC header files. |
1120 | | RecordDecl *MSVCGuidDecl; |
1121 | | |
1122 | | /// Caches identifiers/selectors for NSFoundation APIs. |
1123 | | std::unique_ptr<NSAPI> NSAPIObj; |
1124 | | |
1125 | | /// The declaration of the Objective-C NSNumber class. |
1126 | | ObjCInterfaceDecl *NSNumberDecl; |
1127 | | |
1128 | | /// The declaration of the Objective-C NSValue class. |
1129 | | ObjCInterfaceDecl *NSValueDecl; |
1130 | | |
1131 | | /// Pointer to NSNumber type (NSNumber *). |
1132 | | QualType NSNumberPointer; |
1133 | | |
1134 | | /// Pointer to NSValue type (NSValue *). |
1135 | | QualType NSValuePointer; |
1136 | | |
1137 | | /// The Objective-C NSNumber methods used to create NSNumber literals. |
1138 | | ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]; |
1139 | | |
1140 | | /// The declaration of the Objective-C NSString class. |
1141 | | ObjCInterfaceDecl *NSStringDecl; |
1142 | | |
1143 | | /// Pointer to NSString type (NSString *). |
1144 | | QualType NSStringPointer; |
1145 | | |
1146 | | /// The declaration of the stringWithUTF8String: method. |
1147 | | ObjCMethodDecl *StringWithUTF8StringMethod; |
1148 | | |
1149 | | /// The declaration of the valueWithBytes:objCType: method. |
1150 | | ObjCMethodDecl *ValueWithBytesObjCTypeMethod; |
1151 | | |
1152 | | /// The declaration of the Objective-C NSArray class. |
1153 | | ObjCInterfaceDecl *NSArrayDecl; |
1154 | | |
1155 | | /// The declaration of the arrayWithObjects:count: method. |
1156 | | ObjCMethodDecl *ArrayWithObjectsMethod; |
1157 | | |
1158 | | /// The declaration of the Objective-C NSDictionary class. |
1159 | | ObjCInterfaceDecl *NSDictionaryDecl; |
1160 | | |
1161 | | /// The declaration of the dictionaryWithObjects:forKeys:count: method. |
1162 | | ObjCMethodDecl *DictionaryWithObjectsMethod; |
1163 | | |
1164 | | /// id<NSCopying> type. |
1165 | | QualType QIDNSCopying; |
1166 | | |
1167 | | /// will hold 'respondsToSelector:' |
1168 | | Selector RespondsToSelectorSel; |
1169 | | |
1170 | | /// A flag to remember whether the implicit forms of operator new and delete |
1171 | | /// have been declared. |
1172 | | bool GlobalNewDeleteDeclared; |
1173 | | |
1174 | | /// Describes how the expressions currently being parsed are |
1175 | | /// evaluated at run-time, if at all. |
1176 | | enum class ExpressionEvaluationContext { |
1177 | | /// The current expression and its subexpressions occur within an |
1178 | | /// unevaluated operand (C++11 [expr]p7), such as the subexpression of |
1179 | | /// \c sizeof, where the type of the expression may be significant but |
1180 | | /// no code will be generated to evaluate the value of the expression at |
1181 | | /// run time. |
1182 | | Unevaluated, |
1183 | | |
1184 | | /// The current expression occurs within a braced-init-list within |
1185 | | /// an unevaluated operand. This is mostly like a regular unevaluated |
1186 | | /// context, except that we still instantiate constexpr functions that are |
1187 | | /// referenced here so that we can perform narrowing checks correctly. |
1188 | | UnevaluatedList, |
1189 | | |
1190 | | /// The current expression occurs within a discarded statement. |
1191 | | /// This behaves largely similarly to an unevaluated operand in preventing |
1192 | | /// definitions from being required, but not in other ways. |
1193 | | DiscardedStatement, |
1194 | | |
1195 | | /// The current expression occurs within an unevaluated |
1196 | | /// operand that unconditionally permits abstract references to |
1197 | | /// fields, such as a SIZE operator in MS-style inline assembly. |
1198 | | UnevaluatedAbstract, |
1199 | | |
1200 | | /// The current context is "potentially evaluated" in C++11 terms, |
1201 | | /// but the expression is evaluated at compile-time (like the values of |
1202 | | /// cases in a switch statement). |
1203 | | ConstantEvaluated, |
1204 | | |
1205 | | /// The current expression is potentially evaluated at run time, |
1206 | | /// which means that code may be generated to evaluate the value of the |
1207 | | /// expression at run time. |
1208 | | PotentiallyEvaluated, |
1209 | | |
1210 | | /// The current expression is potentially evaluated, but any |
1211 | | /// declarations referenced inside that expression are only used if |
1212 | | /// in fact the current expression is used. |
1213 | | /// |
1214 | | /// This value is used when parsing default function arguments, for which |
1215 | | /// we would like to provide diagnostics (e.g., passing non-POD arguments |
1216 | | /// through varargs) but do not want to mark declarations as "referenced" |
1217 | | /// until the default argument is used. |
1218 | | PotentiallyEvaluatedIfUsed |
1219 | | }; |
1220 | | |
1221 | | using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>; |
1222 | | |
1223 | | /// Data structure used to record current or nested |
1224 | | /// expression evaluation contexts. |
1225 | | struct ExpressionEvaluationContextRecord { |
1226 | | /// The expression evaluation context. |
1227 | | ExpressionEvaluationContext Context; |
1228 | | |
1229 | | /// Whether the enclosing context needed a cleanup. |
1230 | | CleanupInfo ParentCleanup; |
1231 | | |
1232 | | /// The number of active cleanup objects when we entered |
1233 | | /// this expression evaluation context. |
1234 | | unsigned NumCleanupObjects; |
1235 | | |
1236 | | /// The number of typos encountered during this expression evaluation |
1237 | | /// context (i.e. the number of TypoExprs created). |
1238 | | unsigned NumTypos; |
1239 | | |
1240 | | MaybeODRUseExprSet SavedMaybeODRUseExprs; |
1241 | | |
1242 | | /// The lambdas that are present within this context, if it |
1243 | | /// is indeed an unevaluated context. |
1244 | | SmallVector<LambdaExpr *, 2> Lambdas; |
1245 | | |
1246 | | /// The declaration that provides context for lambda expressions |
1247 | | /// and block literals if the normal declaration context does not |
1248 | | /// suffice, e.g., in a default function argument. |
1249 | | Decl *ManglingContextDecl; |
1250 | | |
1251 | | /// If we are processing a decltype type, a set of call expressions |
1252 | | /// for which we have deferred checking the completeness of the return type. |
1253 | | SmallVector<CallExpr *, 8> DelayedDecltypeCalls; |
1254 | | |
1255 | | /// If we are processing a decltype type, a set of temporary binding |
1256 | | /// expressions for which we have deferred checking the destructor. |
1257 | | SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds; |
1258 | | |
1259 | | llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs; |
1260 | | |
1261 | | /// Expressions appearing as the LHS of a volatile assignment in this |
1262 | | /// context. We produce a warning for these when popping the context if |
1263 | | /// they are not discarded-value expressions nor unevaluated operands. |
1264 | | SmallVector<Expr*, 2> VolatileAssignmentLHSs; |
1265 | | |
1266 | | /// Set of candidates for starting an immediate invocation. |
1267 | | llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates; |
1268 | | |
1269 | | /// Set of DeclRefExprs referencing a consteval function when used in a |
1270 | | /// context not already known to be immediately invoked. |
1271 | | llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval; |
1272 | | |
1273 | | /// \brief Describes whether we are in an expression constext which we have |
1274 | | /// to handle differently. |
1275 | | enum ExpressionKind { |
1276 | | EK_Decltype, EK_TemplateArgument, EK_Other |
1277 | | } ExprContext; |
1278 | | |
1279 | | ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context, |
1280 | | unsigned NumCleanupObjects, |
1281 | | CleanupInfo ParentCleanup, |
1282 | | Decl *ManglingContextDecl, |
1283 | | ExpressionKind ExprContext) |
1284 | | : Context(Context), ParentCleanup(ParentCleanup), |
1285 | | NumCleanupObjects(NumCleanupObjects), NumTypos(0), |
1286 | 39.6M | ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {} |
1287 | | |
1288 | 89.2M | bool isUnevaluated() const { |
1289 | 89.2M | return Context == ExpressionEvaluationContext::Unevaluated || |
1290 | 73.3M | Context == ExpressionEvaluationContext::UnevaluatedAbstract || |
1291 | 73.3M | Context == ExpressionEvaluationContext::UnevaluatedList; |
1292 | 89.2M | } |
1293 | 35.5M | bool isConstantEvaluated() const { |
1294 | 35.5M | return Context == ExpressionEvaluationContext::ConstantEvaluated; |
1295 | 35.5M | } |
1296 | | }; |
1297 | | |
1298 | | /// A stack of expression evaluation contexts. |
1299 | | SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts; |
1300 | | |
1301 | | /// Emit a warning for all pending noderef expressions that we recorded. |
1302 | | void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec); |
1303 | | |
1304 | | /// Compute the mangling number context for a lambda expression or |
1305 | | /// block literal. Also return the extra mangling decl if any. |
1306 | | /// |
1307 | | /// \param DC - The DeclContext containing the lambda expression or |
1308 | | /// block literal. |
1309 | | std::tuple<MangleNumberingContext *, Decl *> |
1310 | | getCurrentMangleNumberContext(const DeclContext *DC); |
1311 | | |
1312 | | |
1313 | | /// SpecialMemberOverloadResult - The overloading result for a special member |
1314 | | /// function. |
1315 | | /// |
1316 | | /// This is basically a wrapper around PointerIntPair. The lowest bits of the |
1317 | | /// integer are used to determine whether overload resolution succeeded. |
1318 | | class SpecialMemberOverloadResult { |
1319 | | public: |
1320 | | enum Kind { |
1321 | | NoMemberOrDeleted, |
1322 | | Ambiguous, |
1323 | | Success |
1324 | | }; |
1325 | | |
1326 | | private: |
1327 | | llvm::PointerIntPair<CXXMethodDecl*, 2> Pair; |
1328 | | |
1329 | | public: |
1330 | 402k | SpecialMemberOverloadResult() : Pair() {} |
1331 | | SpecialMemberOverloadResult(CXXMethodDecl *MD) |
1332 | 988 | : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {} |
1333 | | |
1334 | 1.03M | CXXMethodDecl *getMethod() const { return Pair.getPointer(); } |
1335 | 237k | void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); } |
1336 | | |
1337 | 542k | Kind getKind() const { return static_cast<Kind>(Pair.getInt()); } |
1338 | 237k | void setKind(Kind K) { Pair.setInt(K); } |
1339 | | }; |
1340 | | |
1341 | | class SpecialMemberOverloadResultEntry |
1342 | | : public llvm::FastFoldingSetNode, |
1343 | | public SpecialMemberOverloadResult { |
1344 | | public: |
1345 | | SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID) |
1346 | | : FastFoldingSetNode(ID) |
1347 | 237k | {} |
1348 | | }; |
1349 | | |
1350 | | /// A cache of special member function overload resolution results |
1351 | | /// for C++ records. |
1352 | | llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache; |
1353 | | |
1354 | | /// A cache of the flags available in enumerations with the flag_bits |
1355 | | /// attribute. |
1356 | | mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache; |
1357 | | |
1358 | | /// The kind of translation unit we are processing. |
1359 | | /// |
1360 | | /// When we're processing a complete translation unit, Sema will perform |
1361 | | /// end-of-translation-unit semantic tasks (such as creating |
1362 | | /// initializers for tentative definitions in C) once parsing has |
1363 | | /// completed. Modules and precompiled headers perform different kinds of |
1364 | | /// checks. |
1365 | | TranslationUnitKind TUKind; |
1366 | | |
1367 | | llvm::BumpPtrAllocator BumpAlloc; |
1368 | | |
1369 | | /// The number of SFINAE diagnostics that have been trapped. |
1370 | | unsigned NumSFINAEErrors; |
1371 | | |
1372 | | typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>> |
1373 | | UnparsedDefaultArgInstantiationsMap; |
1374 | | |
1375 | | /// A mapping from parameters with unparsed default arguments to the |
1376 | | /// set of instantiations of each parameter. |
1377 | | /// |
1378 | | /// This mapping is a temporary data structure used when parsing |
1379 | | /// nested class templates or nested classes of class templates, |
1380 | | /// where we might end up instantiating an inner class before the |
1381 | | /// default arguments of its methods have been parsed. |
1382 | | UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations; |
1383 | | |
1384 | | // Contains the locations of the beginning of unparsed default |
1385 | | // argument locations. |
1386 | | llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs; |
1387 | | |
1388 | | /// UndefinedInternals - all the used, undefined objects which require a |
1389 | | /// definition in this translation unit. |
1390 | | llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed; |
1391 | | |
1392 | | /// Determine if VD, which must be a variable or function, is an external |
1393 | | /// symbol that nonetheless can't be referenced from outside this translation |
1394 | | /// unit because its type has no linkage and it's not extern "C". |
1395 | | bool isExternalWithNoLinkageType(ValueDecl *VD); |
1396 | | |
1397 | | /// Obtain a sorted list of functions that are undefined but ODR-used. |
1398 | | void getUndefinedButUsed( |
1399 | | SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined); |
1400 | | |
1401 | | /// Retrieves list of suspicious delete-expressions that will be checked at |
1402 | | /// the end of translation unit. |
1403 | | const llvm::MapVector<FieldDecl *, DeleteLocs> & |
1404 | | getMismatchingDeleteExpressions() const; |
1405 | | |
1406 | | typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods; |
1407 | | typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool; |
1408 | | |
1409 | | /// Method Pool - allows efficient lookup when typechecking messages to "id". |
1410 | | /// We need to maintain a list, since selectors can have differing signatures |
1411 | | /// across classes. In Cocoa, this happens to be extremely uncommon (only 1% |
1412 | | /// of selectors are "overloaded"). |
1413 | | /// At the head of the list it is recorded whether there were 0, 1, or >= 2 |
1414 | | /// methods inside categories with a particular selector. |
1415 | | GlobalMethodPool MethodPool; |
1416 | | |
1417 | | /// Method selectors used in a \@selector expression. Used for implementation |
1418 | | /// of -Wselector. |
1419 | | llvm::MapVector<Selector, SourceLocation> ReferencedSelectors; |
1420 | | |
1421 | | /// List of SourceLocations where 'self' is implicitly retained inside a |
1422 | | /// block. |
1423 | | llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1> |
1424 | | ImplicitlyRetainedSelfLocs; |
1425 | | |
1426 | | /// Kinds of C++ special members. |
1427 | | enum CXXSpecialMember { |
1428 | | CXXDefaultConstructor, |
1429 | | CXXCopyConstructor, |
1430 | | CXXMoveConstructor, |
1431 | | CXXCopyAssignment, |
1432 | | CXXMoveAssignment, |
1433 | | CXXDestructor, |
1434 | | CXXInvalid |
1435 | | }; |
1436 | | |
1437 | | typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember> |
1438 | | SpecialMemberDecl; |
1439 | | |
1440 | | /// The C++ special members which we are currently in the process of |
1441 | | /// declaring. If this process recursively triggers the declaration of the |
1442 | | /// same special member, we should act as if it is not yet declared. |
1443 | | llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared; |
1444 | | |
1445 | | /// Kinds of defaulted comparison operator functions. |
1446 | | enum class DefaultedComparisonKind : unsigned char { |
1447 | | /// This is not a defaultable comparison operator. |
1448 | | None, |
1449 | | /// This is an operator== that should be implemented as a series of |
1450 | | /// subobject comparisons. |
1451 | | Equal, |
1452 | | /// This is an operator<=> that should be implemented as a series of |
1453 | | /// subobject comparisons. |
1454 | | ThreeWay, |
1455 | | /// This is an operator!= that should be implemented as a rewrite in terms |
1456 | | /// of a == comparison. |
1457 | | NotEqual, |
1458 | | /// This is an <, <=, >, or >= that should be implemented as a rewrite in |
1459 | | /// terms of a <=> comparison. |
1460 | | Relational, |
1461 | | }; |
1462 | | |
1463 | | /// The function definitions which were renamed as part of typo-correction |
1464 | | /// to match their respective declarations. We want to keep track of them |
1465 | | /// to ensure that we don't emit a "redefinition" error if we encounter a |
1466 | | /// correctly named definition after the renamed definition. |
1467 | | llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions; |
1468 | | |
1469 | | /// Stack of types that correspond to the parameter entities that are |
1470 | | /// currently being copy-initialized. Can be empty. |
1471 | | llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes; |
1472 | | |
1473 | | void ReadMethodPool(Selector Sel); |
1474 | | void updateOutOfDateSelector(Selector Sel); |
1475 | | |
1476 | | /// Private Helper predicate to check for 'self'. |
1477 | | bool isSelfExpr(Expr *RExpr); |
1478 | | bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method); |
1479 | | |
1480 | | /// Cause the active diagnostic on the DiagosticsEngine to be |
1481 | | /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and |
1482 | | /// should not be used elsewhere. |
1483 | | void EmitCurrentDiagnostic(unsigned DiagID); |
1484 | | |
1485 | | /// Records and restores the CurFPFeatures state on entry/exit of compound |
1486 | | /// statements. |
1487 | | class FPFeaturesStateRAII { |
1488 | | public: |
1489 | 5.52M | FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.CurFPFeatures) { |
1490 | 5.52M | OldOverrides = S.FpPragmaStack.CurrentValue; |
1491 | 5.52M | } |
1492 | 5.52M | ~FPFeaturesStateRAII() { |
1493 | 5.52M | S.CurFPFeatures = OldFPFeaturesState; |
1494 | 5.52M | S.FpPragmaStack.CurrentValue = OldOverrides; |
1495 | 5.52M | } |
1496 | 0 | FPOptionsOverride getOverrides() { return OldOverrides; } |
1497 | | |
1498 | | private: |
1499 | | Sema& S; |
1500 | | FPOptions OldFPFeaturesState; |
1501 | | FPOptionsOverride OldOverrides; |
1502 | | }; |
1503 | | |
1504 | | void addImplicitTypedef(StringRef Name, QualType T); |
1505 | | |
1506 | | bool WarnedStackExhausted = false; |
1507 | | |
1508 | | public: |
1509 | | Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, |
1510 | | TranslationUnitKind TUKind = TU_Complete, |
1511 | | CodeCompleteConsumer *CompletionConsumer = nullptr); |
1512 | | ~Sema(); |
1513 | | |
1514 | | /// Perform initialization that occurs after the parser has been |
1515 | | /// initialized but before it parses anything. |
1516 | | void Initialize(); |
1517 | | |
1518 | 2.91G | const LangOptions &getLangOpts() const { return LangOpts; } |
1519 | 118k | OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; } |
1520 | 3.63M | FPOptions &getCurFPFeatures() { return CurFPFeatures; } |
1521 | | |
1522 | 33.6M | DiagnosticsEngine &getDiagnostics() const { return Diags; } |
1523 | 1.83M | SourceManager &getSourceManager() const { return SourceMgr; } |
1524 | 235k | Preprocessor &getPreprocessor() const { return PP; } |
1525 | 110M | ASTContext &getASTContext() const { return Context; } |
1526 | 881k | ASTConsumer &getASTConsumer() const { return Consumer; } |
1527 | | ASTMutationListener *getASTMutationListener() const; |
1528 | 697k | ExternalSemaSource* getExternalSource() const { return ExternalSource; } |
1529 | | |
1530 | | ///Registers an external source. If an external source already exists, |
1531 | | /// creates a multiplex external source and appends to it. |
1532 | | /// |
1533 | | ///\param[in] E - A non-null external sema source. |
1534 | | /// |
1535 | | void addExternalSource(ExternalSemaSource *E); |
1536 | | |
1537 | | void PrintStats() const; |
1538 | | |
1539 | | /// Warn that the stack is nearly exhausted. |
1540 | | void warnStackExhausted(SourceLocation Loc); |
1541 | | |
1542 | | /// Run some code with "sufficient" stack space. (Currently, at least 256K is |
1543 | | /// guaranteed). Produces a warning if we're low on stack space and allocates |
1544 | | /// more in that case. Use this in code that may recurse deeply (for example, |
1545 | | /// in template instantiation) to avoid stack overflow. |
1546 | | void runWithSufficientStackSpace(SourceLocation Loc, |
1547 | | llvm::function_ref<void()> Fn); |
1548 | | |
1549 | | /// Helper class that creates diagnostics with optional |
1550 | | /// template instantiation stacks. |
1551 | | /// |
1552 | | /// This class provides a wrapper around the basic DiagnosticBuilder |
1553 | | /// class that emits diagnostics. ImmediateDiagBuilder is |
1554 | | /// responsible for emitting the diagnostic (as DiagnosticBuilder |
1555 | | /// does) and, if the diagnostic comes from inside a template |
1556 | | /// instantiation, printing the template instantiation stack as |
1557 | | /// well. |
1558 | | class ImmediateDiagBuilder : public DiagnosticBuilder { |
1559 | | Sema &SemaRef; |
1560 | | unsigned DiagID; |
1561 | | |
1562 | | public: |
1563 | | ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID) |
1564 | 0 | : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {} |
1565 | | ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID) |
1566 | 2.76M | : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {} |
1567 | | |
1568 | | // This is a cunning lie. DiagnosticBuilder actually performs move |
1569 | | // construction in its copy constructor (but due to varied uses, it's not |
1570 | | // possible to conveniently express this as actual move construction). So |
1571 | | // the default copy ctor here is fine, because the base class disables the |
1572 | | // source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op |
1573 | | // in that case anwyay. |
1574 | 2.92M | ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default; |
1575 | | |
1576 | 5.68M | ~ImmediateDiagBuilder() { |
1577 | | // If we aren't active, there is nothing to do. |
1578 | 5.68M | if (!isActive()) return2.92M ; |
1579 | | |
1580 | | // Otherwise, we need to emit the diagnostic. First clear the diagnostic |
1581 | | // builder itself so it won't emit the diagnostic in its own destructor. |
1582 | | // |
1583 | | // This seems wasteful, in that as written the DiagnosticBuilder dtor will |
1584 | | // do its own needless checks to see if the diagnostic needs to be |
1585 | | // emitted. However, because we take care to ensure that the builder |
1586 | | // objects never escape, a sufficiently smart compiler will be able to |
1587 | | // eliminate that code. |
1588 | 2.76M | Clear(); |
1589 | | |
1590 | | // Dispatch to Sema to emit the diagnostic. |
1591 | 2.76M | SemaRef.EmitCurrentDiagnostic(DiagID); |
1592 | 2.76M | } |
1593 | | |
1594 | | /// Teach operator<< to produce an object of the correct type. |
1595 | | template <typename T> |
1596 | | friend const ImmediateDiagBuilder & |
1597 | 1.48M | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { |
1598 | 1.48M | const DiagnosticBuilder &BaseDiag = Diag; |
1599 | 1.48M | BaseDiag << Value; |
1600 | 1.48M | return Diag; |
1601 | 1.48M | } clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCMethodDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCMethodDecl const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FixItHint>(clang::Sema::ImmediateDiagBuilder const&, clang::FixItHint const&) Line | Count | Source | 1597 | 31.7k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 31.7k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 31.7k | BaseDiag << Value; | 1600 | 31.7k | return Diag; | 1601 | 31.7k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallString<32u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallString<32u> const&) Line | Count | Source | 1597 | 392 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 392 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 392 | BaseDiag << Value; | 1600 | 392 | return Diag; | 1601 | 392 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [17]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [17]) Line | Count | Source | 1597 | 30 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 30 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 30 | BaseDiag << Value; | 1600 | 30 | return Diag; | 1601 | 30 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [46]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [46]) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [36]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [36]) Line | Count | Source | 1597 | 16 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 16 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 16 | BaseDiag << Value; | 1600 | 16 | return Diag; | 1601 | 16 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [45]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [45]) Line | Count | Source | 1597 | 90 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 90 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 90 | BaseDiag << Value; | 1600 | 90 | return Diag; | 1601 | 90 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [31]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [31]) Line | Count | Source | 1597 | 12 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 12 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 12 | BaseDiag << Value; | 1600 | 12 | return Diag; | 1601 | 12 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [23]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [23]) Line | Count | Source | 1597 | 33 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 33 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 33 | BaseDiag << Value; | 1600 | 33 | return Diag; | 1601 | 33 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [24]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [24]) Line | Count | Source | 1597 | 9 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 9 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 9 | BaseDiag << Value; | 1600 | 9 | return Diag; | 1601 | 9 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [32]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [32]) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [34]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [34]) Line | Count | Source | 1597 | 42 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 42 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 42 | BaseDiag << Value; | 1600 | 42 | return Diag; | 1601 | 42 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [19]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [19]) Line | Count | Source | 1597 | 88 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 88 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 88 | BaseDiag << Value; | 1600 | 88 | return Diag; | 1601 | 88 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [29]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [29]) Line | Count | Source | 1597 | 62 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 62 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 62 | BaseDiag << Value; | 1600 | 62 | return Diag; | 1601 | 62 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [11]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [11]) Line | Count | Source | 1597 | 28 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 28 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 28 | BaseDiag << Value; | 1600 | 28 | return Diag; | 1601 | 28 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [8]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [8]) Line | Count | Source | 1597 | 89 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 89 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 89 | BaseDiag << Value; | 1600 | 89 | return Diag; | 1601 | 89 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [54]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [54]) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [39]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [39]) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [47]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [47]) Line | Count | Source | 1597 | 5 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5 | BaseDiag << Value; | 1600 | 5 | return Diag; | 1601 | 5 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [16]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [16]) Line | Count | Source | 1597 | 27 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 27 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 27 | BaseDiag << Value; | 1600 | 27 | return Diag; | 1601 | 27 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [22]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [22]) Line | Count | Source | 1597 | 7 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 7 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 7 | BaseDiag << Value; | 1600 | 7 | return Diag; | 1601 | 7 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [58]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [58]) Line | Count | Source | 1597 | 230 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 230 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 230 | BaseDiag << Value; | 1600 | 230 | return Diag; | 1601 | 230 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [59]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [59]) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [6]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [6]) Line | Count | Source | 1597 | 7.24k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 7.24k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 7.24k | BaseDiag << Value; | 1600 | 7.24k | return Diag; | 1601 | 7.24k | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [57]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [57]) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [48]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [48]) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [42]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [42]) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [43]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [43]) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [56]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [56]) Line | Count | Source | 1597 | 17 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 17 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 17 | BaseDiag << Value; | 1600 | 17 | return Diag; | 1601 | 17 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [20]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [20]) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [75]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [75]) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [25]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [25]) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [53]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [53]) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [38]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [38]) Line | Count | Source | 1597 | 12 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 12 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 12 | BaseDiag << Value; | 1600 | 12 | return Diag; | 1601 | 12 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [35]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [35]) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [28]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [28]) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [71]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [71]) Line | Count | Source | 1597 | 5 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5 | BaseDiag << Value; | 1600 | 5 | return Diag; | 1601 | 5 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [92]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [92]) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [67]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [67]) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [49]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [49]) Line | Count | Source | 1597 | 5 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5 | BaseDiag << Value; | 1600 | 5 | return Diag; | 1601 | 5 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [77]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [77]) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [150]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [150]) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [69]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [69]) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [87]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [87]) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ValueDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ValueDecl* const&) Line | Count | Source | 1597 | 8.67k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 8.67k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 8.67k | BaseDiag << Value; | 1600 | 8.67k | return Diag; | 1601 | 8.67k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(clang::Sema::ImmediateDiagBuilder const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 1597 | 53.7k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 53.7k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 53.7k | BaseDiag << Value; | 1600 | 53.7k | return Diag; | 1601 | 53.7k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ValueDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ValueDecl const* const&) Line | Count | Source | 1597 | 11.1k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 11.1k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 11.1k | BaseDiag << Value; | 1600 | 11.1k | return Diag; | 1601 | 11.1k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<int>(clang::Sema::ImmediateDiagBuilder const&, int const&) Line | Count | Source | 1597 | 20.6k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 20.6k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 20.6k | BaseDiag << Value; | 1600 | 20.6k | return Diag; | 1601 | 20.6k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::QualType>(clang::Sema::ImmediateDiagBuilder const&, clang::QualType const&) Line | Count | Source | 1597 | 292k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 292k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 292k | BaseDiag << Value; | 1600 | 292k | return Diag; | 1601 | 292k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [7]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [7]) Line | Count | Source | 1597 | 250 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 250 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 250 | BaseDiag << Value; | 1600 | 250 | return Diag; | 1601 | 250 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::IdentifierInfo*>(clang::Sema::ImmediateDiagBuilder const&, clang::IdentifierInfo* const&) Line | Count | Source | 1597 | 69.5k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 69.5k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 69.5k | BaseDiag << Value; | 1600 | 69.5k | return Diag; | 1601 | 69.5k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FunctionDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::FunctionDecl const* const&) Line | Count | Source | 1597 | 25.2k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 25.2k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 25.2k | BaseDiag << Value; | 1600 | 25.2k | return Diag; | 1601 | 25.2k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VarDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::VarDecl const* const&) Line | Count | Source | 1597 | 1.72k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1.72k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1.72k | BaseDiag << Value; | 1600 | 1.72k | return Diag; | 1601 | 1.72k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<bool>(clang::Sema::ImmediateDiagBuilder const&, bool const&) Line | Count | Source | 1597 | 28.9k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 28.9k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 28.9k | BaseDiag << Value; | 1600 | 28.9k | return Diag; | 1601 | 28.9k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SourceRange>(clang::Sema::ImmediateDiagBuilder const&, clang::SourceRange const&) Line | Count | Source | 1597 | 173k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 173k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 173k | BaseDiag << Value; | 1600 | 173k | return Diag; | 1601 | 173k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<unsigned int>(clang::Sema::ImmediateDiagBuilder const&, unsigned int const&) Line | Count | Source | 1597 | 63.6k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 63.6k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 63.6k | BaseDiag << Value; | 1600 | 63.6k | return Diag; | 1601 | 63.6k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [12]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [12]) Line | Count | Source | 1597 | 269 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 269 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 269 | BaseDiag << Value; | 1600 | 269 | return Diag; | 1601 | 269 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [5]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [5]) Line | Count | Source | 1597 | 134 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 134 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 134 | BaseDiag << Value; | 1600 | 134 | return Diag; | 1601 | 134 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [14]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [14]) Line | Count | Source | 1597 | 31 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 31 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 31 | BaseDiag << Value; | 1600 | 31 | return Diag; | 1601 | 31 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [9]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [9]) Line | Count | Source | 1597 | 18.5k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 18.5k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 18.5k | BaseDiag << Value; | 1600 | 18.5k | return Diag; | 1601 | 18.5k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NamedDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::NamedDecl* const&) Line | Count | Source | 1597 | 153k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 153k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 153k | BaseDiag << Value; | 1600 | 153k | return Diag; | 1601 | 153k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ASTContext::SectionInfo>(clang::Sema::ImmediateDiagBuilder const&, clang::ASTContext::SectionInfo const&) Line | Count | Source | 1597 | 23 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 23 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 23 | BaseDiag << Value; | 1600 | 23 | return Diag; | 1601 | 23 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::StringRef>(clang::Sema::ImmediateDiagBuilder const&, llvm::StringRef const&) Line | Count | Source | 1597 | 43.2k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 43.2k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 43.2k | BaseDiag << Value; | 1600 | 43.2k | return Diag; | 1601 | 43.2k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ParsedAttr>(clang::Sema::ImmediateDiagBuilder const&, clang::ParsedAttr const&) Line | Count | Source | 1597 | 10.5k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 10.5k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 10.5k | BaseDiag << Value; | 1600 | 10.5k | return Diag; | 1601 | 10.5k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::IdentifierInfo const*>(clang::Sema::ImmediateDiagBuilder const&, clang::IdentifierInfo const* const&) Line | Count | Source | 1597 | 231 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 231 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 231 | BaseDiag << Value; | 1600 | 231 | return Diag; | 1601 | 231 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallVector<clang::FixItHint, 12u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallVector<clang::FixItHint, 12u> const&) Line | Count | Source | 1597 | 41.4k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 41.4k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 41.4k | BaseDiag << Value; | 1600 | 41.4k | return Diag; | 1601 | 41.4k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<CastType>(clang::Sema::ImmediateDiagBuilder const&, CastType const&) Line | Count | Source | 1597 | 327 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 327 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 327 | BaseDiag << Value; | 1600 | 327 | return Diag; | 1601 | 327 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [37]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [37]) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallString<16u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallString<16u> const&) Line | Count | Source | 1597 | 227 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 227 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 227 | BaseDiag << Value; | 1600 | 227 | return Diag; | 1601 | 227 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::ArrayRef<clang::FixItHint> >(clang::Sema::ImmediateDiagBuilder const&, llvm::ArrayRef<clang::FixItHint> const&) Line | Count | Source | 1597 | 5.43k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5.43k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5.43k | BaseDiag << Value; | 1600 | 5.43k | return Diag; | 1601 | 5.43k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CharSourceRange>(clang::Sema::ImmediateDiagBuilder const&, clang::CharSourceRange const&) Line | Count | Source | 1597 | 5.33k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5.33k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5.33k | BaseDiag << Value; | 1600 | 5.33k | return Diag; | 1601 | 5.33k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<AbsoluteValueKind>(clang::Sema::ImmediateDiagBuilder const&, AbsoluteValueKind const&) Line | Count | Source | 1597 | 768 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 768 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 768 | BaseDiag << Value; | 1600 | 768 | return Diag; | 1601 | 768 | } |
SemaChecking.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_10>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_10 const&) Line | Count | Source | 1597 | 236 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 236 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 236 | BaseDiag << Value; | 1600 | 236 | return Diag; | 1601 | 236 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ConceptSpecializationExpr*>(clang::Sema::ImmediateDiagBuilder const&, clang::ConceptSpecializationExpr* const&) Line | Count | Source | 1597 | 34 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 34 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 34 | BaseDiag << Value; | 1600 | 34 | return Diag; | 1601 | 34 | } |
SemaCoroutine.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag>(clang::Sema::ImmediateDiagBuilder const&, isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag const&) Line | Count | Source | 1597 | 9 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 9 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 9 | BaseDiag << Value; | 1600 | 9 | return Diag; | 1601 | 9 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::LabelDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::LabelDecl* const&) Line | Count | Source | 1597 | 358 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 358 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 358 | BaseDiag << Value; | 1600 | 358 | return Diag; | 1601 | 358 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlignedAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlignedAttr const* const&) Line | Count | Source | 1597 | 8 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 8 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 8 | BaseDiag << Value; | 1600 | 8 | return Diag; | 1601 | 8 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlignedAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlignedAttr* const&) Line | Count | Source | 1597 | 27 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 27 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 27 | BaseDiag << Value; | 1600 | 27 | return Diag; | 1601 | 27 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DLLImportAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::DLLImportAttr const* const&) Line | Count | Source | 1597 | 511 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 511 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 511 | BaseDiag << Value; | 1600 | 511 | return Diag; | 1601 | 511 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NotTailCalledAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::NotTailCalledAttr* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Attr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::Attr const* const&) Line | Count | Source | 1597 | 5 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5 | BaseDiag << Value; | 1600 | 5 | return Diag; | 1601 | 5 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXRecordDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXRecordDecl const* const&) Line | Count | Source | 1597 | 176 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 176 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 176 | BaseDiag << Value; | 1600 | 176 | return Diag; | 1601 | 176 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FieldDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::FieldDecl const* const&) Line | Count | Source | 1597 | 146 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 146 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 146 | BaseDiag << Value; | 1600 | 146 | return Diag; | 1601 | 146 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char const*>(clang::Sema::ImmediateDiagBuilder const&, char const* const&) Line | Count | Source | 1597 | 3.61k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3.61k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3.61k | BaseDiag << Value; | 1600 | 3.61k | return Diag; | 1601 | 3.61k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AnyX86NoCallerSavedRegistersAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::AnyX86NoCallerSavedRegistersAttr* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VarDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::VarDecl* const&) Line | Count | Source | 1597 | 6.74k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 6.74k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 6.74k | BaseDiag << Value; | 1600 | 6.74k | return Diag; | 1601 | 6.74k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TypedefNameDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TypedefNameDecl* const&) Line | Count | Source | 1597 | 78 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 78 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 78 | BaseDiag << Value; | 1600 | 78 | return Diag; | 1601 | 78 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TemplateName>(clang::Sema::ImmediateDiagBuilder const&, clang::TemplateName const&) Line | Count | Source | 1597 | 356 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 356 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 356 | BaseDiag << Value; | 1600 | 356 | return Diag; | 1601 | 356 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::InheritableAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::InheritableAttr const* const&) Line | Count | Source | 1597 | 431 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 431 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 431 | BaseDiag << Value; | 1600 | 431 | return Diag; | 1601 | 431 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<ShadowedDeclKind>(clang::Sema::ImmediateDiagBuilder const&, ShadowedDeclKind const&) Line | Count | Source | 1597 | 138 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 138 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 138 | BaseDiag << Value; | 1600 | 138 | return Diag; | 1601 | 138 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DeclContext const*>(clang::Sema::ImmediateDiagBuilder const&, clang::DeclContext const* const&) Line | Count | Source | 1597 | 52 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 52 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 52 | BaseDiag << Value; | 1600 | 52 | return Diag; | 1601 | 52 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::StorageClass>(clang::Sema::ImmediateDiagBuilder const&, clang::StorageClass const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::NonTrivialCUnionContext>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::NonTrivialCUnionContext const&) Line | Count | Source | 1597 | 81 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 81 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 81 | BaseDiag << Value; | 1600 | 81 | return Diag; | 1601 | 81 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [1]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [1]) Line | Count | Source | 1597 | 104 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 104 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 104 | BaseDiag << Value; | 1600 | 104 | return Diag; | 1601 | 104 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallVector<clang::FixItHint, 1u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallVector<clang::FixItHint, 1u> const&) Line | Count | Source | 1597 | 17 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 17 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 17 | BaseDiag << Value; | 1600 | 17 | return Diag; | 1601 | 17 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::UsedAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::UsedAttr* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ParmVarDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ParmVarDecl* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ParmVarDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ParmVarDecl const* const&) Line | Count | Source | 1597 | 76 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 76 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 76 | BaseDiag << Value; | 1600 | 76 | return Diag; | 1601 | 76 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TypedefDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TypedefDecl* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TagTypeKind>(clang::Sema::ImmediateDiagBuilder const&, clang::TagTypeKind const&) Line | Count | Source | 1597 | 76 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 76 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 76 | BaseDiag << Value; | 1600 | 76 | return Diag; | 1601 | 76 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::NonTagKind>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::NonTagKind const&) Line | Count | Source | 1597 | 28 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 28 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 28 | BaseDiag << Value; | 1600 | 28 | return Diag; | 1601 | 28 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TagDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TagDecl* const&) Line | Count | Source | 1597 | 9 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 9 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 9 | BaseDiag << Value; | 1600 | 9 | return Diag; | 1601 | 9 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::CXXSpecialMember>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::CXXSpecialMember const&) Line | Count | Source | 1597 | 587 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 587 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 587 | BaseDiag << Value; | 1600 | 587 | return Diag; | 1601 | 587 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::RecordDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::RecordDecl* const&) Line | Count | Source | 1597 | 21 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 21 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 21 | BaseDiag << Value; | 1600 | 21 | return Diag; | 1601 | 21 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::EnumConstantDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::EnumConstantDecl* const&) Line | Count | Source | 1597 | 25 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 25 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 25 | BaseDiag << Value; | 1600 | 25 | return Diag; | 1601 | 25 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::EnumDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::EnumDecl* const&) Line | Count | Source | 1597 | 46 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 46 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 46 | BaseDiag << Value; | 1600 | 46 | return Diag; | 1601 | 46 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Mips16Attr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::Mips16Attr const* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MicroMipsAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::MicroMipsAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MipsInterruptAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::MipsInterruptAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MipsShortCallAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::MipsShortCallAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MipsLongCallAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::MipsLongCallAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NotTailCalledAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NotTailCalledAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDASharedAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDASharedAttr const* const&) Line | Count | Source | 1597 | 6 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 6 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 6 | BaseDiag << Value; | 1600 | 6 | return Diag; | 1601 | 6 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::HIPManagedAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::HIPManagedAttr const* const&) Line | Count | Source | 1597 | 8 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 8 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 8 | BaseDiag << Value; | 1600 | 8 | return Diag; | 1601 | 8 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDADeviceAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDADeviceAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDAHostAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDAHostAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDAGlobalAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDAGlobalAttr const* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDAConstantAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDAConstantAttr const* const&) Line | Count | Source | 1597 | 8 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 8 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 8 | BaseDiag << Value; | 1600 | 8 | return Diag; | 1601 | 8 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDADeviceBuiltinTextureTypeAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDADeviceBuiltinTextureTypeAttr const* const&) Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDADeviceBuiltinSurfaceTypeAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDADeviceBuiltinSurfaceTypeAttr const* const&) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::OwnershipAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::OwnershipAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::HotAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::HotAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ColdAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ColdAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DisableTailCallsAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::DisableTailCallsAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VecReturnAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::VecReturnAttr* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CFUnknownTransferAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CFUnknownTransferAttr const* const&) Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CFAuditedTransferAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CFAuditedTransferAttr const* const&) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AttributeDeclKind>(clang::Sema::ImmediateDiagBuilder const&, clang::AttributeDeclKind const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
SemaDeclAttr.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<handleXReturnsXRetainedAttr(clang::Sema&, clang::Decl*, clang::ParsedAttr const&)::$_3>(clang::Sema::ImmediateDiagBuilder const&, handleXReturnsXRetainedAttr(clang::Sema&, clang::Decl*, clang::ParsedAttr const&)::$_3 const&) Line | Count | Source | 1597 | 13 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 13 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 13 | BaseDiag << Value; | 1600 | 13 | return Diag; | 1601 | 13 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NoSpeculativeLoadHardeningAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NoSpeculativeLoadHardeningAttr const* const&) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SpeculativeLoadHardeningAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::SpeculativeLoadHardeningAttr const* const&) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlwaysInlineAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlwaysInlineAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NakedAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NakedAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::OwnerAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::OwnerAttr const* const&) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::PointerAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::PointerAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [4]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [4]) Line | Count | Source | 1597 | 71 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 71 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 71 | BaseDiag << Value; | 1600 | 71 | return Diag; | 1601 | 71 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NoDestroyAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NoDestroyAttr const* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlwaysDestroyAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlwaysDestroyAttr const* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [18]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [18]) Line | Count | Source | 1597 | 14 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 14 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 14 | BaseDiag << Value; | 1600 | 14 | return Diag; | 1601 | 14 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AttributeCommonInfo>(clang::Sema::ImmediateDiagBuilder const&, clang::AttributeCommonInfo const&) Line | Count | Source | 1597 | 6 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 6 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 6 | BaseDiag << Value; | 1600 | 6 | return Diag; | 1601 | 6 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::InternalLinkageAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::InternalLinkageAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CommonAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CommonAttr const* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SwiftNameAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::SwiftNameAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlwaysInlineAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlwaysInlineAttr* const&) Line | Count | Source | 1597 | 7 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 7 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 7 | BaseDiag << Value; | 1600 | 7 | return Diag; | 1601 | 7 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MinSizeAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::MinSizeAttr* const&) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ParameterABIAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::ParameterABIAttr* const&) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DLLImportAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::DLLImportAttr* const&) Line | Count | Source | 1597 | 169 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 169 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 169 | BaseDiag << Value; | 1600 | 169 | return Diag; | 1601 | 169 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ReqdWorkGroupSizeAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ReqdWorkGroupSizeAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::WorkGroupSizeHintAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::WorkGroupSizeHintAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VecTypeHintAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::VecTypeHintAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::OpenCLIntelReqdSubGroupSizeAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::OpenCLIntelReqdSubGroupSizeAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AMDGPUFlatWorkGroupSizeAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AMDGPUFlatWorkGroupSizeAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AMDGPUWavesPerEUAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AMDGPUWavesPerEUAttr const* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AMDGPUNumSGPRAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AMDGPUNumSGPRAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AMDGPUNumVGPRAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AMDGPUNumVGPRAttr const* const&) Line | Count | Source | 1597 | 1 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1 | BaseDiag << Value; | 1600 | 1 | return Diag; | 1601 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::AbstractDiagSelID>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::AbstractDiagSelID const&) Line | Count | Source | 1597 | 11 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 11 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 11 | BaseDiag << Value; | 1600 | 11 | return Diag; | 1601 | 11 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ClassTemplateDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ClassTemplateDecl* const&) Line | Count | Source | 1597 | 33 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 33 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 33 | BaseDiag << Value; | 1600 | 33 | return Diag; | 1601 | 33 | } |
SemaDeclCXX.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::DefaultedComparisonSubobject::$_7>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::DefaultedComparisonSubobject::$_7 const&) Line | Count | Source | 1597 | 30 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 30 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 30 | BaseDiag << Value; | 1600 | 30 | return Diag; | 1601 | 30 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<TrivialSubobjectKind>(clang::Sema::ImmediateDiagBuilder const&, TrivialSubobjectKind const&) Line | Count | Source | 1597 | 211 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 211 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 211 | BaseDiag << Value; | 1600 | 211 | return Diag; | 1601 | 211 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXConstructorDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXConstructorDecl* const&) Line | Count | Source | 1597 | 7 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 7 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 7 | BaseDiag << Value; | 1600 | 7 | return Diag; | 1601 | 7 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DecompositionDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::DecompositionDecl* const&) Line | Count | Source | 1597 | 7 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 7 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 7 | BaseDiag << Value; | 1600 | 7 | return Diag; | 1601 | 7 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXRecordDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXRecordDecl* const&) Line | Count | Source | 1597 | 6.31k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 6.31k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 6.31k | BaseDiag << Value; | 1600 | 6.31k | return Diag; | 1601 | 6.31k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AccessSpecifier>(clang::Sema::ImmediateDiagBuilder const&, clang::AccessSpecifier const&) Line | Count | Source | 1597 | 8 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 8 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 8 | BaseDiag << Value; | 1600 | 8 | return Diag; | 1601 | 8 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Attr*>(clang::Sema::ImmediateDiagBuilder const&, clang::Attr* const&) Line | Count | Source | 1597 | 40 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 40 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 40 | BaseDiag << Value; | 1600 | 40 | return Diag; | 1601 | 40 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::InheritableAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::InheritableAttr* const&) Line | Count | Source | 1597 | 24 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 24 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 24 | BaseDiag << Value; | 1600 | 24 | return Diag; | 1601 | 24 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ClassTemplateSpecializationDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ClassTemplateSpecializationDecl* const&) Line | Count | Source | 1597 | 78 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 78 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 78 | BaseDiag << Value; | 1600 | 78 | return Diag; | 1601 | 78 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FieldDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::FieldDecl* const&) Line | Count | Source | 1597 | 557 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 557 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 557 | BaseDiag << Value; | 1600 | 557 | return Diag; | 1601 | 557 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TemplateDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TemplateDecl* const&) Line | Count | Source | 1597 | 1.09k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1.09k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1.09k | BaseDiag << Value; | 1600 | 1.09k | return Diag; | 1601 | 1.09k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [15]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [15]) Line | Count | Source | 1597 | 14 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 14 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 14 | BaseDiag << Value; | 1600 | 14 | return Diag; | 1601 | 14 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCMethodDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCMethodDecl* const&) Line | Count | Source | 1597 | 2.64k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2.64k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2.64k | BaseDiag << Value; | 1600 | 2.64k | return Diag; | 1601 | 2.64k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCInterfaceDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCInterfaceDecl const* const&) Line | Count | Source | 1597 | 8 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 8 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 8 | BaseDiag << Value; | 1600 | 8 | return Diag; | 1601 | 8 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCCategoryDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCCategoryDecl* const&) Line | Count | Source | 1597 | 5 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5 | BaseDiag << Value; | 1600 | 5 | return Diag; | 1601 | 5 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCProtocolDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCProtocolDecl const* const&) Line | Count | Source | 1597 | 5 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5 | BaseDiag << Value; | 1600 | 5 | return Diag; | 1601 | 5 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCMethodFamily>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCMethodFamily const&) Line | Count | Source | 1597 | 48 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 48 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 48 | BaseDiag << Value; | 1600 | 48 | return Diag; | 1601 | 48 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [10]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [10]) Line | Count | Source | 1597 | 304 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 304 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 304 | BaseDiag << Value; | 1600 | 304 | return Diag; | 1601 | 304 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCProtocolDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCProtocolDecl* const&) Line | Count | Source | 1597 | 39 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 39 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 39 | BaseDiag << Value; | 1600 | 39 | return Diag; | 1601 | 39 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Selector>(clang::Sema::ImmediateDiagBuilder const&, clang::Selector const&) Line | Count | Source | 1597 | 3.86k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3.86k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3.86k | BaseDiag << Value; | 1600 | 3.86k | return Diag; | 1601 | 3.86k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCIvarDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCIvarDecl const* const&) Line | Count | Source | 1597 | 10 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 10 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 10 | BaseDiag << Value; | 1600 | 10 | return Diag; | 1601 | 10 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CanQual<clang::Type> >(clang::Sema::ImmediateDiagBuilder const&, clang::CanQual<clang::Type> const&) Line | Count | Source | 1597 | 72 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 72 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 72 | BaseDiag << Value; | 1600 | 72 | return Diag; | 1601 | 72 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallString<40u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallString<40u> const&) Line | Count | Source | 1597 | 9.59k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 9.59k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 9.59k | BaseDiag << Value; | 1600 | 9.59k | return Diag; | 1601 | 9.59k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SourceLocation>(clang::Sema::ImmediateDiagBuilder const&, clang::SourceLocation const&) Line | Count | Source | 1597 | 933 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 933 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 933 | BaseDiag << Value; | 1600 | 933 | return Diag; | 1601 | 933 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXMethodDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXMethodDecl const* const&) Line | Count | Source | 1597 | 36 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 36 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 36 | BaseDiag << Value; | 1600 | 36 | return Diag; | 1601 | 36 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<OriginalExprKind>(clang::Sema::ImmediateDiagBuilder const&, OriginalExprKind const&) Line | Count | Source | 1597 | 11 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 11 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 11 | BaseDiag << Value; | 1600 | 11 | return Diag; | 1601 | 11 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TypeAliasTemplateDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TypeAliasTemplateDecl* const&) Line | Count | Source | 1597 | 7 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 7 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 7 | BaseDiag << Value; | 1600 | 7 | return Diag; | 1601 | 7 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::UsingPackDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::UsingPackDecl* const&) Line | Count | Source | 1597 | 2 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 2 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 2 | BaseDiag << Value; | 1600 | 2 | return Diag; | 1601 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::VariadicCallType>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::VariadicCallType const&) Line | Count | Source | 1597 | 6 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 6 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 6 | BaseDiag << Value; | 1600 | 6 | return Diag; | 1601 | 6 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Expr*>(clang::Sema::ImmediateDiagBuilder const&, clang::Expr* const&) Line | Count | Source | 1597 | 302 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 302 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 302 | BaseDiag << Value; | 1600 | 302 | return Diag; | 1601 | 302 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [2]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [2]) Line | Count | Source | 1597 | 109 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 109 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 109 | BaseDiag << Value; | 1600 | 109 | return Diag; | 1601 | 109 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::AssignmentAction>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::AssignmentAction const&) Line | Count | Source | 1597 | 13 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 13 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 13 | BaseDiag << Value; | 1600 | 13 | return Diag; | 1601 | 13 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::ObjCLiteralKind>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::ObjCLiteralKind const&) Line | Count | Source | 1597 | 79 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 79 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 79 | BaseDiag << Value; | 1600 | 79 | return Diag; | 1601 | 79 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [3]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [3]) Line | Count | Source | 1597 | 254 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 254 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 254 | BaseDiag << Value; | 1600 | 254 | return Diag; | 1601 | 254 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCBridgeCastKind>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCBridgeCastKind const&) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
SemaInit.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::ReferenceKind>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::ReferenceKind const&) Line | Count | Source | 1597 | 120 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 120 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 120 | BaseDiag << Value; | 1600 | 120 | return Diag; | 1601 | 120 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DeclarationName>(clang::Sema::ImmediateDiagBuilder const&, clang::DeclarationName const&) Line | Count | Source | 1597 | 22.5k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 22.5k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 22.5k | BaseDiag << Value; | 1600 | 22.5k | return Diag; | 1601 | 22.5k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Qualifiers::ObjCLifetime>(clang::Sema::ImmediateDiagBuilder const&, clang::Qualifiers::ObjCLifetime const&) Line | Count | Source | 1597 | 251 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 251 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 251 | BaseDiag << Value; | 1600 | 251 | return Diag; | 1601 | 251 | } |
SemaObjCProperty.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<SelectPropertyForSynthesisFromProtocols(clang::Sema&, clang::SourceLocation, clang::ObjCInterfaceDecl*, clang::ObjCPropertyDecl*)::MismatchKind>(clang::Sema::ImmediateDiagBuilder const&, SelectPropertyForSynthesisFromProtocols(clang::Sema&, clang::SourceLocation, clang::ObjCInterfaceDecl*, clang::ObjCPropertyDecl*)::MismatchKind const&) Line | Count | Source | 1597 | 24 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 24 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 24 | BaseDiag << Value; | 1600 | 24 | return Diag; | 1601 | 24 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCPropertyDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCPropertyDecl* const&) Line | Count | Source | 1597 | 31 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 31 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 31 | BaseDiag << Value; | 1600 | 31 | return Diag; | 1601 | 31 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCIvarDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCIvarDecl* const&) Line | Count | Source | 1597 | 46 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 46 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 46 | BaseDiag << Value; | 1600 | 46 | return Diag; | 1601 | 46 | } |
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<reportOriginalDsa(clang::Sema&, (anonymous namespace)::DSAStackTy const*, clang::ValueDecl const*, (anonymous namespace)::DSAStackTy::DSAVarData const&, bool)::$_33>(clang::Sema::ImmediateDiagBuilder const&, reportOriginalDsa(clang::Sema&, (anonymous namespace)::DSAStackTy const*, clang::ValueDecl const*, (anonymous namespace)::DSAStackTy::DSAVarData const&, bool)::$_33 const&) Line | Count | Source | 1597 | 1.07k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 1.07k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 1.07k | BaseDiag << Value; | 1600 | 1.07k | return Diag; | 1601 | 1.07k | } |
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<getPrivateItem(clang::Sema&, clang::Expr*&, clang::SourceLocation&, clang::SourceRange&, bool)::$_37>(clang::Sema::ImmediateDiagBuilder const&, getPrivateItem(clang::Sema&, clang::Expr*&, clang::SourceLocation&, clang::SourceRange&, bool)::$_37 const&) Line | Count | Source | 1597 | 24 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 24 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 24 | BaseDiag << Value; | 1600 | 24 | return Diag; | 1601 | 24 | } |
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<checkNestingOfRegions(clang::Sema&, (anonymous namespace)::DSAStackTy const*, llvm::omp::Directive, clang::DeclarationNameInfo const&, llvm::omp::Directive, clang::SourceLocation)::$_36>(clang::Sema::ImmediateDiagBuilder const&, checkNestingOfRegions(clang::Sema&, (anonymous namespace)::DSAStackTy const*, llvm::omp::Directive, clang::DeclarationNameInfo const&, llvm::omp::Directive, clang::SourceLocation)::$_36 const&) Line | Count | Source | 1597 | 6.14k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 6.14k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 6.14k | BaseDiag << Value; | 1600 | 6.14k | return Diag; | 1601 | 6.14k | } |
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::OpenMPAtomicUpdateChecker::ExprAnalysisErrorCode>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::OpenMPAtomicUpdateChecker::ExprAnalysisErrorCode const&) Line | Count | Source | 1597 | 800 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 800 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 800 | BaseDiag << Value; | 1600 | 800 | return Diag; | 1601 | 800 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [13]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [13]) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_20>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_20 const&) Line | Count | Source | 1597 | 72 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 72 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 72 | BaseDiag << Value; | 1600 | 72 | return Diag; | 1601 | 72 | } |
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_21>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_21 const&) Line | Count | Source | 1597 | 48 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 48 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 48 | BaseDiag << Value; | 1600 | 48 | return Diag; | 1601 | 48 | } |
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_22>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::ActOnOpenMPAtomicDirective(llvm::ArrayRef<clang::OMPClause*>, clang::Stmt*, clang::SourceLocation, clang::SourceLocation)::$_22 const&) Line | Count | Source | 1597 | 72 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 72 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 72 | BaseDiag << Value; | 1600 | 72 | return Diag; | 1601 | 72 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [50]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [50]) Line | Count | Source | 1597 | 16 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 16 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 16 | BaseDiag << Value; | 1600 | 16 | return Diag; | 1601 | 16 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::CCEKind>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::CCEKind const&) Line | Count | Source | 1597 | 111 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 111 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 111 | BaseDiag << Value; | 1600 | 111 | return Diag; | 1601 | 111 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Qualifiers>(clang::Sema::ImmediateDiagBuilder const&, clang::Qualifiers const&) Line | Count | Source | 1597 | 9 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 9 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 9 | BaseDiag << Value; | 1600 | 9 | return Diag; | 1601 | 9 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::CUDAFunctionTarget>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::CUDAFunctionTarget const&) Line | Count | Source | 1597 | 392 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 392 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 392 | BaseDiag << Value; | 1600 | 392 | return Diag; | 1601 | 392 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TemplateArgument>(clang::Sema::ImmediateDiagBuilder const&, clang::TemplateArgument const&) Line | Count | Source | 1597 | 635 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 635 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 635 | BaseDiag << Value; | 1600 | 635 | return Diag; | 1601 | 635 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallString<128u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallString<128u> const&) Line | Count | Source | 1597 | 4.90k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4.90k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4.90k | BaseDiag << Value; | 1600 | 4.90k | return Diag; | 1601 | 4.90k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DeclContext*>(clang::Sema::ImmediateDiagBuilder const&, clang::DeclContext* const&) Line | Count | Source | 1597 | 36.6k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 36.6k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 36.6k | BaseDiag << Value; | 1600 | 36.6k | return Diag; | 1601 | 36.6k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NamedDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NamedDecl const* const&) Line | Count | Source | 1597 | 126k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 126k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 126k | BaseDiag << Value; | 1600 | 126k | return Diag; | 1601 | 126k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FunctionDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::FunctionDecl* const&) Line | Count | Source | 1597 | 169k | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 169k | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 169k | BaseDiag << Value; | 1600 | 169k | return Diag; | 1601 | 169k | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXMethodDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXMethodDecl* const&) Line | Count | Source | 1597 | 15 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 15 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 15 | BaseDiag << Value; | 1600 | 15 | return Diag; | 1601 | 15 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::WarnUnusedResultAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::WarnUnusedResultAttr const* const&) Line | Count | Source | 1597 | 117 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 117 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 117 | BaseDiag << Value; | 1600 | 117 | return Diag; | 1601 | 117 | } |
SemaStmt.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::BeginEndFunction>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::BeginEndFunction const&) Line | Count | Source | 1597 | 40 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 40 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 40 | BaseDiag << Value; | 1600 | 40 | return Diag; | 1601 | 40 | } |
SemaStmtAsm.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<checkExprMemoryConstraintCompat(clang::Sema&, clang::Expr*, clang::TargetInfo::ConstraintInfo&, bool)::$_2>(clang::Sema::ImmediateDiagBuilder const&, checkExprMemoryConstraintCompat(clang::Sema&, clang::Expr*, clang::TargetInfo::ConstraintInfo&, bool)::$_2 const&) Line | Count | Source | 1597 | 6 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 6 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 6 | BaseDiag << Value; | 1600 | 6 | return Diag; | 1601 | 6 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::UnlikelyAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::UnlikelyAttr const* const&) Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::LikelyAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::LikelyAttr const* const&) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NamespaceDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::NamespaceDecl* const&) Line | Count | Source | 1597 | 39 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 39 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 39 | BaseDiag << Value; | 1600 | 39 | return Diag; | 1601 | 39 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NestedNameSpecifier*>(clang::Sema::ImmediateDiagBuilder const&, clang::NestedNameSpecifier* const&) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ConceptDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ConceptDecl* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VarTemplateSpecializationDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::VarTemplateSpecializationDecl* const&) Line | Count | Source | 1597 | 3 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 3 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 3 | BaseDiag << Value; | 1600 | 3 | return Diag; | 1601 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TemplateTemplateParmDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TemplateTemplateParmDecl* const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
SemaTemplate.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::CheckDependentFunctionTemplateSpecialization(clang::FunctionDecl*, clang::TemplateArgumentListInfo const&, clang::LookupResult&)::DiscardReason>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::CheckDependentFunctionTemplateSpecialization(clang::FunctionDecl*, clang::TemplateArgumentListInfo const&, clang::LookupResult&)::DiscardReason const&) Line | Count | Source | 1597 | 4 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 4 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 4 | BaseDiag << Value; | 1600 | 4 | return Diag; | 1601 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VarTemplateDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::VarTemplateDecl* const&) Line | Count | Source | 1597 | 21 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 21 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 21 | BaseDiag << Value; | 1600 | 21 | return Diag; | 1601 | 21 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DeducedTemplateArgument>(clang::Sema::ImmediateDiagBuilder const&, clang::DeducedTemplateArgument const&) Line | Count | Source | 1597 | 19 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 19 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 19 | BaseDiag << Value; | 1600 | 19 | return Diag; | 1601 | 19 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MSPropertyDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::MSPropertyDecl* const&) clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCInterfaceDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCInterfaceDecl* const&) Line | Count | Source | 1597 | 5 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5 | BaseDiag << Value; | 1600 | 5 | return Diag; | 1601 | 5 | } |
SemaType.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::QualifiedFunctionKind>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::QualifiedFunctionKind const&) Line | Count | Source | 1597 | 22 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 22 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 22 | BaseDiag << Value; | 1600 | 22 | return Diag; | 1601 | 22 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<TypeDiagSelector>(clang::Sema::ImmediateDiagBuilder const&, TypeDiagSelector const&) Line | Count | Source | 1597 | 29 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 29 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 29 | BaseDiag << Value; | 1600 | 29 | return Diag; | 1601 | 29 | } |
SemaType.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<GetFullTypeForDeclarator((anonymous namespace)::TypeProcessingState&, clang::QualType, clang::TypeSourceInfo*)::$_7>(clang::Sema::ImmediateDiagBuilder const&, GetFullTypeForDeclarator((anonymous namespace)::TypeProcessingState&, clang::QualType, clang::TypeSourceInfo*)::$_7 const&) Line | Count | Source | 1597 | 50 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 50 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 50 | BaseDiag << Value; | 1600 | 50 | return Diag; | 1601 | 50 | } |
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ArrayType::ArraySizeModifier>(clang::Sema::ImmediateDiagBuilder const&, clang::ArrayType::ArraySizeModifier const&) Line | Count | Source | 1597 | 5 | operator<<(const ImmediateDiagBuilder &Diag, const T &Value) { | 1598 | 5 | const DiagnosticBuilder &BaseDiag = Diag; | 1599 | 5 | BaseDiag << Value; | 1600 | 5 | return Diag; | 1601 | 5 | } |
|
1602 | | |
1603 | | // It is necessary to limit this to rvalue reference to avoid calling this |
1604 | | // function with a bitfield lvalue argument since non-const reference to |
1605 | | // bitfield is not allowed. |
1606 | | template <typename T, typename = typename std::enable_if< |
1607 | | !std::is_lvalue_reference<T>::value>::type> |
1608 | 1.65M | const ImmediateDiagBuilder &operator<<(T &&V) const { |
1609 | 1.65M | const DiagnosticBuilder &BaseDiag = *this; |
1610 | 1.65M | BaseDiag << std::move(V); |
1611 | 1.65M | return *this; |
1612 | 1.65M | } clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<unsigned int, void>(unsigned int&&) const Line | Count | Source | 1608 | 16.3k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 16.3k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 16.3k | BaseDiag << std::move(V); | 1611 | 16.3k | return *this; | 1612 | 16.3k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::FixItHint, void>(clang::FixItHint&&) const Line | Count | Source | 1608 | 192k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 192k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 192k | BaseDiag << std::move(V); | 1611 | 192k | return *this; | 1612 | 192k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<bool, void>(bool&&) const Line | Count | Source | 1608 | 65.1k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 65.1k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 65.1k | BaseDiag << std::move(V); | 1611 | 65.1k | return *this; | 1612 | 65.1k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::DeclarationName, void>(clang::DeclarationName&&) const Line | Count | Source | 1608 | 69.1k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 69.1k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 69.1k | BaseDiag << std::move(V); | 1611 | 69.1k | return *this; | 1612 | 69.1k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AttributeDeclKind, void>(clang::AttributeDeclKind&&) const Line | Count | Source | 1608 | 67 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 67 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 67 | BaseDiag << std::move(V); | 1611 | 67 | return *this; | 1612 | 67 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<int, void>(int&&) const Line | Count | Source | 1608 | 208k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 208k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 208k | BaseDiag << std::move(V); | 1611 | 208k | return *this; | 1612 | 208k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<llvm::StringRef, void>(llvm::StringRef&&) const Line | Count | Source | 1608 | 64.1k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 64.1k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 64.1k | BaseDiag << std::move(V); | 1611 | 64.1k | return *this; | 1612 | 64.1k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::SourceRange, void>(clang::SourceRange&&) const Line | Count | Source | 1608 | 921k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 921k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 921k | BaseDiag << std::move(V); | 1611 | 921k | return *this; | 1612 | 921k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<char const*, void>(char const*&&) const Line | Count | Source | 1608 | 3.53k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 3.53k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 3.53k | BaseDiag << std::move(V); | 1611 | 3.53k | return *this; | 1612 | 3.53k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::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 | 1608 | 29.7k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 29.7k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 29.7k | BaseDiag << std::move(V); | 1611 | 29.7k | return *this; | 1612 | 29.7k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<CastType, void>(CastType&&) const Line | Count | Source | 1608 | 122 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 122 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 122 | BaseDiag << std::move(V); | 1611 | 122 | return *this; | 1612 | 122 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Expr*, void>(clang::Expr*&&) const Line | Count | Source | 1608 | 5 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 5 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 5 | BaseDiag << std::move(V); | 1611 | 5 | return *this; | 1612 | 5 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::FunctionDecl*, void>(clang::FunctionDecl*&&) const Line | Count | Source | 1608 | 169 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 169 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 169 | BaseDiag << std::move(V); | 1611 | 169 | return *this; | 1612 | 169 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::AssignmentAction, void>(clang::Sema::AssignmentAction&&) const Line | Count | Source | 1608 | 75 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 75 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 75 | BaseDiag << std::move(V); | 1611 | 75 | return *this; | 1612 | 75 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ConceptDecl*, void>(clang::ConceptDecl*&&) const Line | Count | Source | 1608 | 49 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 49 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 49 | BaseDiag << std::move(V); | 1611 | 49 | return *this; | 1612 | 49 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::VarDecl*, void>(clang::VarDecl*&&) const Line | Count | Source | 1608 | 485 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 485 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 485 | BaseDiag << std::move(V); | 1611 | 485 | return *this; | 1612 | 485 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Attr const*, void>(clang::Attr const*&&) const Line | Count | Source | 1608 | 813 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 813 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 813 | BaseDiag << std::move(V); | 1611 | 813 | return *this; | 1612 | 813 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::SourceLocation, void>(clang::SourceLocation&&) const Line | Count | Source | 1608 | 284 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 284 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 284 | BaseDiag << std::move(V); | 1611 | 284 | return *this; | 1612 | 284 | } |
SemaDecl.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<CheckMultiVersionValue(clang::Sema&, clang::FunctionDecl const*)::ErrType, void>(CheckMultiVersionValue(clang::Sema&, clang::FunctionDecl const*)::ErrType&&) const Line | Count | Source | 1608 | 1 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 1 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 1 | BaseDiag << std::move(V); | 1611 | 1 | return *this; | 1612 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::NestedNameSpecifier*, void>(clang::NestedNameSpecifier*&&) const Line | Count | Source | 1608 | 342 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 342 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 342 | BaseDiag << std::move(V); | 1611 | 342 | return *this; | 1612 | 342 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::RecordDecl const*, void>(clang::RecordDecl const*&&) const Line | Count | Source | 1608 | 4 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 4 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 4 | BaseDiag << std::move(V); | 1611 | 4 | return *this; | 1612 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::DeclContext*, void>(clang::DeclContext*&&) const Line | Count | Source | 1608 | 69 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 69 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 69 | BaseDiag << std::move(V); | 1611 | 69 | return *this; | 1612 | 69 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<ShadowedDeclKind, void>(ShadowedDeclKind&&) const Line | Count | Source | 1608 | 48 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 48 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 48 | BaseDiag << std::move(V); | 1611 | 48 | return *this; | 1612 | 48 | } |
SemaDecl.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::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 | 1608 | 23 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 23 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 23 | BaseDiag << std::move(V); | 1611 | 23 | return *this; | 1612 | 23 | } |
SemaDecl.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::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 | 1608 | 27 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 27 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 27 | BaseDiag << std::move(V); | 1611 | 27 | return *this; | 1612 | 27 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::NamedDecl const*, void>(clang::NamedDecl const*&&) const Line | Count | Source | 1608 | 6 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 6 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 6 | BaseDiag << std::move(V); | 1611 | 6 | return *this; | 1612 | 6 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::CUDALaunchBoundsAttr const*, void>(clang::CUDALaunchBoundsAttr const*&&) const Line | Count | Source | 1608 | 7 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 7 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 7 | BaseDiag << std::move(V); | 1611 | 7 | return *this; | 1612 | 7 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AMDGPUFlatWorkGroupSizeAttr const*, void>(clang::AMDGPUFlatWorkGroupSizeAttr const*&&) const Line | Count | Source | 1608 | 11 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 11 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 11 | BaseDiag << std::move(V); | 1611 | 11 | return *this; | 1612 | 11 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AMDGPUWavesPerEUAttr const*, void>(clang::AMDGPUWavesPerEUAttr const*&&) const Line | Count | Source | 1608 | 11 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 11 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 11 | BaseDiag << std::move(V); | 1611 | 11 | return *this; | 1612 | 11 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ParsedAttr const*, void>(clang::ParsedAttr const*&&) const Line | Count | Source | 1608 | 83 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 83 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 83 | BaseDiag << std::move(V); | 1611 | 83 | return *this; | 1612 | 83 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<AttributeLangSupport::LANG, void>(AttributeLangSupport::LANG&&) const Line | Count | Source | 1608 | 3 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 3 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 3 | BaseDiag << std::move(V); | 1611 | 3 | return *this; | 1612 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::TypedefNameDecl*, void>(clang::TypedefNameDecl*&&) const Line | Count | Source | 1608 | 4 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 4 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 4 | BaseDiag << std::move(V); | 1611 | 4 | return *this; | 1612 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::FieldDecl*, void>(clang::FieldDecl*&&) const Line | Count | Source | 1608 | 325 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 325 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 325 | BaseDiag << std::move(V); | 1611 | 325 | return *this; | 1612 | 325 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AssumeAlignedAttr*, void>(clang::AssumeAlignedAttr*&&) const Line | Count | Source | 1608 | 3 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 3 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 3 | BaseDiag << std::move(V); | 1611 | 3 | return *this; | 1612 | 3 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AllocAlignAttr*, void>(clang::AllocAlignAttr*&&) const Line | Count | Source | 1608 | 5 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 5 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 5 | BaseDiag << std::move(V); | 1611 | 5 | return *this; | 1612 | 5 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AllocAlignAttr const*, void>(clang::AllocAlignAttr const*&&) const Line | Count | Source | 1608 | 5 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 5 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 5 | BaseDiag << std::move(V); | 1611 | 5 | return *this; | 1612 | 5 | } |
SemaDeclAttr.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::FirstParam, void>(clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::FirstParam&&) const Line | Count | Source | 1608 | 13 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 13 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 13 | BaseDiag << std::move(V); | 1611 | 13 | return *this; | 1612 | 13 | } |
SemaDeclAttr.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::SecondParam, void>(clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::SecondParam&&) const Line | Count | Source | 1608 | 13 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 13 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 13 | BaseDiag << std::move(V); | 1611 | 13 | return *this; | 1612 | 13 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AlignValueAttr*, void>(clang::AlignValueAttr*&&) const Line | Count | Source | 1608 | 1 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 1 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 1 | BaseDiag << std::move(V); | 1611 | 1 | return *this; | 1612 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AlignedAttr*, void>(clang::AlignedAttr*&&) const Line | Count | Source | 1608 | 17 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 17 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 17 | BaseDiag << std::move(V); | 1611 | 17 | return *this; | 1612 | 17 | } |
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::InternalLinkageAttr const*, void>(clang::InternalLinkageAttr const*&&) const clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::SwiftNameAttr const*, void>(clang::SwiftNameAttr const*&&) const Line | Count | Source | 1608 | 1 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 1 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 1 | BaseDiag << std::move(V); | 1611 | 1 | return *this; | 1612 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AccessSpecifier, void>(clang::AccessSpecifier&&) const Line | Count | Source | 1608 | 8 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 8 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 8 | BaseDiag << std::move(V); | 1611 | 8 | return *this; | 1612 | 8 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::NamespaceDecl*, void>(clang::NamespaceDecl*&&) const Line | Count | Source | 1608 | 1 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 1 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 1 | BaseDiag << std::move(V); | 1611 | 1 | return *this; | 1612 | 1 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::CanQual<clang::Type>, void>(clang::CanQual<clang::Type>&&) const Line | Count | Source | 1608 | 9 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 9 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 9 | BaseDiag << std::move(V); | 1611 | 9 | return *this; | 1612 | 9 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<std::__1::pair<clang::NullabilityKind, bool>, void>(std::__1::pair<clang::NullabilityKind, bool>&&) const Line | Count | Source | 1608 | 141 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 141 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 141 | BaseDiag << std::move(V); | 1611 | 141 | return *this; | 1612 | 141 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::TagTypeKind, void>(clang::TagTypeKind&&) const Line | Count | Source | 1608 | 241 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 241 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 241 | BaseDiag << std::move(V); | 1611 | 241 | return *this; | 1612 | 241 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ObjCMethodDecl const*, void>(clang::ObjCMethodDecl const*&&) const Line | Count | Source | 1608 | 2 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 2 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 2 | BaseDiag << std::move(V); | 1611 | 2 | return *this; | 1612 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::QualType, void>(clang::QualType&&) const Line | Count | Source | 1608 | 70.8k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 70.8k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 70.8k | BaseDiag << std::move(V); | 1611 | 70.8k | return *this; | 1612 | 70.8k | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Selector, void>(clang::Selector&&) const Line | Count | Source | 1608 | 170 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 170 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 170 | BaseDiag << std::move(V); | 1611 | 170 | return *this; | 1612 | 170 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::IdentifierInfo const*, void>(clang::IdentifierInfo const*&&) const Line | Count | Source | 1608 | 140 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 140 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 140 | BaseDiag << std::move(V); | 1611 | 140 | return *this; | 1612 | 140 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::IdentifierInfo*, void>(clang::IdentifierInfo*&&) const Line | Count | Source | 1608 | 10.3k | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 10.3k | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 10.3k | BaseDiag << std::move(V); | 1611 | 10.3k | return *this; | 1612 | 10.3k | } |
SemaExpr.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<$_14, void>($_14&&) const Line | Count | Source | 1608 | 330 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 330 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 330 | BaseDiag << std::move(V); | 1611 | 330 | return *this; | 1612 | 330 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::NonTagKind, void>(clang::Sema::NonTagKind&&) const Line | Count | Source | 1608 | 7 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 7 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 7 | BaseDiag << std::move(V); | 1611 | 7 | return *this; | 1612 | 7 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ValueDecl const*, void>(clang::ValueDecl const*&&) const Line | Count | Source | 1608 | 64 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 64 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 64 | BaseDiag << std::move(V); | 1611 | 64 | return *this; | 1612 | 64 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ValueDecl*, void>(clang::ValueDecl*&&) const Line | Count | Source | 1608 | 156 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 156 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 156 | BaseDiag << std::move(V); | 1611 | 156 | return *this; | 1612 | 156 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::tok::TokenKind, void>(clang::tok::TokenKind&&) const Line | Count | Source | 1608 | 2 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 2 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 2 | BaseDiag << std::move(V); | 1611 | 2 | return *this; | 1612 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Qualifiers, void>(clang::Qualifiers&&) const Line | Count | Source | 1608 | 72 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 72 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 72 | BaseDiag << std::move(V); | 1611 | 72 | return *this; | 1612 | 72 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::QualType const, void>(clang::QualType const&&) const Line | Count | Source | 1608 | 42 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 42 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 42 | BaseDiag << std::move(V); | 1611 | 42 | return *this; | 1612 | 42 | } |
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::checkOpenMPDeclareVariantFunction(clang::OpaquePtr<clang::DeclGroupRef>, clang::Expr*, clang::OMPTraitInfo&, clang::SourceRange)::DoesntSupport, void>(clang::Sema::checkOpenMPDeclareVariantFunction(clang::OpaquePtr<clang::DeclGroupRef>, clang::Expr*, clang::OMPTraitInfo&, clang::SourceRange)::DoesntSupport&&) const Line | Count | Source | 1608 | 10 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 10 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 10 | BaseDiag << std::move(V); | 1611 | 10 | return *this; | 1612 | 10 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::CXXRecordDecl*, void>(clang::CXXRecordDecl*&&) const Line | Count | Source | 1608 | 633 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 633 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 633 | BaseDiag << std::move(V); | 1611 | 633 | return *this; | 1612 | 633 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ParmVarDecl*, void>(clang::ParmVarDecl*&&) const Line | Count | Source | 1608 | 367 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 367 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 367 | BaseDiag << std::move(V); | 1611 | 367 | return *this; | 1612 | 367 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::LangAS, void>(clang::LangAS&&) const Line | Count | Source | 1608 | 68 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 68 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 68 | BaseDiag << std::move(V); | 1611 | 68 | return *this; | 1612 | 68 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Qualifiers::ObjCLifetime, void>(clang::Qualifiers::ObjCLifetime&&) const Line | Count | Source | 1608 | 34 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 34 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 34 | BaseDiag << std::move(V); | 1611 | 34 | return *this; | 1612 | 34 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Qualifiers::GC, void>(clang::Qualifiers::GC&&) const Line | Count | Source | 1608 | 4 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 4 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 4 | BaseDiag << std::move(V); | 1611 | 4 | return *this; | 1612 | 4 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::TemplateDecl*, void>(clang::TemplateDecl*&&) const Line | Count | Source | 1608 | 6 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 6 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 6 | BaseDiag << std::move(V); | 1611 | 6 | return *this; | 1612 | 6 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::RefQualifierKind, void>(clang::RefQualifierKind&&) const Line | Count | Source | 1608 | 22 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 22 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 22 | BaseDiag << std::move(V); | 1611 | 22 | return *this; | 1612 | 22 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::NamedDecl*, void>(clang::NamedDecl*&&) const Line | Count | Source | 1608 | 478 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 478 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 478 | BaseDiag << std::move(V); | 1611 | 478 | return *this; | 1612 | 478 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::CXXSpecialMember, void>(clang::Sema::CXXSpecialMember&&) const Line | Count | Source | 1608 | 880 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 880 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 880 | BaseDiag << std::move(V); | 1611 | 880 | return *this; | 1612 | 880 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::CXXRecordDecl const*, void>(clang::CXXRecordDecl const*&&) const Line | Count | Source | 1608 | 47 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 47 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 47 | BaseDiag << std::move(V); | 1611 | 47 | return *this; | 1612 | 47 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::MSPropertyDecl*, void>(clang::MSPropertyDecl*&&) const Line | Count | Source | 1608 | 25 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 25 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 25 | BaseDiag << std::move(V); | 1611 | 25 | return *this; | 1612 | 25 | } |
SemaStmt.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<(anonymous namespace)::BeginEndFunction, void>((anonymous namespace)::BeginEndFunction&&) const Line | Count | Source | 1608 | 6 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 6 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 6 | BaseDiag << std::move(V); | 1611 | 6 | return *this; | 1612 | 6 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<TypeDiagSelector, void>(TypeDiagSelector&&) const Line | Count | Source | 1608 | 25 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 25 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 25 | BaseDiag << std::move(V); | 1611 | 25 | return *this; | 1612 | 25 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<llvm::IntegerType::'unnamed', void>(llvm::IntegerType::'unnamed'&&) const Line | Count | Source | 1608 | 2 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 2 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 2 | BaseDiag << std::move(V); | 1611 | 2 | return *this; | 1612 | 2 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::CUDAFunctionTarget, void>(clang::Sema::CUDAFunctionTarget&&) const Line | Count | Source | 1608 | 201 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 201 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 201 | BaseDiag << std::move(V); | 1611 | 201 | return *this; | 1612 | 201 | } |
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AttributeArgumentNType, void>(clang::AttributeArgumentNType&&) const Line | Count | Source | 1608 | 166 | const ImmediateDiagBuilder &operator<<(T &&V) const { | 1609 | 166 | const DiagnosticBuilder &BaseDiag = *this; | 1610 | 166 | BaseDiag << std::move(V); | 1611 | 166 | return *this; | 1612 | 166 | } |
|
1613 | | }; |
1614 | | |
1615 | | /// A generic diagnostic builder for errors which may or may not be deferred. |
1616 | | /// |
1617 | | /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch) |
1618 | | /// which are not allowed to appear inside __device__ functions and are |
1619 | | /// allowed to appear in __host__ __device__ functions only if the host+device |
1620 | | /// function is never codegen'ed. |
1621 | | /// |
1622 | | /// To handle this, we use the notion of "deferred diagnostics", where we |
1623 | | /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed. |
1624 | | /// |
1625 | | /// This class lets you emit either a regular diagnostic, a deferred |
1626 | | /// diagnostic, or no diagnostic at all, according to an argument you pass to |
1627 | | /// its constructor, thus simplifying the process of creating these "maybe |
1628 | | /// deferred" diagnostics. |
1629 | | class SemaDiagnosticBuilder { |
1630 | | public: |
1631 | | enum Kind { |
1632 | | /// Emit no diagnostics. |
1633 | | K_Nop, |
1634 | | /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()). |
1635 | | K_Immediate, |
1636 | | /// Emit the diagnostic immediately, and, if it's a warning or error, also |
1637 | | /// emit a call stack showing how this function can be reached by an a |
1638 | | /// priori known-emitted function. |
1639 | | K_ImmediateWithCallStack, |
1640 | | /// Create a deferred diagnostic, which is emitted only if the function |
1641 | | /// it's attached to is codegen'ed. Also emit a call stack as with |
1642 | | /// K_ImmediateWithCallStack. |
1643 | | K_Deferred |
1644 | | }; |
1645 | | |
1646 | | SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID, |
1647 | | FunctionDecl *Fn, Sema &S); |
1648 | | SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D); |
1649 | 159k | SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default; |
1650 | | ~SemaDiagnosticBuilder(); |
1651 | | |
1652 | 6.67k | bool isImmediate() const { return ImmediateDiag.hasValue(); } |
1653 | | |
1654 | | /// Convertible to bool: True if we immediately emitted an error, false if |
1655 | | /// we didn't emit an error or we created a deferred error. |
1656 | | /// |
1657 | | /// Example usage: |
1658 | | /// |
1659 | | /// if (SemaDiagnosticBuilder(...) << foo << bar) |
1660 | | /// return ExprError(); |
1661 | | /// |
1662 | | /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably |
1663 | | /// want to use these instead of creating a SemaDiagnosticBuilder yourself. |
1664 | 6.64k | operator bool() const { return isImmediate(); } |
1665 | | |
1666 | | template <typename T> |
1667 | | friend const SemaDiagnosticBuilder & |
1668 | 1.48M | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { |
1669 | 1.48M | if (Diag.ImmediateDiag.hasValue()) |
1670 | 1.48M | *Diag.ImmediateDiag << Value; |
1671 | 547 | else if (Diag.PartialDiagId.hasValue()) |
1672 | 511 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second |
1673 | 511 | << Value; |
1674 | 1.48M | return Diag; |
1675 | 1.48M | } clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ObjCMethodDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ObjCMethodDecl const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::FixItHint>(clang::Sema::SemaDiagnosticBuilder const&, clang::FixItHint const&) Line | Count | Source | 1668 | 31.7k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 31.7k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 31.7k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 31.7k | return Diag; | 1675 | 31.7k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::SmallString<32u> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::SmallString<32u> const&) Line | Count | Source | 1668 | 392 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 392 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 392 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 392 | return Diag; | 1675 | 392 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [17]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [17]) Line | Count | Source | 1668 | 30 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 30 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 30 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 30 | return Diag; | 1675 | 30 | } |
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [46]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [46]) clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [36]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [36]) Line | Count | Source | 1668 | 16 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 16 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 16 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 16 | return Diag; | 1675 | 16 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [45]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [45]) Line | Count | Source | 1668 | 90 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 90 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 90 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 90 | return Diag; | 1675 | 90 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [31]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [31]) Line | Count | Source | 1668 | 12 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 12 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 12 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 12 | return Diag; | 1675 | 12 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [23]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [23]) Line | Count | Source | 1668 | 33 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 33 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 33 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 33 | return Diag; | 1675 | 33 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [24]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [24]) Line | Count | Source | 1668 | 9 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 9 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 9 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 9 | return Diag; | 1675 | 9 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [32]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [32]) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [34]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [34]) Line | Count | Source | 1668 | 42 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 42 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 42 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 42 | return Diag; | 1675 | 42 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [19]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [19]) Line | Count | Source | 1668 | 88 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 88 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 88 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 88 | return Diag; | 1675 | 88 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [29]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [29]) Line | Count | Source | 1668 | 62 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 62 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 62 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 62 | return Diag; | 1675 | 62 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [11]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [11]) Line | Count | Source | 1668 | 28 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 28 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 28 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 28 | return Diag; | 1675 | 28 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [8]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [8]) Line | Count | Source | 1668 | 89 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 89 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 89 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 89 | return Diag; | 1675 | 89 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [54]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [54]) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [39]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [39]) Line | Count | Source | 1668 | 4 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 4 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 4 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 4 | return Diag; | 1675 | 4 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [47]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [47]) Line | Count | Source | 1668 | 5 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 5 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 5 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 5 | return Diag; | 1675 | 5 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [16]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [16]) Line | Count | Source | 1668 | 27 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 27 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 27 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 27 | return Diag; | 1675 | 27 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [22]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [22]) Line | Count | Source | 1668 | 7 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 7 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 7 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 7 | return Diag; | 1675 | 7 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [58]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [58]) Line | Count | Source | 1668 | 230 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 230 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 230 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 230 | return Diag; | 1675 | 230 | } |
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [59]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [59]) clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [6]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [6]) Line | Count | Source | 1668 | 7.25k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 7.25k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 7.24k | *Diag.ImmediateDiag << Value; | 1671 | 17 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 8 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 8 | << Value; | 1674 | 7.25k | return Diag; | 1675 | 7.25k | } |
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [57]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [57]) clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [48]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [48]) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [42]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [42]) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [43]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [43]) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [56]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [56]) Line | Count | Source | 1668 | 17 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 17 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 17 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 17 | return Diag; | 1675 | 17 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [20]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [20]) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [75]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [75]) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [25]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [25]) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [53]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [53]) clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [38]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [38]) Line | Count | Source | 1668 | 12 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 12 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 12 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 12 | return Diag; | 1675 | 12 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [35]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [35]) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [28]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [28]) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [71]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [71]) Line | Count | Source | 1668 | 5 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 5 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 5 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 5 | return Diag; | 1675 | 5 | } |
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [92]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [92]) clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [67]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [67]) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [49]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [49]) Line | Count | Source | 1668 | 5 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 5 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 5 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 5 | return Diag; | 1675 | 5 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [77]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [77]) Line | Count | Source | 1668 | 4 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 4 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 4 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 4 | return Diag; | 1675 | 4 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [150]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [150]) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [69]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [69]) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [87]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [87]) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ValueDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ValueDecl* const&) Line | Count | Source | 1668 | 8.67k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 8.67k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 8.67k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 8.67k | return Diag; | 1675 | 8.67k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(clang::Sema::SemaDiagnosticBuilder const&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > const&) Line | Count | Source | 1668 | 53.8k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 53.8k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 53.7k | *Diag.ImmediateDiag << Value; | 1671 | 102 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 95 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 95 | << Value; | 1674 | 53.8k | return Diag; | 1675 | 53.8k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ValueDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ValueDecl const* const&) Line | Count | Source | 1668 | 11.2k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 11.2k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 11.1k | *Diag.ImmediateDiag << Value; | 1671 | 124 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 114 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 114 | << Value; | 1674 | 11.2k | return Diag; | 1675 | 11.2k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<int>(clang::Sema::SemaDiagnosticBuilder const&, int const&) Line | Count | Source | 1668 | 20.6k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 20.6k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 20.6k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 20.6k | return Diag; | 1675 | 20.6k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::QualType>(clang::Sema::SemaDiagnosticBuilder const&, clang::QualType const&) Line | Count | Source | 1668 | 292k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 292k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 292k | *Diag.ImmediateDiag << Value; | 1671 | 62 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 57 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 57 | << Value; | 1674 | 292k | return Diag; | 1675 | 292k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [7]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [7]) Line | Count | Source | 1668 | 250 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 250 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 250 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 250 | return Diag; | 1675 | 250 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::IdentifierInfo*>(clang::Sema::SemaDiagnosticBuilder const&, clang::IdentifierInfo* const&) Line | Count | Source | 1668 | 69.5k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 69.5k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 69.5k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 69.5k | return Diag; | 1675 | 69.5k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::FunctionDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::FunctionDecl const* const&) Line | Count | Source | 1668 | 25.2k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 25.2k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 25.2k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 25.2k | return Diag; | 1675 | 25.2k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::VarDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::VarDecl const* const&) Line | Count | Source | 1668 | 1.72k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1.72k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1.72k | *Diag.ImmediateDiag << Value; | 1671 | 5 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 5 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 5 | << Value; | 1674 | 1.72k | return Diag; | 1675 | 1.72k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<bool>(clang::Sema::SemaDiagnosticBuilder const&, bool const&) Line | Count | Source | 1668 | 28.9k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 28.9k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 28.9k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 28.9k | return Diag; | 1675 | 28.9k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::SourceRange>(clang::Sema::SemaDiagnosticBuilder const&, clang::SourceRange const&) Line | Count | Source | 1668 | 173k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 173k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 173k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 173k | return Diag; | 1675 | 173k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<unsigned int>(clang::Sema::SemaDiagnosticBuilder const&, unsigned int const&) Line | Count | Source | 1668 | 63.6k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 63.6k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 63.6k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 63.6k | return Diag; | 1675 | 63.6k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [12]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [12]) Line | Count | Source | 1668 | 269 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 269 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 269 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 269 | return Diag; | 1675 | 269 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [5]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [5]) Line | Count | Source | 1668 | 134 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 134 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 134 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 134 | return Diag; | 1675 | 134 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [14]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [14]) Line | Count | Source | 1668 | 31 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 31 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 31 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 31 | return Diag; | 1675 | 31 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [9]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [9]) Line | Count | Source | 1668 | 18.5k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 18.5k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 18.5k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 18.5k | return Diag; | 1675 | 18.5k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NamedDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NamedDecl* const&) Line | Count | Source | 1668 | 153k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 153k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 153k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 153k | return Diag; | 1675 | 153k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ASTContext::SectionInfo>(clang::Sema::SemaDiagnosticBuilder const&, clang::ASTContext::SectionInfo const&) Line | Count | Source | 1668 | 23 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 23 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 23 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 23 | return Diag; | 1675 | 23 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::StringRef>(clang::Sema::SemaDiagnosticBuilder const&, llvm::StringRef const&) Line | Count | Source | 1668 | 43.2k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 43.2k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 43.2k | *Diag.ImmediateDiag << Value; | 1671 | 16 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 16 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 16 | << Value; | 1674 | 43.2k | return Diag; | 1675 | 43.2k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ParsedAttr>(clang::Sema::SemaDiagnosticBuilder const&, clang::ParsedAttr const&) Line | Count | Source | 1668 | 10.5k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 10.5k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 10.5k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 10.5k | return Diag; | 1675 | 10.5k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::IdentifierInfo const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::IdentifierInfo const* const&) Line | Count | Source | 1668 | 231 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 231 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 231 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 231 | return Diag; | 1675 | 231 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::SmallVector<clang::FixItHint, 12u> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::SmallVector<clang::FixItHint, 12u> const&) Line | Count | Source | 1668 | 41.4k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 41.4k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 41.4k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 41.4k | return Diag; | 1675 | 41.4k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<CastType>(clang::Sema::SemaDiagnosticBuilder const&, CastType const&) Line | Count | Source | 1668 | 327 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 327 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 327 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 327 | return Diag; | 1675 | 327 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [37]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [37]) Line | Count | Source | 1668 | 4 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 4 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 4 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 4 | return Diag; | 1675 | 4 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::SmallString<16u> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::SmallString<16u> const&) Line | Count | Source | 1668 | 227 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 227 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 227 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 227 | return Diag; | 1675 | 227 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::ArrayRef<clang::FixItHint> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::ArrayRef<clang::FixItHint> const&) Line | Count | Source | 1668 | 5.43k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 5.43k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 5.43k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 5.43k | return Diag; | 1675 | 5.43k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CharSourceRange>(clang::Sema::SemaDiagnosticBuilder const&, clang::CharSourceRange const&) Line | Count | Source | 1668 | 5.33k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 5.33k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 5.33k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 5.33k | return Diag; | 1675 | 5.33k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<AbsoluteValueKind>(clang::Sema::SemaDiagnosticBuilder const&, AbsoluteValueKind const&) Line | Count | Source | 1668 | 768 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 768 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 768 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 768 | return Diag; | 1675 | 768 | } |
SemaChecking.cpp:clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_10>(clang::Sema::SemaDiagnosticBuilder const&, clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_10 const&) Line | Count | Source | 1668 | 236 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 236 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 236 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 236 | return Diag; | 1675 | 236 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ConceptSpecializationExpr*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ConceptSpecializationExpr* const&) Line | Count | Source | 1668 | 34 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 34 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 34 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 34 | return Diag; | 1675 | 34 | } |
SemaCoroutine.cpp:clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag>(clang::Sema::SemaDiagnosticBuilder const&, isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag const&) Line | Count | Source | 1668 | 9 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 9 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 9 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 9 | return Diag; | 1675 | 9 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::LabelDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::LabelDecl* const&) Line | Count | Source | 1668 | 358 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 358 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 358 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 358 | return Diag; | 1675 | 358 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AlignedAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::AlignedAttr const* const&) Line | Count | Source | 1668 | 8 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 8 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 8 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 8 | return Diag; | 1675 | 8 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AlignedAttr*>(clang::Sema::SemaDiagnosticBuilder const&, clang::AlignedAttr* const&) Line | Count | Source | 1668 | 27 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 27 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 27 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 27 | return Diag; | 1675 | 27 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::DLLImportAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::DLLImportAttr const* const&) Line | Count | Source | 1668 | 511 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 511 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 511 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 511 | return Diag; | 1675 | 511 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NotTailCalledAttr*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NotTailCalledAttr* const&) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Attr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::Attr const* const&) Line | Count | Source | 1668 | 5 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 5 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 5 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 5 | return Diag; | 1675 | 5 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CXXRecordDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CXXRecordDecl const* const&) Line | Count | Source | 1668 | 176 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 176 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 176 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 176 | return Diag; | 1675 | 176 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::FieldDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::FieldDecl const* const&) Line | Count | Source | 1668 | 146 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 146 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 146 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 146 | return Diag; | 1675 | 146 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char const*>(clang::Sema::SemaDiagnosticBuilder const&, char const* const&) Line | Count | Source | 1668 | 3.61k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3.61k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3.61k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3.61k | return Diag; | 1675 | 3.61k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AnyX86NoCallerSavedRegistersAttr*>(clang::Sema::SemaDiagnosticBuilder const&, clang::AnyX86NoCallerSavedRegistersAttr* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::VarDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::VarDecl* const&) Line | Count | Source | 1668 | 6.74k | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 6.74k | if (Diag.ImmediateDiag.hasValue()) | 1670 | 6.74k | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 6.74k | return Diag; | 1675 | 6.74k | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::TypedefNameDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::TypedefNameDecl* const&) Line | Count | Source | 1668 | 78 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 78 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 78 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 78 | return Diag; | 1675 | 78 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::TemplateName>(clang::Sema::SemaDiagnosticBuilder const&, clang::TemplateName const&) Line | Count | Source | 1668 | 356 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 356 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 356 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 356 | return Diag; | 1675 | 356 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::InheritableAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::InheritableAttr const* const&) Line | Count | Source | 1668 | 431 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 431 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 431 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 431 | return Diag; | 1675 | 431 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<ShadowedDeclKind>(clang::Sema::SemaDiagnosticBuilder const&, ShadowedDeclKind const&) Line | Count | Source | 1668 | 138 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 138 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 138 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 138 | return Diag; | 1675 | 138 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::DeclContext const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::DeclContext const* const&) Line | Count | Source | 1668 | 52 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 52 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 52 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 52 | return Diag; | 1675 | 52 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::StorageClass>(clang::Sema::SemaDiagnosticBuilder const&, clang::StorageClass const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Sema::NonTrivialCUnionContext>(clang::Sema::SemaDiagnosticBuilder const&, clang::Sema::NonTrivialCUnionContext const&) Line | Count | Source | 1668 | 81 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 81 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 81 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 81 | return Diag; | 1675 | 81 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [1]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [1]) Line | Count | Source | 1668 | 104 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 104 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 104 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 104 | return Diag; | 1675 | 104 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::SmallVector<clang::FixItHint, 1u> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::SmallVector<clang::FixItHint, 1u> const&) Line | Count | Source | 1668 | 17 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 17 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 17 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 17 | return Diag; | 1675 | 17 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::UsedAttr*>(clang::Sema::SemaDiagnosticBuilder const&, clang::UsedAttr* const&) Line | Count | Source | 1668 | 4 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 4 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 4 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 4 | return Diag; | 1675 | 4 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ParmVarDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ParmVarDecl* const&) Line | Count | Source | 1668 | 4 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 4 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 4 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 4 | return Diag; | 1675 | 4 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ParmVarDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ParmVarDecl const* const&) Line | Count | Source | 1668 | 76 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 76 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 76 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 76 | return Diag; | 1675 | 76 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::TypedefDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::TypedefDecl* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::TagTypeKind>(clang::Sema::SemaDiagnosticBuilder const&, clang::TagTypeKind const&) Line | Count | Source | 1668 | 76 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 76 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 76 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 76 | return Diag; | 1675 | 76 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Sema::NonTagKind>(clang::Sema::SemaDiagnosticBuilder const&, clang::Sema::NonTagKind const&) Line | Count | Source | 1668 | 28 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 28 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 28 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 28 | return Diag; | 1675 | 28 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::TagDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::TagDecl* const&) Line | Count | Source | 1668 | 9 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 9 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 9 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 9 | return Diag; | 1675 | 9 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Sema::CXXSpecialMember>(clang::Sema::SemaDiagnosticBuilder const&, clang::Sema::CXXSpecialMember const&) Line | Count | Source | 1668 | 587 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 587 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 587 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 587 | return Diag; | 1675 | 587 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::RecordDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::RecordDecl* const&) Line | Count | Source | 1668 | 21 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 21 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 21 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 21 | return Diag; | 1675 | 21 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::EnumConstantDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::EnumConstantDecl* const&) Line | Count | Source | 1668 | 25 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 25 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 25 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 25 | return Diag; | 1675 | 25 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::EnumDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::EnumDecl* const&) Line | Count | Source | 1668 | 46 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 46 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 46 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 46 | return Diag; | 1675 | 46 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Mips16Attr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::Mips16Attr const* const&) Line | Count | Source | 1668 | 4 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 4 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 4 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 4 | return Diag; | 1675 | 4 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::MicroMipsAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::MicroMipsAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::MipsInterruptAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::MipsInterruptAttr const* const&) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::MipsShortCallAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::MipsShortCallAttr const* const&) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::MipsLongCallAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::MipsLongCallAttr const* const&) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NotTailCalledAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NotTailCalledAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDASharedAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDASharedAttr const* const&) Line | Count | Source | 1668 | 6 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 6 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 6 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 6 | return Diag; | 1675 | 6 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::HIPManagedAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::HIPManagedAttr const* const&) Line | Count | Source | 1668 | 8 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 8 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 8 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 8 | return Diag; | 1675 | 8 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDADeviceAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDADeviceAttr const* const&) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDAHostAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDAHostAttr const* const&) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDAGlobalAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDAGlobalAttr const* const&) Line | Count | Source | 1668 | 4 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 4 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 4 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 4 | return Diag; | 1675 | 4 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDAConstantAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDAConstantAttr const* const&) Line | Count | Source | 1668 | 8 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 8 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 8 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 8 | return Diag; | 1675 | 8 | } |
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDADeviceBuiltinTextureTypeAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDADeviceBuiltinTextureTypeAttr const* const&) Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDADeviceBuiltinSurfaceTypeAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDADeviceBuiltinSurfaceTypeAttr const* const&) clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::OwnershipAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::OwnershipAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::HotAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::HotAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ColdAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ColdAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::DisableTailCallsAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::DisableTailCallsAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::VecReturnAttr*>(clang::Sema::SemaDiagnosticBuilder const&, clang::VecReturnAttr* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CFUnknownTransferAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CFUnknownTransferAttr const* const&) Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CFAuditedTransferAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CFAuditedTransferAttr const* const&) clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AttributeDeclKind>(clang::Sema::SemaDiagnosticBuilder const&, clang::AttributeDeclKind const&) Line | Count | Source | 1668 | 2 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 2 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 2 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 2 | return Diag; | 1675 | 2 | } |
SemaDeclAttr.cpp:clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<handleXReturnsXRetainedAttr(clang::Sema&, clang::Decl*, clang::ParsedAttr const&)::$_3>(clang::Sema::SemaDiagnosticBuilder const&, handleXReturnsXRetainedAttr(clang::Sema&, clang::Decl*, clang::ParsedAttr const&)::$_3 const&) Line | Count | Source | 1668 | 13 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 13 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 13 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 13 | return Diag; | 1675 | 13 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NoSpeculativeLoadHardeningAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NoSpeculativeLoadHardeningAttr const* const&) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::SpeculativeLoadHardeningAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::SpeculativeLoadHardeningAttr const* const&) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AlwaysInlineAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::AlwaysInlineAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NakedAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NakedAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 1 | return Diag; | 1675 | 1 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::OwnerAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::OwnerAttr const* const&) Line | Count | Source | 1668 | 3 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 3 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 3 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | 1673 | 0 | << Value; | 1674 | 3 | return Diag; | 1675 | 3 | } |
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::PointerAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::PointerAttr const* const&) Line | Count | Source | 1668 | 1 | operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { | 1669 | 1 | if (Diag.ImmediateDiag.hasValue()) | 1670 | 1 | *Diag.ImmediateDiag << Value; | 1671 | 0 | else if (Diag.PartialDiagId.hasValue()) | 1672 | 0 | Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second | |
|