Coverage Report

Created: 2022-05-17 06:19

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