Coverage Report

Created: 2021-01-23 06:44

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