Coverage Report

Created: 2022-07-16 07:03

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