Coverage Report

Created: 2021-08-24 07:12

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