Coverage Report

Created: 2022-01-18 06:27

/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
37.5k
  FileNullability &operator[](FileID file) {
275
    // Check the single-element cache.
276
37.5k
    if (file == Cache.File)
277
34.3k
      return Cache.Nullability;
278
279
    // It's not in the single-element cache; flush the cache if we have one.
280
3.20k
    if (!Cache.File.isInvalid()) {
281
1.64k
      Map[Cache.File] = Cache.Nullability;
282
1.64k
    }
283
284
    // Pull this entry into the cache.
285
3.20k
    Cache.File = file;
286
3.20k
    Cache.Nullability = Map[file];
287
3.20k
    return Cache.Nullability;
288
37.5k
  }
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
85.3k
  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
82.0k
  QualType get(SourceLocation Tok) const {
333
82.0k
    if (!Enabled || 
Tok != ExpectedLoc744
)
334
81.5k
      return QualType();
335
506
    if (!Type.isNull())
336
255
      return Type;
337
251
    if (ComputeType)
338
232
      return ComputeType();
339
19
    return QualType();
340
251
  }
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
186k
                                    const NamedDecl *New) {
373
186k
    if (isVisible(Old))
374
186k
     return true;
375
    // See comment in below overload for why it's safe to compute the linkage
376
    // of the new declaration here.
377
164
    if (New->isExternallyDeclarable()) {
378
163
      assert(Old->isExternallyDeclarable() &&
379
163
             "should not have found a non-externally-declarable previous decl");
380
0
      return true;
381
163
    }
382
1
    return false;
383
164
  }
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
254k
        : PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) {
497
254k
      assert(Num == PackNumber && "The pack number has been truncated.");
498
254k
    }
499
500
    // #pragma align info constructor
501
    AlignPackInfo(AlignPackInfo::Mode M, bool IsXL)
502
        : PackAttr(false), AlignMode(M),
503
92.1k
          PackNumber(M == Packed ? 1 : UninitPackVal), XLStack(IsXL) {}
504
505
85.4k
    explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {}
Unexecuted instantiation: clang::Sema::AlignPackInfo::AlignPackInfo(bool)
clang::Sema::AlignPackInfo::AlignPackInfo(bool)
Line
Count
Source
505
85.4k
    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.43k
    static uint32_t getRawEncoding(const AlignPackInfo &Info) {
513
3.43k
      std::uint32_t Encoding{};
514
3.43k
      if (Info.IsXLStack())
515
20
        Encoding |= IsXLMask;
516
517
3.43k
      Encoding |= static_cast<uint32_t>(Info.getAlignMode()) << 1;
518
519
3.43k
      if (Info.IsPackAttr())
520
14
        Encoding |= PackAttrMask;
521
522
3.43k
      Encoding |= static_cast<uint32_t>(Info.getPackNumber()) << 4;
523
524
3.43k
      return Encoding;
525
3.43k
    }
526
527
3.95k
    static AlignPackInfo getFromRawEncoding(unsigned Encoding) {
528
3.95k
      bool IsXL = static_cast<bool>(Encoding & IsXLMask);
529
3.95k
      AlignPackInfo::Mode M =
530
3.95k
          static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> 1);
531
3.95k
      int PackNumber = (Encoding & PackNumMask) >> 4;
532
533
3.95k
      if (Encoding & PackAttrMask)
534
14
        return AlignPackInfo(M, PackNumber, IsXL);
535
536
3.93k
      return AlignPackInfo(M, IsXL);
537
3.95k
    }
538
539
3.58k
    bool IsPackAttr() const { return PackAttr; }
540
541
280
    bool IsAlignAttr() const { return !PackAttr; }
542
543
1.33M
    Mode getAlignMode() const { return AlignMode; }
544
545
239k
    unsigned getPackNumber() const { return PackNumber; }
546
547
1.08M
    bool IsPackSet() const {
548
      // #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack
549
      // attriute on a decl.
550
1.08M
      return PackNumber != UninitPackVal && 
PackNumber != 0235k
;
551
1.08M
    }
552
553
257k
    bool IsXLStack() const { return XLStack; }
554
555
1.76M
    bool operator==(const AlignPackInfo &Info) const {
556
1.76M
      return std::tie(AlignMode, PackNumber, PackAttr, XLStack) ==
557
1.76M
             std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr,
558
1.76M
                      Info.XLStack);
559
1.76M
    }
560
561
1.76M
    bool operator!=(const AlignPackInfo &Info) const {
562
1.76M
      return !(*this == Info);
563
1.76M
    }
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.39M
            PragmaPushLocation(PragmaPushLocation) {}
clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::Slot::Slot(llvm::StringRef, clang::Sema::AlignPackInfo, clang::SourceLocation, clang::SourceLocation)
Line
Count
Source
600
126k
            PragmaPushLocation(PragmaPushLocation) {}
clang::Sema::PragmaStack<clang::FPOptionsOverride>::Slot::Slot(llvm::StringRef, clang::FPOptionsOverride, clang::SourceLocation, clang::SourceLocation)
Line
Count
Source
600
51
            PragmaPushLocation(PragmaPushLocation) {}
clang::Sema::PragmaStack<clang::MSVtorDispMode>::Slot::Slot(llvm::StringRef, clang::MSVtorDispMode, clang::SourceLocation, clang::SourceLocation)
Line
Count
Source
600
653k
            PragmaPushLocation(PragmaPushLocation) {}
clang::Sema::PragmaStack<clang::StringLiteral*>::Slot::Slot(llvm::StringRef, clang::StringLiteral*, clang::SourceLocation, clang::SourceLocation)
Line
Count
Source
600
2.61M
            PragmaPushLocation(PragmaPushLocation) {}
601
    };
602
603
    void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action,
604
6.53M
             llvm::StringRef StackSlotLabel, ValueType Value) {
605
6.53M
      if (Action == PSK_Reset) {
606
7
        CurrentValue = DefaultValue;
607
7
        CurrentPragmaLocation = PragmaLocation;
608
7
        return;
609
7
      }
610
6.53M
      if (Action & PSK_Push)
611
3.26M
        Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
612
3.26M
                           PragmaLocation);
613
3.26M
      else if (Action & PSK_Pop) {
614
3.26M
        if (!StackSlotLabel.empty()) {
615
          // If we've got a label, try to find it and jump there.
616
3.26M
          auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
617
3.26M
            return x.StackSlotLabel == StackSlotLabel;
618
3.26M
          });
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
653k
          auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
617
653k
            return x.StackSlotLabel == StackSlotLabel;
618
653k
          });
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.61M
          auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
617
2.61M
            return x.StackSlotLabel == StackSlotLabel;
618
2.61M
          });
619
          // If we found the label so pop from there.
620
3.26M
          if (I != Stack.rend()) {
621
3.26M
            CurrentValue = I->Value;
622
3.26M
            CurrentPragmaLocation = I->PragmaLocation;
623
3.26M
            Stack.erase(std::prev(I.base()), Stack.end());
624
3.26M
          }
625
3.26M
        } else 
if (74
!Stack.empty()74
) {
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
3.26M
      }
632
6.53M
      if (Action & PSK_Set) {
633
421
        CurrentValue = Value;
634
421
        CurrentPragmaLocation = PragmaLocation;
635
421
      }
636
6.53M
    }
clang::Sema::PragmaStack<clang::FPOptionsOverride>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::FPOptionsOverride)
Line
Count
Source
604
403
             llvm::StringRef StackSlotLabel, ValueType Value) {
605
403
      if (Action == PSK_Reset) {
606
0
        CurrentValue = DefaultValue;
607
0
        CurrentPragmaLocation = PragmaLocation;
608
0
        return;
609
0
      }
610
403
      if (Action & PSK_Push)
611
49
        Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
612
49
                           PragmaLocation);
613
354
      else if (Action & PSK_Pop) {
614
48
        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
48
        } else if (!Stack.empty()) {
626
          // We do not have a label, just pop the last entry.
627
48
          CurrentValue = Stack.back().Value;
628
48
          CurrentPragmaLocation = Stack.back().PragmaLocation;
629
48
          Stack.pop_back();
630
48
        }
631
48
      }
632
403
      if (Action & PSK_Set) {
633
355
        CurrentValue = Value;
634
355
        CurrentPragmaLocation = PragmaLocation;
635
355
      }
636
403
    }
clang::Sema::PragmaStack<clang::MSVtorDispMode>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::MSVtorDispMode)
Line
Count
Source
604
1.30M
             llvm::StringRef StackSlotLabel, ValueType Value) {
605
1.30M
      if (Action == PSK_Reset) {
606
3
        CurrentValue = DefaultValue;
607
3
        CurrentPragmaLocation = PragmaLocation;
608
3
        return;
609
3
      }
610
1.30M
      if (Action & PSK_Push)
611
653k
        Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
612
653k
                           PragmaLocation);
613
653k
      else if (Action & PSK_Pop) {
614
653k
        if (!StackSlotLabel.empty()) {
615
          // If we've got a label, try to find it and jump there.
616
653k
          auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
617
653k
            return x.StackSlotLabel == StackSlotLabel;
618
653k
          });
619
          // If we found the label so pop from there.
620
653k
          if (I != Stack.rend()) {
621
653k
            CurrentValue = I->Value;
622
653k
            CurrentPragmaLocation = I->PragmaLocation;
623
653k
            Stack.erase(std::prev(I.base()), Stack.end());
624
653k
          }
625
653k
        } 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
653k
      }
632
1.30M
      if (Action & PSK_Set) {
633
22
        CurrentValue = Value;
634
22
        CurrentPragmaLocation = PragmaLocation;
635
22
      }
636
1.30M
    }
clang::Sema::PragmaStack<clang::StringLiteral*>::Act(clang::SourceLocation, clang::Sema::PragmaMsStackAction, llvm::StringRef, clang::StringLiteral*)
Line
Count
Source
604
5.22M
             llvm::StringRef StackSlotLabel, ValueType Value) {
605
5.22M
      if (Action == PSK_Reset) {
606
4
        CurrentValue = DefaultValue;
607
4
        CurrentPragmaLocation = PragmaLocation;
608
4
        return;
609
4
      }
610
5.22M
      if (Action & PSK_Push)
611
2.61M
        Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
612
2.61M
                           PragmaLocation);
613
2.61M
      else if (Action & PSK_Pop) {
614
2.61M
        if (!StackSlotLabel.empty()) {
615
          // If we've got a label, try to find it and jump there.
616
2.61M
          auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
617
2.61M
            return x.StackSlotLabel == StackSlotLabel;
618
2.61M
          });
619
          // If we found the label so pop from there.
620
2.61M
          if (I != Stack.rend()) {
621
2.61M
            CurrentValue = I->Value;
622
2.61M
            CurrentPragmaLocation = I->PragmaLocation;
623
2.61M
            Stack.erase(std::prev(I.base()), Stack.end());
624
2.61M
          }
625
2.61M
        } 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.61M
      }
632
5.22M
      if (Action & PSK_Set) {
633
44
        CurrentValue = Value;
634
44
        CurrentPragmaLocation = PragmaLocation;
635
44
      }
636
5.22M
    }
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.53M
    void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
653
6.53M
      assert((Action == PSK_Push || Action == PSK_Pop) &&
654
6.53M
             "Can only push / pop #pragma stack sentinels!");
655
0
      Act(CurrentPragmaLocation, Action, Label, CurrentValue);
656
6.53M
    }
clang::Sema::PragmaStack<clang::MSVtorDispMode>::SentinelAction(clang::Sema::PragmaMsStackAction, llvm::StringRef)
Line
Count
Source
652
1.30M
    void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
653
1.30M
      assert((Action == PSK_Push || Action == PSK_Pop) &&
654
1.30M
             "Can only push / pop #pragma stack sentinels!");
655
0
      Act(CurrentPragmaLocation, Action, Label, CurrentValue);
656
1.30M
    }
clang::Sema::PragmaStack<clang::StringLiteral*>::SentinelAction(clang::Sema::PragmaMsStackAction, llvm::StringRef)
Line
Count
Source
652
5.22M
    void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
653
5.22M
      assert((Action == PSK_Push || Action == PSK_Pop) &&
654
5.22M
             "Can only push / pop #pragma stack sentinels!");
655
0
      Act(CurrentPragmaLocation, Action, Label, CurrentValue);
656
5.22M
    }
657
658
    // Constructors.
659
    explicit PragmaStack(const ValueType &Default)
660
598k
        : DefaultValue(Default), CurrentValue(Default) {}
clang::Sema::PragmaStack<clang::MSVtorDispMode>::PragmaStack(clang::MSVtorDispMode const&)
Line
Count
Source
660
85.4k
        : DefaultValue(Default), CurrentValue(Default) {}
clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::PragmaStack(clang::Sema::AlignPackInfo const&)
Line
Count
Source
660
85.4k
        : DefaultValue(Default), CurrentValue(Default) {}
clang::Sema::PragmaStack<clang::StringLiteral*>::PragmaStack(clang::StringLiteral* const&)
Line
Count
Source
660
341k
        : DefaultValue(Default), CurrentValue(Default) {}
clang::Sema::PragmaStack<clang::FPOptionsOverride>::PragmaStack(clang::FPOptionsOverride const&)
Line
Count
Source
660
85.4k
        : DefaultValue(Default), CurrentValue(Default) {}
661
662
39.7M
    bool hasValue() const { return CurrentValue != DefaultValue; }
clang::Sema::PragmaStack<clang::FPOptionsOverride>::hasValue() const
Line
Count
Source
662
38.6M
    bool hasValue() const { return CurrentValue != DefaultValue; }
clang::Sema::PragmaStack<clang::Sema::AlignPackInfo>::hasValue() const
Line
Count
Source
662
1.17M
    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.6M
  FPOptionsOverride CurFPFeatureOverrides() {
698
38.6M
    FPOptionsOverride result;
699
38.6M
    if (!FpPragmaStack.hasValue()) {
700
38.1M
      result = FPOptionsOverride();
701
38.1M
    } else {
702
443k
      result = FpPragmaStack.CurrentValue;
703
443k
    }
704
38.6M
    return result;
705
38.6M
  }
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
  /// VisContext - Manages the stack for \#pragma GCC visibility.
728
  void *VisContext; // Really a "PragmaVisStack*"
729
730
  /// This an attribute introduced by \#pragma clang attribute.
731
  struct PragmaAttributeEntry {
732
    SourceLocation Loc;
733
    ParsedAttr *Attribute;
734
    SmallVector<attr::SubjectMatchRule, 4> MatchRules;
735
    bool IsUsed;
736
  };
737
738
  /// A push'd group of PragmaAttributeEntries.
739
  struct PragmaAttributeGroup {
740
    /// The location of the push attribute.
741
    SourceLocation Loc;
742
    /// The namespace of this push group.
743
    const IdentifierInfo *Namespace;
744
    SmallVector<PragmaAttributeEntry, 2> Entries;
745
  };
746
747
  SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack;
748
749
  /// The declaration that is currently receiving an attribute from the
750
  /// #pragma attribute stack.
751
  const Decl *PragmaAttributeCurrentTargetDecl;
752
753
  /// This represents the last location of a "#pragma clang optimize off"
754
  /// directive if such a directive has not been closed by an "on" yet. If
755
  /// optimizations are currently "on", this is set to an invalid location.
756
  SourceLocation OptimizeOffPragmaLocation;
757
758
  /// Flag indicating if Sema is building a recovery call expression.
759
  ///
760
  /// This flag is used to avoid building recovery call expressions
761
  /// if Sema is already doing so, which would cause infinite recursions.
762
  bool IsBuildingRecoveryCallExpr;
763
764
  /// Used to control the generation of ExprWithCleanups.
765
  CleanupInfo Cleanup;
766
767
  /// ExprCleanupObjects - This is the stack of objects requiring
768
  /// cleanup that are created by the current full expression.
769
  SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects;
770
771
  /// Store a set of either DeclRefExprs or MemberExprs that contain a reference
772
  /// to a variable (constant) that may or may not be odr-used in this Expr, and
773
  /// we won't know until all lvalue-to-rvalue and discarded value conversions
774
  /// have been applied to all subexpressions of the enclosing full expression.
775
  /// This is cleared at the end of each full expression.
776
  using MaybeODRUseExprSet = llvm::SetVector<Expr *, SmallVector<Expr *, 4>,
777
                                             llvm::SmallPtrSet<Expr *, 4>>;
778
  MaybeODRUseExprSet MaybeODRUseExprs;
779
780
  std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope;
781
782
  /// Stack containing information about each of the nested
783
  /// function, block, and method scopes that are currently active.
784
  SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
785
786
  /// The index of the first FunctionScope that corresponds to the current
787
  /// context.
788
  unsigned FunctionScopesStart = 0;
789
790
350k
  ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const {
791
350k
    return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart,
792
350k
                              FunctionScopes.end());
793
350k
  }
794
795
  /// Stack containing information needed when in C++2a an 'auto' is encountered
796
  /// in a function declaration parameter type specifier in order to invent a
797
  /// corresponding template parameter in the enclosing abbreviated function
798
  /// template. This information is also present in LambdaScopeInfo, stored in
799
  /// the FunctionScopes stack.
800
  SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos;
801
802
  /// The index of the first InventedParameterInfo that refers to the current
803
  /// context.
804
  unsigned InventedParameterInfosStart = 0;
805
806
350k
  ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const {
807
350k
    return llvm::makeArrayRef(InventedParameterInfos.begin() +
808
350k
                                  InventedParameterInfosStart,
809
350k
                              InventedParameterInfos.end());
810
350k
  }
811
812
  typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
813
                     &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
814
    ExtVectorDeclsType;
815
816
  /// ExtVectorDecls - This is a list all the extended vector types. This allows
817
  /// us to associate a raw vector type with one of the ext_vector type names.
818
  /// This is only necessary for issuing pretty diagnostics.
819
  ExtVectorDeclsType ExtVectorDecls;
820
821
  /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
822
  std::unique_ptr<CXXFieldCollector> FieldCollector;
823
824
  typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;
825
826
  /// Set containing all declared private fields that are not used.
827
  NamedDeclSetType UnusedPrivateFields;
828
829
  /// Set containing all typedefs that are likely unused.
830
  llvm::SmallSetVector<const TypedefNameDecl *, 4>
831
      UnusedLocalTypedefNameCandidates;
832
833
  /// Delete-expressions to be analyzed at the end of translation unit
834
  ///
835
  /// This list contains class members, and locations of delete-expressions
836
  /// that could not be proven as to whether they mismatch with new-expression
837
  /// used in initializer of the field.
838
  typedef std::pair<SourceLocation, bool> DeleteExprLoc;
839
  typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;
840
  llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
841
842
  typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
843
844
  /// PureVirtualClassDiagSet - a set of class declarations which we have
845
  /// emitted a list of pure virtual functions. Used to prevent emitting the
846
  /// same list more than once.
847
  std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
848
849
  /// ParsingInitForAutoVars - a set of declarations with auto types for which
850
  /// we are currently parsing the initializer.
851
  llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
852
853
  /// Look for a locally scoped extern "C" declaration by the given name.
854
  NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
855
856
  typedef LazyVector<VarDecl *, ExternalSemaSource,
857
                     &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
858
    TentativeDefinitionsType;
859
860
  /// All the tentative definitions encountered in the TU.
861
  TentativeDefinitionsType TentativeDefinitions;
862
863
  /// All the external declarations encoutered and used in the TU.
864
  SmallVector<VarDecl *, 4> ExternalDeclarations;
865
866
  typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
867
                     &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
868
    UnusedFileScopedDeclsType;
869
870
  /// The set of file scoped decls seen so far that have not been used
871
  /// and must warn if not used. Only contains the first declaration.
872
  UnusedFileScopedDeclsType UnusedFileScopedDecls;
873
874
  typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
875
                     &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
876
    DelegatingCtorDeclsType;
877
878
  /// All the delegating constructors seen so far in the file, used for
879
  /// cycle detection at the end of the TU.
880
  DelegatingCtorDeclsType DelegatingCtorDecls;
881
882
  /// All the overriding functions seen during a class definition
883
  /// that had their exception spec checks delayed, plus the overridden
884
  /// function.
885
  SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2>
886
    DelayedOverridingExceptionSpecChecks;
887
888
  /// All the function redeclarations seen during a class definition that had
889
  /// their exception spec checks delayed, plus the prior declaration they
890
  /// should be checked against. Except during error recovery, the new decl
891
  /// should always be a friend declaration, as that's the only valid way to
892
  /// redeclare a special member before its class is complete.
893
  SmallVector<std::pair<FunctionDecl*, FunctionDecl*>, 2>
894
    DelayedEquivalentExceptionSpecChecks;
895
896
  typedef llvm::MapVector<const FunctionDecl *,
897
                          std::unique_ptr<LateParsedTemplate>>
898
      LateParsedTemplateMapT;
899
  LateParsedTemplateMapT LateParsedTemplateMap;
900
901
  /// Callback to the parser to parse templated functions when needed.
902
  typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
903
  typedef void LateTemplateParserCleanupCB(void *P);
904
  LateTemplateParserCB *LateTemplateParser;
905
  LateTemplateParserCleanupCB *LateTemplateParserCleanup;
906
  void *OpaqueParser;
907
908
  void SetLateTemplateParser(LateTemplateParserCB *LTP,
909
                             LateTemplateParserCleanupCB *LTPCleanup,
910
85.3k
                             void *P) {
911
85.3k
    LateTemplateParser = LTP;
912
85.3k
    LateTemplateParserCleanup = LTPCleanup;
913
85.3k
    OpaqueParser = P;
914
85.3k
  }
915
916
  class DelayedDiagnostics;
917
918
  class DelayedDiagnosticsState {
919
    sema::DelayedDiagnosticPool *SavedPool;
920
    friend class Sema::DelayedDiagnostics;
921
  };
922
  typedef DelayedDiagnosticsState ParsingDeclState;
923
  typedef DelayedDiagnosticsState ProcessingContextState;
924
925
  /// A class which encapsulates the logic for delaying diagnostics
926
  /// during parsing and other processing.
927
  class DelayedDiagnostics {
928
    /// The current pool of diagnostics into which delayed
929
    /// diagnostics should go.
930
    sema::DelayedDiagnosticPool *CurPool;
931
932
  public:
933
85.4k
    DelayedDiagnostics() : CurPool(nullptr) {}
934
935
    /// Adds a delayed diagnostic.
936
    void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
937
938
    /// Determines whether diagnostics should be delayed.
939
1.72M
    bool shouldDelayDiagnostics() { return CurPool != nullptr; }
940
941
    /// Returns the current delayed-diagnostics pool.
942
166M
    sema::DelayedDiagnosticPool *getCurrentPool() const {
943
166M
      return CurPool;
944
166M
    }
945
946
    /// Enter a new scope.  Access and deprecation diagnostics will be
947
    /// collected in this pool.
948
83.3M
    DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
949
83.3M
      DelayedDiagnosticsState state;
950
83.3M
      state.SavedPool = CurPool;
951
83.3M
      CurPool = &pool;
952
83.3M
      return state;
953
83.3M
    }
954
955
    /// Leave a delayed-diagnostic state that was previously pushed.
956
    /// Do not emit any of the diagnostics.  This is performed as part
957
    /// of the bookkeeping of popping a pool "properly".
958
83.3M
    void popWithoutEmitting(DelayedDiagnosticsState state) {
959
83.3M
      CurPool = state.SavedPool;
960
83.3M
    }
961
962
    /// Enter a new scope where access and deprecation diagnostics are
963
    /// not delayed.
964
6.10M
    DelayedDiagnosticsState pushUndelayed() {
965
6.10M
      DelayedDiagnosticsState state;
966
6.10M
      state.SavedPool = CurPool;
967
6.10M
      CurPool = nullptr;
968
6.10M
      return state;
969
6.10M
    }
970
971
    /// Undo a previous pushUndelayed().
972
6.10M
    void popUndelayed(DelayedDiagnosticsState state) {
973
6.10M
      assert(CurPool == nullptr);
974
0
      CurPool = state.SavedPool;
975
6.10M
    }
976
  } DelayedDiagnostics;
977
978
  /// A RAII object to temporarily push a declaration context.
979
  class ContextRAII {
980
  private:
981
    Sema &S;
982
    DeclContext *SavedContext;
983
    ProcessingContextState SavedContextState;
984
    QualType SavedCXXThisTypeOverride;
985
    unsigned SavedFunctionScopesStart;
986
    unsigned SavedInventedParameterInfosStart;
987
988
  public:
989
    ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)
990
      : S(S), SavedContext(S.CurContext),
991
        SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
992
        SavedCXXThisTypeOverride(S.CXXThisTypeOverride),
993
        SavedFunctionScopesStart(S.FunctionScopesStart),
994
        SavedInventedParameterInfosStart(S.InventedParameterInfosStart)
995
5.42M
    {
996
5.42M
      assert(ContextToPush && "pushing null context");
997
0
      S.CurContext = ContextToPush;
998
5.42M
      if (NewThisContext)
999
5.41M
        S.CXXThisTypeOverride = QualType();
1000
      // Any saved FunctionScopes do not refer to this context.
1001
5.42M
      S.FunctionScopesStart = S.FunctionScopes.size();
1002
5.42M
      S.InventedParameterInfosStart = S.InventedParameterInfos.size();
1003
5.42M
    }
1004
1005
6.38M
    void pop() {
1006
6.38M
      if (!SavedContext) 
return962k
;
1007
5.42M
      S.CurContext = SavedContext;
1008
5.42M
      S.DelayedDiagnostics.popUndelayed(SavedContextState);
1009
5.42M
      S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
1010
5.42M
      S.FunctionScopesStart = SavedFunctionScopesStart;
1011
5.42M
      S.InventedParameterInfosStart = SavedInventedParameterInfosStart;
1012
5.42M
      SavedContext = nullptr;
1013
5.42M
    }
1014
1015
5.42M
    ~ContextRAII() {
1016
5.42M
      pop();
1017
5.42M
    }
1018
  };
1019
1020
  /// Whether the AST is currently being rebuilt to correct immediate
1021
  /// invocations. Immediate invocation candidates and references to consteval
1022
  /// functions aren't tracked when this is set.
1023
  bool RebuildingImmediateInvocation = false;
1024
1025
  /// Used to change context to isConstantEvaluated without pushing a heavy
1026
  /// ExpressionEvaluationContextRecord object.
1027
  bool isConstantEvaluatedOverride;
1028
1029
12.0M
  bool isConstantEvaluated() {
1030
12.0M
    return ExprEvalContexts.back().isConstantEvaluated() ||
1031
12.0M
           
isConstantEvaluatedOverride11.5M
;
1032
12.0M
  }
1033
1034
  /// RAII object to handle the state changes required to synthesize
1035
  /// a function body.
1036
  class SynthesizedFunctionScope {
1037
    Sema &S;
1038
    Sema::ContextRAII SavedContext;
1039
    bool PushedCodeSynthesisContext = false;
1040
1041
  public:
1042
    SynthesizedFunctionScope(Sema &S, DeclContext *DC)
1043
79.7k
        : S(S), SavedContext(S, DC) {
1044
79.7k
      S.PushFunctionScope();
1045
79.7k
      S.PushExpressionEvaluationContext(
1046
79.7k
          Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1047
79.7k
      if (auto *FD = dyn_cast<FunctionDecl>(DC))
1048
79.6k
        FD->setWillHaveBody(true);
1049
78
      else
1050
78
        assert(isa<ObjCMethodDecl>(DC));
1051
79.7k
    }
1052
1053
78.8k
    void addContextNote(SourceLocation UseLoc) {
1054
78.8k
      assert(!PushedCodeSynthesisContext);
1055
1056
0
      Sema::CodeSynthesisContext Ctx;
1057
78.8k
      Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
1058
78.8k
      Ctx.PointOfInstantiation = UseLoc;
1059
78.8k
      Ctx.Entity = cast<Decl>(S.CurContext);
1060
78.8k
      S.pushCodeSynthesisContext(Ctx);
1061
1062
78.8k
      PushedCodeSynthesisContext = true;
1063
78.8k
    }
1064
1065
79.7k
    ~SynthesizedFunctionScope() {
1066
79.7k
      if (PushedCodeSynthesisContext)
1067
78.8k
        S.popCodeSynthesisContext();
1068
79.7k
      if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
1069
79.6k
        FD->setWillHaveBody(false);
1070
79.7k
      S.PopExpressionEvaluationContext();
1071
79.7k
      S.PopFunctionScopeInfo();
1072
79.7k
    }
1073
  };
1074
1075
  /// WeakUndeclaredIdentifiers - Identifiers contained in
1076
  /// \#pragma weak before declared. rare. may alias another
1077
  /// identifier, declared or undeclared
1078
  llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
1079
1080
  /// ExtnameUndeclaredIdentifiers - Identifiers contained in
1081
  /// \#pragma redefine_extname before declared.  Used in Solaris system headers
1082
  /// to define functions that occur in multiple standards to call the version
1083
  /// in the currently selected standard.
1084
  llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
1085
1086
1087
  /// Load weak undeclared identifiers from the external source.
1088
  void LoadExternalWeakUndeclaredIdentifiers();
1089
1090
  /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
1091
  /// \#pragma weak during processing of other Decls.
1092
  /// I couldn't figure out a clean way to generate these in-line, so
1093
  /// we store them here and handle separately -- which is a hack.
1094
  /// It would be best to refactor this.
1095
  SmallVector<Decl*,2> WeakTopLevelDecl;
1096
1097
  IdentifierResolver IdResolver;
1098
1099
  /// Translation Unit Scope - useful to Objective-C actions that need
1100
  /// to lookup file scope declarations in the "ordinary" C decl namespace.
1101
  /// For example, user-defined classes, built-in "id" type, etc.
1102
  Scope *TUScope;
1103
1104
  /// The C++ "std" namespace, where the standard library resides.
1105
  LazyDeclPtr StdNamespace;
1106
1107
  /// The C++ "std::bad_alloc" class, which is defined by the C++
1108
  /// standard library.
1109
  LazyDeclPtr StdBadAlloc;
1110
1111
  /// The C++ "std::align_val_t" enum class, which is defined by the C++
1112
  /// standard library.
1113
  LazyDeclPtr StdAlignValT;
1114
1115
  /// The C++ "std::experimental" namespace, where the experimental parts
1116
  /// of the standard library resides.
1117
  NamespaceDecl *StdExperimentalNamespaceCache;
1118
1119
  /// The C++ "std::initializer_list" template, which is defined in
1120
  /// \<initializer_list>.
1121
  ClassTemplateDecl *StdInitializerList;
1122
1123
  /// The C++ "std::coroutine_traits" template, which is defined in
1124
  /// \<coroutine_traits>
1125
  ClassTemplateDecl *StdCoroutineTraitsCache;
1126
  /// The namespace where coroutine components are defined. In standard,
1127
  /// they are defined in std namespace. And in the previous implementation,
1128
  /// they are defined in std::experimental namespace.
1129
  NamespaceDecl *CoroTraitsNamespaceCache;
1130
1131
  /// The C++ "type_info" declaration, which is defined in \<typeinfo>.
1132
  RecordDecl *CXXTypeInfoDecl;
1133
1134
  /// The MSVC "_GUID" struct, which is defined in MSVC header files.
1135
  RecordDecl *MSVCGuidDecl;
1136
1137
  /// Caches identifiers/selectors for NSFoundation APIs.
1138
  std::unique_ptr<NSAPI> NSAPIObj;
1139
1140
  /// The declaration of the Objective-C NSNumber class.
1141
  ObjCInterfaceDecl *NSNumberDecl;
1142
1143
  /// The declaration of the Objective-C NSValue class.
1144
  ObjCInterfaceDecl *NSValueDecl;
1145
1146
  /// Pointer to NSNumber type (NSNumber *).
1147
  QualType NSNumberPointer;
1148
1149
  /// Pointer to NSValue type (NSValue *).
1150
  QualType NSValuePointer;
1151
1152
  /// The Objective-C NSNumber methods used to create NSNumber literals.
1153
  ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
1154
1155
  /// The declaration of the Objective-C NSString class.
1156
  ObjCInterfaceDecl *NSStringDecl;
1157
1158
  /// Pointer to NSString type (NSString *).
1159
  QualType NSStringPointer;
1160
1161
  /// The declaration of the stringWithUTF8String: method.
1162
  ObjCMethodDecl *StringWithUTF8StringMethod;
1163
1164
  /// The declaration of the valueWithBytes:objCType: method.
1165
  ObjCMethodDecl *ValueWithBytesObjCTypeMethod;
1166
1167
  /// The declaration of the Objective-C NSArray class.
1168
  ObjCInterfaceDecl *NSArrayDecl;
1169
1170
  /// The declaration of the arrayWithObjects:count: method.
1171
  ObjCMethodDecl *ArrayWithObjectsMethod;
1172
1173
  /// The declaration of the Objective-C NSDictionary class.
1174
  ObjCInterfaceDecl *NSDictionaryDecl;
1175
1176
  /// The declaration of the dictionaryWithObjects:forKeys:count: method.
1177
  ObjCMethodDecl *DictionaryWithObjectsMethod;
1178
1179
  /// id<NSCopying> type.
1180
  QualType QIDNSCopying;
1181
1182
  /// will hold 'respondsToSelector:'
1183
  Selector RespondsToSelectorSel;
1184
1185
  /// A flag to remember whether the implicit forms of operator new and delete
1186
  /// have been declared.
1187
  bool GlobalNewDeleteDeclared;
1188
1189
  /// Describes how the expressions currently being parsed are
1190
  /// evaluated at run-time, if at all.
1191
  enum class ExpressionEvaluationContext {
1192
    /// The current expression and its subexpressions occur within an
1193
    /// unevaluated operand (C++11 [expr]p7), such as the subexpression of
1194
    /// \c sizeof, where the type of the expression may be significant but
1195
    /// no code will be generated to evaluate the value of the expression at
1196
    /// run time.
1197
    Unevaluated,
1198
1199
    /// The current expression occurs within a braced-init-list within
1200
    /// an unevaluated operand. This is mostly like a regular unevaluated
1201
    /// context, except that we still instantiate constexpr functions that are
1202
    /// referenced here so that we can perform narrowing checks correctly.
1203
    UnevaluatedList,
1204
1205
    /// The current expression occurs within a discarded statement.
1206
    /// This behaves largely similarly to an unevaluated operand in preventing
1207
    /// definitions from being required, but not in other ways.
1208
    DiscardedStatement,
1209
1210
    /// The current expression occurs within an unevaluated
1211
    /// operand that unconditionally permits abstract references to
1212
    /// fields, such as a SIZE operator in MS-style inline assembly.
1213
    UnevaluatedAbstract,
1214
1215
    /// The current context is "potentially evaluated" in C++11 terms,
1216
    /// but the expression is evaluated at compile-time (like the values of
1217
    /// cases in a switch statement).
1218
    ConstantEvaluated,
1219
1220
    /// In addition of being constant evaluated, the current expression
1221
    /// occurs in an immediate function context - either a consteval function
1222
    /// or a consteval if function.
1223
    ImmediateFunctionContext,
1224
1225
    /// The current expression is potentially evaluated at run time,
1226
    /// which means that code may be generated to evaluate the value of the
1227
    /// expression at run time.
1228
    PotentiallyEvaluated,
1229
1230
    /// The current expression is potentially evaluated, but any
1231
    /// declarations referenced inside that expression are only used if
1232
    /// in fact the current expression is used.
1233
    ///
1234
    /// This value is used when parsing default function arguments, for which
1235
    /// we would like to provide diagnostics (e.g., passing non-POD arguments
1236
    /// through varargs) but do not want to mark declarations as "referenced"
1237
    /// until the default argument is used.
1238
    PotentiallyEvaluatedIfUsed
1239
  };
1240
1241
  using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>;
1242
1243
  /// Data structure used to record current or nested
1244
  /// expression evaluation contexts.
1245
  struct ExpressionEvaluationContextRecord {
1246
    /// The expression evaluation context.
1247
    ExpressionEvaluationContext Context;
1248
1249
    /// Whether the enclosing context needed a cleanup.
1250
    CleanupInfo ParentCleanup;
1251
1252
    /// The number of active cleanup objects when we entered
1253
    /// this expression evaluation context.
1254
    unsigned NumCleanupObjects;
1255
1256
    /// The number of typos encountered during this expression evaluation
1257
    /// context (i.e. the number of TypoExprs created).
1258
    unsigned NumTypos;
1259
1260
    MaybeODRUseExprSet SavedMaybeODRUseExprs;
1261
1262
    /// The lambdas that are present within this context, if it
1263
    /// is indeed an unevaluated context.
1264
    SmallVector<LambdaExpr *, 2> Lambdas;
1265
1266
    /// The declaration that provides context for lambda expressions
1267
    /// and block literals if the normal declaration context does not
1268
    /// suffice, e.g., in a default function argument.
1269
    Decl *ManglingContextDecl;
1270
1271
    /// If we are processing a decltype type, a set of call expressions
1272
    /// for which we have deferred checking the completeness of the return type.
1273
    SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
1274
1275
    /// If we are processing a decltype type, a set of temporary binding
1276
    /// expressions for which we have deferred checking the destructor.
1277
    SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
1278
1279
    llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs;
1280
1281
    /// Expressions appearing as the LHS of a volatile assignment in this
1282
    /// context. We produce a warning for these when popping the context if
1283
    /// they are not discarded-value expressions nor unevaluated operands.
1284
    SmallVector<Expr*, 2> VolatileAssignmentLHSs;
1285
1286
    /// Set of candidates for starting an immediate invocation.
1287
    llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates;
1288
1289
    /// Set of DeclRefExprs referencing a consteval function when used in a
1290
    /// context not already known to be immediately invoked.
1291
    llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval;
1292
1293
    /// \brief Describes whether we are in an expression constext which we have
1294
    /// to handle differently.
1295
    enum ExpressionKind {
1296
      EK_Decltype, EK_TemplateArgument, EK_Other
1297
    } ExprContext;
1298
1299
    // A context can be nested in both a discarded statement context and
1300
    // an immediate function context, so they need to be tracked independently.
1301
    bool InDiscardedStatement;
1302
    bool InImmediateFunctionContext;
1303
1304
    ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
1305
                                      unsigned NumCleanupObjects,
1306
                                      CleanupInfo ParentCleanup,
1307
                                      Decl *ManglingContextDecl,
1308
                                      ExpressionKind ExprContext)
1309
        : Context(Context), ParentCleanup(ParentCleanup),
1310
          NumCleanupObjects(NumCleanupObjects), NumTypos(0),
1311
          ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext),
1312
40.5M
          InDiscardedStatement(false), InImmediateFunctionContext(false) {}
1313
1314
133M
    bool isUnevaluated() const {
1315
133M
      return Context == ExpressionEvaluationContext::Unevaluated ||
1316
133M
             
Context == ExpressionEvaluationContext::UnevaluatedAbstract116M
||
1317
133M
             
Context == ExpressionEvaluationContext::UnevaluatedList116M
;
1318
133M
    }
1319
1320
35.8M
    bool isConstantEvaluated() const {
1321
35.8M
      return Context == ExpressionEvaluationContext::ConstantEvaluated ||
1322
35.8M
             
Context == ExpressionEvaluationContext::ImmediateFunctionContext17.8M
;
1323
35.8M
    }
1324
1325
40.4M
    bool isImmediateFunctionContext() const {
1326
40.4M
      return Context == ExpressionEvaluationContext::ImmediateFunctionContext ||
1327
40.4M
             
(40.4M
Context == ExpressionEvaluationContext::DiscardedStatement40.4M
&&
1328
40.4M
              
InImmediateFunctionContext54
);
1329
40.4M
    }
1330
1331
46.7M
    bool isDiscardedStatementContext() const {
1332
46.7M
      return Context == ExpressionEvaluationContext::DiscardedStatement ||
1333
46.7M
             
(46.7M
Context ==
1334
46.7M
                  ExpressionEvaluationContext::ImmediateFunctionContext &&
1335
46.7M
              
InDiscardedStatement38
);
1336
46.7M
    }
1337
  };
1338
1339
  /// A stack of expression evaluation contexts.
1340
  SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
1341
1342
  /// Emit a warning for all pending noderef expressions that we recorded.
1343
  void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
1344
1345
  /// Compute the mangling number context for a lambda expression or
1346
  /// block literal. Also return the extra mangling decl if any.
1347
  ///
1348
  /// \param DC - The DeclContext containing the lambda expression or
1349
  /// block literal.
1350
  std::tuple<MangleNumberingContext *, Decl *>
1351
  getCurrentMangleNumberContext(const DeclContext *DC);
1352
1353
1354
  /// SpecialMemberOverloadResult - The overloading result for a special member
1355
  /// function.
1356
  ///
1357
  /// This is basically a wrapper around PointerIntPair. The lowest bits of the
1358
  /// integer are used to determine whether overload resolution succeeded.
1359
  class SpecialMemberOverloadResult {
1360
  public:
1361
    enum Kind {
1362
      NoMemberOrDeleted,
1363
      Ambiguous,
1364
      Success
1365
    };
1366
1367
  private:
1368
    llvm::PointerIntPair<CXXMethodDecl *, 2> Pair;
1369
1370
  public:
1371
442k
    SpecialMemberOverloadResult() {}
1372
    SpecialMemberOverloadResult(CXXMethodDecl *MD)
1373
1.04k
        : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1374
1375
1.13M
    CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
1376
260k
    void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1377
1378
604k
    Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1379
260k
    void setKind(Kind K) { Pair.setInt(K); }
1380
  };
1381
1382
  class SpecialMemberOverloadResultEntry
1383
      : public llvm::FastFoldingSetNode,
1384
        public SpecialMemberOverloadResult {
1385
  public:
1386
    SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1387
      : FastFoldingSetNode(ID)
1388
260k
    {}
1389
  };
1390
1391
  /// A cache of special member function overload resolution results
1392
  /// for C++ records.
1393
  llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1394
1395
  /// A cache of the flags available in enumerations with the flag_bits
1396
  /// attribute.
1397
  mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1398
1399
  /// The kind of translation unit we are processing.
1400
  ///
1401
  /// When we're processing a complete translation unit, Sema will perform
1402
  /// end-of-translation-unit semantic tasks (such as creating
1403
  /// initializers for tentative definitions in C) once parsing has
1404
  /// completed. Modules and precompiled headers perform different kinds of
1405
  /// checks.
1406
  const TranslationUnitKind TUKind;
1407
1408
  llvm::BumpPtrAllocator BumpAlloc;
1409
1410
  /// The number of SFINAE diagnostics that have been trapped.
1411
  unsigned NumSFINAEErrors;
1412
1413
  typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1414
    UnparsedDefaultArgInstantiationsMap;
1415
1416
  /// A mapping from parameters with unparsed default arguments to the
1417
  /// set of instantiations of each parameter.
1418
  ///
1419
  /// This mapping is a temporary data structure used when parsing
1420
  /// nested class templates or nested classes of class templates,
1421
  /// where we might end up instantiating an inner class before the
1422
  /// default arguments of its methods have been parsed.
1423
  UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
1424
1425
  // Contains the locations of the beginning of unparsed default
1426
  // argument locations.
1427
  llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1428
1429
  /// UndefinedInternals - all the used, undefined objects which require a
1430
  /// definition in this translation unit.
1431
  llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1432
1433
  /// Determine if VD, which must be a variable or function, is an external
1434
  /// symbol that nonetheless can't be referenced from outside this translation
1435
  /// unit because its type has no linkage and it's not extern "C".
1436
  bool isExternalWithNoLinkageType(ValueDecl *VD);
1437
1438
  /// Obtain a sorted list of functions that are undefined but ODR-used.
1439
  void getUndefinedButUsed(
1440
      SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1441
1442
  /// Retrieves list of suspicious delete-expressions that will be checked at
1443
  /// the end of translation unit.
1444
  const llvm::MapVector<FieldDecl *, DeleteLocs> &
1445
  getMismatchingDeleteExpressions() const;
1446
1447
  class GlobalMethodPool {
1448
  public:
1449
    using Lists = std::pair<ObjCMethodList, ObjCMethodList>;
1450
    using iterator = llvm::DenseMap<Selector, Lists>::iterator;
1451
708
    iterator begin() { return Methods.begin(); }
1452
2.29M
    iterator end() { return Methods.end(); }
1453
2.29M
    iterator find(Selector Sel) { return Methods.find(Sel); }
1454
898k
    std::pair<iterator, bool> insert(std::pair<Selector, Lists> &&Val) {
1455
898k
      return Methods.insert(Val);
1456
898k
    }
1457
8
    int count(Selector Sel) const { return Methods.count(Sel); }
1458
5.38k
    bool empty() const { return Methods.empty(); }
1459
1460
  private:
1461
    llvm::DenseMap<Selector, Lists> Methods;
1462
  };
1463
1464
  /// Method Pool - allows efficient lookup when typechecking messages to "id".
1465
  /// We need to maintain a list, since selectors can have differing signatures
1466
  /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1467
  /// of selectors are "overloaded").
1468
  /// At the head of the list it is recorded whether there were 0, 1, or >= 2
1469
  /// methods inside categories with a particular selector.
1470
  GlobalMethodPool MethodPool;
1471
1472
  /// Method selectors used in a \@selector expression. Used for implementation
1473
  /// of -Wselector.
1474
  llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1475
1476
  /// List of SourceLocations where 'self' is implicitly retained inside a
1477
  /// block.
1478
  llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1>
1479
      ImplicitlyRetainedSelfLocs;
1480
1481
  /// Kinds of C++ special members.
1482
  enum CXXSpecialMember {
1483
    CXXDefaultConstructor,
1484
    CXXCopyConstructor,
1485
    CXXMoveConstructor,
1486
    CXXCopyAssignment,
1487
    CXXMoveAssignment,
1488
    CXXDestructor,
1489
    CXXInvalid
1490
  };
1491
1492
  typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1493
      SpecialMemberDecl;
1494
1495
  /// The C++ special members which we are currently in the process of
1496
  /// declaring. If this process recursively triggers the declaration of the
1497
  /// same special member, we should act as if it is not yet declared.
1498
  llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
1499
1500
  /// Kinds of defaulted comparison operator functions.
1501
  enum class DefaultedComparisonKind : unsigned char {
1502
    /// This is not a defaultable comparison operator.
1503
    None,
1504
    /// This is an operator== that should be implemented as a series of
1505
    /// subobject comparisons.
1506
    Equal,
1507
    /// This is an operator<=> that should be implemented as a series of
1508
    /// subobject comparisons.
1509
    ThreeWay,
1510
    /// This is an operator!= that should be implemented as a rewrite in terms
1511
    /// of a == comparison.
1512
    NotEqual,
1513
    /// This is an <, <=, >, or >= that should be implemented as a rewrite in
1514
    /// terms of a <=> comparison.
1515
    Relational,
1516
  };
1517
1518
  /// The function definitions which were renamed as part of typo-correction
1519
  /// to match their respective declarations. We want to keep track of them
1520
  /// to ensure that we don't emit a "redefinition" error if we encounter a
1521
  /// correctly named definition after the renamed definition.
1522
  llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
1523
1524
  /// Stack of types that correspond to the parameter entities that are
1525
  /// currently being copy-initialized. Can be empty.
1526
  llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes;
1527
1528
  void ReadMethodPool(Selector Sel);
1529
  void updateOutOfDateSelector(Selector Sel);
1530
1531
  /// Private Helper predicate to check for 'self'.
1532
  bool isSelfExpr(Expr *RExpr);
1533
  bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
1534
1535
  /// Cause the active diagnostic on the DiagosticsEngine to be
1536
  /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1537
  /// should not be used elsewhere.
1538
  void EmitCurrentDiagnostic(unsigned DiagID);
1539
1540
  /// Records and restores the CurFPFeatures state on entry/exit of compound
1541
  /// statements.
1542
  class FPFeaturesStateRAII {
1543
  public:
1544
5.15M
    FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.CurFPFeatures) {
1545
5.15M
      OldOverrides = S.FpPragmaStack.CurrentValue;
1546
5.15M
    }
1547
5.15M
    ~FPFeaturesStateRAII() {
1548
5.15M
      S.CurFPFeatures = OldFPFeaturesState;
1549
5.15M
      S.FpPragmaStack.CurrentValue = OldOverrides;
1550
5.15M
    }
1551
0
    FPOptionsOverride getOverrides() { return OldOverrides; }
1552
1553
  private:
1554
    Sema& S;
1555
    FPOptions OldFPFeaturesState;
1556
    FPOptionsOverride OldOverrides;
1557
  };
1558
1559
  void addImplicitTypedef(StringRef Name, QualType T);
1560
1561
  bool WarnedStackExhausted = false;
1562
1563
  /// Increment when we find a reference; decrement when we find an ignored
1564
  /// assignment.  Ultimately the value is 0 if every reference is an ignored
1565
  /// assignment.
1566
  llvm::DenseMap<const VarDecl *, int> RefsMinusAssignments;
1567
1568
private:
1569
  Optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;
1570
1571
  bool WarnedDarwinSDKInfoMissing = false;
1572
1573
public:
1574
  Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1575
       TranslationUnitKind TUKind = TU_Complete,
1576
       CodeCompleteConsumer *CompletionConsumer = nullptr);
1577
  ~Sema();
1578
1579
  /// Perform initialization that occurs after the parser has been
1580
  /// initialized but before it parses anything.
1581
  void Initialize();
1582
1583
  /// This virtual key function only exists to limit the emission of debug info
1584
  /// describing the Sema class. GCC and Clang only emit debug info for a class
1585
  /// with a vtable when the vtable is emitted. Sema is final and not
1586
  /// polymorphic, but the debug info size savings are so significant that it is
1587
  /// worth adding a vtable just to take advantage of this optimization.
1588
  virtual void anchor();
1589
1590
4.36G
  const LangOptions &getLangOpts() const { return LangOpts; }
1591
1.94M
  OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1592
33.5M
  FPOptions     &getCurFPFeatures() { return CurFPFeatures; }
1593
1594
33.3M
  DiagnosticsEngine &getDiagnostics() const { return Diags; }
1595
1.45M
  SourceManager &getSourceManager() const { return SourceMgr; }
1596
348k
  Preprocessor &getPreprocessor() const { return PP; }
1597
132M
  ASTContext &getASTContext() const { return Context; }
1598
954k
  ASTConsumer &getASTConsumer() const { return Consumer; }
1599
  ASTMutationListener *getASTMutationListener() const;
1600
532k
  ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1601
1602
  DarwinSDKInfo *getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc,
1603
                                                         StringRef Platform);
1604
  DarwinSDKInfo *getDarwinSDKInfoForAvailabilityChecking();
1605
1606
  ///Registers an external source. If an external source already exists,
1607
  /// creates a multiplex external source and appends to it.
1608
  ///
1609
  ///\param[in] E - A non-null external sema source.
1610
  ///
1611
  void addExternalSource(ExternalSemaSource *E);
1612
1613
  void PrintStats() const;
1614
1615
  /// Warn that the stack is nearly exhausted.
1616
  void warnStackExhausted(SourceLocation Loc);
1617
1618
  /// Run some code with "sufficient" stack space. (Currently, at least 256K is
1619
  /// guaranteed). Produces a warning if we're low on stack space and allocates
1620
  /// more in that case. Use this in code that may recurse deeply (for example,
1621
  /// in template instantiation) to avoid stack overflow.
1622
  void runWithSufficientStackSpace(SourceLocation Loc,
1623
                                   llvm::function_ref<void()> Fn);
1624
1625
  /// Helper class that creates diagnostics with optional
1626
  /// template instantiation stacks.
1627
  ///
1628
  /// This class provides a wrapper around the basic DiagnosticBuilder
1629
  /// class that emits diagnostics. ImmediateDiagBuilder is
1630
  /// responsible for emitting the diagnostic (as DiagnosticBuilder
1631
  /// does) and, if the diagnostic comes from inside a template
1632
  /// instantiation, printing the template instantiation stack as
1633
  /// well.
1634
  class ImmediateDiagBuilder : public DiagnosticBuilder {
1635
    Sema &SemaRef;
1636
    unsigned DiagID;
1637
1638
  public:
1639
    ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1640
0
        : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1641
    ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID)
1642
3.01M
        : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1643
1644
    // This is a cunning lie. DiagnosticBuilder actually performs move
1645
    // construction in its copy constructor (but due to varied uses, it's not
1646
    // possible to conveniently express this as actual move construction). So
1647
    // the default copy ctor here is fine, because the base class disables the
1648
    // source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op
1649
    // in that case anwyay.
1650
3.11M
    ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default;
1651
1652
6.12M
    ~ImmediateDiagBuilder() {
1653
      // If we aren't active, there is nothing to do.
1654
6.12M
      if (!isActive()) 
return3.11M
;
1655
1656
      // Otherwise, we need to emit the diagnostic. First clear the diagnostic
1657
      // builder itself so it won't emit the diagnostic in its own destructor.
1658
      //
1659
      // This seems wasteful, in that as written the DiagnosticBuilder dtor will
1660
      // do its own needless checks to see if the diagnostic needs to be
1661
      // emitted. However, because we take care to ensure that the builder
1662
      // objects never escape, a sufficiently smart compiler will be able to
1663
      // eliminate that code.
1664
3.01M
      Clear();
1665
1666
      // Dispatch to Sema to emit the diagnostic.
1667
3.01M
      SemaRef.EmitCurrentDiagnostic(DiagID);
1668
3.01M
    }
1669
1670
    /// Teach operator<< to produce an object of the correct type.
1671
    template <typename T>
1672
    friend const ImmediateDiagBuilder &
1673
1.59M
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1.59M
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1.59M
      BaseDiag << Value;
1676
1.59M
      return Diag;
1677
1.59M
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCMethodDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCMethodDecl const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FixItHint>(clang::Sema::ImmediateDiagBuilder const&, clang::FixItHint const&)
Line
Count
Source
1673
33.7k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
33.7k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
33.7k
      BaseDiag << Value;
1676
33.7k
      return Diag;
1677
33.7k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallString<32u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallString<32u> const&)
Line
Count
Source
1673
382
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
382
      const DiagnosticBuilder &BaseDiag = Diag;
1675
382
      BaseDiag << Value;
1676
382
      return Diag;
1677
382
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [17]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [17])
Line
Count
Source
1673
77
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
77
      const DiagnosticBuilder &BaseDiag = Diag;
1675
77
      BaseDiag << Value;
1676
77
      return Diag;
1677
77
    }
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
1673
14
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
14
      const DiagnosticBuilder &BaseDiag = Diag;
1675
14
      BaseDiag << Value;
1676
14
      return Diag;
1677
14
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [45]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [45])
Line
Count
Source
1673
90
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
90
      const DiagnosticBuilder &BaseDiag = Diag;
1675
90
      BaseDiag << Value;
1676
90
      return Diag;
1677
90
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [31]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [31])
Line
Count
Source
1673
12
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
12
      const DiagnosticBuilder &BaseDiag = Diag;
1675
12
      BaseDiag << Value;
1676
12
      return Diag;
1677
12
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [23]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [23])
Line
Count
Source
1673
33
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
33
      const DiagnosticBuilder &BaseDiag = Diag;
1675
33
      BaseDiag << Value;
1676
33
      return Diag;
1677
33
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [24]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [24])
Line
Count
Source
1673
22
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
22
      const DiagnosticBuilder &BaseDiag = Diag;
1675
22
      BaseDiag << Value;
1676
22
      return Diag;
1677
22
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NoDestroyAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NoDestroyAttr const* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NotTailCalledAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NotTailCalledAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [32]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [32])
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [34]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [34])
Line
Count
Source
1673
44
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
44
      const DiagnosticBuilder &BaseDiag = Diag;
1675
44
      BaseDiag << Value;
1676
44
      return Diag;
1677
44
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [19]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [19])
Line
Count
Source
1673
141
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
141
      const DiagnosticBuilder &BaseDiag = Diag;
1675
141
      BaseDiag << Value;
1676
141
      return Diag;
1677
141
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [29]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [29])
Line
Count
Source
1673
62
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
62
      const DiagnosticBuilder &BaseDiag = Diag;
1675
62
      BaseDiag << Value;
1676
62
      return Diag;
1677
62
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [86]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [86])
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CFUnknownTransferAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CFUnknownTransferAttr const* const&)
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [11]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [11])
Line
Count
Source
1673
30
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
30
      const DiagnosticBuilder &BaseDiag = Diag;
1675
30
      BaseDiag << Value;
1676
30
      return Diag;
1677
30
    }
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CFAuditedTransferAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CFAuditedTransferAttr const* const&)
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TargetClonesAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::TargetClonesAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TargetAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::TargetAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CPUSpecificAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CPUSpecificAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
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
1673
6
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
6
      const DiagnosticBuilder &BaseDiag = Diag;
1675
6
      BaseDiag << Value;
1676
6
      return Diag;
1677
6
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::HIPManagedAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::HIPManagedAttr const* const&)
Line
Count
Source
1673
8
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
8
      const DiagnosticBuilder &BaseDiag = Diag;
1675
8
      BaseDiag << Value;
1676
8
      return Diag;
1677
8
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDAGlobalAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDAGlobalAttr const* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [8]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [8])
Line
Count
Source
1673
94
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
94
      const DiagnosticBuilder &BaseDiag = Diag;
1675
94
      BaseDiag << Value;
1676
94
      return Diag;
1677
94
    }
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
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDAHostAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDAHostAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [54]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [54])
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CUDAConstantAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CUDAConstantAttr const* const&)
Line
Count
Source
1673
8
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
8
      const DiagnosticBuilder &BaseDiag = Diag;
1675
8
      BaseDiag << Value;
1676
8
      return Diag;
1677
8
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [39]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [39])
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [47]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [47])
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [16]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [16])
Line
Count
Source
1673
27
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
27
      const DiagnosticBuilder &BaseDiag = Diag;
1675
27
      BaseDiag << Value;
1676
27
      return Diag;
1677
27
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [22]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [22])
Line
Count
Source
1673
32
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
32
      const DiagnosticBuilder &BaseDiag = Diag;
1675
32
      BaseDiag << Value;
1676
32
      return Diag;
1677
32
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::HotAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::HotAttr const* const&)
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::InternalLinkageAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::InternalLinkageAttr const* const&)
Line
Count
Source
1673
6
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
6
      const DiagnosticBuilder &BaseDiag = Diag;
1675
6
      BaseDiag << Value;
1676
6
      return Diag;
1677
6
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [58]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [58])
Line
Count
Source
1673
230
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
230
      const DiagnosticBuilder &BaseDiag = Diag;
1675
230
      BaseDiag << Value;
1676
230
      return Diag;
1677
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
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [6]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [6])
Line
Count
Source
1673
1.58k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1.58k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1.58k
      BaseDiag << Value;
1676
1.58k
      return Diag;
1677
1.58k
    }
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
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ColdAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ColdAttr const* const&)
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CommonAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CommonAttr const* const&)
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [42]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [42])
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [43]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [43])
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Mips16Attr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::Mips16Attr const* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MipsInterruptAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::MipsInterruptAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MicroMipsAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::MicroMipsAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MipsShortCallAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::MipsShortCallAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MipsLongCallAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::MipsLongCallAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [56]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [56])
Line
Count
Source
1673
17
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
17
      const DiagnosticBuilder &BaseDiag = Diag;
1675
17
      BaseDiag << Value;
1676
17
      return Diag;
1677
17
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [18]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [18])
Line
Count
Source
1673
39
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
39
      const DiagnosticBuilder &BaseDiag = Diag;
1675
39
      BaseDiag << Value;
1676
39
      return Diag;
1677
39
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [20]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [20])
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DisableTailCallsAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::DisableTailCallsAttr const* const&)
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [75]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [75])
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlwaysDestroyAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlwaysDestroyAttr const* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [25]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [25])
Line
Count
Source
1673
7
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7
      BaseDiag << Value;
1676
7
      return Diag;
1677
7
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SpeculativeLoadHardeningAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::SpeculativeLoadHardeningAttr const* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [38]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [38])
Line
Count
Source
1673
12
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
12
      const DiagnosticBuilder &BaseDiag = Diag;
1675
12
      BaseDiag << Value;
1676
12
      return Diag;
1677
12
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [35]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [35])
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlwaysInlineAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlwaysInlineAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [28]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [28])
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [71]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [71])
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
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
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [49]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [49])
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::PointerAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::PointerAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::OwnerAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::OwnerAttr const* const&)
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [69]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [69])
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [77]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [77])
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NoSpeculativeLoadHardeningAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NoSpeculativeLoadHardeningAttr const* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [150]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [150])
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [50]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [50])
Line
Count
Source
1673
20
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
20
      const DiagnosticBuilder &BaseDiag = Diag;
1675
20
      BaseDiag << Value;
1676
20
      return Diag;
1677
20
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [87]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [87])
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ValueDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ValueDecl* const&)
Line
Count
Source
1673
7.80k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7.80k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7.80k
      BaseDiag << Value;
1676
7.80k
      return Diag;
1677
7.80k
    }
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
1673
71.9k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
71.9k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
71.9k
      BaseDiag << Value;
1676
71.9k
      return Diag;
1677
71.9k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<unsigned int>(clang::Sema::ImmediateDiagBuilder const&, unsigned int const&)
Line
Count
Source
1673
54.4k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
54.4k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
54.4k
      BaseDiag << Value;
1676
54.4k
      return Diag;
1677
54.4k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::StringRef>(clang::Sema::ImmediateDiagBuilder const&, llvm::StringRef const&)
Line
Count
Source
1673
31.4k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
31.4k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
31.4k
      BaseDiag << Value;
1676
31.4k
      return Diag;
1677
31.4k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::QualType>(clang::Sema::ImmediateDiagBuilder const&, clang::QualType const&)
Line
Count
Source
1673
294k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
294k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
294k
      BaseDiag << Value;
1676
294k
      return Diag;
1677
294k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [7]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [7])
Line
Count
Source
1673
294
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
294
      const DiagnosticBuilder &BaseDiag = Diag;
1675
294
      BaseDiag << Value;
1676
294
      return Diag;
1677
294
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::IdentifierInfo*>(clang::Sema::ImmediateDiagBuilder const&, clang::IdentifierInfo* const&)
Line
Count
Source
1673
3.07k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3.07k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3.07k
      BaseDiag << Value;
1676
3.07k
      return Diag;
1677
3.07k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FunctionDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::FunctionDecl const* const&)
Line
Count
Source
1673
10.4k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
10.4k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
10.4k
      BaseDiag << Value;
1676
10.4k
      return Diag;
1677
10.4k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VarDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::VarDecl const* const&)
Line
Count
Source
1673
5.08k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5.08k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5.08k
      BaseDiag << Value;
1676
5.08k
      return Diag;
1677
5.08k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<bool>(clang::Sema::ImmediateDiagBuilder const&, bool const&)
Line
Count
Source
1673
122k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
122k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
122k
      BaseDiag << Value;
1676
122k
      return Diag;
1677
122k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SourceRange>(clang::Sema::ImmediateDiagBuilder const&, clang::SourceRange const&)
Line
Count
Source
1673
222k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
222k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
222k
      BaseDiag << Value;
1676
222k
      return Diag;
1677
222k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [12]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [12])
Line
Count
Source
1673
276
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
276
      const DiagnosticBuilder &BaseDiag = Diag;
1675
276
      BaseDiag << Value;
1676
276
      return Diag;
1677
276
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [5]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [5])
Line
Count
Source
1673
129
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
129
      const DiagnosticBuilder &BaseDiag = Diag;
1675
129
      BaseDiag << Value;
1676
129
      return Diag;
1677
129
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [14]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [14])
Line
Count
Source
1673
34
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
34
      const DiagnosticBuilder &BaseDiag = Diag;
1675
34
      BaseDiag << Value;
1676
34
      return Diag;
1677
34
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [9]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [9])
Line
Count
Source
1673
19.4k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
19.4k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
19.4k
      BaseDiag << Value;
1676
19.4k
      return Diag;
1677
19.4k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NamedDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::NamedDecl* const&)
Line
Count
Source
1673
117k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
117k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
117k
      BaseDiag << Value;
1676
117k
      return Diag;
1677
117k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ASTContext::SectionInfo>(clang::Sema::ImmediateDiagBuilder const&, clang::ASTContext::SectionInfo const&)
Line
Count
Source
1673
23
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
23
      const DiagnosticBuilder &BaseDiag = Diag;
1675
23
      BaseDiag << Value;
1676
23
      return Diag;
1677
23
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ParsedAttr>(clang::Sema::ImmediateDiagBuilder const&, clang::ParsedAttr const&)
Line
Count
Source
1673
18.5k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
18.5k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
18.5k
      BaseDiag << Value;
1676
18.5k
      return Diag;
1677
18.5k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::IdentifierInfo const*>(clang::Sema::ImmediateDiagBuilder const&, clang::IdentifierInfo const* const&)
Line
Count
Source
1673
235
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
235
      const DiagnosticBuilder &BaseDiag = Diag;
1675
235
      BaseDiag << Value;
1676
235
      return Diag;
1677
235
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallVector<clang::FixItHint, 12u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallVector<clang::FixItHint, 12u> const&)
Line
Count
Source
1673
29.4k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
29.4k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
29.4k
      BaseDiag << Value;
1676
29.4k
      return Diag;
1677
29.4k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<CastType>(clang::Sema::ImmediateDiagBuilder const&, CastType const&)
Line
Count
Source
1673
399
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
399
      const DiagnosticBuilder &BaseDiag = Diag;
1675
399
      BaseDiag << Value;
1676
399
      return Diag;
1677
399
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [37]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [37])
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallString<16u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallString<16u> const&)
Line
Count
Source
1673
223
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
223
      const DiagnosticBuilder &BaseDiag = Diag;
1675
223
      BaseDiag << Value;
1676
223
      return Diag;
1677
223
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::ArrayRef<clang::FixItHint> >(clang::Sema::ImmediateDiagBuilder const&, llvm::ArrayRef<clang::FixItHint> const&)
Line
Count
Source
1673
5.44k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5.44k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5.44k
      BaseDiag << Value;
1676
5.44k
      return Diag;
1677
5.44k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CharSourceRange>(clang::Sema::ImmediateDiagBuilder const&, clang::CharSourceRange const&)
Line
Count
Source
1673
5.33k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5.33k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5.33k
      BaseDiag << Value;
1676
5.33k
      return Diag;
1677
5.33k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<AbsoluteValueKind>(clang::Sema::ImmediateDiagBuilder const&, AbsoluteValueKind const&)
Line
Count
Source
1673
768
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
768
      const DiagnosticBuilder &BaseDiag = Diag;
1675
768
      BaseDiag << Value;
1676
768
      return Diag;
1677
768
    }
SemaChecking.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_19>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_19 const&)
Line
Count
Source
1673
253
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
253
      const DiagnosticBuilder &BaseDiag = Diag;
1675
253
      BaseDiag << Value;
1676
253
      return Diag;
1677
253
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ConceptSpecializationExpr*>(clang::Sema::ImmediateDiagBuilder const&, clang::ConceptSpecializationExpr* const&)
Line
Count
Source
1673
38
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
38
      const DiagnosticBuilder &BaseDiag = Diag;
1675
38
      BaseDiag << Value;
1676
38
      return Diag;
1677
38
    }
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
1673
42
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
42
      const DiagnosticBuilder &BaseDiag = Diag;
1675
42
      BaseDiag << Value;
1676
42
      return Diag;
1677
42
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::LabelDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::LabelDecl* const&)
Line
Count
Source
1673
377
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
377
      const DiagnosticBuilder &BaseDiag = Diag;
1675
377
      BaseDiag << Value;
1676
377
      return Diag;
1677
377
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlignedAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlignedAttr const* const&)
Line
Count
Source
1673
8
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
8
      const DiagnosticBuilder &BaseDiag = Diag;
1675
8
      BaseDiag << Value;
1676
8
      return Diag;
1677
8
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlignedAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlignedAttr* const&)
Line
Count
Source
1673
27
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
27
      const DiagnosticBuilder &BaseDiag = Diag;
1675
27
      BaseDiag << Value;
1676
27
      return Diag;
1677
27
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DLLImportAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::DLLImportAttr const* const&)
Line
Count
Source
1673
511
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
511
      const DiagnosticBuilder &BaseDiag = Diag;
1675
511
      BaseDiag << Value;
1676
511
      return Diag;
1677
511
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Attr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::Attr const* const&)
Line
Count
Source
1673
7
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7
      BaseDiag << Value;
1676
7
      return Diag;
1677
7
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXRecordDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXRecordDecl const* const&)
Line
Count
Source
1673
185
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
185
      const DiagnosticBuilder &BaseDiag = Diag;
1675
185
      BaseDiag << Value;
1676
185
      return Diag;
1677
185
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FieldDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::FieldDecl const* const&)
Line
Count
Source
1673
159
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
159
      const DiagnosticBuilder &BaseDiag = Diag;
1675
159
      BaseDiag << Value;
1676
159
      return Diag;
1677
159
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char const*>(clang::Sema::ImmediateDiagBuilder const&, char const* const&)
Line
Count
Source
1673
3.73k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3.73k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3.73k
      BaseDiag << Value;
1676
3.73k
      return Diag;
1677
3.73k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ErrorAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::ErrorAttr* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AnyX86NoCallerSavedRegistersAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::AnyX86NoCallerSavedRegistersAttr* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXX11NoReturnAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXX11NoReturnAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VarDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::VarDecl* const&)
Line
Count
Source
1673
7.37k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7.37k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7.37k
      BaseDiag << Value;
1676
7.37k
      return Diag;
1677
7.37k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TypedefNameDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TypedefNameDecl* const&)
Line
Count
Source
1673
75
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
75
      const DiagnosticBuilder &BaseDiag = Diag;
1675
75
      BaseDiag << Value;
1676
75
      return Diag;
1677
75
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TemplateName>(clang::Sema::ImmediateDiagBuilder const&, clang::TemplateName const&)
Line
Count
Source
1673
379
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
379
      const DiagnosticBuilder &BaseDiag = Diag;
1675
379
      BaseDiag << Value;
1676
379
      return Diag;
1677
379
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::InheritableAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::InheritableAttr const* const&)
Line
Count
Source
1673
431
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
431
      const DiagnosticBuilder &BaseDiag = Diag;
1675
431
      BaseDiag << Value;
1676
431
      return Diag;
1677
431
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<ShadowedDeclKind>(clang::Sema::ImmediateDiagBuilder const&, ShadowedDeclKind const&)
Line
Count
Source
1673
149
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
149
      const DiagnosticBuilder &BaseDiag = Diag;
1675
149
      BaseDiag << Value;
1676
149
      return Diag;
1677
149
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DeclContext const*>(clang::Sema::ImmediateDiagBuilder const&, clang::DeclContext const* const&)
Line
Count
Source
1673
52
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
52
      const DiagnosticBuilder &BaseDiag = Diag;
1675
52
      BaseDiag << Value;
1676
52
      return Diag;
1677
52
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::StorageClass>(clang::Sema::ImmediateDiagBuilder const&, clang::StorageClass const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::NonTrivialCUnionContext>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::NonTrivialCUnionContext const&)
Line
Count
Source
1673
81
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
81
      const DiagnosticBuilder &BaseDiag = Diag;
1675
81
      BaseDiag << Value;
1676
81
      return Diag;
1677
81
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [1]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [1])
Line
Count
Source
1673
109
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
109
      const DiagnosticBuilder &BaseDiag = Diag;
1675
109
      BaseDiag << Value;
1676
109
      return Diag;
1677
109
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallVector<clang::FixItHint, 1u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallVector<clang::FixItHint, 1u> const&)
Line
Count
Source
1673
17
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
17
      const DiagnosticBuilder &BaseDiag = Diag;
1675
17
      BaseDiag << Value;
1676
17
      return Diag;
1677
17
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::UsedAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::UsedAttr* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::RetainAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::RetainAttr* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ParmVarDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ParmVarDecl* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ParmVarDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ParmVarDecl const* const&)
Line
Count
Source
1673
49
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
49
      const DiagnosticBuilder &BaseDiag = Diag;
1675
49
      BaseDiag << Value;
1676
49
      return Diag;
1677
49
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TypedefDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TypedefDecl* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TagTypeKind>(clang::Sema::ImmediateDiagBuilder const&, clang::TagTypeKind const&)
Line
Count
Source
1673
80
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
80
      const DiagnosticBuilder &BaseDiag = Diag;
1675
80
      BaseDiag << Value;
1676
80
      return Diag;
1677
80
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::NonTagKind>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::NonTagKind const&)
Line
Count
Source
1673
28
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
28
      const DiagnosticBuilder &BaseDiag = Diag;
1675
28
      BaseDiag << Value;
1676
28
      return Diag;
1677
28
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TagDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TagDecl* const&)
Line
Count
Source
1673
12
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
12
      const DiagnosticBuilder &BaseDiag = Diag;
1675
12
      BaseDiag << Value;
1676
12
      return Diag;
1677
12
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::CXXSpecialMember>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::CXXSpecialMember const&)
Line
Count
Source
1673
610
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
610
      const DiagnosticBuilder &BaseDiag = Diag;
1675
610
      BaseDiag << Value;
1676
610
      return Diag;
1677
610
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::RecordDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::RecordDecl* const&)
Line
Count
Source
1673
23
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
23
      const DiagnosticBuilder &BaseDiag = Diag;
1675
23
      BaseDiag << Value;
1676
23
      return Diag;
1677
23
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::EnumConstantDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::EnumConstantDecl* const&)
Line
Count
Source
1673
25
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
25
      const DiagnosticBuilder &BaseDiag = Diag;
1675
25
      BaseDiag << Value;
1676
25
      return Diag;
1677
25
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::EnumDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::EnumDecl* const&)
Line
Count
Source
1673
46
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
46
      const DiagnosticBuilder &BaseDiag = Diag;
1675
46
      BaseDiag << Value;
1676
46
      return Diag;
1677
46
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AttributeArgumentNType>(clang::Sema::ImmediateDiagBuilder const&, clang::AttributeArgumentNType const&)
Line
Count
Source
1673
7
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7
      BaseDiag << Value;
1676
7
      return Diag;
1677
7
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::OwnershipAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::OwnershipAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VecReturnAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::VecReturnAttr* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AttributeDeclKind>(clang::Sema::ImmediateDiagBuilder const&, clang::AttributeDeclKind const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
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
1673
13
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
13
      const DiagnosticBuilder &BaseDiag = Diag;
1675
13
      BaseDiag << Value;
1676
13
      return Diag;
1677
13
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [4]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [4])
Line
Count
Source
1673
70
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
70
      const DiagnosticBuilder &BaseDiag = Diag;
1675
70
      BaseDiag << Value;
1676
70
      return Diag;
1677
70
    }
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SwiftAsyncAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::SwiftAsyncAttr const* const&)
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SwiftAsyncErrorAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::SwiftAsyncErrorAttr const* const&)
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<unsigned long long>(clang::Sema::ImmediateDiagBuilder const&, unsigned long long const&)
Line
Count
Source
1673
22
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
22
      const DiagnosticBuilder &BaseDiag = Diag;
1675
22
      BaseDiag << Value;
1676
22
      return Diag;
1677
22
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AttributeCommonInfo>(clang::Sema::ImmediateDiagBuilder const&, clang::AttributeCommonInfo const&)
Line
Count
Source
1673
9
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
9
      const DiagnosticBuilder &BaseDiag = Diag;
1675
9
      BaseDiag << Value;
1676
9
      return Diag;
1677
9
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ErrorAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ErrorAttr const* const&)
Line
Count
Source
1673
11
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
11
      const DiagnosticBuilder &BaseDiag = Diag;
1675
11
      BaseDiag << Value;
1676
11
      return Diag;
1677
11
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SwiftNameAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::SwiftNameAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AlwaysInlineAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::AlwaysInlineAttr* const&)
Line
Count
Source
1673
6
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
6
      const DiagnosticBuilder &BaseDiag = Diag;
1675
6
      BaseDiag << Value;
1676
6
      return Diag;
1677
6
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MinSizeAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::MinSizeAttr* const&)
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
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
1673
169
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
169
      const DiagnosticBuilder &BaseDiag = Diag;
1675
169
      BaseDiag << Value;
1676
169
      return Diag;
1677
169
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ReqdWorkGroupSizeAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ReqdWorkGroupSizeAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::WorkGroupSizeHintAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::WorkGroupSizeHintAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VecTypeHintAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::VecTypeHintAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::OpenCLIntelReqdSubGroupSizeAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::OpenCLIntelReqdSubGroupSizeAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AMDGPUFlatWorkGroupSizeAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AMDGPUFlatWorkGroupSizeAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AMDGPUWavesPerEUAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AMDGPUWavesPerEUAttr const* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AMDGPUNumSGPRAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AMDGPUNumSGPRAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AMDGPUNumVGPRAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::AMDGPUNumVGPRAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::AbstractDiagSelID>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::AbstractDiagSelID const&)
Line
Count
Source
1673
16
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
16
      const DiagnosticBuilder &BaseDiag = Diag;
1675
16
      BaseDiag << Value;
1676
16
      return Diag;
1677
16
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ClassTemplateDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ClassTemplateDecl* const&)
Line
Count
Source
1673
62
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
62
      const DiagnosticBuilder &BaseDiag = Diag;
1675
62
      BaseDiag << Value;
1676
62
      return Diag;
1677
62
    }
SemaDeclCXX.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::DefaultedComparisonSubobject::$_8>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::DefaultedComparisonSubobject::$_8 const&)
Line
Count
Source
1673
40
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
40
      const DiagnosticBuilder &BaseDiag = Diag;
1675
40
      BaseDiag << Value;
1676
40
      return Diag;
1677
40
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<TrivialSubobjectKind>(clang::Sema::ImmediateDiagBuilder const&, TrivialSubobjectKind const&)
Line
Count
Source
1673
215
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
215
      const DiagnosticBuilder &BaseDiag = Diag;
1675
215
      BaseDiag << Value;
1676
215
      return Diag;
1677
215
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXConstructorDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXConstructorDecl* const&)
Line
Count
Source
1673
7
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7
      BaseDiag << Value;
1676
7
      return Diag;
1677
7
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DecompositionDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::DecompositionDecl* const&)
Line
Count
Source
1673
7
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7
      BaseDiag << Value;
1676
7
      return Diag;
1677
7
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXRecordDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXRecordDecl* const&)
Line
Count
Source
1673
7.75k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7.75k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7.75k
      BaseDiag << Value;
1676
7.75k
      return Diag;
1677
7.75k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::AccessSpecifier>(clang::Sema::ImmediateDiagBuilder const&, clang::AccessSpecifier const&)
Line
Count
Source
1673
8
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
8
      const DiagnosticBuilder &BaseDiag = Diag;
1675
8
      BaseDiag << Value;
1676
8
      return Diag;
1677
8
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Attr*>(clang::Sema::ImmediateDiagBuilder const&, clang::Attr* const&)
Line
Count
Source
1673
40
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
40
      const DiagnosticBuilder &BaseDiag = Diag;
1675
40
      BaseDiag << Value;
1676
40
      return Diag;
1677
40
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::InheritableAttr*>(clang::Sema::ImmediateDiagBuilder const&, clang::InheritableAttr* const&)
Line
Count
Source
1673
24
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
24
      const DiagnosticBuilder &BaseDiag = Diag;
1675
24
      BaseDiag << Value;
1676
24
      return Diag;
1677
24
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ClassTemplateSpecializationDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ClassTemplateSpecializationDecl* const&)
Line
Count
Source
1673
79
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
79
      const DiagnosticBuilder &BaseDiag = Diag;
1675
79
      BaseDiag << Value;
1676
79
      return Diag;
1677
79
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FieldDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::FieldDecl* const&)
Line
Count
Source
1673
567
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
567
      const DiagnosticBuilder &BaseDiag = Diag;
1675
567
      BaseDiag << Value;
1676
567
      return Diag;
1677
567
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TemplateDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TemplateDecl* const&)
Line
Count
Source
1673
1.17k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1.17k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1.17k
      BaseDiag << Value;
1676
1.17k
      return Diag;
1677
1.17k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [15]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [15])
Line
Count
Source
1673
14
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
14
      const DiagnosticBuilder &BaseDiag = Diag;
1675
14
      BaseDiag << Value;
1676
14
      return Diag;
1677
14
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCMethodDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCMethodDecl* const&)
Line
Count
Source
1673
2.65k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2.65k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2.65k
      BaseDiag << Value;
1676
2.65k
      return Diag;
1677
2.65k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCInterfaceDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCInterfaceDecl const* const&)
Line
Count
Source
1673
8
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
8
      const DiagnosticBuilder &BaseDiag = Diag;
1675
8
      BaseDiag << Value;
1676
8
      return Diag;
1677
8
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCCategoryDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCCategoryDecl* const&)
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<int>(clang::Sema::ImmediateDiagBuilder const&, int const&)
Line
Count
Source
1673
16.5k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
16.5k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
16.5k
      BaseDiag << Value;
1676
16.5k
      return Diag;
1677
16.5k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCProtocolDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCProtocolDecl const* const&)
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCMethodFamily>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCMethodFamily const&)
Line
Count
Source
1673
48
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
48
      const DiagnosticBuilder &BaseDiag = Diag;
1675
48
      BaseDiag << Value;
1676
48
      return Diag;
1677
48
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [10]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [10])
Line
Count
Source
1673
309
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
309
      const DiagnosticBuilder &BaseDiag = Diag;
1675
309
      BaseDiag << Value;
1676
309
      return Diag;
1677
309
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCProtocolDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCProtocolDecl* const&)
Line
Count
Source
1673
39
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
39
      const DiagnosticBuilder &BaseDiag = Diag;
1675
39
      BaseDiag << Value;
1676
39
      return Diag;
1677
39
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Selector>(clang::Sema::ImmediateDiagBuilder const&, clang::Selector const&)
Line
Count
Source
1673
3.64k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3.64k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3.64k
      BaseDiag << Value;
1676
3.64k
      return Diag;
1677
3.64k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCIvarDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCIvarDecl const* const&)
Line
Count
Source
1673
10
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
10
      const DiagnosticBuilder &BaseDiag = Diag;
1675
10
      BaseDiag << Value;
1676
10
      return Diag;
1677
10
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ValueDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::ValueDecl const* const&)
Line
Count
Source
1673
11.2k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
11.2k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
11.2k
      BaseDiag << Value;
1676
11.2k
      return Diag;
1677
11.2k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CanQual<clang::Type> >(clang::Sema::ImmediateDiagBuilder const&, clang::CanQual<clang::Type> const&)
Line
Count
Source
1673
91
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
91
      const DiagnosticBuilder &BaseDiag = Diag;
1675
91
      BaseDiag << Value;
1676
91
      return Diag;
1677
91
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallString<40u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallString<40u> const&)
Line
Count
Source
1673
8.71k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
8.71k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
8.71k
      BaseDiag << Value;
1676
8.71k
      return Diag;
1677
8.71k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::SourceLocation>(clang::Sema::ImmediateDiagBuilder const&, clang::SourceLocation const&)
Line
Count
Source
1673
639
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
639
      const DiagnosticBuilder &BaseDiag = Diag;
1675
639
      BaseDiag << Value;
1676
639
      return Diag;
1677
639
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXMethodDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXMethodDecl const* const&)
Line
Count
Source
1673
43
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
43
      const DiagnosticBuilder &BaseDiag = Diag;
1675
43
      BaseDiag << Value;
1676
43
      return Diag;
1677
43
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<OriginalExprKind>(clang::Sema::ImmediateDiagBuilder const&, OriginalExprKind const&)
Line
Count
Source
1673
11
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
11
      const DiagnosticBuilder &BaseDiag = Diag;
1675
11
      BaseDiag << Value;
1676
11
      return Diag;
1677
11
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TypeAliasTemplateDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TypeAliasTemplateDecl* const&)
Line
Count
Source
1673
7
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
7
      const DiagnosticBuilder &BaseDiag = Diag;
1675
7
      BaseDiag << Value;
1676
7
      return Diag;
1677
7
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::UsingPackDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::UsingPackDecl* const&)
Line
Count
Source
1673
2
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
2
      const DiagnosticBuilder &BaseDiag = Diag;
1675
2
      BaseDiag << Value;
1676
2
      return Diag;
1677
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::VariadicCallType>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::VariadicCallType const&)
Line
Count
Source
1673
6
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
6
      const DiagnosticBuilder &BaseDiag = Diag;
1675
6
      BaseDiag << Value;
1676
6
      return Diag;
1677
6
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Expr*>(clang::Sema::ImmediateDiagBuilder const&, clang::Expr* const&)
Line
Count
Source
1673
311
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
311
      const DiagnosticBuilder &BaseDiag = Diag;
1675
311
      BaseDiag << Value;
1676
311
      return Diag;
1677
311
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [2]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [2])
Line
Count
Source
1673
213
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
213
      const DiagnosticBuilder &BaseDiag = Diag;
1675
213
      BaseDiag << Value;
1676
213
      return Diag;
1677
213
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::AssignmentAction>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::AssignmentAction const&)
Line
Count
Source
1673
13
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
13
      const DiagnosticBuilder &BaseDiag = Diag;
1675
13
      BaseDiag << Value;
1676
13
      return Diag;
1677
13
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::ObjCLiteralKind>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::ObjCLiteralKind const&)
Line
Count
Source
1673
79
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
79
      const DiagnosticBuilder &BaseDiag = Diag;
1675
79
      BaseDiag << Value;
1676
79
      return Diag;
1677
79
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [3]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [3])
Line
Count
Source
1673
254
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
254
      const DiagnosticBuilder &BaseDiag = Diag;
1675
254
      BaseDiag << Value;
1676
254
      return Diag;
1677
254
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCBridgeCastKind>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCBridgeCastKind const&)
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
SemaInit.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::ReferenceKind>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::ReferenceKind const&)
Line
Count
Source
1673
126
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
126
      const DiagnosticBuilder &BaseDiag = Diag;
1675
126
      BaseDiag << Value;
1676
126
      return Diag;
1677
126
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DeclarationName>(clang::Sema::ImmediateDiagBuilder const&, clang::DeclarationName const&)
Line
Count
Source
1673
22.4k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
22.4k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
22.4k
      BaseDiag << Value;
1676
22.4k
      return Diag;
1677
22.4k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Qualifiers::ObjCLifetime>(clang::Sema::ImmediateDiagBuilder const&, clang::Qualifiers::ObjCLifetime const&)
Line
Count
Source
1673
251
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
251
      const DiagnosticBuilder &BaseDiag = Diag;
1675
251
      BaseDiag << Value;
1676
251
      return Diag;
1677
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
1673
24
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
24
      const DiagnosticBuilder &BaseDiag = Diag;
1675
24
      BaseDiag << Value;
1676
24
      return Diag;
1677
24
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCPropertyDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCPropertyDecl* const&)
Line
Count
Source
1673
31
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
31
      const DiagnosticBuilder &BaseDiag = Diag;
1675
31
      BaseDiag << Value;
1676
31
      return Diag;
1677
31
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCIvarDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCIvarDecl* const&)
Line
Count
Source
1673
46
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
46
      const DiagnosticBuilder &BaseDiag = Diag;
1675
46
      BaseDiag << Value;
1676
46
      return Diag;
1677
46
    }
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<reportOriginalDsa(clang::Sema&, (anonymous namespace)::DSAStackTy const*, clang::ValueDecl const*, (anonymous namespace)::DSAStackTy::DSAVarData const&, bool)::$_38>(clang::Sema::ImmediateDiagBuilder const&, reportOriginalDsa(clang::Sema&, (anonymous namespace)::DSAStackTy const*, clang::ValueDecl const*, (anonymous namespace)::DSAStackTy::DSAVarData const&, bool)::$_38 const&)
Line
Count
Source
1673
1.08k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1.08k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1.08k
      BaseDiag << Value;
1676
1.08k
      return Diag;
1677
1.08k
    }
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<getPrivateItem(clang::Sema&, clang::Expr*&, clang::SourceLocation&, clang::SourceRange&, bool)::$_42>(clang::Sema::ImmediateDiagBuilder const&, getPrivateItem(clang::Sema&, clang::Expr*&, clang::SourceLocation&, clang::SourceRange&, bool)::$_42 const&)
Line
Count
Source
1673
24
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
24
      const DiagnosticBuilder &BaseDiag = Diag;
1675
24
      BaseDiag << Value;
1676
24
      return Diag;
1677
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)::$_41>(clang::Sema::ImmediateDiagBuilder const&, checkNestingOfRegions(clang::Sema&, (anonymous namespace)::DSAStackTy const*, llvm::omp::Directive, clang::DeclarationNameInfo const&, llvm::omp::Directive, clang::OpenMPBindClauseKind, clang::SourceLocation)::$_41 const&)
Line
Count
Source
1673
6.16k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
6.16k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
6.16k
      BaseDiag << Value;
1676
6.16k
      return Diag;
1677
6.16k
    }
SemaOpenMP.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::OpenMPAtomicUpdateChecker::ExprAnalysisErrorCode>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::OpenMPAtomicUpdateChecker::ExprAnalysisErrorCode const&)
Line
Count
Source
1673
904
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
904
      const DiagnosticBuilder &BaseDiag = Diag;
1675
904
      BaseDiag << Value;
1676
904
      return Diag;
1677
904
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<char [13]>(clang::Sema::ImmediateDiagBuilder const&, char const (&) [13])
Line
Count
Source
1673
8
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
8
      const DiagnosticBuilder &BaseDiag = Diag;
1675
8
      BaseDiag << Value;
1676
8
      return Diag;
1677
8
    }
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
1673
98
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
98
      const DiagnosticBuilder &BaseDiag = Diag;
1675
98
      BaseDiag << Value;
1676
98
      return Diag;
1677
98
    }
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
1673
64
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
64
      const DiagnosticBuilder &BaseDiag = Diag;
1675
64
      BaseDiag << Value;
1676
64
      return Diag;
1677
64
    }
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
1673
96
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
96
      const DiagnosticBuilder &BaseDiag = Diag;
1675
96
      BaseDiag << Value;
1676
96
      return Diag;
1677
96
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::CCEKind>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::CCEKind const&)
Line
Count
Source
1673
137
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
137
      const DiagnosticBuilder &BaseDiag = Diag;
1675
137
      BaseDiag << Value;
1676
137
      return Diag;
1677
137
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Qualifiers>(clang::Sema::ImmediateDiagBuilder const&, clang::Qualifiers const&)
Line
Count
Source
1673
9
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
9
      const DiagnosticBuilder &BaseDiag = Diag;
1675
9
      BaseDiag << Value;
1676
9
      return Diag;
1677
9
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::CUDAFunctionTarget>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::CUDAFunctionTarget const&)
Line
Count
Source
1673
254
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
254
      const DiagnosticBuilder &BaseDiag = Diag;
1675
254
      BaseDiag << Value;
1676
254
      return Diag;
1677
254
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TemplateArgument>(clang::Sema::ImmediateDiagBuilder const&, clang::TemplateArgument const&)
Line
Count
Source
1673
710
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
710
      const DiagnosticBuilder &BaseDiag = Diag;
1675
710
      BaseDiag << Value;
1676
710
      return Diag;
1677
710
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<llvm::SmallString<128u> >(clang::Sema::ImmediateDiagBuilder const&, llvm::SmallString<128u> const&)
Line
Count
Source
1673
4.97k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4.97k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4.97k
      BaseDiag << Value;
1676
4.97k
      return Diag;
1677
4.97k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DeclContext*>(clang::Sema::ImmediateDiagBuilder const&, clang::DeclContext* const&)
Line
Count
Source
1673
46.7k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
46.7k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
46.7k
      BaseDiag << Value;
1676
46.7k
      return Diag;
1677
46.7k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NamedDecl const*>(clang::Sema::ImmediateDiagBuilder const&, clang::NamedDecl const* const&)
Line
Count
Source
1673
164k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
164k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
164k
      BaseDiag << Value;
1676
164k
      return Diag;
1677
164k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::FunctionDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::FunctionDecl* const&)
Line
Count
Source
1673
215k
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
215k
      const DiagnosticBuilder &BaseDiag = Diag;
1675
215k
      BaseDiag << Value;
1676
215k
      return Diag;
1677
215k
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::CXXMethodDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::CXXMethodDecl* const&)
Line
Count
Source
1673
23
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
23
      const DiagnosticBuilder &BaseDiag = Diag;
1675
23
      BaseDiag << Value;
1676
23
      return Diag;
1677
23
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::WarnUnusedResultAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::WarnUnusedResultAttr const* const&)
Line
Count
Source
1673
125
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
125
      const DiagnosticBuilder &BaseDiag = Diag;
1675
125
      BaseDiag << Value;
1676
125
      return Diag;
1677
125
    }
SemaStmt.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::BeginEndFunction>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::BeginEndFunction const&)
Line
Count
Source
1673
40
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
40
      const DiagnosticBuilder &BaseDiag = Diag;
1675
40
      BaseDiag << Value;
1676
40
      return Diag;
1677
40
    }
SemaStmt.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::Sema::checkMustTailAttr(clang::Stmt const*, clang::Attr const&)::FuncType::$_6>(clang::Sema::ImmediateDiagBuilder const&, clang::Sema::checkMustTailAttr(clang::Stmt const*, clang::Attr const&)::FuncType::$_6 const&)
Line
Count
Source
1673
12
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
12
      const DiagnosticBuilder &BaseDiag = Diag;
1675
12
      BaseDiag << Value;
1676
12
      return Diag;
1677
12
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::sema::FunctionScopeInfo::'unnamed'>(clang::Sema::ImmediateDiagBuilder const&, clang::sema::FunctionScopeInfo::'unnamed' const&)
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
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
1673
6
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
6
      const DiagnosticBuilder &BaseDiag = Diag;
1675
6
      BaseDiag << Value;
1676
6
      return Diag;
1677
6
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::LikelyAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::LikelyAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::UnlikelyAttr const*>(clang::Sema::ImmediateDiagBuilder const&, clang::UnlikelyAttr const* const&)
Line
Count
Source
1673
1
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
1
      const DiagnosticBuilder &BaseDiag = Diag;
1675
1
      BaseDiag << Value;
1676
1
      return Diag;
1677
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::NamespaceDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::NamespaceDecl* const&)
Line
Count
Source
1673
39
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
39
      const DiagnosticBuilder &BaseDiag = Diag;
1675
39
      BaseDiag << Value;
1676
39
      return Diag;
1677
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
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VarTemplateSpecializationDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::VarTemplateSpecializationDecl* const&)
Line
Count
Source
1673
3
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
3
      const DiagnosticBuilder &BaseDiag = Diag;
1675
3
      BaseDiag << Value;
1676
3
      return Diag;
1677
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::TemplateTemplateParmDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::TemplateTemplateParmDecl* const&)
Line
Count
Source
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
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
1673
4
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
4
      const DiagnosticBuilder &BaseDiag = Diag;
1675
4
      BaseDiag << Value;
1676
4
      return Diag;
1677
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::VarTemplateDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::VarTemplateDecl* const&)
Line
Count
Source
1673
21
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
21
      const DiagnosticBuilder &BaseDiag = Diag;
1675
21
      BaseDiag << Value;
1676
21
      return Diag;
1677
21
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::DeducedTemplateArgument>(clang::Sema::ImmediateDiagBuilder const&, clang::DeducedTemplateArgument const&)
Line
Count
Source
1673
19
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
19
      const DiagnosticBuilder &BaseDiag = Diag;
1675
19
      BaseDiag << Value;
1676
19
      return Diag;
1677
19
    }
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::MSPropertyDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::MSPropertyDecl* const&)
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ObjCInterfaceDecl*>(clang::Sema::ImmediateDiagBuilder const&, clang::ObjCInterfaceDecl* const&)
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
SemaType.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<(anonymous namespace)::QualifiedFunctionKind>(clang::Sema::ImmediateDiagBuilder const&, (anonymous namespace)::QualifiedFunctionKind const&)
Line
Count
Source
1673
24
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
24
      const DiagnosticBuilder &BaseDiag = Diag;
1675
24
      BaseDiag << Value;
1676
24
      return Diag;
1677
24
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<TypeDiagSelector>(clang::Sema::ImmediateDiagBuilder const&, TypeDiagSelector const&)
Line
Count
Source
1673
32
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
32
      const DiagnosticBuilder &BaseDiag = Diag;
1675
32
      BaseDiag << Value;
1676
32
      return Diag;
1677
32
    }
SemaType.cpp:clang::Sema::ImmediateDiagBuilder const& clang::operator<<<GetFullTypeForDeclarator((anonymous namespace)::TypeProcessingState&, clang::QualType, clang::TypeSourceInfo*)::$_7>(clang::Sema::ImmediateDiagBuilder const&, GetFullTypeForDeclarator((anonymous namespace)::TypeProcessingState&, clang::QualType, clang::TypeSourceInfo*)::$_7 const&)
Line
Count
Source
1673
50
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
50
      const DiagnosticBuilder &BaseDiag = Diag;
1675
50
      BaseDiag << Value;
1676
50
      return Diag;
1677
50
    }
clang::Sema::ImmediateDiagBuilder const& clang::operator<<<clang::ArrayType::ArraySizeModifier>(clang::Sema::ImmediateDiagBuilder const&, clang::ArrayType::ArraySizeModifier const&)
Line
Count
Source
1673
5
    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1674
5
      const DiagnosticBuilder &BaseDiag = Diag;
1675
5
      BaseDiag << Value;
1676
5
      return Diag;
1677
5
    }
1678
1679
    // It is necessary to limit this to rvalue reference to avoid calling this
1680
    // function with a bitfield lvalue argument since non-const reference to
1681
    // bitfield is not allowed.
1682
    template <typename T, typename = typename std::enable_if<
1683
                              !std::is_lvalue_reference<T>::value>::type>
1684
2.01M
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
2.01M
      const DiagnosticBuilder &BaseDiag = *this;
1686
2.01M
      BaseDiag << std::move(V);
1687
2.01M
      return *this;
1688
2.01M
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::SourceLocation, void>(clang::SourceLocation&&) const
Line
Count
Source
1684
329
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
329
      const DiagnosticBuilder &BaseDiag = *this;
1686
329
      BaseDiag << std::move(V);
1687
329
      return *this;
1688
329
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<unsigned int, void>(unsigned int&&) const
Line
Count
Source
1684
17.2k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
17.2k
      const DiagnosticBuilder &BaseDiag = *this;
1686
17.2k
      BaseDiag << std::move(V);
1687
17.2k
      return *this;
1688
17.2k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::FixItHint, void>(clang::FixItHint&&) const
Line
Count
Source
1684
329k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
329k
      const DiagnosticBuilder &BaseDiag = *this;
1686
329k
      BaseDiag << std::move(V);
1687
329k
      return *this;
1688
329k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<int, void>(int&&) const
Line
Count
Source
1684
333k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
333k
      const DiagnosticBuilder &BaseDiag = *this;
1686
333k
      BaseDiag << std::move(V);
1687
333k
      return *this;
1688
333k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::SourceRange, void>(clang::SourceRange&&) const
Line
Count
Source
1684
1.04M
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
1.04M
      const DiagnosticBuilder &BaseDiag = *this;
1686
1.04M
      BaseDiag << std::move(V);
1687
1.04M
      return *this;
1688
1.04M
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<bool, void>(bool&&) const
Line
Count
Source
1684
50.9k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
50.9k
      const DiagnosticBuilder &BaseDiag = *this;
1686
50.9k
      BaseDiag << std::move(V);
1687
50.9k
      return *this;
1688
50.9k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::DeclarationName, void>(clang::DeclarationName&&) const
Line
Count
Source
1684
56.1k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
56.1k
      const DiagnosticBuilder &BaseDiag = *this;
1686
56.1k
      BaseDiag << std::move(V);
1687
56.1k
      return *this;
1688
56.1k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AttributeDeclKind, void>(clang::AttributeDeclKind&&) const
Line
Count
Source
1684
69
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
69
      const DiagnosticBuilder &BaseDiag = *this;
1686
69
      BaseDiag << std::move(V);
1687
69
      return *this;
1688
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
1684
23.3k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
23.3k
      const DiagnosticBuilder &BaseDiag = *this;
1686
23.3k
      BaseDiag << std::move(V);
1687
23.3k
      return *this;
1688
23.3k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<llvm::StringRef, void>(llvm::StringRef&&) const
Line
Count
Source
1684
72.3k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
72.3k
      const DiagnosticBuilder &BaseDiag = *this;
1686
72.3k
      BaseDiag << std::move(V);
1687
72.3k
      return *this;
1688
72.3k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<char const*, void>(char const*&&) const
Line
Count
Source
1684
3.65k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
3.65k
      const DiagnosticBuilder &BaseDiag = *this;
1686
3.65k
      BaseDiag << std::move(V);
1687
3.65k
      return *this;
1688
3.65k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<CastType, void>(CastType&&) const
Line
Count
Source
1684
138
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
138
      const DiagnosticBuilder &BaseDiag = *this;
1686
138
      BaseDiag << std::move(V);
1687
138
      return *this;
1688
138
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Expr*, void>(clang::Expr*&&) const
Line
Count
Source
1684
5
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
5
      const DiagnosticBuilder &BaseDiag = *this;
1686
5
      BaseDiag << std::move(V);
1687
5
      return *this;
1688
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::FunctionDecl*, void>(clang::FunctionDecl*&&) const
Line
Count
Source
1684
185
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
185
      const DiagnosticBuilder &BaseDiag = *this;
1686
185
      BaseDiag << std::move(V);
1687
185
      return *this;
1688
185
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::AssignmentAction, void>(clang::Sema::AssignmentAction&&) const
Line
Count
Source
1684
114
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
114
      const DiagnosticBuilder &BaseDiag = *this;
1686
114
      BaseDiag << std::move(V);
1687
114
      return *this;
1688
114
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ConceptDecl*, void>(clang::ConceptDecl*&&) const
Line
Count
Source
1684
56
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
56
      const DiagnosticBuilder &BaseDiag = *this;
1686
56
      BaseDiag << std::move(V);
1687
56
      return *this;
1688
56
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::VarDecl*, void>(clang::VarDecl*&&) const
Line
Count
Source
1684
515
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
515
      const DiagnosticBuilder &BaseDiag = *this;
1686
515
      BaseDiag << std::move(V);
1687
515
      return *this;
1688
515
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Attr const*, void>(clang::Attr const*&&) const
Line
Count
Source
1684
841
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
841
      const DiagnosticBuilder &BaseDiag = *this;
1686
841
      BaseDiag << std::move(V);
1687
841
      return *this;
1688
841
    }
SemaDecl.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<CheckMultiVersionValue(clang::Sema&, clang::FunctionDecl const*)::ErrType, void>(CheckMultiVersionValue(clang::Sema&, clang::FunctionDecl const*)::ErrType&&) const
Line
Count
Source
1684
1
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
1
      const DiagnosticBuilder &BaseDiag = *this;
1686
1
      BaseDiag << std::move(V);
1687
1
      return *this;
1688
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::NestedNameSpecifier*, void>(clang::NestedNameSpecifier*&&) const
Line
Count
Source
1684
386
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
386
      const DiagnosticBuilder &BaseDiag = *this;
1686
386
      BaseDiag << std::move(V);
1687
386
      return *this;
1688
386
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::RecordDecl const*, void>(clang::RecordDecl const*&&) const
Line
Count
Source
1684
4
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
4
      const DiagnosticBuilder &BaseDiag = *this;
1686
4
      BaseDiag << std::move(V);
1687
4
      return *this;
1688
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::DeclContext*, void>(clang::DeclContext*&&) const
Line
Count
Source
1684
180
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
180
      const DiagnosticBuilder &BaseDiag = *this;
1686
180
      BaseDiag << std::move(V);
1687
180
      return *this;
1688
180
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<ShadowedDeclKind, void>(ShadowedDeclKind&&) const
Line
Count
Source
1684
48
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
48
      const DiagnosticBuilder &BaseDiag = *this;
1686
48
      BaseDiag << std::move(V);
1687
48
      return *this;
1688
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
1684
28
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
28
      const DiagnosticBuilder &BaseDiag = *this;
1686
28
      BaseDiag << std::move(V);
1687
28
      return *this;
1688
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
1684
27
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
27
      const DiagnosticBuilder &BaseDiag = *this;
1686
27
      BaseDiag << std::move(V);
1687
27
      return *this;
1688
27
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::NamedDecl const*, void>(clang::NamedDecl const*&&) const
Line
Count
Source
1684
44
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
44
      const DiagnosticBuilder &BaseDiag = *this;
1686
44
      BaseDiag << std::move(V);
1687
44
      return *this;
1688
44
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::CUDALaunchBoundsAttr const*, void>(clang::CUDALaunchBoundsAttr const*&&) const
Line
Count
Source
1684
7
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
7
      const DiagnosticBuilder &BaseDiag = *this;
1686
7
      BaseDiag << std::move(V);
1687
7
      return *this;
1688
7
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AMDGPUFlatWorkGroupSizeAttr const*, void>(clang::AMDGPUFlatWorkGroupSizeAttr const*&&) const
Line
Count
Source
1684
11
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
11
      const DiagnosticBuilder &BaseDiag = *this;
1686
11
      BaseDiag << std::move(V);
1687
11
      return *this;
1688
11
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AMDGPUWavesPerEUAttr const*, void>(clang::AMDGPUWavesPerEUAttr const*&&) const
Line
Count
Source
1684
11
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
11
      const DiagnosticBuilder &BaseDiag = *this;
1686
11
      BaseDiag << std::move(V);
1687
11
      return *this;
1688
11
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ParsedAttr const*, void>(clang::ParsedAttr const*&&) const
Line
Count
Source
1684
85
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
85
      const DiagnosticBuilder &BaseDiag = *this;
1686
85
      BaseDiag << std::move(V);
1687
85
      return *this;
1688
85
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<AttributeLangSupport::LANG, void>(AttributeLangSupport::LANG&&) const
Line
Count
Source
1684
3
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
3
      const DiagnosticBuilder &BaseDiag = *this;
1686
3
      BaseDiag << std::move(V);
1687
3
      return *this;
1688
3
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::TypedefNameDecl*, void>(clang::TypedefNameDecl*&&) const
Line
Count
Source
1684
30
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
30
      const DiagnosticBuilder &BaseDiag = *this;
1686
30
      BaseDiag << std::move(V);
1687
30
      return *this;
1688
30
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AssumeAlignedAttr*, void>(clang::AssumeAlignedAttr*&&) const
Line
Count
Source
1684
5
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
5
      const DiagnosticBuilder &BaseDiag = *this;
1686
5
      BaseDiag << std::move(V);
1687
5
      return *this;
1688
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AllocAlignAttr*, void>(clang::AllocAlignAttr*&&) const
Line
Count
Source
1684
5
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
5
      const DiagnosticBuilder &BaseDiag = *this;
1686
5
      BaseDiag << std::move(V);
1687
5
      return *this;
1688
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AllocAlignAttr const*, void>(clang::AllocAlignAttr const*&&) const
Line
Count
Source
1684
5
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
5
      const DiagnosticBuilder &BaseDiag = *this;
1686
5
      BaseDiag << std::move(V);
1687
5
      return *this;
1688
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
1684
13
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
13
      const DiagnosticBuilder &BaseDiag = *this;
1686
13
      BaseDiag << std::move(V);
1687
13
      return *this;
1688
13
    }
SemaDeclAttr.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::SecondParam, void>(clang::Sema::checkTargetAttr(clang::SourceLocation, llvm::StringRef)::SecondParam&&) const
Line
Count
Source
1684
13
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
13
      const DiagnosticBuilder &BaseDiag = *this;
1686
13
      BaseDiag << std::move(V);
1687
13
      return *this;
1688
13
    }
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
1684
13
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
13
      const DiagnosticBuilder &BaseDiag = *this;
1686
13
      BaseDiag << std::move(V);
1687
13
      return *this;
1688
13
    }
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
1684
5
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
5
      const DiagnosticBuilder &BaseDiag = *this;
1686
5
      BaseDiag << std::move(V);
1687
5
      return *this;
1688
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
1684
5
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
5
      const DiagnosticBuilder &BaseDiag = *this;
1686
5
      BaseDiag << std::move(V);
1687
5
      return *this;
1688
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
1684
5
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
5
      const DiagnosticBuilder &BaseDiag = *this;
1686
5
      BaseDiag << std::move(V);
1687
5
      return *this;
1688
5
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AlignValueAttr*, void>(clang::AlignValueAttr*&&) const
Line
Count
Source
1684
1
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
1
      const DiagnosticBuilder &BaseDiag = *this;
1686
1
      BaseDiag << std::move(V);
1687
1
      return *this;
1688
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AlignedAttr*, void>(clang::AlignedAttr*&&) const
Line
Count
Source
1684
18
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
18
      const DiagnosticBuilder &BaseDiag = *this;
1686
18
      BaseDiag << std::move(V);
1687
18
      return *this;
1688
18
    }
Unexecuted instantiation: clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::InternalLinkageAttr const*, void>(clang::InternalLinkageAttr const*&&) const
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::SwiftNameAttr const*, void>(clang::SwiftNameAttr const*&&) const
Line
Count
Source
1684
1
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
1
      const DiagnosticBuilder &BaseDiag = *this;
1686
1
      BaseDiag << std::move(V);
1687
1
      return *this;
1688
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::FieldDecl*, void>(clang::FieldDecl*&&) const
Line
Count
Source
1684
388
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
388
      const DiagnosticBuilder &BaseDiag = *this;
1686
388
      BaseDiag << std::move(V);
1687
388
      return *this;
1688
388
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AccessSpecifier, void>(clang::AccessSpecifier&&) const
Line
Count
Source
1684
8
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
8
      const DiagnosticBuilder &BaseDiag = *this;
1686
8
      BaseDiag << std::move(V);
1687
8
      return *this;
1688
8
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::NamespaceDecl*, void>(clang::NamespaceDecl*&&) const
Line
Count
Source
1684
1
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
1
      const DiagnosticBuilder &BaseDiag = *this;
1686
1
      BaseDiag << std::move(V);
1687
1
      return *this;
1688
1
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::CanQual<clang::Type>, void>(clang::CanQual<clang::Type>&&) const
Line
Count
Source
1684
11
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
11
      const DiagnosticBuilder &BaseDiag = *this;
1686
11
      BaseDiag << std::move(V);
1687
11
      return *this;
1688
11
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<std::__1::pair<clang::NullabilityKind, bool>, void>(std::__1::pair<clang::NullabilityKind, bool>&&) const
Line
Count
Source
1684
141
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
141
      const DiagnosticBuilder &BaseDiag = *this;
1686
141
      BaseDiag << std::move(V);
1687
141
      return *this;
1688
141
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::TagTypeKind, void>(clang::TagTypeKind&&) const
Line
Count
Source
1684
275
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
275
      const DiagnosticBuilder &BaseDiag = *this;
1686
275
      BaseDiag << std::move(V);
1687
275
      return *this;
1688
275
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ObjCMethodDecl const*, void>(clang::ObjCMethodDecl const*&&) const
Line
Count
Source
1684
2
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
2
      const DiagnosticBuilder &BaseDiag = *this;
1686
2
      BaseDiag << std::move(V);
1687
2
      return *this;
1688
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::QualType, void>(clang::QualType&&) const
Line
Count
Source
1684
70.9k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
70.9k
      const DiagnosticBuilder &BaseDiag = *this;
1686
70.9k
      BaseDiag << std::move(V);
1687
70.9k
      return *this;
1688
70.9k
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Selector, void>(clang::Selector&&) const
Line
Count
Source
1684
170
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
170
      const DiagnosticBuilder &BaseDiag = *this;
1686
170
      BaseDiag << std::move(V);
1687
170
      return *this;
1688
170
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::IdentifierInfo const*, void>(clang::IdentifierInfo const*&&) const
Line
Count
Source
1684
140
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
140
      const DiagnosticBuilder &BaseDiag = *this;
1686
140
      BaseDiag << std::move(V);
1687
140
      return *this;
1688
140
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::IdentifierInfo*, void>(clang::IdentifierInfo*&&) const
Line
Count
Source
1684
10.0k
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
10.0k
      const DiagnosticBuilder &BaseDiag = *this;
1686
10.0k
      BaseDiag << std::move(V);
1687
10.0k
      return *this;
1688
10.0k
    }
SemaExpr.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<$_14, void>($_14&&) const
Line
Count
Source
1684
347
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
347
      const DiagnosticBuilder &BaseDiag = *this;
1686
347
      BaseDiag << std::move(V);
1687
347
      return *this;
1688
347
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::NonTagKind, void>(clang::Sema::NonTagKind&&) const
Line
Count
Source
1684
7
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
7
      const DiagnosticBuilder &BaseDiag = *this;
1686
7
      BaseDiag << std::move(V);
1687
7
      return *this;
1688
7
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ValueDecl const*, void>(clang::ValueDecl const*&&) const
Line
Count
Source
1684
64
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
64
      const DiagnosticBuilder &BaseDiag = *this;
1686
64
      BaseDiag << std::move(V);
1687
64
      return *this;
1688
64
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ValueDecl*, void>(clang::ValueDecl*&&) const
Line
Count
Source
1684
242
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
242
      const DiagnosticBuilder &BaseDiag = *this;
1686
242
      BaseDiag << std::move(V);
1687
242
      return *this;
1688
242
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::tok::TokenKind, void>(clang::tok::TokenKind&&) const
Line
Count
Source
1684
2
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
2
      const DiagnosticBuilder &BaseDiag = *this;
1686
2
      BaseDiag << std::move(V);
1687
2
      return *this;
1688
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Qualifiers, void>(clang::Qualifiers&&) const
Line
Count
Source
1684
72
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
72
      const DiagnosticBuilder &BaseDiag = *this;
1686
72
      BaseDiag << std::move(V);
1687
72
      return *this;
1688
72
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::QualType const, void>(clang::QualType const&&) const
Line
Count
Source
1684
42
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
42
      const DiagnosticBuilder &BaseDiag = *this;
1686
42
      BaseDiag << std::move(V);
1687
42
      return *this;
1688
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
1684
12
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
12
      const DiagnosticBuilder &BaseDiag = *this;
1686
12
      BaseDiag << std::move(V);
1687
12
      return *this;
1688
12
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::CXXRecordDecl*, void>(clang::CXXRecordDecl*&&) const
Line
Count
Source
1684
657
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
657
      const DiagnosticBuilder &BaseDiag = *this;
1686
657
      BaseDiag << std::move(V);
1687
657
      return *this;
1688
657
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::ParmVarDecl*, void>(clang::ParmVarDecl*&&) const
Line
Count
Source
1684
383
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
383
      const DiagnosticBuilder &BaseDiag = *this;
1686
383
      BaseDiag << std::move(V);
1687
383
      return *this;
1688
383
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::LangAS, void>(clang::LangAS&&) const
Line
Count
Source
1684
104
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
104
      const DiagnosticBuilder &BaseDiag = *this;
1686
104
      BaseDiag << std::move(V);
1687
104
      return *this;
1688
104
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Qualifiers::ObjCLifetime, void>(clang::Qualifiers::ObjCLifetime&&) const
Line
Count
Source
1684
34
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
34
      const DiagnosticBuilder &BaseDiag = *this;
1686
34
      BaseDiag << std::move(V);
1687
34
      return *this;
1688
34
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Qualifiers::GC, void>(clang::Qualifiers::GC&&) const
Line
Count
Source
1684
4
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
4
      const DiagnosticBuilder &BaseDiag = *this;
1686
4
      BaseDiag << std::move(V);
1687
4
      return *this;
1688
4
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::TemplateDecl*, void>(clang::TemplateDecl*&&) const
Line
Count
Source
1684
6
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
6
      const DiagnosticBuilder &BaseDiag = *this;
1686
6
      BaseDiag << std::move(V);
1687
6
      return *this;
1688
6
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::RefQualifierKind, void>(clang::RefQualifierKind&&) const
Line
Count
Source
1684
22
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
22
      const DiagnosticBuilder &BaseDiag = *this;
1686
22
      BaseDiag << std::move(V);
1687
22
      return *this;
1688
22
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::NamedDecl*, void>(clang::NamedDecl*&&) const
Line
Count
Source
1684
478
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
478
      const DiagnosticBuilder &BaseDiag = *this;
1686
478
      BaseDiag << std::move(V);
1687
478
      return *this;
1688
478
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::CXXSpecialMember, void>(clang::Sema::CXXSpecialMember&&) const
Line
Count
Source
1684
900
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
900
      const DiagnosticBuilder &BaseDiag = *this;
1686
900
      BaseDiag << std::move(V);
1687
900
      return *this;
1688
900
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::CXXRecordDecl const*, void>(clang::CXXRecordDecl const*&&) const
Line
Count
Source
1684
52
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
52
      const DiagnosticBuilder &BaseDiag = *this;
1686
52
      BaseDiag << std::move(V);
1687
52
      return *this;
1688
52
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::MSPropertyDecl*, void>(clang::MSPropertyDecl*&&) const
Line
Count
Source
1684
25
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
25
      const DiagnosticBuilder &BaseDiag = *this;
1686
25
      BaseDiag << std::move(V);
1687
25
      return *this;
1688
25
    }
SemaStmt.cpp:clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<(anonymous namespace)::BeginEndFunction, void>((anonymous namespace)::BeginEndFunction&&) const
Line
Count
Source
1684
6
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
6
      const DiagnosticBuilder &BaseDiag = *this;
1686
6
      BaseDiag << std::move(V);
1687
6
      return *this;
1688
6
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<TypeDiagSelector, void>(TypeDiagSelector&&) const
Line
Count
Source
1684
25
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
25
      const DiagnosticBuilder &BaseDiag = *this;
1686
25
      BaseDiag << std::move(V);
1687
25
      return *this;
1688
25
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<llvm::IntegerType::'unnamed', void>(llvm::IntegerType::'unnamed'&&) const
Line
Count
Source
1684
2
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
2
      const DiagnosticBuilder &BaseDiag = *this;
1686
2
      BaseDiag << std::move(V);
1687
2
      return *this;
1688
2
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::Sema::CUDAFunctionTarget, void>(clang::Sema::CUDAFunctionTarget&&) const
Line
Count
Source
1684
99
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
99
      const DiagnosticBuilder &BaseDiag = *this;
1686
99
      BaseDiag << std::move(V);
1687
99
      return *this;
1688
99
    }
clang::Sema::ImmediateDiagBuilder const& clang::Sema::ImmediateDiagBuilder::operator<<<clang::AttributeArgumentNType, void>(clang::AttributeArgumentNType&&) const
Line
Count
Source
1684
172
    const ImmediateDiagBuilder &operator<<(T &&V) const {
1685
172
      const DiagnosticBuilder &BaseDiag = *this;
1686
172
      BaseDiag << std::move(V);
1687
172
      return *this;
1688
172
    }
1689
  };
1690
1691
  /// A generic diagnostic builder for errors which may or may not be deferred.
1692
  ///
1693
  /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)
1694
  /// which are not allowed to appear inside __device__ functions and are
1695
  /// allowed to appear in __host__ __device__ functions only if the host+device
1696
  /// function is never codegen'ed.
1697
  ///
1698
  /// To handle this, we use the notion of "deferred diagnostics", where we
1699
  /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.
1700
  ///
1701
  /// This class lets you emit either a regular diagnostic, a deferred
1702
  /// diagnostic, or no diagnostic at all, according to an argument you pass to
1703
  /// its constructor, thus simplifying the process of creating these "maybe
1704
  /// deferred" diagnostics.
1705
  class SemaDiagnosticBuilder {
1706
  public:
1707
    enum Kind {
1708
      /// Emit no diagnostics.
1709
      K_Nop,
1710
      /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
1711
      K_Immediate,
1712
      /// Emit the diagnostic immediately, and, if it's a warning or error, also
1713
      /// emit a call stack showing how this function can be reached by an a
1714
      /// priori known-emitted function.
1715
      K_ImmediateWithCallStack,
1716
      /// Create a deferred diagnostic, which is emitted only if the function
1717
      /// it's attached to is codegen'ed.  Also emit a call stack as with
1718
      /// K_ImmediateWithCallStack.
1719
      K_Deferred
1720
    };
1721
1722
    SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
1723
                          FunctionDecl *Fn, Sema &S);
1724
    SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D);
1725
101k
    SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default;
1726
    ~SemaDiagnosticBuilder();
1727
1728
6.52k
    bool isImmediate() const { return ImmediateDiag.hasValue(); }
1729
1730
    /// Convertible to bool: True if we immediately emitted an error, false if
1731
    /// we didn't emit an error or we created a deferred error.
1732
    ///
1733
    /// Example usage:
1734
    ///
1735
    ///   if (SemaDiagnosticBuilder(...) << foo << bar)
1736
    ///     return ExprError();
1737
    ///
1738
    /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably
1739
    /// want to use these instead of creating a SemaDiagnosticBuilder yourself.
1740
6.50k
    operator bool() const { return isImmediate(); }
1741
1742
    template <typename T>
1743
    friend const SemaDiagnosticBuilder &
1744
1.59M
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1.59M
      if (Diag.ImmediateDiag.hasValue())
1746
1.59M
        *Diag.ImmediateDiag << Value;
1747
649
      else if (Diag.PartialDiagId.hasValue())
1748
541
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
541
            << Value;
1750
1.59M
      return Diag;
1751
1.59M
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ObjCMethodDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ObjCMethodDecl const* const&)
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::FixItHint>(clang::Sema::SemaDiagnosticBuilder const&, clang::FixItHint const&)
Line
Count
Source
1744
33.7k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
33.7k
      if (Diag.ImmediateDiag.hasValue())
1746
33.7k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
33.7k
      return Diag;
1751
33.7k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::SmallString<32u> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::SmallString<32u> const&)
Line
Count
Source
1744
382
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
382
      if (Diag.ImmediateDiag.hasValue())
1746
382
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
382
      return Diag;
1751
382
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [17]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [17])
Line
Count
Source
1744
77
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
77
      if (Diag.ImmediateDiag.hasValue())
1746
77
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
77
      return Diag;
1751
77
    }
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
1744
14
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
14
      if (Diag.ImmediateDiag.hasValue())
1746
14
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
14
      return Diag;
1751
14
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [45]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [45])
Line
Count
Source
1744
90
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
90
      if (Diag.ImmediateDiag.hasValue())
1746
90
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
90
      return Diag;
1751
90
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [31]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [31])
Line
Count
Source
1744
12
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
12
      if (Diag.ImmediateDiag.hasValue())
1746
12
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
12
      return Diag;
1751
12
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [23]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [23])
Line
Count
Source
1744
33
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
33
      if (Diag.ImmediateDiag.hasValue())
1746
33
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
33
      return Diag;
1751
33
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [24]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [24])
Line
Count
Source
1744
22
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
22
      if (Diag.ImmediateDiag.hasValue())
1746
22
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
22
      return Diag;
1751
22
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NoDestroyAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NoDestroyAttr const* const&)
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NotTailCalledAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NotTailCalledAttr const* const&)
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [32]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [32])
Line
Count
Source
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [34]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [34])
Line
Count
Source
1744
44
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
44
      if (Diag.ImmediateDiag.hasValue())
1746
44
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
44
      return Diag;
1751
44
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [19]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [19])
Line
Count
Source
1744
141
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
141
      if (Diag.ImmediateDiag.hasValue())
1746
141
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
141
      return Diag;
1751
141
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [29]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [29])
Line
Count
Source
1744
62
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
62
      if (Diag.ImmediateDiag.hasValue())
1746
62
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
62
      return Diag;
1751
62
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [86]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [86])
Line
Count
Source
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CFUnknownTransferAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CFUnknownTransferAttr const* const&)
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [11]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [11])
Line
Count
Source
1744
30
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
30
      if (Diag.ImmediateDiag.hasValue())
1746
30
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
30
      return Diag;
1751
30
    }
Unexecuted instantiation: clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CFAuditedTransferAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CFAuditedTransferAttr const* const&)
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::TargetClonesAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::TargetClonesAttr const* const&)
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::TargetAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::TargetAttr const* const&)
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CPUSpecificAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CPUSpecificAttr const* const&)
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
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
1744
6
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
6
      if (Diag.ImmediateDiag.hasValue())
1746
6
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
6
      return Diag;
1751
6
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::HIPManagedAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::HIPManagedAttr const* const&)
Line
Count
Source
1744
8
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
8
      if (Diag.ImmediateDiag.hasValue())
1746
8
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
8
      return Diag;
1751
8
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDAGlobalAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDAGlobalAttr const* const&)
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [8]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [8])
Line
Count
Source
1744
94
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
94
      if (Diag.ImmediateDiag.hasValue())
1746
94
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
94
      return Diag;
1751
94
    }
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
1744
2
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
2
      if (Diag.ImmediateDiag.hasValue())
1746
2
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
2
      return Diag;
1751
2
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDAHostAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDAHostAttr const* const&)
Line
Count
Source
1744
2
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
2
      if (Diag.ImmediateDiag.hasValue())
1746
2
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
2
      return Diag;
1751
2
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [54]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [54])
Line
Count
Source
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CUDAConstantAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CUDAConstantAttr const* const&)
Line
Count
Source
1744
8
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
8
      if (Diag.ImmediateDiag.hasValue())
1746
8
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
8
      return Diag;
1751
8
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [39]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [39])
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [47]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [47])
Line
Count
Source
1744
5
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
5
      if (Diag.ImmediateDiag.hasValue())
1746
5
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
5
      return Diag;
1751
5
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [16]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [16])
Line
Count
Source
1744
27
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
27
      if (Diag.ImmediateDiag.hasValue())
1746
27
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
27
      return Diag;
1751
27
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [22]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [22])
Line
Count
Source
1744
32
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
32
      if (Diag.ImmediateDiag.hasValue())
1746
32
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
32
      return Diag;
1751
32
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::HotAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::HotAttr const* const&)
Line
Count
Source
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::InternalLinkageAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::InternalLinkageAttr const* const&)
Line
Count
Source
1744
6
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
6
      if (Diag.ImmediateDiag.hasValue())
1746
6
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
6
      return Diag;
1751
6
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [58]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [58])
Line
Count
Source
1744
230
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
230
      if (Diag.ImmediateDiag.hasValue())
1746
230
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
230
      return Diag;
1751
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
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [6]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [6])
Line
Count
Source
1744
1.60k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1.60k
      if (Diag.ImmediateDiag.hasValue())
1746
1.58k
        *Diag.ImmediateDiag << Value;
1747
20
      else if (Diag.PartialDiagId.hasValue())
1748
11
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
11
            << Value;
1750
1.60k
      return Diag;
1751
1.60k
    }
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
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ColdAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ColdAttr const* const&)
Line
Count
Source
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CommonAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CommonAttr const* const&)
Line
Count
Source
1744
5
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
5
      if (Diag.ImmediateDiag.hasValue())
1746
5
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
5
      return Diag;
1751
5
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [42]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [42])
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [43]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [43])
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Mips16Attr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::Mips16Attr const* const&)
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::MipsInterruptAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::MipsInterruptAttr const* const&)
Line
Count
Source
1744
2
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
2
      if (Diag.ImmediateDiag.hasValue())
1746
2
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
2
      return Diag;
1751
2
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::MicroMipsAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::MicroMipsAttr const* const&)
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::MipsShortCallAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::MipsShortCallAttr const* const&)
Line
Count
Source
1744
2
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
2
      if (Diag.ImmediateDiag.hasValue())
1746
2
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
2
      return Diag;
1751
2
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::MipsLongCallAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::MipsLongCallAttr const* const&)
Line
Count
Source
1744
2
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
2
      if (Diag.ImmediateDiag.hasValue())
1746
2
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
2
      return Diag;
1751
2
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [56]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [56])
Line
Count
Source
1744
17
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
17
      if (Diag.ImmediateDiag.hasValue())
1746
17
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
17
      return Diag;
1751
17
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [18]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [18])
Line
Count
Source
1744
39
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
39
      if (Diag.ImmediateDiag.hasValue())
1746
39
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
39
      return Diag;
1751
39
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [20]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [20])
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::DisableTailCallsAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::DisableTailCallsAttr const* const&)
Line
Count
Source
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [75]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [75])
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AlwaysDestroyAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::AlwaysDestroyAttr const* const&)
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [25]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [25])
Line
Count
Source
1744
7
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
7
      if (Diag.ImmediateDiag.hasValue())
1746
7
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
7
      return Diag;
1751
7
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::SpeculativeLoadHardeningAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::SpeculativeLoadHardeningAttr const* const&)
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [38]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [38])
Line
Count
Source
1744
12
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
12
      if (Diag.ImmediateDiag.hasValue())
1746
12
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
12
      return Diag;
1751
12
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [35]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [35])
Line
Count
Source
1744
2
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
2
      if (Diag.ImmediateDiag.hasValue())
1746
2
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
2
      return Diag;
1751
2
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AlwaysInlineAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::AlwaysInlineAttr const* const&)
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [28]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [28])
Line
Count
Source
1744
2
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
2
      if (Diag.ImmediateDiag.hasValue())
1746
2
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
2
      return Diag;
1751
2
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [71]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [71])
Line
Count
Source
1744
5
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
5
      if (Diag.ImmediateDiag.hasValue())
1746
5
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
5
      return Diag;
1751
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
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [49]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [49])
Line
Count
Source
1744
5
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
5
      if (Diag.ImmediateDiag.hasValue())
1746
5
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
5
      return Diag;
1751
5
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::PointerAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::PointerAttr const* const&)
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::OwnerAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::OwnerAttr const* const&)
Line
Count
Source
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [69]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [69])
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [77]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [77])
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NoSpeculativeLoadHardeningAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NoSpeculativeLoadHardeningAttr const* const&)
Line
Count
Source
1744
4
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
4
      if (Diag.ImmediateDiag.hasValue())
1746
4
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
4
      return Diag;
1751
4
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [150]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [150])
Line
Count
Source
1744
1
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
1
      if (Diag.ImmediateDiag.hasValue())
1746
1
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
1
      return Diag;
1751
1
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [50]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [50])
Line
Count
Source
1744
20
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
20
      if (Diag.ImmediateDiag.hasValue())
1746
20
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
20
      return Diag;
1751
20
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [87]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [87])
Line
Count
Source
1744
3
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3
      if (Diag.ImmediateDiag.hasValue())
1746
3
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3
      return Diag;
1751
3
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ValueDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ValueDecl* const&)
Line
Count
Source
1744
7.94k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
7.94k
      if (Diag.ImmediateDiag.hasValue())
1746
7.80k
        *Diag.ImmediateDiag << Value;
1747
141
      else if (Diag.PartialDiagId.hasValue())
1748
117
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
117
            << Value;
1750
7.94k
      return Diag;
1751
7.94k
    }
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
1744
72.1k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
72.1k
      if (Diag.ImmediateDiag.hasValue())
1746
71.9k
        *Diag.ImmediateDiag << Value;
1747
191
      else if (Diag.PartialDiagId.hasValue())
1748
157
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
157
            << Value;
1750
72.1k
      return Diag;
1751
72.1k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<unsigned int>(clang::Sema::SemaDiagnosticBuilder const&, unsigned int const&)
Line
Count
Source
1744
54.4k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
54.4k
      if (Diag.ImmediateDiag.hasValue())
1746
54.4k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
54.4k
      return Diag;
1751
54.4k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::StringRef>(clang::Sema::SemaDiagnosticBuilder const&, llvm::StringRef const&)
Line
Count
Source
1744
31.4k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
31.4k
      if (Diag.ImmediateDiag.hasValue())
1746
31.4k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
31.4k
      return Diag;
1751
31.4k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::QualType>(clang::Sema::SemaDiagnosticBuilder const&, clang::QualType const&)
Line
Count
Source
1744
294k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
294k
      if (Diag.ImmediateDiag.hasValue())
1746
294k
        *Diag.ImmediateDiag << Value;
1747
187
      else if (Diag.PartialDiagId.hasValue())
1748
155
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
155
            << Value;
1750
294k
      return Diag;
1751
294k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [7]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [7])
Line
Count
Source
1744
294
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
294
      if (Diag.ImmediateDiag.hasValue())
1746
294
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
294
      return Diag;
1751
294
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::IdentifierInfo*>(clang::Sema::SemaDiagnosticBuilder const&, clang::IdentifierInfo* const&)
Line
Count
Source
1744
3.07k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
3.07k
      if (Diag.ImmediateDiag.hasValue())
1746
3.07k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
3.07k
      return Diag;
1751
3.07k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::FunctionDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::FunctionDecl const* const&)
Line
Count
Source
1744
10.4k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
10.4k
      if (Diag.ImmediateDiag.hasValue())
1746
10.4k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
10.4k
      return Diag;
1751
10.4k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::VarDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::VarDecl const* const&)
Line
Count
Source
1744
5.08k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
5.08k
      if (Diag.ImmediateDiag.hasValue())
1746
5.08k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
5.08k
      return Diag;
1751
5.08k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<bool>(clang::Sema::SemaDiagnosticBuilder const&, bool const&)
Line
Count
Source
1744
122k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
122k
      if (Diag.ImmediateDiag.hasValue())
1746
122k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
122k
      return Diag;
1751
122k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::SourceRange>(clang::Sema::SemaDiagnosticBuilder const&, clang::SourceRange const&)
Line
Count
Source
1744
222k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
222k
      if (Diag.ImmediateDiag.hasValue())
1746
222k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
222k
      return Diag;
1751
222k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [12]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [12])
Line
Count
Source
1744
276
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
276
      if (Diag.ImmediateDiag.hasValue())
1746
276
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
276
      return Diag;
1751
276
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [5]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [5])
Line
Count
Source
1744
129
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
129
      if (Diag.ImmediateDiag.hasValue())
1746
129
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
129
      return Diag;
1751
129
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [14]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [14])
Line
Count
Source
1744
34
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
34
      if (Diag.ImmediateDiag.hasValue())
1746
34
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
34
      return Diag;
1751
34
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [9]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [9])
Line
Count
Source
1744
19.4k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
19.4k
      if (Diag.ImmediateDiag.hasValue())
1746
19.4k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
19.4k
      return Diag;
1751
19.4k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::NamedDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::NamedDecl* const&)
Line
Count
Source
1744
117k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
117k
      if (Diag.ImmediateDiag.hasValue())
1746
117k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
117k
      return Diag;
1751
117k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ASTContext::SectionInfo>(clang::Sema::SemaDiagnosticBuilder const&, clang::ASTContext::SectionInfo const&)
Line
Count
Source
1744
23
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
23
      if (Diag.ImmediateDiag.hasValue())
1746
23
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
23
      return Diag;
1751
23
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ParsedAttr>(clang::Sema::SemaDiagnosticBuilder const&, clang::ParsedAttr const&)
Line
Count
Source
1744
18.5k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
18.5k
      if (Diag.ImmediateDiag.hasValue())
1746
18.5k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
18.5k
      return Diag;
1751
18.5k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::IdentifierInfo const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::IdentifierInfo const* const&)
Line
Count
Source
1744
235
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
235
      if (Diag.ImmediateDiag.hasValue())
1746
235
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
235
      return Diag;
1751
235
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::SmallVector<clang::FixItHint, 12u> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::SmallVector<clang::FixItHint, 12u> const&)
Line
Count
Source
1744
29.4k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
29.4k
      if (Diag.ImmediateDiag.hasValue())
1746
29.4k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
29.4k
      return Diag;
1751
29.4k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<CastType>(clang::Sema::SemaDiagnosticBuilder const&, CastType const&)
Line
Count
Source
1744
399
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
399
      if (Diag.ImmediateDiag.hasValue())
1746
399
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
399
      return Diag;
1751
399
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<char [37]>(clang::Sema::SemaDiagnosticBuilder const&, char const (&) [37])
Line
Count
Source
1744
5
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
5
      if (Diag.ImmediateDiag.hasValue())
1746
5
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
5
      return Diag;
1751
5
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::SmallString<16u> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::SmallString<16u> const&)
Line
Count
Source
1744
223
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
223
      if (Diag.ImmediateDiag.hasValue())
1746
223
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
223
      return Diag;
1751
223
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<llvm::ArrayRef<clang::FixItHint> >(clang::Sema::SemaDiagnosticBuilder const&, llvm::ArrayRef<clang::FixItHint> const&)
Line
Count
Source
1744
5.44k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
5.44k
      if (Diag.ImmediateDiag.hasValue())
1746
5.44k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
5.44k
      return Diag;
1751
5.44k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CharSourceRange>(clang::Sema::SemaDiagnosticBuilder const&, clang::CharSourceRange const&)
Line
Count
Source
1744
5.33k
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
5.33k
      if (Diag.ImmediateDiag.hasValue())
1746
5.33k
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
5.33k
      return Diag;
1751
5.33k
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<AbsoluteValueKind>(clang::Sema::SemaDiagnosticBuilder const&, AbsoluteValueKind const&)
Line
Count
Source
1744
768
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
768
      if (Diag.ImmediateDiag.hasValue())
1746
768
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
768
      return Diag;
1751
768
    }
SemaChecking.cpp:clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_19>(clang::Sema::SemaDiagnosticBuilder const&, clang::Sema::DiagnoseAlwaysNonNullPointer(clang::Expr*, clang::Expr::NullPointerConstantKind, bool, clang::SourceRange)::$_19 const&)
Line
Count
Source
1744
253
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
253
      if (Diag.ImmediateDiag.hasValue())
1746
253
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
253
      return Diag;
1751
253
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::ConceptSpecializationExpr*>(clang::Sema::SemaDiagnosticBuilder const&, clang::ConceptSpecializationExpr* const&)
Line
Count
Source
1744
38
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
38
      if (Diag.ImmediateDiag.hasValue())
1746
38
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
38
      return Diag;
1751
38
    }
SemaCoroutine.cpp:clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag>(clang::Sema::SemaDiagnosticBuilder const&, isValidCoroutineContext(clang::Sema&, clang::SourceLocation, llvm::StringRef)::InvalidFuncDiag const&)
Line
Count
Source
1744
42
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
42
      if (Diag.ImmediateDiag.hasValue())
1746
42
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
42
      return Diag;
1751
42
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::LabelDecl*>(clang::Sema::SemaDiagnosticBuilder const&, clang::LabelDecl* const&)
Line
Count
Source
1744
377
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
377
      if (Diag.ImmediateDiag.hasValue())
1746
377
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
377
      return Diag;
1751
377
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AlignedAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::AlignedAttr const* const&)
Line
Count
Source
1744
8
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
8
      if (Diag.ImmediateDiag.hasValue())
1746
8
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
8
      return Diag;
1751
8
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::AlignedAttr*>(clang::Sema::SemaDiagnosticBuilder const&, clang::AlignedAttr* const&)
Line
Count
Source
1744
27
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
27
      if (Diag.ImmediateDiag.hasValue())
1746
27
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
27
      return Diag;
1751
27
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::DLLImportAttr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::DLLImportAttr const* const&)
Line
Count
Source
1744
511
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
511
      if (Diag.ImmediateDiag.hasValue())
1746
511
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
511
      return Diag;
1751
511
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::Attr const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::Attr const* const&)
Line
Count
Source
1744
7
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
7
      if (Diag.ImmediateDiag.hasValue())
1746
7
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
7
      return Diag;
1751
7
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::CXXRecordDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::CXXRecordDecl const* const&)
Line
Count
Source
1744
185
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
185
      if (Diag.ImmediateDiag.hasValue())
1746
185
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;
1750
185
      return Diag;
1751
185
    }
clang::Sema::SemaDiagnosticBuilder const& clang::operator<<<clang::FieldDecl const*>(clang::Sema::SemaDiagnosticBuilder const&, clang::FieldDecl const* const&)
Line
Count
Source
1744
159
    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1745
159
      if (Diag.ImmediateDiag.hasValue())
1746
159
        *Diag.ImmediateDiag << Value;
1747
0
      else if (Diag.PartialDiagId.hasValue())
1748
0
        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1749
0
            << Value;