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