clang  15.0.0git
Sema.cpp
Go to the documentation of this file.
1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
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 implements the actions class which performs semantic analysis and
10 // builds an AST out of a parse stream.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "UsedDeclVisitor.h"
15 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclFriend.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/StmtCXX.h"
29 #include "clang/Basic/Stack.h"
30 #include "clang/Basic/TargetInfo.h"
31 #include "clang/Lex/HeaderSearch.h"
33 #include "clang/Lex/Preprocessor.h"
40 #include "clang/Sema/Scope.h"
41 #include "clang/Sema/ScopeInfo.h"
47 #include "llvm/ADT/DenseMap.h"
48 #include "llvm/ADT/SmallPtrSet.h"
49 #include "llvm/Support/TimeProfiler.h"
50 
51 using namespace clang;
52 using namespace sema;
53 
55  return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
56 }
57 
58 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
59 
62  StringRef Platform) {
63  auto *SDKInfo = getDarwinSDKInfoForAvailabilityChecking();
64  if (!SDKInfo && !WarnedDarwinSDKInfoMissing) {
65  Diag(Loc, diag::warn_missing_sdksettings_for_availability_checking)
66  << Platform;
67  WarnedDarwinSDKInfoMissing = true;
68  }
69  return SDKInfo;
70 }
71 
73  if (CachedDarwinSDKInfo)
74  return CachedDarwinSDKInfo->get();
75  auto SDKInfo = parseDarwinSDKInfo(
76  PP.getFileManager().getVirtualFileSystem(),
77  PP.getHeaderSearchInfo().getHeaderSearchOpts().Sysroot);
78  if (SDKInfo && *SDKInfo) {
79  CachedDarwinSDKInfo = std::make_unique<DarwinSDKInfo>(std::move(**SDKInfo));
80  return CachedDarwinSDKInfo->get();
81  }
82  if (!SDKInfo)
83  llvm::consumeError(SDKInfo.takeError());
84  CachedDarwinSDKInfo = std::unique_ptr<DarwinSDKInfo>();
85  return nullptr;
86 }
87 
90  unsigned int Index) {
91  std::string InventedName;
92  llvm::raw_string_ostream OS(InventedName);
93 
94  if (!ParamName)
95  OS << "auto:" << Index + 1;
96  else
97  OS << ParamName->getName() << ":auto";
98 
99  OS.flush();
100  return &Context.Idents.get(OS.str());
101 }
102 
104  const Preprocessor &PP) {
105  PrintingPolicy Policy = Context.getPrintingPolicy();
106  // In diagnostics, we print _Bool as bool if the latter is defined as the
107  // former.
108  Policy.Bool = Context.getLangOpts().Bool;
109  if (!Policy.Bool) {
110  if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
111  Policy.Bool = BoolMacro->isObjectLike() &&
112  BoolMacro->getNumTokens() == 1 &&
113  BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
114  }
115  }
116 
117  // Shorten the data output if needed
118  Policy.EntireContentsOfLargeArray = false;
119 
120  return Policy;
121 }
122 
124  TUScope = S;
125  PushDeclContext(S, Context.getTranslationUnitDecl());
126 }
127 
128 namespace clang {
129 namespace sema {
130 
131 class SemaPPCallbacks : public PPCallbacks {
132  Sema *S = nullptr;
134 
135 public:
136  void set(Sema &S) { this->S = &S; }
137 
138  void reset() { S = nullptr; }
139 
140  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
142  FileID PrevFID) override {
143  if (!S)
144  return;
145  switch (Reason) {
146  case EnterFile: {
148  SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
149  if (IncludeLoc.isValid()) {
150  if (llvm::timeTraceProfilerEnabled()) {
151  const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
152  llvm::timeTraceProfilerBegin(
153  "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));
154  }
155 
156  IncludeStack.push_back(IncludeLoc);
159  IncludeLoc);
160  }
161  break;
162  }
163  case ExitFile:
164  if (!IncludeStack.empty()) {
165  if (llvm::timeTraceProfilerEnabled())
166  llvm::timeTraceProfilerEnd();
167 
170  IncludeStack.pop_back_val());
171  }
172  break;
173  default:
174  break;
175  }
176  }
177 };
178 
179 } // end namespace sema
180 } // end namespace clang
181 
182 const unsigned Sema::MaxAlignmentExponent;
183 const uint64_t Sema::MaximumAlignment;
184 
185 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
186  TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
187  : ExternalSource(nullptr), isMultiplexExternalSource(false),
188  CurFPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
189  Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
190  SourceMgr(PP.getSourceManager()), CollectStats(false),
191  CodeCompleter(CodeCompleter), CurContext(nullptr),
192  OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
193  MSPointerToMemberRepresentationMethod(
194  LangOpts.getMSPointerToMemberRepresentationMethod()),
195  VtorDispStack(LangOpts.getVtorDispMode()),
196  AlignPackStack(AlignPackInfo(getLangOpts().XLPragmaPack)),
197  DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
198  CodeSegStack(nullptr), FpPragmaStack(FPOptionsOverride()),
199  CurInitSeg(nullptr), VisContext(nullptr),
200  PragmaAttributeCurrentTargetDecl(nullptr),
201  IsBuildingRecoveryCallExpr(false), LateTemplateParser(nullptr),
202  LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
203  StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr),
204  StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
205  MSVCGuidDecl(nullptr), StdSourceLocationImplDecl(nullptr),
206  NSNumberDecl(nullptr), NSValueDecl(nullptr), NSStringDecl(nullptr),
207  StringWithUTF8StringMethod(nullptr),
208  ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
209  ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
210  DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),
211  TUKind(TUKind), NumSFINAEErrors(0),
212  FullyCheckedComparisonCategories(
213  static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
214  SatisfactionCache(Context), AccessCheckingSFINAE(false),
215  InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0),
216  ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr),
217  DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this),
218  ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
219  CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
220  assert(pp.TUKind == TUKind);
221  TUScope = nullptr;
223 
224  LoadedExternalKnownNamespaces = false;
225  for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
226  NSNumberLiteralMethods[I] = nullptr;
227 
228  if (getLangOpts().ObjC)
229  NSAPIObj.reset(new NSAPI(Context));
230 
231  if (getLangOpts().CPlusPlus)
232  FieldCollector.reset(new CXXFieldCollector());
233 
234  // Tell diagnostics how to render things from the AST library.
236 
237  // This evaluation context exists to ensure that there's always at least one
238  // valid evaluation context available. It is never removed from the
239  // evaluation stack.
240  ExprEvalContexts.emplace_back(
243 
244  // Initialization of data sharing attributes stack for OpenMP
245  InitDataSharingAttributesStack();
246 
247  std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
248  std::make_unique<sema::SemaPPCallbacks>();
249  SemaPPCallbackHandler = Callbacks.get();
250  PP.addPPCallbacks(std::move(Callbacks));
251  SemaPPCallbackHandler->set(*this);
252  if (getLangOpts().getFPEvalMethod() == LangOptions::FEM_UnsetOnCommandLine)
253  // Use setting from TargetInfo.
255  ctxt.getTargetInfo().getFPEvalMethod());
256  else
257  // Set initial value of __FLT_EVAL_METHOD__ from the command line.
259  getLangOpts().getFPEvalMethod());
260  CurFPFeatures.setFPEvalMethod(PP.getCurrentFPEvalMethod());
261  // When `-ffast-math` option is enabled, it triggers several driver math
262  // options to be enabled. Among those, only one the following two modes
263  // affect the eval-method: reciprocal or reassociate.
264  if (getLangOpts().AllowFPReassoc || getLangOpts().AllowRecip)
267 }
268 
269 // Anchor Sema's type info to this TU.
270 void Sema::anchor() {}
271 
272 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
273  DeclarationName DN = &Context.Idents.get(Name);
274  if (IdResolver.begin(DN) == IdResolver.end())
276 }
277 
279  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
280  SC->InitializeSema(*this);
281 
282  // Tell the external Sema source about this Sema object.
283  if (ExternalSemaSource *ExternalSema
284  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
285  ExternalSema->InitializeSema(*this);
286 
287  // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
288  // will not be able to merge any duplicate __va_list_tag decls correctly.
289  VAListTagName = PP.getIdentifierInfo("__va_list_tag");
290 
291  if (!TUScope)
292  return;
293 
294  // Initialize predefined 128-bit integer types, if needed.
298  // If either of the 128-bit integer types are unavailable to name lookup,
299  // define them now.
300  DeclarationName Int128 = &Context.Idents.get("__int128_t");
301  if (IdResolver.begin(Int128) == IdResolver.end())
303 
304  DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
305  if (IdResolver.begin(UInt128) == IdResolver.end())
307  }
308 
309 
310  // Initialize predefined Objective-C types:
311  if (getLangOpts().ObjC) {
312  // If 'SEL' does not yet refer to any declarations, make it refer to the
313  // predefined 'SEL'.
314  DeclarationName SEL = &Context.Idents.get("SEL");
315  if (IdResolver.begin(SEL) == IdResolver.end())
317 
318  // If 'id' does not yet refer to any declarations, make it refer to the
319  // predefined 'id'.
321  if (IdResolver.begin(Id) == IdResolver.end())
323 
324  // Create the built-in typedef for 'Class'.
325  DeclarationName Class = &Context.Idents.get("Class");
326  if (IdResolver.begin(Class) == IdResolver.end())
328 
329  // Create the built-in forward declaratino for 'Protocol'.
330  DeclarationName Protocol = &Context.Idents.get("Protocol");
331  if (IdResolver.begin(Protocol) == IdResolver.end())
333  }
334 
335  // Create the internal type for the *StringMakeConstantString builtins.
336  DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
337  if (IdResolver.begin(ConstantString) == IdResolver.end())
339 
340  // Initialize Microsoft "predefined C++ types".
341  if (getLangOpts().MSVCCompat) {
342  if (getLangOpts().CPlusPlus &&
343  IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
345  TUScope);
346 
348  }
349 
350  // Initialize predefined OpenCL types and supported extensions and (optional)
351  // core features.
352  if (getLangOpts().OpenCL) {
357  auto OCLCompatibleVersion = getLangOpts().getOpenCLCompatibleVersion();
358  if (OCLCompatibleVersion >= 200) {
359  if (getLangOpts().OpenCLCPlusPlus || getLangOpts().Blocks) {
360  addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
362  }
363  if (getLangOpts().OpenCLPipes)
364  addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
366  addImplicitTypedef("atomic_uint",
368  addImplicitTypedef("atomic_float",
370  // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
371  // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
373 
374 
375  // OpenCL v2.0 s6.13.11.6:
376  // - The atomic_long and atomic_ulong types are supported if the
377  // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
378  // extensions are supported.
379  // - The atomic_double type is only supported if double precision
380  // is supported and the cl_khr_int64_base_atomics and
381  // cl_khr_int64_extended_atomics extensions are supported.
382  // - If the device address space is 64-bits, the data types
383  // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
384  // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
385  // cl_khr_int64_extended_atomics extensions are supported.
386 
387  auto AddPointerSizeDependentTypes = [&]() {
388  auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
389  auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
390  auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
391  auto AtomicPtrDiffT =
393  addImplicitTypedef("atomic_size_t", AtomicSizeT);
394  addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
395  addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
396  addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
397  };
398 
399  if (Context.getTypeSize(Context.getSizeType()) == 32) {
400  AddPointerSizeDependentTypes();
401  }
402 
403  if (getOpenCLOptions().isSupported("cl_khr_fp16", getLangOpts())) {
404  auto AtomicHalfT = Context.getAtomicType(Context.HalfTy);
405  addImplicitTypedef("atomic_half", AtomicHalfT);
406  }
407 
408  std::vector<QualType> Atomic64BitTypes;
409  if (getOpenCLOptions().isSupported("cl_khr_int64_base_atomics",
410  getLangOpts()) &&
411  getOpenCLOptions().isSupported("cl_khr_int64_extended_atomics",
412  getLangOpts())) {
413  if (getOpenCLOptions().isSupported("cl_khr_fp64", getLangOpts())) {
414  auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
415  addImplicitTypedef("atomic_double", AtomicDoubleT);
416  Atomic64BitTypes.push_back(AtomicDoubleT);
417  }
418  auto AtomicLongT = Context.getAtomicType(Context.LongTy);
419  auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
420  addImplicitTypedef("atomic_long", AtomicLongT);
421  addImplicitTypedef("atomic_ulong", AtomicULongT);
422 
423 
424  if (Context.getTypeSize(Context.getSizeType()) == 64) {
425  AddPointerSizeDependentTypes();
426  }
427  }
428  }
429 
430 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
431  if (getOpenCLOptions().isSupported(#Ext, getLangOpts())) { \
432  addImplicitTypedef(#ExtType, Context.Id##Ty); \
433  }
434 #include "clang/Basic/OpenCLExtensionTypes.def"
435  }
436 
438 #define SVE_TYPE(Name, Id, SingletonId) \
439  addImplicitTypedef(Name, Context.SingletonId);
440 #include "clang/Basic/AArch64SVEACLETypes.def"
441  }
442 
443  if (Context.getTargetInfo().getTriple().isPPC64()) {
444 #define PPC_VECTOR_MMA_TYPE(Name, Id, Size) \
445  addImplicitTypedef(#Name, Context.Id##Ty);
446 #include "clang/Basic/PPCTypes.def"
447 #define PPC_VECTOR_VSX_TYPE(Name, Id, Size) \
448  addImplicitTypedef(#Name, Context.Id##Ty);
449 #include "clang/Basic/PPCTypes.def"
450  }
451 
453 #define RVV_TYPE(Name, Id, SingletonId) \
454  addImplicitTypedef(Name, Context.SingletonId);
455 #include "clang/Basic/RISCVVTypes.def"
456  }
457 
459  DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
460  if (IdResolver.begin(MSVaList) == IdResolver.end())
462  }
463 
464  DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
465  if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
467 }
468 
470  assert(InstantiatingSpecializations.empty() &&
471  "failed to clean up an InstantiatingTemplate?");
472 
473  if (VisContext) FreeVisContext();
474 
475  // Kill all the active scopes.
477  delete FSI;
478 
479  // Tell the SemaConsumer to forget about us; we're going out of scope.
480  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
481  SC->ForgetSema();
482 
483  // Detach from the external Sema source.
484  if (ExternalSemaSource *ExternalSema
485  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
486  ExternalSema->ForgetSema();
487 
488  // If Sema's ExternalSource is the multiplexer - we own it.
489  if (isMultiplexExternalSource)
490  delete ExternalSource;
491 
492  // Delete cached satisfactions.
493  std::vector<ConstraintSatisfaction *> Satisfactions;
494  Satisfactions.reserve(Satisfactions.size());
495  for (auto &Node : SatisfactionCache)
496  Satisfactions.push_back(&Node);
497  for (auto *Node : Satisfactions)
498  delete Node;
499 
501 
502  // Destroys data sharing attributes stack for OpenMP
503  DestroyDataSharingAttributesStack();
504 
505  // Detach from the PP callback handler which outlives Sema since it's owned
506  // by the preprocessor.
507  SemaPPCallbackHandler->reset();
508 }
509 
511  // Only warn about this once.
512  if (!WarnedStackExhausted) {
513  Diag(Loc, diag::warn_stack_exhausted);
514  WarnedStackExhausted = true;
515  }
516 }
517 
519  llvm::function_ref<void()> Fn) {
521 }
522 
523 /// makeUnavailableInSystemHeader - There is an error in the current
524 /// context. If we're still in a system header, and we can plausibly
525 /// make the relevant declaration unavailable instead of erroring, do
526 /// so and return true.
528  UnavailableAttr::ImplicitReason reason) {
529  // If we're not in a function, it's an error.
530  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
531  if (!fn) return false;
532 
533  // If we're in template instantiation, it's an error.
535  return false;
536 
537  // If that function's not in a system header, it's an error.
539  return false;
540 
541  // If the function is already unavailable, it's not an error.
542  if (fn->hasAttr<UnavailableAttr>()) return true;
543 
544  fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
545  return true;
546 }
547 
550 }
551 
552 ///Registers an external source. If an external source already exists,
553 /// creates a multiplex external source and appends to it.
554 ///
555 ///\param[in] E - A non-null external sema source.
556 ///
558  assert(E && "Cannot use with NULL ptr");
559 
560  if (!ExternalSource) {
561  ExternalSource = E;
562  return;
563  }
564 
565  if (isMultiplexExternalSource)
566  static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
567  else {
568  ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
569  isMultiplexExternalSource = true;
570  }
571 }
572 
573 /// Print out statistics about the semantic analysis.
574 void Sema::PrintStats() const {
575  llvm::errs() << "\n*** Semantic Analysis Stats:\n";
576  llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
577 
578  BumpAlloc.PrintStats();
580 }
581 
583  QualType SrcType,
584  SourceLocation Loc) {
585  Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
586  if (!ExprNullability || (*ExprNullability != NullabilityKind::Nullable &&
587  *ExprNullability != NullabilityKind::NullableResult))
588  return;
589 
590  Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
591  if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
592  return;
593 
594  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
595 }
596 
598  if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
599  E->getBeginLoc()))
600  return;
601  // nullptr only exists from C++11 on, so don't warn on its absence earlier.
602  if (!getLangOpts().CPlusPlus11)
603  return;
604 
605  if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
606  return;
608  return;
609 
610  // Don't diagnose the conversion from a 0 literal to a null pointer argument
611  // in a synthesized call to operator<=>.
612  if (!CodeSynthesisContexts.empty() &&
613  CodeSynthesisContexts.back().Kind ==
615  return;
616 
617  // If it is a macro from system header, and if the macro name is not "NULL",
618  // do not warn.
619  SourceLocation MaybeMacroLoc = E->getBeginLoc();
621  SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
622  !findMacroSpelling(MaybeMacroLoc, "NULL"))
623  return;
624 
625  Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
626  << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
627 }
628 
629 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
630 /// If there is already an implicit cast, merge into the existing one.
631 /// The result is of the given category.
634  const CXXCastPath *BasePath,
635  CheckedConversionKind CCK) {
636 #ifndef NDEBUG
637  if (VK == VK_PRValue && !E->isPRValue()) {
638  switch (Kind) {
639  default:
640  llvm_unreachable(
641  ("can't implicitly cast glvalue to prvalue with this cast "
642  "kind: " +
644  .c_str());
645  case CK_Dependent:
646  case CK_LValueToRValue:
647  case CK_ArrayToPointerDecay:
648  case CK_FunctionToPointerDecay:
649  case CK_ToVoid:
650  case CK_NonAtomicToAtomic:
651  break;
652  }
653  }
654  assert((VK == VK_PRValue || Kind == CK_Dependent || !E->isPRValue()) &&
655  "can't cast prvalue to glvalue");
656 #endif
657 
660 
661  QualType ExprTy = Context.getCanonicalType(E->getType());
663 
664  if (ExprTy == TypeTy)
665  return E;
666 
667  if (Kind == CK_ArrayToPointerDecay) {
668  // C++1z [conv.array]: The temporary materialization conversion is applied.
669  // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
670  if (getLangOpts().CPlusPlus && E->isPRValue()) {
671  // The temporary is an lvalue in C++98 and an xvalue otherwise.
673  E->getType(), E, !getLangOpts().CPlusPlus11);
674  if (Materialized.isInvalid())
675  return ExprError();
676  E = Materialized.get();
677  }
678  // C17 6.7.1p6 footnote 124: The implementation can treat any register
679  // declaration simply as an auto declaration. However, whether or not
680  // addressable storage is actually used, the address of any part of an
681  // object declared with storage-class specifier register cannot be
682  // computed, either explicitly(by use of the unary & operator as discussed
683  // in 6.5.3.2) or implicitly(by converting an array name to a pointer as
684  // discussed in 6.3.2.1).Thus, the only operator that can be applied to an
685  // array declared with storage-class specifier register is sizeof.
686  if (VK == VK_PRValue && !getLangOpts().CPlusPlus && !E->isPRValue()) {
687  if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
688  if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
689  if (VD->getStorageClass() == SC_Register) {
690  Diag(E->getExprLoc(), diag::err_typecheck_address_of)
691  << /*register variable*/ 3 << E->getSourceRange();
692  return ExprError();
693  }
694  }
695  }
696  }
697  }
698 
699  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
700  if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
701  ImpCast->setType(Ty);
702  ImpCast->setValueKind(VK);
703  return E;
704  }
705  }
706 
707  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK,
709 }
710 
711 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
712 /// to the conversion from scalar type ScalarTy to the Boolean type.
714  switch (ScalarTy->getScalarTypeKind()) {
715  case Type::STK_Bool: return CK_NoOp;
716  case Type::STK_CPointer: return CK_PointerToBoolean;
717  case Type::STK_BlockPointer: return CK_PointerToBoolean;
718  case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
719  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
720  case Type::STK_Integral: return CK_IntegralToBoolean;
721  case Type::STK_Floating: return CK_FloatingToBoolean;
722  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
723  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
724  case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
725  }
726  llvm_unreachable("unknown scalar type kind");
727 }
728 
729 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
730 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
731  if (D->getMostRecentDecl()->isUsed())
732  return true;
733 
734  if (D->isExternallyVisible())
735  return true;
736 
737  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
738  // If this is a function template and none of its specializations is used,
739  // we should warn.
740  if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
741  for (const auto *Spec : Template->specializations())
742  if (ShouldRemoveFromUnused(SemaRef, Spec))
743  return true;
744 
745  // UnusedFileScopedDecls stores the first declaration.
746  // The declaration may have become definition so check again.
747  const FunctionDecl *DeclToCheck;
748  if (FD->hasBody(DeclToCheck))
749  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
750 
751  // Later redecls may add new information resulting in not having to warn,
752  // so check again.
753  DeclToCheck = FD->getMostRecentDecl();
754  if (DeclToCheck != FD)
755  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
756  }
757 
758  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
759  // If a variable usable in constant expressions is referenced,
760  // don't warn if it isn't used: if the value of a variable is required
761  // for the computation of a constant expression, it doesn't make sense to
762  // warn even if the variable isn't odr-used. (isReferenced doesn't
763  // precisely reflect that, but it's a decent approximation.)
764  if (VD->isReferenced() &&
765  VD->mightBeUsableInConstantExpressions(SemaRef->Context))
766  return true;
767 
768  if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
769  // If this is a variable template and none of its specializations is used,
770  // we should warn.
771  for (const auto *Spec : Template->specializations())
772  if (ShouldRemoveFromUnused(SemaRef, Spec))
773  return true;
774 
775  // UnusedFileScopedDecls stores the first declaration.
776  // The declaration may have become definition so check again.
777  const VarDecl *DeclToCheck = VD->getDefinition();
778  if (DeclToCheck)
779  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
780 
781  // Later redecls may add new information resulting in not having to warn,
782  // so check again.
783  DeclToCheck = VD->getMostRecentDecl();
784  if (DeclToCheck != VD)
785  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
786  }
787 
788  return false;
789 }
790 
792  if (auto *FD = dyn_cast<FunctionDecl>(ND))
793  return FD->isExternC();
794  return cast<VarDecl>(ND)->isExternC();
795 }
796 
797 /// Determine whether ND is an external-linkage function or variable whose
798 /// type has no linkage.
800  // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
801  // because we also want to catch the case where its type has VisibleNoLinkage,
802  // which does not affect the linkage of VD.
803  return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
806 }
807 
808 /// Obtains a sorted list of functions and variables that are undefined but
809 /// ODR-used.
811  SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
812  for (const auto &UndefinedUse : UndefinedButUsed) {
813  NamedDecl *ND = UndefinedUse.first;
814 
815  // Ignore attributes that have become invalid.
816  if (ND->isInvalidDecl()) continue;
817 
818  // __attribute__((weakref)) is basically a definition.
819  if (ND->hasAttr<WeakRefAttr>()) continue;
820 
821  if (isa<CXXDeductionGuideDecl>(ND))
822  continue;
823 
824  if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
825  // An exported function will always be emitted when defined, so even if
826  // the function is inline, it doesn't have to be emitted in this TU. An
827  // imported function implies that it has been exported somewhere else.
828  continue;
829  }
830 
831  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
832  if (FD->isDefined())
833  continue;
834  if (FD->isExternallyVisible() &&
836  !FD->getMostRecentDecl()->isInlined() &&
837  !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
838  continue;
839  if (FD->getBuiltinID())
840  continue;
841  } else {
842  auto *VD = cast<VarDecl>(ND);
843  if (VD->hasDefinition() != VarDecl::DeclarationOnly)
844  continue;
845  if (VD->isExternallyVisible() &&
847  !VD->getMostRecentDecl()->isInline() &&
848  !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
849  continue;
850 
851  // Skip VarDecls that lack formal definitions but which we know are in
852  // fact defined somewhere.
853  if (VD->isKnownToBeDefined())
854  continue;
855  }
856 
857  Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
858  }
859 }
860 
861 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
862 /// or that are inline.
863 static void checkUndefinedButUsed(Sema &S) {
864  if (S.UndefinedButUsed.empty()) return;
865 
866  // Collect all the still-undefined entities with internal linkage.
868  S.getUndefinedButUsed(Undefined);
869  if (Undefined.empty()) return;
870 
871  for (auto Undef : Undefined) {
872  ValueDecl *VD = cast<ValueDecl>(Undef.first);
873  SourceLocation UseLoc = Undef.second;
874 
875  if (S.isExternalWithNoLinkageType(VD)) {
876  // C++ [basic.link]p8:
877  // A type without linkage shall not be used as the type of a variable
878  // or function with external linkage unless
879  // -- the entity has C language linkage
880  // -- the entity is not odr-used or is defined in the same TU
881  //
882  // As an extension, accept this in cases where the type is externally
883  // visible, since the function or variable actually can be defined in
884  // another translation unit in that case.
886  ? diag::ext_undefined_internal_type
887  : diag::err_undefined_internal_type)
888  << isa<VarDecl>(VD) << VD;
889  } else if (!VD->isExternallyVisible()) {
890  // FIXME: We can promote this to an error. The function or variable can't
891  // be defined anywhere else, so the program must necessarily violate the
892  // one definition rule.
893  bool IsImplicitBase = false;
894  if (const auto *BaseD = dyn_cast<FunctionDecl>(VD)) {
895  auto *DVAttr = BaseD->getAttr<OMPDeclareVariantAttr>();
896  if (DVAttr && !DVAttr->getTraitInfo().isExtensionActive(
897  llvm::omp::TraitProperty::
898  implementation_extension_disable_implicit_base)) {
899  const auto *Func = cast<FunctionDecl>(
900  cast<DeclRefExpr>(DVAttr->getVariantFuncRef())->getDecl());
901  IsImplicitBase = BaseD->isImplicit() &&
902  Func->getIdentifier()->isMangledOpenMPVariantName();
903  }
904  }
905  if (!S.getLangOpts().OpenMP || !IsImplicitBase)
906  S.Diag(VD->getLocation(), diag::warn_undefined_internal)
907  << isa<VarDecl>(VD) << VD;
908  } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
909  (void)FD;
910  assert(FD->getMostRecentDecl()->isInlined() &&
911  "used object requires definition but isn't inline or internal?");
912  // FIXME: This is ill-formed; we should reject.
913  S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
914  } else {
915  assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
916  "used var requires definition but isn't inline or internal?");
917  S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
918  }
919  if (UseLoc.isValid())
920  S.Diag(UseLoc, diag::note_used_here);
921  }
922 
923  S.UndefinedButUsed.clear();
924 }
925 
927  if (!ExternalSource)
928  return;
929 
931  ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
932  for (auto &WeakID : WeakIDs)
933  (void)WeakUndeclaredIdentifiers[WeakID.first].insert(WeakID.second);
934 }
935 
936 
937 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
938 
939 /// Returns true, if all methods and nested classes of the given
940 /// CXXRecordDecl are defined in this translation unit.
941 ///
942 /// Should only be called from ActOnEndOfTranslationUnit so that all
943 /// definitions are actually read.
945  RecordCompleteMap &MNCComplete) {
946  RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
947  if (Cache != MNCComplete.end())
948  return Cache->second;
949  if (!RD->isCompleteDefinition())
950  return false;
951  bool Complete = true;
953  E = RD->decls_end();
954  I != E && Complete; ++I) {
955  if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
956  Complete = M->isDefined() || M->isDefaulted() ||
957  (M->isPure() && !isa<CXXDestructorDecl>(M));
958  else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
959  // If the template function is marked as late template parsed at this
960  // point, it has not been instantiated and therefore we have not
961  // performed semantic analysis on it yet, so we cannot know if the type
962  // can be considered complete.
963  Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
964  F->getTemplatedDecl()->isDefined();
965  else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
966  if (R->isInjectedClassName())
967  continue;
968  if (R->hasDefinition())
969  Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
970  MNCComplete);
971  else
972  Complete = false;
973  }
974  }
975  MNCComplete[RD] = Complete;
976  return Complete;
977 }
978 
979 /// Returns true, if the given CXXRecordDecl is fully defined in this
980 /// translation unit, i.e. all methods are defined or pure virtual and all
981 /// friends, friend functions and nested classes are fully defined in this
982 /// translation unit.
983 ///
984 /// Should only be called from ActOnEndOfTranslationUnit so that all
985 /// definitions are actually read.
986 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
987  RecordCompleteMap &RecordsComplete,
988  RecordCompleteMap &MNCComplete) {
989  RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
990  if (Cache != RecordsComplete.end())
991  return Cache->second;
992  bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
994  E = RD->friend_end();
995  I != E && Complete; ++I) {
996  // Check if friend classes and methods are complete.
997  if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
998  // Friend classes are available as the TypeSourceInfo of the FriendDecl.
999  if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
1000  Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
1001  else
1002  Complete = false;
1003  } else {
1004  // Friend functions are available through the NamedDecl of FriendDecl.
1005  if (const FunctionDecl *FD =
1006  dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
1007  Complete = FD->isDefined();
1008  else
1009  // This is a template friend, give up.
1010  Complete = false;
1011  }
1012  }
1013  RecordsComplete[RD] = Complete;
1014  return Complete;
1015 }
1016 
1018  if (ExternalSource)
1019  ExternalSource->ReadUnusedLocalTypedefNameCandidates(
1022  if (TD->isReferenced())
1023  continue;
1024  Diag(TD->getLocation(), diag::warn_unused_local_typedef)
1025  << isa<TypeAliasDecl>(TD) << TD->getDeclName();
1026  }
1028 }
1029 
1030 /// This is called before the very first declaration in the translation unit
1031 /// is parsed. Note that the ASTContext may have already injected some
1032 /// declarations.
1034  if (getLangOpts().CPlusPlusModules &&
1035  getLangOpts().getCompilingModule() == LangOptions::CMK_HeaderUnit)
1036  HandleStartOfHeaderUnit();
1037  else if (getLangOpts().ModulesTS &&
1038  (getLangOpts().getCompilingModule() ==
1040  getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
1041  // We start in an implied global module fragment.
1042  SourceLocation StartOfTU =
1044  ActOnGlobalModuleFragmentDecl(StartOfTU);
1045  ModuleScopes.back().ImplicitGlobalModuleFragment = true;
1046  }
1047 }
1048 
1050  // No explicit actions are required at the end of the global module fragment.
1051  if (Kind == TUFragmentKind::Global)
1052  return;
1053 
1054  // Transfer late parsed template instantiations over to the pending template
1055  // instantiation list. During normal compilation, the late template parser
1056  // will be installed and instantiating these templates will succeed.
1057  //
1058  // If we are building a TU prefix for serialization, it is also safe to
1059  // transfer these over, even though they are not parsed. The end of the TU
1060  // should be outside of any eager template instantiation scope, so when this
1061  // AST is deserialized, these templates will not be parsed until the end of
1062  // the combined TU.
1064  LateParsedInstantiations.begin(),
1065  LateParsedInstantiations.end());
1066  LateParsedInstantiations.clear();
1067 
1068  // If DefinedUsedVTables ends up marking any virtual member functions it
1069  // might lead to more pending template instantiations, which we then need
1070  // to instantiate.
1072 
1073  // C++: Perform implicit template instantiations.
1074  //
1075  // FIXME: When we perform these implicit instantiations, we do not
1076  // carefully keep track of the point of instantiation (C++ [temp.point]).
1077  // This means that name lookup that occurs within the template
1078  // instantiation will always happen at the end of the translation unit,
1079  // so it will find some names that are not required to be found. This is
1080  // valid, but we could do better by diagnosing if an instantiation uses a
1081  // name that was not visible at its first point of instantiation.
1082  if (ExternalSource) {
1083  // Load pending instantiations from the external source.
1085  ExternalSource->ReadPendingInstantiations(Pending);
1086  for (auto PII : Pending)
1087  if (auto Func = dyn_cast<FunctionDecl>(PII.first))
1088  Func->setInstantiationIsPending(true);
1090  Pending.begin(), Pending.end());
1091  }
1092 
1093  {
1094  llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");
1096  }
1097 
1099 
1100  assert(LateParsedInstantiations.empty() &&
1101  "end of TU template instantiation should not create more "
1102  "late-parsed templates");
1103 
1104  // Report diagnostics for uncorrected delayed typos. Ideally all of them
1105  // should have been corrected by that time, but it is very hard to cover all
1106  // cases in practice.
1107  for (const auto &Typo : DelayedTypos) {
1108  // We pass an empty TypoCorrection to indicate no correction was performed.
1109  Typo.second.DiagHandler(TypoCorrection());
1110  }
1111  DelayedTypos.clear();
1112 }
1113 
1114 /// ActOnEndOfTranslationUnit - This is called at the very end of the
1115 /// translation unit when EOF is reached and all but the top-level scope is
1116 /// popped.
1118  assert(DelayedDiagnostics.getCurrentPool() == nullptr
1119  && "reached end of translation unit with a pool attached?");
1120 
1121  // If code completion is enabled, don't perform any end-of-translation-unit
1122  // work.
1124  return;
1125 
1126  // Complete translation units and modules define vtables and perform implicit
1127  // instantiations. PCH files do not.
1128  if (TUKind != TU_Prefix) {
1130 
1132  !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
1134  ? TUFragmentKind::Private
1135  : TUFragmentKind::Normal);
1136 
1139 
1141  } else {
1142  // If we are building a TU prefix for serialization, it is safe to transfer
1143  // these over, even though they are not parsed. The end of the TU should be
1144  // outside of any eager template instantiation scope, so when this AST is
1145  // deserialized, these templates will not be parsed until the end of the
1146  // combined TU.
1148  LateParsedInstantiations.begin(),
1149  LateParsedInstantiations.end());
1150  LateParsedInstantiations.clear();
1151 
1152  if (LangOpts.PCHInstantiateTemplates) {
1153  llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");
1155  }
1156  }
1157 
1160 
1161  // All delayed member exception specs should be checked or we end up accepting
1162  // incompatible declarations.
1163  assert(DelayedOverridingExceptionSpecChecks.empty());
1164  assert(DelayedEquivalentExceptionSpecChecks.empty());
1165 
1166  // All dllexport classes should have been processed already.
1167  assert(DelayedDllExportClasses.empty());
1168  assert(DelayedDllExportMemberFunctions.empty());
1169 
1170  // Remove file scoped decls that turned out to be used.
1172  std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
1174  [this](const DeclaratorDecl *DD) {
1175  return ShouldRemoveFromUnused(this, DD);
1176  }),
1178 
1179  if (TUKind == TU_Prefix) {
1180  // Translation unit prefixes don't need any of the checking below.
1182  TUScope = nullptr;
1183  return;
1184  }
1185 
1186  // Check for #pragma weak identifiers that were never declared
1188  for (const auto &WeakIDs : WeakUndeclaredIdentifiers) {
1189  if (WeakIDs.second.empty())
1190  continue;
1191 
1192  Decl *PrevDecl = LookupSingleName(TUScope, WeakIDs.first, SourceLocation(),
1194  if (PrevDecl != nullptr &&
1195  !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
1196  for (const auto &WI : WeakIDs.second)
1197  Diag(WI.getLocation(), diag::warn_attribute_wrong_decl_type)
1198  << "'weak'" << ExpectedVariableOrFunction;
1199  else
1200  for (const auto &WI : WeakIDs.second)
1201  Diag(WI.getLocation(), diag::warn_weak_identifier_undeclared)
1202  << WeakIDs.first;
1203  }
1204 
1205  if (LangOpts.CPlusPlus11 &&
1206  !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
1208 
1209  if (!Diags.hasErrorOccurred()) {
1210  if (ExternalSource)
1211  ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1212  checkUndefinedButUsed(*this);
1213  }
1214 
1215  // A global-module-fragment is only permitted within a module unit.
1216  bool DiagnosedMissingModuleDeclaration = false;
1217  if (!ModuleScopes.empty() &&
1218  ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1219  !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1220  Diag(ModuleScopes.back().BeginLoc,
1221  diag::err_module_declaration_missing_after_global_module_introducer);
1222  DiagnosedMissingModuleDeclaration = true;
1223  }
1224 
1225  if (TUKind == TU_Module) {
1226  // If we are building a module interface unit, we need to have seen the
1227  // module declaration by now.
1228  if (getLangOpts().getCompilingModule() ==
1230  (ModuleScopes.empty() ||
1231  !ModuleScopes.back().Module->isModulePurview()) &&
1232  !DiagnosedMissingModuleDeclaration) {
1233  // FIXME: Make a better guess as to where to put the module declaration.
1234  Diag(getSourceManager().getLocForStartOfFile(
1235  getSourceManager().getMainFileID()),
1236  diag::err_module_declaration_missing);
1237  }
1238 
1239  // If we are building a module, resolve all of the exported declarations
1240  // now.
1241  if (Module *CurrentModule = PP.getCurrentModule()) {
1243 
1245  Stack.push_back(CurrentModule);
1246  while (!Stack.empty()) {
1247  Module *Mod = Stack.pop_back_val();
1248 
1249  // Resolve the exported declarations and conflicts.
1250  // FIXME: Actually complain, once we figure out how to teach the
1251  // diagnostic client to deal with complaints in the module map at this
1252  // point.
1253  ModMap.resolveExports(Mod, /*Complain=*/false);
1254  ModMap.resolveUses(Mod, /*Complain=*/false);
1255  ModMap.resolveConflicts(Mod, /*Complain=*/false);
1256 
1257  // Queue the submodules, so their exports will also be resolved.
1258  Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1259  }
1260  }
1261 
1262  // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1263  // modules when they are built, not every time they are used.
1265  }
1266 
1267  // C99 6.9.2p2:
1268  // A declaration of an identifier for an object that has file
1269  // scope without an initializer, and without a storage-class
1270  // specifier or with the storage-class specifier static,
1271  // constitutes a tentative definition. If a translation unit
1272  // contains one or more tentative definitions for an identifier,
1273  // and the translation unit contains no external definition for
1274  // that identifier, then the behavior is exactly as if the
1275  // translation unit contains a file scope declaration of that
1276  // identifier, with the composite type as of the end of the
1277  // translation unit, with an initializer equal to 0.
1278  llvm::SmallSet<VarDecl *, 32> Seen;
1279  for (TentativeDefinitionsType::iterator
1280  T = TentativeDefinitions.begin(ExternalSource),
1281  TEnd = TentativeDefinitions.end();
1282  T != TEnd; ++T) {
1283  VarDecl *VD = (*T)->getActingDefinition();
1284 
1285  // If the tentative definition was completed, getActingDefinition() returns
1286  // null. If we've already seen this variable before, insert()'s second
1287  // return value is false.
1288  if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1289  continue;
1290 
1291  if (const IncompleteArrayType *ArrayT
1293  // Set the length of the array to 1 (C99 6.9.2p5).
1294  Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1296  QualType T = Context.getConstantArrayType(ArrayT->getElementType(), One,
1297  nullptr, ArrayType::Normal, 0);
1298  VD->setType(T);
1299  } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1300  diag::err_tentative_def_incomplete_type))
1301  VD->setInvalidDecl();
1302 
1303  // No initialization is performed for a tentative definition.
1305 
1306  // Notify the consumer that we've completed a tentative definition.
1307  if (!VD->isInvalidDecl())
1309  }
1310 
1311  for (auto D : ExternalDeclarations) {
1312  if (!D || D->isInvalidDecl() || D->getPreviousDecl() || !D->isUsed())
1313  continue;
1314 
1316  }
1317 
1318  // If there were errors, disable 'unused' warnings since they will mostly be
1319  // noise. Don't warn for a use from a module: either we should warn on all
1320  // file-scope declarations in modules or not at all, but whether the
1321  // declaration is used is immaterial.
1322  if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1323  // Output warning for unused file scoped decls.
1324  for (UnusedFileScopedDeclsType::iterator
1325  I = UnusedFileScopedDecls.begin(ExternalSource),
1326  E = UnusedFileScopedDecls.end(); I != E; ++I) {
1327  if (ShouldRemoveFromUnused(this, *I))
1328  continue;
1329 
1330  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1331  const FunctionDecl *DiagD;
1332  if (!FD->hasBody(DiagD))
1333  DiagD = FD;
1334  if (DiagD->isDeleted())
1335  continue; // Deleted functions are supposed to be unused.
1336  if (DiagD->isReferenced()) {
1337  if (isa<CXXMethodDecl>(DiagD))
1338  Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1339  << DiagD;
1340  else {
1341  if (FD->getStorageClass() == SC_Static &&
1342  !FD->isInlineSpecified() &&
1344  SourceMgr.getExpansionLoc(FD->getLocation())))
1345  Diag(DiagD->getLocation(),
1346  diag::warn_unneeded_static_internal_decl)
1347  << DiagD;
1348  else
1349  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1350  << /*function*/ 0 << DiagD;
1351  }
1352  } else {
1353  if (FD->getDescribedFunctionTemplate())
1354  Diag(DiagD->getLocation(), diag::warn_unused_template)
1355  << /*function*/ 0 << DiagD;
1356  else
1357  Diag(DiagD->getLocation(), isa<CXXMethodDecl>(DiagD)
1358  ? diag::warn_unused_member_function
1359  : diag::warn_unused_function)
1360  << DiagD;
1361  }
1362  } else {
1363  const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1364  if (!DiagD)
1365  DiagD = cast<VarDecl>(*I);
1366  if (DiagD->isReferenced()) {
1367  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1368  << /*variable*/ 1 << DiagD;
1369  } else if (DiagD->getType().isConstQualified()) {
1370  const SourceManager &SM = SourceMgr;
1371  if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1373  Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1374  << DiagD;
1375  } else {
1376  if (DiagD->getDescribedVarTemplate())
1377  Diag(DiagD->getLocation(), diag::warn_unused_template)
1378  << /*variable*/ 1 << DiagD;
1379  else
1380  Diag(DiagD->getLocation(), diag::warn_unused_variable) << DiagD;
1381  }
1382  }
1383  }
1384 
1386  }
1387 
1388  if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1389  // FIXME: Load additional unused private field candidates from the external
1390  // source.
1391  RecordCompleteMap RecordsComplete;
1392  RecordCompleteMap MNCComplete;
1393  for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1394  E = UnusedPrivateFields.end(); I != E; ++I) {
1395  const NamedDecl *D = *I;
1396  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1397  if (RD && !RD->isUnion() &&
1398  IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1399  Diag(D->getLocation(), diag::warn_unused_private_field)
1400  << D->getDeclName();
1401  }
1402  }
1403  }
1404 
1405  if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1406  if (ExternalSource)
1408  for (const auto &DeletedFieldInfo : DeleteExprs) {
1409  for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1410  AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1411  DeleteExprLoc.second);
1412  }
1413  }
1414  }
1415 
1416  // Check we've noticed that we're no longer parsing the initializer for every
1417  // variable. If we miss cases, then at best we have a performance issue and
1418  // at worst a rejects-valid bug.
1419  assert(ParsingInitForAutoVars.empty() &&
1420  "Didn't unmark var as having its initializer parsed");
1421 
1423  TUScope = nullptr;
1424 }
1425 
1426 
1427 //===----------------------------------------------------------------------===//
1428 // Helper functions.
1429 //===----------------------------------------------------------------------===//
1430 
1432  DeclContext *DC = CurContext;
1433 
1434  while (true) {
1435  if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC) ||
1436  isa<RequiresExprBodyDecl>(DC)) {
1437  DC = DC->getParent();
1438  } else if (!AllowLambda && isa<CXXMethodDecl>(DC) &&
1439  cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1440  cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1441  DC = DC->getParent()->getParent();
1442  } else break;
1443  }
1444 
1445  return DC;
1446 }
1447 
1448 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1449 /// to the function decl for the function being parsed. If we're currently
1450 /// in a 'block', this returns the containing context.
1452  DeclContext *DC = getFunctionLevelDeclContext(AllowLambda);
1453  return dyn_cast<FunctionDecl>(DC);
1454 }
1455 
1458  while (isa<RecordDecl>(DC))
1459  DC = DC->getParent();
1460  return dyn_cast<ObjCMethodDecl>(DC);
1461 }
1462 
1465  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1466  return cast<NamedDecl>(DC);
1467  return nullptr;
1468 }
1469 
1471  if (getLangOpts().OpenCL)
1473  return LangAS::Default;
1474 }
1475 
1476 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1477  // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1478  // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1479  // been made more painfully obvious by the refactor that introduced this
1480  // function, but it is possible that the incoming argument can be
1481  // eliminated. If it truly cannot be (for example, there is some reentrancy
1482  // issue I am not seeing yet), then there should at least be a clarifying
1483  // comment somewhere.
1486  Diags.getCurrentDiagID())) {
1488  // We'll report the diagnostic below.
1489  break;
1490 
1492  // Count this failure so that we know that template argument deduction
1493  // has failed.
1494  ++NumSFINAEErrors;
1495 
1496  // Make a copy of this suppressed diagnostic and store it with the
1497  // template-deduction information.
1498  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1499  Diagnostic DiagInfo(&Diags);
1500  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1502  }
1503 
1505  Diags.Clear();
1506  return;
1507 
1509  // Per C++ Core Issue 1170, access control is part of SFINAE.
1510  // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1511  // make access control a part of SFINAE for the purposes of checking
1512  // type traits.
1514  break;
1515 
1517 
1518  // Suppress this diagnostic.
1519  ++NumSFINAEErrors;
1520 
1521  // Make a copy of this suppressed diagnostic and store it with the
1522  // template-deduction information.
1523  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1524  Diagnostic DiagInfo(&Diags);
1525  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1527  }
1528 
1530  Diags.Clear();
1531 
1532  // Now the diagnostic state is clear, produce a C++98 compatibility
1533  // warning.
1534  Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1535 
1536  // The last diagnostic which Sema produced was ignored. Suppress any
1537  // notes attached to it.
1539  return;
1540  }
1541 
1543  // Make a copy of this suppressed diagnostic and store it with the
1544  // template-deduction information;
1545  if (*Info) {
1546  Diagnostic DiagInfo(&Diags);
1547  (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1549  }
1550 
1551  // Suppress this diagnostic.
1553  Diags.Clear();
1554  return;
1555  }
1556  }
1557 
1558  // Copy the diagnostic printing policy over the ASTContext printing policy.
1559  // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1561 
1562  // Emit the diagnostic.
1564  return;
1565 
1566  // If this is not a note, and we're in a template instantiation
1567  // that is different from the last template instantiation where
1568  // we emitted an error, print a template instantiation
1569  // backtrace.
1570  if (!DiagnosticIDs::isBuiltinNote(DiagID))
1572 }
1573 
1575 Sema::Diag(SourceLocation Loc, const PartialDiagnostic &PD, bool DeferHint) {
1576  return Diag(Loc, PD.getDiagID(), DeferHint) << PD;
1577 }
1578 
1581  return true;
1582  auto *FD = dyn_cast<FunctionDecl>(CurContext);
1583  if (!FD)
1584  return false;
1585  auto Loc = DeviceDeferredDiags.find(FD);
1586  if (Loc == DeviceDeferredDiags.end())
1587  return false;
1588  for (auto PDAt : Loc->second) {
1589  if (DiagnosticIDs::isDefaultMappingAsError(PDAt.second.getDiagID()))
1590  return true;
1591  }
1592  return false;
1593 }
1594 
1595 // Print notes showing how we can reach FD starting from an a priori
1596 // known-callable function.
1597 static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1598  auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1599  while (FnIt != S.DeviceKnownEmittedFns.end()) {
1600  // Respect error limit.
1601  if (S.Diags.hasFatalErrorOccurred())
1602  return;
1603  DiagnosticBuilder Builder(
1604  S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1605  Builder << FnIt->second.FD;
1606  FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1607  }
1608 }
1609 
1610 namespace {
1611 
1612 /// Helper class that emits deferred diagnostic messages if an entity directly
1613 /// or indirectly using the function that causes the deferred diagnostic
1614 /// messages is known to be emitted.
1615 ///
1616 /// During parsing of AST, certain diagnostic messages are recorded as deferred
1617 /// diagnostics since it is unknown whether the functions containing such
1618 /// diagnostics will be emitted. A list of potentially emitted functions and
1619 /// variables that may potentially trigger emission of functions are also
1620 /// recorded. DeferredDiagnosticsEmitter recursively visits used functions
1621 /// by each function to emit deferred diagnostics.
1622 ///
1623 /// During the visit, certain OpenMP directives or initializer of variables
1624 /// with certain OpenMP attributes will cause subsequent visiting of any
1625 /// functions enter a state which is called OpenMP device context in this
1626 /// implementation. The state is exited when the directive or initializer is
1627 /// exited. This state can change the emission states of subsequent uses
1628 /// of functions.
1629 ///
1630 /// Conceptually the functions or variables to be visited form a use graph
1631 /// where the parent node uses the child node. At any point of the visit,
1632 /// the tree nodes traversed from the tree root to the current node form a use
1633 /// stack. The emission state of the current node depends on two factors:
1634 /// 1. the emission state of the root node
1635 /// 2. whether the current node is in OpenMP device context
1636 /// If the function is decided to be emitted, its contained deferred diagnostics
1637 /// are emitted, together with the information about the use stack.
1638 ///
1639 class DeferredDiagnosticsEmitter
1640  : public UsedDeclVisitor<DeferredDiagnosticsEmitter> {
1641 public:
1643 
1644  // Whether the function is already in the current use-path.
1646 
1647  // The current use-path.
1649 
1650  // Whether the visiting of the function has been done. Done[0] is for the
1651  // case not in OpenMP device context. Done[1] is for the case in OpenMP
1652  // device context. We need two sets because diagnostics emission may be
1653  // different depending on whether it is in OpenMP device context.
1655 
1656  // Emission state of the root node of the current use graph.
1657  bool ShouldEmitRootNode;
1658 
1659  // Current OpenMP device context level. It is initialized to 0 and each
1660  // entering of device context increases it by 1 and each exit decreases
1661  // it by 1. Non-zero value indicates it is currently in device context.
1662  unsigned InOMPDeviceContext;
1663 
1664  DeferredDiagnosticsEmitter(Sema &S)
1665  : Inherited(S), ShouldEmitRootNode(false), InOMPDeviceContext(0) {}
1666 
1667  bool shouldVisitDiscardedStmt() const { return false; }
1668 
1669  void VisitOMPTargetDirective(OMPTargetDirective *Node) {
1670  ++InOMPDeviceContext;
1671  Inherited::VisitOMPTargetDirective(Node);
1672  --InOMPDeviceContext;
1673  }
1674 
1675  void visitUsedDecl(SourceLocation Loc, Decl *D) {
1676  if (isa<VarDecl>(D))
1677  return;
1678  if (auto *FD = dyn_cast<FunctionDecl>(D))
1679  checkFunc(Loc, FD);
1680  else
1681  Inherited::visitUsedDecl(Loc, D);
1682  }
1683 
1684  void checkVar(VarDecl *VD) {
1685  assert(VD->isFileVarDecl() &&
1686  "Should only check file-scope variables");
1687  if (auto *Init = VD->getInit()) {
1688  auto DevTy = OMPDeclareTargetDeclAttr::getDeviceType(VD);
1689  bool IsDev = DevTy && (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost ||
1690  *DevTy == OMPDeclareTargetDeclAttr::DT_Any);
1691  if (IsDev)
1692  ++InOMPDeviceContext;
1693  this->Visit(Init);
1694  if (IsDev)
1695  --InOMPDeviceContext;
1696  }
1697  }
1698 
1699  void checkFunc(SourceLocation Loc, FunctionDecl *FD) {
1700  auto &Done = DoneMap[InOMPDeviceContext > 0 ? 1 : 0];
1701  FunctionDecl *Caller = UsePath.empty() ? nullptr : UsePath.back();
1702  if ((!ShouldEmitRootNode && !S.getLangOpts().OpenMP && !Caller) ||
1703  S.shouldIgnoreInHostDeviceCheck(FD) || InUsePath.count(FD))
1704  return;
1705  // Finalize analysis of OpenMP-specific constructs.
1706  if (Caller && S.LangOpts.OpenMP && UsePath.size() == 1 &&
1707  (ShouldEmitRootNode || InOMPDeviceContext))
1708  S.finalizeOpenMPDelayedAnalysis(Caller, FD, Loc);
1709  if (Caller)
1710  S.DeviceKnownEmittedFns[FD] = {Caller, Loc};
1711  // Always emit deferred diagnostics for the direct users. This does not
1712  // lead to explosion of diagnostics since each user is visited at most
1713  // twice.
1714  if (ShouldEmitRootNode || InOMPDeviceContext)
1715  emitDeferredDiags(FD, Caller);
1716  // Do not revisit a function if the function body has been completely
1717  // visited before.
1718  if (!Done.insert(FD).second)
1719  return;
1720  InUsePath.insert(FD);
1721  UsePath.push_back(FD);
1722  if (auto *S = FD->getBody()) {
1723  this->Visit(S);
1724  }
1725  UsePath.pop_back();
1726  InUsePath.erase(FD);
1727  }
1728 
1729  void checkRecordedDecl(Decl *D) {
1730  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
1731  ShouldEmitRootNode = S.getEmissionStatus(FD, /*Final=*/true) ==
1733  checkFunc(SourceLocation(), FD);
1734  } else
1735  checkVar(cast<VarDecl>(D));
1736  }
1737 
1738  // Emit any deferred diagnostics for FD
1739  void emitDeferredDiags(FunctionDecl *FD, bool ShowCallStack) {
1740  auto It = S.DeviceDeferredDiags.find(FD);
1741  if (It == S.DeviceDeferredDiags.end())
1742  return;
1743  bool HasWarningOrError = false;
1744  bool FirstDiag = true;
1745  for (PartialDiagnosticAt &PDAt : It->second) {
1746  // Respect error limit.
1747  if (S.Diags.hasFatalErrorOccurred())
1748  return;
1749  const SourceLocation &Loc = PDAt.first;
1750  const PartialDiagnostic &PD = PDAt.second;
1751  HasWarningOrError |=
1752  S.getDiagnostics().getDiagnosticLevel(PD.getDiagID(), Loc) >=
1754  {
1755  DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1756  PD.Emit(Builder);
1757  }
1758  // Emit the note on the first diagnostic in case too many diagnostics
1759  // cause the note not emitted.
1760  if (FirstDiag && HasWarningOrError && ShowCallStack) {
1761  emitCallStackNotes(S, FD);
1762  FirstDiag = false;
1763  }
1764  }
1765  }
1766 };
1767 } // namespace
1768 
1770  if (ExternalSource)
1771  ExternalSource->ReadDeclsToCheckForDeferredDiags(
1772  DeclsToCheckForDeferredDiags);
1773 
1774  if ((DeviceDeferredDiags.empty() && !LangOpts.OpenMP) ||
1775  DeclsToCheckForDeferredDiags.empty())
1776  return;
1777 
1778  DeferredDiagnosticsEmitter DDE(*this);
1779  for (auto D : DeclsToCheckForDeferredDiags)
1780  DDE.checkRecordedDecl(D);
1781 }
1782 
1783 // In CUDA, there are some constructs which may appear in semantically-valid
1784 // code, but trigger errors if we ever generate code for the function in which
1785 // they appear. Essentially every construct you're not allowed to use on the
1786 // device falls into this category, because you are allowed to use these
1787 // constructs in a __host__ __device__ function, but only if that function is
1788 // never codegen'ed on the device.
1789 //
1790 // To handle semantic checking for these constructs, we keep track of the set of
1791 // functions we know will be emitted, either because we could tell a priori that
1792 // they would be emitted, or because they were transitively called by a
1793 // known-emitted function.
1794 //
1795 // We also keep a partial call graph of which not-known-emitted functions call
1796 // which other not-known-emitted functions.
1797 //
1798 // When we see something which is illegal if the current function is emitted
1799 // (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1800 // CheckCUDACall), we first check if the current function is known-emitted. If
1801 // so, we immediately output the diagnostic.
1802 //
1803 // Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1804 // until we discover that the function is known-emitted, at which point we take
1805 // it out of this map and emit the diagnostic.
1806 
1808  unsigned DiagID,
1809  FunctionDecl *Fn, Sema &S)
1810  : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1811  ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1812  switch (K) {
1813  case K_Nop:
1814  break;
1815  case K_Immediate:
1817  ImmediateDiag.emplace(
1818  ImmediateDiagBuilder(S.Diags.Report(Loc, DiagID), S, DiagID));
1819  break;
1820  case K_Deferred:
1821  assert(Fn && "Must have a function to attach the deferred diag to.");
1822  auto &Diags = S.DeviceDeferredDiags[Fn];
1823  PartialDiagId.emplace(Diags.size());
1824  Diags.emplace_back(Loc, S.PDiag(DiagID));
1825  break;
1826  }
1827 }
1828 
1830  : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1831  ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1832  PartialDiagId(D.PartialDiagId) {
1833  // Clean the previous diagnostics.
1834  D.ShowCallStack = false;
1835  D.ImmediateDiag.reset();
1836  D.PartialDiagId.reset();
1837 }
1838 
1840  if (ImmediateDiag) {
1841  // Emit our diagnostic and, if it was a warning or error, output a callstack
1842  // if Fn isn't a priori known-emitted.
1843  bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1844  DiagID, Loc) >= DiagnosticsEngine::Warning;
1845  ImmediateDiag.reset(); // Emit the immediate diag.
1846  if (IsWarningOrError && ShowCallStack)
1847  emitCallStackNotes(S, Fn);
1848  } else {
1849  assert((!PartialDiagId || ShowCallStack) &&
1850  "Must always show call stack for deferred diags.");
1851  }
1852 }
1853 
1855 Sema::targetDiag(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD) {
1856  FD = FD ? FD : getCurFunctionDecl();
1857  if (LangOpts.OpenMP)
1858  return LangOpts.OpenMPIsDevice ? diagIfOpenMPDeviceCode(Loc, DiagID, FD)
1859  : diagIfOpenMPHostCode(Loc, DiagID, FD);
1860  if (getLangOpts().CUDA)
1861  return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1862  : CUDADiagIfHostCode(Loc, DiagID);
1863 
1864  if (getLangOpts().SYCLIsDevice)
1865  return SYCLDiagIfDeviceCode(Loc, DiagID);
1866 
1868  FD, *this);
1869 }
1870 
1872  bool DeferHint) {
1873  bool IsError = Diags.getDiagnosticIDs()->isDefaultMappingAsError(DiagID);
1874  bool ShouldDefer = getLangOpts().CUDA && LangOpts.GPUDeferDiag &&
1875  DiagnosticIDs::isDeferrable(DiagID) &&
1876  (DeferHint || DeferDiags || !IsError);
1877  auto SetIsLastErrorImmediate = [&](bool Flag) {
1878  if (IsError)
1879  IsLastErrorImmediate = Flag;
1880  };
1881  if (!ShouldDefer) {
1882  SetIsLastErrorImmediate(true);
1884  DiagID, getCurFunctionDecl(), *this);
1885  }
1886 
1887  SemaDiagnosticBuilder DB = getLangOpts().CUDAIsDevice
1888  ? CUDADiagIfDeviceCode(Loc, DiagID)
1889  : CUDADiagIfHostCode(Loc, DiagID);
1890  SetIsLastErrorImmediate(DB.isImmediate());
1891  return DB;
1892 }
1893 
1895  if (isUnevaluatedContext() || Ty.isNull())
1896  return;
1897 
1898  // The original idea behind checkTypeSupport function is that unused
1899  // declarations can be replaced with an array of bytes of the same size during
1900  // codegen, such replacement doesn't seem to be possible for types without
1901  // constant byte size like zero length arrays. So, do a deep check for SYCL.
1902  if (D && LangOpts.SYCLIsDevice) {
1903  llvm::DenseSet<QualType> Visited;
1904  deepTypeCheckForSYCLDevice(Loc, Visited, D);
1905  }
1906 
1907  Decl *C = cast<Decl>(getCurLexicalContext());
1908 
1909  // Memcpy operations for structs containing a member with unsupported type
1910  // are ok, though.
1911  if (const auto *MD = dyn_cast<CXXMethodDecl>(C)) {
1912  if ((MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()) &&
1913  MD->isTrivial())
1914  return;
1915 
1916  if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(MD))
1917  if (Ctor->isCopyOrMoveConstructor() && Ctor->isTrivial())
1918  return;
1919  }
1920 
1921  // Try to associate errors with the lexical context, if that is a function, or
1922  // the value declaration otherwise.
1923  FunctionDecl *FD = isa<FunctionDecl>(C) ? cast<FunctionDecl>(C)
1924  : dyn_cast_or_null<FunctionDecl>(D);
1925 
1926  auto CheckDeviceType = [&](QualType Ty) {
1927  if (Ty->isDependentType())
1928  return;
1929 
1930  if (Ty->isBitIntType()) {
1931  if (!Context.getTargetInfo().hasBitIntType()) {
1932  PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);
1933  if (D)
1934  PD << D;
1935  else
1936  PD << "expression";
1937  targetDiag(Loc, PD, FD)
1938  << false /*show bit size*/ << 0 /*bitsize*/ << false /*return*/
1939  << Ty << Context.getTargetInfo().getTriple().str();
1940  }
1941  return;
1942  }
1943 
1944  // Check if we are dealing with two 'long double' but with different
1945  // semantics.
1946  bool LongDoubleMismatched = false;
1947  if (Ty->isRealFloatingType() && Context.getTypeSize(Ty) == 128) {
1948  const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(Ty);
1949  if ((&Sem != &llvm::APFloat::PPCDoubleDouble() &&
1951  (&Sem == &llvm::APFloat::PPCDoubleDouble() &&
1953  LongDoubleMismatched = true;
1954  }
1955 
1956  if ((Ty->isFloat16Type() && !Context.getTargetInfo().hasFloat16Type()) ||
1958  (Ty->isIbm128Type() && !Context.getTargetInfo().hasIbm128Type()) ||
1959  (Ty->isIntegerType() && Context.getTypeSize(Ty) == 128 &&
1961  LongDoubleMismatched) {
1962  PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);
1963  if (D)
1964  PD << D;
1965  else
1966  PD << "expression";
1967 
1968  if (targetDiag(Loc, PD, FD)
1969  << true /*show bit size*/
1970  << static_cast<unsigned>(Context.getTypeSize(Ty)) << Ty
1971  << false /*return*/ << Context.getTargetInfo().getTriple().str()) {
1972  if (D)
1973  D->setInvalidDecl();
1974  }
1975  if (D)
1976  targetDiag(D->getLocation(), diag::note_defined_here, FD) << D;
1977  }
1978  };
1979 
1980  auto CheckType = [&](QualType Ty, bool IsRetTy = false) {
1981  if (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice) ||
1982  LangOpts.CUDAIsDevice)
1983  CheckDeviceType(Ty);
1984 
1985  QualType UnqualTy = Ty.getCanonicalType().getUnqualifiedType();
1986  const TargetInfo &TI = Context.getTargetInfo();
1987  if (!TI.hasLongDoubleType() && UnqualTy == Context.LongDoubleTy) {
1988  PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);
1989  if (D)
1990  PD << D;
1991  else
1992  PD << "expression";
1993 
1994  if (Diag(Loc, PD, FD)
1995  << false /*show bit size*/ << 0 << Ty << false /*return*/
1996  << Context.getTargetInfo().getTriple().str()) {
1997  if (D)
1998  D->setInvalidDecl();
1999  }
2000  if (D)
2001  targetDiag(D->getLocation(), diag::note_defined_here, FD) << D;
2002  }
2003 
2004  bool IsDouble = UnqualTy == Context.DoubleTy;
2005  bool IsFloat = UnqualTy == Context.FloatTy;
2006  if (IsRetTy && !TI.hasFPReturn() && (IsDouble || IsFloat)) {
2007  PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);
2008  if (D)
2009  PD << D;
2010  else
2011  PD << "expression";
2012 
2013  if (Diag(Loc, PD, FD)
2014  << false /*show bit size*/ << 0 << Ty << true /*return*/
2015  << Context.getTargetInfo().getTriple().str()) {
2016  if (D)
2017  D->setInvalidDecl();
2018  }
2019  if (D)
2020  targetDiag(D->getLocation(), diag::note_defined_here, FD) << D;
2021  }
2022  };
2023 
2024  CheckType(Ty);
2025  if (const auto *FPTy = dyn_cast<FunctionProtoType>(Ty)) {
2026  for (const auto &ParamTy : FPTy->param_types())
2027  CheckType(ParamTy);
2028  CheckType(FPTy->getReturnType(), /*IsRetTy=*/true);
2029  }
2030  if (const auto *FNPTy = dyn_cast<FunctionNoProtoType>(Ty))
2031  CheckType(FNPTy->getReturnType(), /*IsRetTy=*/true);
2032 }
2033 
2034 /// Looks through the macro-expansion chain for the given
2035 /// location, looking for a macro expansion with the given name.
2036 /// If one is found, returns true and sets the location to that
2037 /// expansion loc.
2038 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
2039  SourceLocation loc = locref;
2040  if (!loc.isMacroID()) return false;
2041 
2042  // There's no good way right now to look at the intermediate
2043  // expansions, so just jump to the expansion location.
2044  loc = getSourceManager().getExpansionLoc(loc);
2045 
2046  // If that's written with the name, stop here.
2047  SmallString<16> buffer;
2048  if (getPreprocessor().getSpelling(loc, buffer) == name) {
2049  locref = loc;
2050  return true;
2051  }
2052  return false;
2053 }
2054 
2055 /// Determines the active Scope associated with the given declaration
2056 /// context.
2057 ///
2058 /// This routine maps a declaration context to the active Scope object that
2059 /// represents that declaration context in the parser. It is typically used
2060 /// from "scope-less" code (e.g., template instantiation, lazy creation of
2061 /// declarations) that injects a name for name-lookup purposes and, therefore,
2062 /// must update the Scope.
2063 ///
2064 /// \returns The scope corresponding to the given declaraion context, or NULL
2065 /// if no such scope is open.
2067 
2068  if (!Ctx)
2069  return nullptr;
2070 
2071  Ctx = Ctx->getPrimaryContext();
2072  for (Scope *S = getCurScope(); S; S = S->getParent()) {
2073  // Ignore scopes that cannot have declarations. This is important for
2074  // out-of-line definitions of static class members.
2075  if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
2076  if (DeclContext *Entity = S->getEntity())
2077  if (Ctx == Entity->getPrimaryContext())
2078  return S;
2079  }
2080 
2081  return nullptr;
2082 }
2083 
2084 /// Enter a new function scope
2086  if (FunctionScopes.empty() && CachedFunctionScope) {
2087  // Use CachedFunctionScope to avoid allocating memory when possible.
2088  CachedFunctionScope->Clear();
2089  FunctionScopes.push_back(CachedFunctionScope.release());
2090  } else {
2092  }
2093  if (LangOpts.OpenMP)
2094  pushOpenMPFunctionRegion();
2095 }
2096 
2097 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
2099  BlockScope, Block));
2100 }
2101 
2103  LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
2104  FunctionScopes.push_back(LSI);
2105  return LSI;
2106 }
2107 
2109  if (LambdaScopeInfo *const LSI = getCurLambda()) {
2110  LSI->AutoTemplateParameterDepth = Depth;
2111  return;
2112  }
2113  llvm_unreachable(
2114  "Remove assertion if intentionally called in a non-lambda context.");
2115 }
2116 
2117 // Check that the type of the VarDecl has an accessible copy constructor and
2118 // resolve its destructor's exception specification.
2119 // This also performs initialization of block variables when they are moved
2120 // to the heap. It uses the same rules as applicable for implicit moves
2121 // according to the C++ standard in effect ([class.copy.elision]p3).
2122 static void checkEscapingByref(VarDecl *VD, Sema &S) {
2123  QualType T = VD->getType();
2126  SourceLocation Loc = VD->getLocation();
2127  Expr *VarRef =
2128  new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
2129  ExprResult Result;
2130  auto IE = InitializedEntity::InitializeBlock(Loc, T);
2131  if (S.getLangOpts().CPlusPlus2b) {
2132  auto *E = ImplicitCastExpr::Create(S.Context, T, CK_NoOp, VarRef, nullptr,
2134  Result = S.PerformCopyInitialization(IE, SourceLocation(), E);
2135  } else {
2138  VarRef);
2139  }
2140 
2141  if (!Result.isInvalid()) {
2142  Result = S.MaybeCreateExprWithCleanups(Result);
2143  Expr *Init = Result.getAs<Expr>();
2144  S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
2145  }
2146 
2147  // The destructor's exception specification is needed when IRGen generates
2148  // block copy/destroy functions. Resolve it here.
2149  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
2150  if (CXXDestructorDecl *DD = RD->getDestructor()) {
2151  auto *FPT = DD->getType()->getAs<FunctionProtoType>();
2152  S.ResolveExceptionSpec(Loc, FPT);
2153  }
2154 }
2155 
2156 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
2157  // Set the EscapingByref flag of __block variables captured by
2158  // escaping blocks.
2159  for (const BlockDecl *BD : FSI.Blocks) {
2160  for (const BlockDecl::Capture &BC : BD->captures()) {
2161  VarDecl *VD = BC.getVariable();
2162  if (VD->hasAttr<BlocksAttr>()) {
2163  // Nothing to do if this is a __block variable captured by a
2164  // non-escaping block.
2165  if (BD->doesNotEscape())
2166  continue;
2167  VD->setEscapingByref();
2168  }
2169  // Check whether the captured variable is or contains an object of
2170  // non-trivial C union type.
2171  QualType CapType = BC.getVariable()->getType();
2174  S.checkNonTrivialCUnion(BC.getVariable()->getType(),
2175  BD->getCaretLocation(),
2178  }
2179  }
2180 
2181  for (VarDecl *VD : FSI.ByrefBlockVars) {
2182  // __block variables might require us to capture a copy-initializer.
2183  if (!VD->isEscapingByref())
2184  continue;
2185  // It's currently invalid to ever have a __block variable with an
2186  // array type; should we diagnose that here?
2187  // Regardless, we don't want to ignore array nesting when
2188  // constructing this copy.
2189  if (VD->getType()->isStructureOrClassType())
2190  checkEscapingByref(VD, S);
2191  }
2192 }
2193 
2194 /// Pop a function (or block or lambda or captured region) scope from the stack.
2195 ///
2196 /// \param WP The warning policy to use for CFG-based warnings, or null if such
2197 /// warnings should not be produced.
2198 /// \param D The declaration corresponding to this function scope, if producing
2199 /// CFG-based warnings.
2200 /// \param BlockType The type of the block expression, if D is a BlockDecl.
2203  const Decl *D, QualType BlockType) {
2204  assert(!FunctionScopes.empty() && "mismatched push/pop!");
2205 
2206  markEscapingByrefs(*FunctionScopes.back(), *this);
2207 
2210 
2211  if (LangOpts.OpenMP)
2212  popOpenMPFunctionRegion(Scope.get());
2213 
2214  // Issue any analysis-based warnings.
2215  if (WP && D)
2216  AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
2217  else
2218  for (const auto &PUD : Scope->PossiblyUnreachableDiags)
2219  Diag(PUD.Loc, PUD.PD);
2220 
2221  return Scope;
2222 }
2223 
2226  // Stash the function scope for later reuse if it's for a normal function.
2227  if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
2228  Self->CachedFunctionScope.reset(Scope);
2229  else
2230  delete Scope;
2231 }
2232 
2233 void Sema::PushCompoundScope(bool IsStmtExpr) {
2234  getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
2235 }
2236 
2238  FunctionScopeInfo *CurFunction = getCurFunction();
2239  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
2240 
2241  CurFunction->CompoundScopes.pop_back();
2242 }
2243 
2244 /// Determine whether any errors occurred within this function/method/
2245 /// block.
2248 }
2249 
2251  if (!FunctionScopes.empty())
2252  FunctionScopes.back()->setHasBranchIntoScope();
2253 }
2254 
2256  if (!FunctionScopes.empty())
2257  FunctionScopes.back()->setHasBranchProtectedScope();
2258 }
2259 
2261  if (!FunctionScopes.empty())
2262  FunctionScopes.back()->setHasIndirectGoto();
2263 }
2264 
2266  if (!FunctionScopes.empty())
2267  FunctionScopes.back()->setHasMustTail();
2268 }
2269 
2271  if (FunctionScopes.empty())
2272  return nullptr;
2273 
2274  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
2275  if (CurBSI && CurBSI->TheDecl &&
2276  !CurBSI->TheDecl->Encloses(CurContext)) {
2277  // We have switched contexts due to template instantiation.
2278  assert(!CodeSynthesisContexts.empty());
2279  return nullptr;
2280  }
2281 
2282  return CurBSI;
2283 }
2284 
2286  if (FunctionScopes.empty())
2287  return nullptr;
2288 
2289  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
2290  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
2291  continue;
2292  return FunctionScopes[e];
2293  }
2294  return nullptr;
2295 }
2296 
2298  for (auto *Scope : llvm::reverse(FunctionScopes)) {
2299  if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Scope)) {
2300  if (LSI->Lambda && !LSI->Lambda->Encloses(CurContext)) {
2301  // We have switched contexts due to template instantiation.
2302  // FIXME: We should swap out the FunctionScopes during code synthesis
2303  // so that we don't need to check for this.
2304  assert(!CodeSynthesisContexts.empty());
2305  return nullptr;
2306  }
2307  return LSI;
2308  }
2309  }
2310  return nullptr;
2311 }
2312 
2313 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
2314  if (FunctionScopes.empty())
2315  return nullptr;
2316 
2317  auto I = FunctionScopes.rbegin();
2318  if (IgnoreNonLambdaCapturingScope) {
2319  auto E = FunctionScopes.rend();
2320  while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
2321  ++I;
2322  if (I == E)
2323  return nullptr;
2324  }
2325  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
2326  if (CurLSI && CurLSI->Lambda &&
2327  !CurLSI->Lambda->Encloses(CurContext)) {
2328  // We have switched contexts due to template instantiation.
2329  assert(!CodeSynthesisContexts.empty());
2330  return nullptr;
2331  }
2332 
2333  return CurLSI;
2334 }
2335 
2336 // We have a generic lambda if we parsed auto parameters, or we have
2337 // an associated template parameter list.
2339  if (LambdaScopeInfo *LSI = getCurLambda()) {
2340  return (LSI->TemplateParams.size() ||
2341  LSI->GLTemplateParameterList) ? LSI : nullptr;
2342  }
2343  return nullptr;
2344 }
2345 
2346 
2348  if (!LangOpts.RetainCommentsFromSystemHeaders &&
2349  SourceMgr.isInSystemHeader(Comment.getBegin()))
2350  return;
2351  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
2352  if (RC.isAlmostTrailingComment()) {
2353  SourceRange MagicMarkerRange(Comment.getBegin(),
2354  Comment.getBegin().getLocWithOffset(3));
2355  StringRef MagicMarkerText;
2356  switch (RC.getKind()) {
2358  MagicMarkerText = "///<";
2359  break;
2361  MagicMarkerText = "/**<";
2362  break;
2363  default:
2364  llvm_unreachable("if this is an almost Doxygen comment, "
2365  "it should be ordinary");
2366  }
2367  Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
2368  FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
2369  }
2370  Context.addComment(RC);
2371 }
2372 
2373 // Pin this vtable to this file.
2375 char ExternalSemaSource::ID;
2376 
2379 
2381  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
2382 }
2383 
2385  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
2386 
2388  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
2389 
2390 /// Figure out if an expression could be turned into a call.
2391 ///
2392 /// Use this when trying to recover from an error where the programmer may have
2393 /// written just the name of a function instead of actually calling it.
2394 ///
2395 /// \param E - The expression to examine.
2396 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
2397 /// with no arguments, this parameter is set to the type returned by such a
2398 /// call; otherwise, it is set to an empty QualType.
2399 /// \param OverloadSet - If the expression is an overloaded function
2400 /// name, this parameter is populated with the decls of the various overloads.
2401 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
2402  UnresolvedSetImpl &OverloadSet) {
2403  ZeroArgCallReturnTy = QualType();
2404  OverloadSet.clear();
2405 
2406  const OverloadExpr *Overloads = nullptr;
2407  bool IsMemExpr = false;
2408  if (E.getType() == Context.OverloadTy) {
2409  OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
2410 
2411  // Ignore overloads that are pointer-to-member constants.
2412  if (FR.HasFormOfMemberPointer)
2413  return false;
2414 
2415  Overloads = FR.Expression;
2416  } else if (E.getType() == Context.BoundMemberTy) {
2417  Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
2418  IsMemExpr = true;
2419  }
2420 
2421  bool Ambiguous = false;
2422  bool IsMV = false;
2423 
2424  if (Overloads) {
2425  for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
2426  DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
2427  OverloadSet.addDecl(*it);
2428 
2429  // Check whether the function is a non-template, non-member which takes no
2430  // arguments.
2431  if (IsMemExpr)
2432  continue;
2433  if (const FunctionDecl *OverloadDecl
2434  = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
2435  if (OverloadDecl->getMinRequiredArguments() == 0) {
2436  if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
2437  (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
2438  OverloadDecl->isCPUSpecificMultiVersion()))) {
2439  ZeroArgCallReturnTy = QualType();
2440  Ambiguous = true;
2441  } else {
2442  ZeroArgCallReturnTy = OverloadDecl->getReturnType();
2443  IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
2444  OverloadDecl->isCPUSpecificMultiVersion();
2445  }
2446  }
2447  }
2448  }
2449 
2450  // If it's not a member, use better machinery to try to resolve the call
2451  if (!IsMemExpr)
2452  return !ZeroArgCallReturnTy.isNull();
2453  }
2454 
2455  // Attempt to call the member with no arguments - this will correctly handle
2456  // member templates with defaults/deduction of template arguments, overloads
2457  // with default arguments, etc.
2458  if (IsMemExpr && !E.isTypeDependent()) {
2459  Sema::TentativeAnalysisScope Trap(*this);
2461  None, SourceLocation());
2462  if (R.isUsable()) {
2463  ZeroArgCallReturnTy = R.get()->getType();
2464  return true;
2465  }
2466  return false;
2467  }
2468 
2469  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
2470  if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
2471  if (Fun->getMinRequiredArguments() == 0)
2472  ZeroArgCallReturnTy = Fun->getReturnType();
2473  return true;
2474  }
2475  }
2476 
2477  // We don't have an expression that's convenient to get a FunctionDecl from,
2478  // but we can at least check if the type is "function of 0 arguments".
2479  QualType ExprTy = E.getType();
2480  const FunctionType *FunTy = nullptr;
2481  QualType PointeeTy = ExprTy->getPointeeType();
2482  if (!PointeeTy.isNull())
2483  FunTy = PointeeTy->getAs<FunctionType>();
2484  if (!FunTy)
2485  FunTy = ExprTy->getAs<FunctionType>();
2486 
2487  if (const FunctionProtoType *FPT =
2488  dyn_cast_or_null<FunctionProtoType>(FunTy)) {
2489  if (FPT->getNumParams() == 0)
2490  ZeroArgCallReturnTy = FunTy->getReturnType();
2491  return true;
2492  }
2493  return false;
2494 }
2495 
2496 /// Give notes for a set of overloads.
2497 ///
2498 /// A companion to tryExprAsCall. In cases when the name that the programmer
2499 /// wrote was an overloaded function, we may be able to make some guesses about
2500 /// plausible overloads based on their return types; such guesses can be handed
2501 /// off to this method to be emitted as notes.
2502 ///
2503 /// \param Overloads - The overloads to note.
2504 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
2505 /// -fshow-overloads=best, this is the location to attach to the note about too
2506 /// many candidates. Typically this will be the location of the original
2507 /// ill-formed expression.
2508 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
2509  const SourceLocation FinalNoteLoc) {
2510  unsigned ShownOverloads = 0;
2511  unsigned SuppressedOverloads = 0;
2512  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
2513  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2514  if (ShownOverloads >= S.Diags.getNumOverloadCandidatesToShow()) {
2515  ++SuppressedOverloads;
2516  continue;
2517  }
2518 
2519  NamedDecl *Fn = (*It)->getUnderlyingDecl();
2520  // Don't print overloads for non-default multiversioned functions.
2521  if (const auto *FD = Fn->getAsFunction()) {
2522  if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
2523  !FD->getAttr<TargetAttr>()->isDefaultVersion())
2524  continue;
2525  }
2526  S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
2527  ++ShownOverloads;
2528  }
2529 
2530  S.Diags.overloadCandidatesShown(ShownOverloads);
2531 
2532  if (SuppressedOverloads)
2533  S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
2534  << SuppressedOverloads;
2535 }
2536 
2538  const UnresolvedSetImpl &Overloads,
2539  bool (*IsPlausibleResult)(QualType)) {
2540  if (!IsPlausibleResult)
2541  return noteOverloads(S, Overloads, Loc);
2542 
2543  UnresolvedSet<2> PlausibleOverloads;
2544  for (OverloadExpr::decls_iterator It = Overloads.begin(),
2545  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2546  const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
2547  QualType OverloadResultTy = OverloadDecl->getReturnType();
2548  if (IsPlausibleResult(OverloadResultTy))
2549  PlausibleOverloads.addDecl(It.getDecl());
2550  }
2551  noteOverloads(S, PlausibleOverloads, Loc);
2552 }
2553 
2554 /// Determine whether the given expression can be called by just
2555 /// putting parentheses after it. Notably, expressions with unary
2556 /// operators can't be because the unary operator will start parsing
2557 /// outside the call.
2558 static bool IsCallableWithAppend(Expr *E) {
2559  E = E->IgnoreImplicit();
2560  return (!isa<CStyleCastExpr>(E) &&
2561  !isa<UnaryOperator>(E) &&
2562  !isa<BinaryOperator>(E) &&
2563  !isa<CXXOperatorCallExpr>(E));
2564 }
2565 
2567  if (const auto *UO = dyn_cast<UnaryOperator>(E))
2568  E = UO->getSubExpr();
2569 
2570  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2571  if (ULE->getNumDecls() == 0)
2572  return false;
2573 
2574  const NamedDecl *ND = *ULE->decls_begin();
2575  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2577  }
2578  return false;
2579 }
2580 
2582  bool ForceComplain,
2583  bool (*IsPlausibleResult)(QualType)) {
2584  SourceLocation Loc = E.get()->getExprLoc();
2585  SourceRange Range = E.get()->getSourceRange();
2586  UnresolvedSet<4> Overloads;
2587 
2588  // If this is a SFINAE context, don't try anything that might trigger ADL
2589  // prematurely.
2590  if (!isSFINAEContext()) {
2591  QualType ZeroArgCallTy;
2592  if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
2593  !ZeroArgCallTy.isNull() &&
2594  (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2595  // At this point, we know E is potentially callable with 0
2596  // arguments and that it returns something of a reasonable type,
2597  // so we can emit a fixit and carry on pretending that E was
2598  // actually a CallExpr.
2599  SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
2600  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2601  Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2602  << (IsCallableWithAppend(E.get())
2603  ? FixItHint::CreateInsertion(ParenInsertionLoc,
2604  "()")
2605  : FixItHint());
2606  if (!IsMV)
2607  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2608 
2609  // FIXME: Try this before emitting the fixit, and suppress diagnostics
2610  // while doing so.
2611  E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
2612  Range.getEnd().getLocWithOffset(1));
2613  return true;
2614  }
2615  }
2616  if (!ForceComplain) return false;
2617 
2618  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2619  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2620  if (!IsMV)
2621  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2622  E = ExprError();
2623  return true;
2624 }
2625 
2627  if (!Ident_super)
2628  Ident_super = &Context.Idents.get("super");
2629  return Ident_super;
2630 }
2631 
2633  if (!Ident___float128)
2634  Ident___float128 = &Context.Idents.get("__float128");
2635  return Ident___float128;
2636 }
2637 
2640  unsigned OpenMPCaptureLevel) {
2641  auto *CSI = new CapturedRegionScopeInfo(
2642  getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2643  (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0,
2644  OpenMPCaptureLevel);
2645  CSI->ReturnType = Context.VoidTy;
2646  FunctionScopes.push_back(CSI);
2647 }
2648 
2650  if (FunctionScopes.empty())
2651  return nullptr;
2652 
2653  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2654 }
2655 
2656 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2658  return DeleteExprs;
2659 }
2660 
2662  : S(S), OldFPFeaturesState(S.CurFPFeatures),
2663  OldOverrides(S.FpPragmaStack.CurrentValue),
2664  OldEvalMethod(S.PP.getCurrentFPEvalMethod()),
2665  OldFPPragmaLocation(S.PP.getLastFPEvalPragmaLocation()) {}
2666 
2668  S.CurFPFeatures = OldFPFeaturesState;
2669  S.FpPragmaStack.CurrentValue = OldOverrides;
2670  S.PP.setCurrentFPEvalMethod(OldFPPragmaLocation, OldEvalMethod);
2671 }
clang::OpenCL
@ OpenCL
Definition: LangStandard.h:62
clang::PrintingPolicy::EntireContentsOfLargeArray
unsigned EntireContentsOfLargeArray
Whether to print the entire array initializers, especially on non-type template parameters,...
Definition: PrettyPrinter.h:292
clang::ASTContext::getBuiltinVaListDecl
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
Definition: ASTContext.cpp:8912
clang::Type::STK_FixedPoint
@ STK_FixedPoint
Definition: Type.h:2168
clang::Sema::hasAnyUnrecoverableErrorsInThisFunction
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
Definition: Sema.cpp:2246
clang::Language::CUDA
@ CUDA
RecordCompleteMap
llvm::DenseMap< const CXXRecordDecl *, bool > RecordCompleteMap
Definition: Sema.cpp:937
clang::Sema::CheckDelayedMemberExceptionSpecs
void CheckDelayedMemberExceptionSpecs()
Definition: SemaDeclCXX.cpp:8855
clang::DiagnosticIDs::isDeferrable
static bool isDeferrable(unsigned DiagID)
Whether the diagnostic message can be deferred.
Definition: DiagnosticIDs.cpp:341
clang::ASTContext::OCLEventTy
CanQualType OCLEventTy
Definition: ASTContext.h:1132
clang::ASTContext::LongDoubleTy
CanQualType LongDoubleTy
Definition: ASTContext.h:1108
clang::Sema::CurContext
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:422
clang::Type::getNullability
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:4089
clang::ModuleMap::resolveConflicts
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
Definition: ModuleMap.cpp:1350
clang::Sema::getUndefinedButUsed
void getUndefinedButUsed(SmallVectorImpl< std::pair< NamedDecl *, SourceLocation > > &Undefined)
Obtain a sorted list of functions that are undefined but ODR-used.
Definition: Sema.cpp:810
clang::Sema::setFunctionHasIndirectGoto
void setFunctionHasIndirectGoto()
Definition: Sema.cpp:2260
clang::Sema::VAListTagName
DeclarationName VAListTagName
VAListTagName - The declaration name corresponding to __va_list_tag.
Definition: Sema.h:430
clang::Sema::warnStackExhausted
void warnStackExhausted(SourceLocation Loc)
Warn that the stack is nearly exhausted.
Definition: Sema.cpp:510
clang::Sema::ActOnGlobalModuleFragmentDecl
DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc)
The parser has processed a global-module-fragment declaration that begins the definition of the globa...
Definition: SemaModule.cpp:75
clang::Sema::DelayedDiagnostics
A class which encapsulates the logic for delaying diagnostics during parsing and other processing.
Definition: Sema.h:933
clang::DeclContext::decls_end
decl_iterator decls_end() const
Definition: DeclBase.h:2133
clang::ExternalSemaSource::updateOutOfDateSelector
virtual void updateOutOfDateSelector(Selector Sel)
Load the contents of the global method pool for a given selector if necessary.
Definition: Sema.cpp:2378
clang::Preprocessor::getCurrentFPEvalMethod
LangOptions::FPEvalMethodKind getCurrentFPEvalMethod() const
Definition: Preprocessor.h:2091
clang::ModuleMap::resolveUses
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1337
clang::Sema::ScalarTypeToBooleanCastKind
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
Definition: Sema.cpp:713
clang::LangOptions::CMK_ModuleInterface
@ CMK_ModuleInterface
Compiling a C++ modules TS module interface unit.
Definition: LangOptions.h:117
clang::Sema::runWithSufficientStackSpace
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
Definition: Sema.cpp:518
clang::QualType::hasNonTrivialToPrimitiveCopyCUnion
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
Definition: Type.h:6642
clang::ASTContext::getInt128Decl
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
Definition: ASTContext.cpp:1261
clang::Sema::PopCompoundScope
void PopCompoundScope()
Definition: Sema.cpp:2237
clang::DiagnosticsEngine::SetArgToStringFn
void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie)
Definition: Diagnostic.h:883
clang::VarDecl::isFileVarDecl
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
Definition: Decl.h:1257
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::Sema::isExternalWithNoLinkageType
bool isExternalWithNoLinkageType(ValueDecl *VD)
Determine if VD, which must be a variable or function, is an external symbol that nonetheless can't b...
Definition: Sema.cpp:799
clang::Sema::DelayedDllExportMemberFunctions
SmallVector< CXXMethodDecl *, 4 > DelayedDllExportMemberFunctions
Definition: Sema.h:13210
clang::DiagnosticBuilder
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1265
clang::ASTContext::OCLReserveIDTy
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1133
clang::Sema::TUKind
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:1426
clang::Sema::DeferDiags
bool DeferDiags
Whether deferrable diagnostics should be deferred.
Definition: Sema.h:1840
clang::FunctionDecl::getReturnType
QualType getReturnType() const
Definition: Decl.h:2557
clang::UnresolvedSetImpl
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
clang::LangOptions::getOpenCLCompatibleVersion
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Definition: LangOptions.cpp:55
clang::UsedDeclVisitor
Definition: UsedDeclVisitor.h:21
clang::ASTContext::buildImplicitRecord
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=TTK_Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
Definition: ASTContext.cpp:1235
clang::ExternalSemaSource::ReadKnownNamespaces
virtual void ReadKnownNamespaces(SmallVectorImpl< NamespaceDecl * > &Namespaces)
Load the set of namespaces that are known to the external source, which will be used during typo corr...
Definition: Sema.cpp:2380
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::Sema::ActOnEndOfTranslationUnit
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
Definition: Sema.cpp:1117
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1356
clang::Decl::hasAttr
bool hasAttr() const
Definition: DeclBase.h:542
clang::TypoCorrection
Simple class containing the result of Sema::CorrectTypo.
Definition: TypoCorrection.h:42
clang::Type::isFloat16Type
bool isFloat16Type() const
Definition: Type.h:7046
clang::LazyVector::erase
void erase(iterator From, iterator To)
Definition: ExternalASTSource.h:553
clang::Preprocessor::isIncrementalProcessingEnabled
bool isIncrementalProcessingEnabled() const
Returns true if incremental processing is enabled.
Definition: Preprocessor.h:1688
clang::FixItHint::CreateInsertion
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:97
clang::ExpectedVariableOrFunction
@ ExpectedVariableOrFunction
Definition: ParsedAttr.h:1122
clang::Sema::getASTContext
ASTContext & getASTContext() const
Definition: Sema.h:1614
clang::Sema::FreeVisContext
void FreeVisContext()
FreeVisContext - Deallocate and null out VisContext.
Definition: SemaAttr.cpp:1176
clang::QualType::isConstQualified
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6559
clang::Sema::getCurFunction
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1939
clang::Decl::getAsFunction
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
clang::Sema::SemaDiagnosticBuilder::Kind
Kind
Definition: Sema.h:1724
clang::Type::STK_IntegralComplex
@ STK_IntegralComplex
Definition: Type.h:2166
clang::Sema::SourceMgr
SourceManager & SourceMgr
Definition: Sema.h:413
clang::IdentifierResolver::begin
iterator begin(DeclarationName Name)
begin - Returns an iterator for decls with the name 'Name'.
Definition: IdentifierResolver.cpp:232
clang::sema::AnalysisBasedWarnings::PrintStats
void PrintStats() const
Definition: AnalysisBasedWarnings.cpp:2455
Diag
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Definition: LiteralSupport.cpp:78
clang::Sema::ThreadSafetyDeclCache
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:9380
clang::SourceManager::isInMainFile
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
Definition: SourceManager.cpp:1589
clang::FunctionDecl::isDeleted
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2354
clang::NamedDecl::isExternallyVisible
bool isExternallyVisible() const
Definition: Decl.h:405
SemaInternal.h
clang::sema::FunctionScopeInfo::ByrefBlockVars
llvm::TinyPtrVector< VarDecl * > ByrefBlockVars
The set of __block variables that are introduced in this function.
Definition: ScopeInfo.h:220
clang::ASTContext::VoidTy
CanQualType VoidTy
Definition: ASTContext.h:1096
clang::Expr::IgnoreImplicit
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:2935
llvm::SmallVector
Definition: LLVM.h:38
clang::ASTContext::getAtomicType
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
Definition: ASTContext.cpp:5766
clang::IdentifierTable::get
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Definition: IdentifierTable.h:596
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::Sema::FunctionScopes
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:790
clang::Preprocessor::TUKind
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Preprocessor.h:291
clang::DiagnosticsEngine::isIgnored
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:910
clang::Sema::AnalysisWarnings
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
Definition: Sema.h:9379
clang::SourceLocation::getLocWithOffset
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
Definition: SourceLocation.h:134
clang::PPCallbacks
This interface provides a way to observe the actions of the preprocessor as it does its thing.
Definition: PPCallbacks.h:35
clang::Type::STK_FloatingComplex
@ STK_FloatingComplex
Definition: Type.h:2167
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::DeclContext::getPrimaryContext
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1242
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:219
clang::Sema::getEnclosingFunction
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.cpp:2285
clang::CXXRecordDecl::friend_begin
friend_iterator friend_begin() const
Definition: DeclFriend.h:239
TargetInfo.h
clang::NamedDecl::getUnderlyingDecl
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:457
clang::Sema::DiagnoseUnterminatedPragmaAttribute
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:1086
clang::Sema::findMacroSpelling
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
Definition: Sema.cpp:2038
isFunctionOrVarDeclExternC
static bool isFunctionOrVarDeclExternC(NamedDecl *ND)
Definition: Sema.cpp:791
clang::Sema::FpPragmaStack
PragmaStack< FPOptionsOverride > FpPragmaStack
Definition: Sema.h:696
clang::ASTContext::getObjCClassDecl
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C 'Class' type.
Definition: ASTContext.cpp:8503
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:324
clang::TargetInfo::hasLongDoubleType
virtual bool hasLongDoubleType() const
Determine whether the long double type is supported on this target.
Definition: TargetInfo.h:622
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:675
clang::Sema::LateTemplateParserCleanup
LateTemplateParserCleanupCB * LateTemplateParserCleanup
Definition: Sema.h:911
clang::ExternalSemaSource::ReadUnusedLocalTypedefNameCandidates
virtual void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls)
Read the set of potentially unused typedefs known to the source.
Definition: ExternalSemaSource.h:143
clang::Module::submodule_begin
submodule_iterator submodule_begin()
Definition: Module.h:679
clang::ExternalSemaSource::ReadMismatchingDeleteExpressions
virtual void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 >> &)
Definition: Sema.cpp:2387
clang::ASTContext::getFloatTypeSemantics
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
Definition: ASTContext.cpp:1703
clang::UnresolvedSetIterator
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
clang::QualType::getCanonicalType
QualType getCanonicalType() const
Definition: Type.h:6539
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2855
TypoCorrection.h
clang::Sema::Diag
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: Sema.cpp:1871
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:186
clang::Sema::TUScope
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:1118
clang::Sema::CreateMaterializeTemporaryExpr
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:7963
DeclCXX.h
clang::VK_XValue
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
Definition: Specifiers.h:129
clang::ASTContext::getAuxTargetInfo
const TargetInfo * getAuxTargetInfo() const
Definition: ASTContext.h:769
clang::Decl::isUsed
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
Definition: DeclBase.cpp:443
clang::ASTContext::addComment
void addComment(const RawComment &RC)
Definition: ASTContext.cpp:308
clang::DiagnosticsEngine::getNumOverloadCandidatesToShow
unsigned getNumOverloadCandidatesToShow() const
When a call or operator fails, print out up to this many candidate overloads as suggestions.
Definition: Diagnostic.h:725
clang::Sema::CodeSynthesisContexts
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:8982
clang::TargetInfo::hasFloat16Type
virtual bool hasFloat16Type() const
Determine whether the _Float16 type is supported on this target.
Definition: TargetInfo.h:613
clang::RawComment::getKind
CommentKind getKind() const LLVM_READONLY
Definition: RawCommentList.h:50
clang::Sema::getSourceManager
SourceManager & getSourceManager() const
Definition: Sema.h:1612
clang::Sema::LateParsedInstantiations
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
Definition: Sema.h:9398
clang::Type::isRealFloatingType
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:2137
clang::CapturedRegionKind
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
clang::ASTContext::OverloadTy
CanQualType OverloadTy
Definition: ASTContext.h:1124
clang::Sema::CachedFunctionScope
std::unique_ptr< sema::FunctionScopeInfo > CachedFunctionScope
Definition: Sema.h:786
clang::Sema::setFunctionHasMustTail
void setFunctionHasMustTail()
Definition: Sema.cpp:2265
llvm::Optional
Definition: LLVM.h:40
llvm::SmallPtrSet
Definition: ASTContext.h:82
clang::Expr::isPRValue
bool isPRValue() const
Definition: Expr.h:271
clang::MacroInfo
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
SourceManager.h
clang::DiagnosticsEngine::setLastDiagnosticIgnored
void setLastDiagnosticIgnored(bool Ignored)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed,...
Definition: Diagnostic.h:755
clang::TypePropertyCache
The type-property cache.
Definition: Type.cpp:3833
emitCallStackNotes
static void emitCallStackNotes(Sema &S, FunctionDecl *FD)
Definition: Sema.cpp:1597
clang::SrcMgr::CharacteristicKind
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:79
clang::Sema::BuildCallExpr
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:6636
IsRecordFullyDefined
static bool IsRecordFullyDefined(const CXXRecordDecl *RD, RecordCompleteMap &RecordsComplete, RecordCompleteMap &MNCComplete)
Returns true, if the given CXXRecordDecl is fully defined in this translation unit,...
Definition: Sema.cpp:986
clang::Decl::getAttr
T * getAttr() const
Definition: DeclBase.h:538
clang::PrintingPolicy
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
clang::Sema::BuildCallToMemberFunction
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)
BuildCallToMemberFunction - Build a call to a member function.
Definition: SemaOverload.cpp:14307
clang::DiagnosticIDs::isBuiltinNote
static bool isBuiltinNote(unsigned DiagID)
Determine whether the given built-in diagnostic ID is a Note.
Definition: DiagnosticIDs.cpp:434
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3559
clang::Sema::ExprEvalContexts
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1360
clang::CapturedDecl
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4390
clang::sema::BlockScopeInfo
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:748
clang::Sema::getCurCapturedRegion
sema::CapturedRegionScopeInfo * getCurCapturedRegion()
Retrieve the current captured region, if any.
Definition: Sema.cpp:2649
clang::CXXFieldCollector
CXXFieldCollector - Used to keep track of CXXFieldDecls during parsing of C++ classes.
Definition: CXXFieldCollector.h:25
clang::Sema::ActOnEndOfTranslationUnitFragment
void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind)
Definition: Sema.cpp:1049
clang::TargetInfo::hasInt128Type
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:581
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:144
clang::PrintingPolicy::Bool
unsigned Bool
Whether we can use 'bool' rather than '_Bool' (even if the language doesn't actually have 'bool',...
Definition: PrettyPrinter.h:193
clang::ASTContext::getSourceManager
SourceManager & getSourceManager()
Definition: ASTContext.h:716
clang::Sema::PendingInstantiations
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed.
Definition: Sema.h:9394
clang::Sema::ExternalDeclarations
SmallVector< VarDecl *, 4 > ExternalDeclarations
All the external declarations encoutered and used in the TU.
Definition: Sema.h:870
clang::ASTContext::getTranslationUnitDecl
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1078
clang::OverloadExpr::decls_end
decls_iterator decls_end() const
Definition: ExprCXX.h:2992
clang::ArrayType::Normal
@ Normal
Definition: Type.h:2903
clang::Decl::isReferenced
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:468
clang::sema::CapturedRegionScopeInfo
Retains information about a captured region.
Definition: ScopeInfo.h:774
clang::Sema::isUnevaluatedContext
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
Definition: Sema.h:9288
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:627
clang::Type::STK_Integral
@ STK_Integral
Definition: Type.h:2164
clang::Sema::ActOnTranslationUnitScope
void ActOnTranslationUnitScope(Scope *S)
Definition: Sema.cpp:123
clang::Preprocessor::getLangOpts
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:994
clang::Sema::Context
ASTContext & Context
Definition: Sema.h:410
Preprocessor.h
markEscapingByrefs
static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S)
Definition: Sema.cpp:2156
clang::Sema::FieldCollector
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition: Sema.h:828
clang::TU_Prefix
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:822
clang::ExprError
ExprResult ExprError()
Definition: Ownership.h:278
Decl.h
clang::OverloadExpr::find
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2957
clang::ExternalSemaSource::~ExternalSemaSource
~ExternalSemaSource() override
Definition: Sema.cpp:2374
DeclObjC.h
Offset
unsigned Offset
Definition: Format.cpp:2553
clang::ASTContext::getObjCSelDecl
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined 'SEL' type in Objective-C.
Definition: ASTContext.cpp:8495
clang::Sema::WarnedStackExhausted
bool WarnedStackExhausted
Definition: Sema.h:1578
checkEscapingByref
static void checkEscapingByref(VarDecl *VD, Sema &S)
Definition: Sema.cpp:2122
clang::Sema::CUDADiagIfDeviceCode
SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
Definition: SemaCUDA.cpp:728
clang::FixItHint
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:71
clang::Diagnostic
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1560
clang::ASTContext::BoundMemberTy
CanQualType BoundMemberTy
Definition: ASTContext.h:1124
clang::Sema::getLangOpts
const LangOptions & getLangOpts() const
Definition: Sema.h:1607
clang::BlockDecl::captures
ArrayRef< Capture > captures() const
Definition: Decl.h:4328
clang::BlockDecl::doesNotEscape
bool doesNotEscape() const
Definition: Decl.h:4352
clang::Sema::getSuperIdentifier
IdentifierInfo * getSuperIdentifier() const
Definition: Sema.cpp:2626
clang::Sema::getCurLexicalContext
DeclContext * getCurLexicalContext() const
Definition: Sema.h:13178
clang::TargetInfo::getSupportedOpenCLOpts
llvm::StringMap< bool > & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1576
clang::OverloadExpr::FindResult
Definition: ExprCXX.h:2946
clang::Sema::getCurFunctionDecl
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false)
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
Definition: Sema.cpp:1451
clang::TU_Module
@ TU_Module
The translation unit is a module.
Definition: LangOptions.h:825
clang::TargetInfo::hasBitIntType
virtual bool hasBitIntType() const
Determine whether the _BitInt type is supported on this target.
Definition: TargetInfo.h:591
clang::isExternalFormalLinkage
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:108
clang::FunctionTemplateDecl
Declaration of a template function.
Definition: DeclTemplate.h:979
clang::Sema::RequireCompleteType
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:8523
clang::ASTContext::getUIntPtrType
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
Definition: ASTContext.cpp:5861
clang::Type::STK_BlockPointer
@ STK_BlockPointer
Definition: Type.h:2160
clang::Sema::tryExprAsCall
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
Definition: Sema.cpp:2401
clang::ASTContext::getExternalSource
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1183
clang::ASTContext::getObjCIdDecl
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
Definition: ASTContext.cpp:8486
clang::Type::isBitIntType
bool isBitIntType() const
Definition: Type.h:6972
clang::Sema::getEnclosingLambda
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
Definition: Sema.cpp:2297
clang::Expr::isTypeDependent
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Definition: Expr.h:185
clang::Sema::DelayedOverridingExceptionSpecChecks
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedOverridingExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
Definition: Sema.h:892
clang::SemaConsumer
An abstract interface that should be implemented by clients that read ASTs and then require further s...
Definition: SemaConsumer.h:25
clang::FunctionDecl::isCPUDispatchMultiVersion
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
Definition: Decl.cpp:3336
clang::sema::FunctionScopeInfo::Blocks
llvm::SmallPtrSet< const BlockDecl *, 1 > Blocks
The set of blocks that are introduced in this function.
Definition: ScopeInfo.h:217
clang::Module
Describes a module or submodule.
Definition: Module.h:96
clang::Sema::CurFPFeatures
FPOptions CurFPFeatures
Definition: Sema.h:406
clang::Sema::inTemplateInstantiation
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:9259
clang::OverloadExpr::decls_begin
decls_iterator decls_begin() const
Definition: ExprCXX.h:2989
clang::PartialDiagnosticAt
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
Definition: PartialDiagnostic.h:205
clang::Sema::TentativeDefinitions
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:867
clang::Sema::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1611
clang::ASTContext::OCLSamplerTy
CanQualType OCLSamplerTy
Definition: ASTContext.h:1132
HeaderSearchOptions.h
clang::Sema::CurFPFeatureOverrides
FPOptionsOverride CurFPFeatureOverrides()
Definition: Sema.h:697
Node
DynTypedNode Node
Definition: ASTMatchFinder.cpp:68
DeclFriend.h
clang::BlockDecl
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4201
clang::LangOptions::CMK_None
@ CMK_None
Not compiling a module interface at all.
Definition: LangOptions.h:105
clang::ASTContext::getAsIncompleteArrayType
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2696
clang::Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder
~SemaDiagnosticBuilder()
Definition: Sema.cpp:1839
clang::DiagnosticsEngine::hasFatalErrorOccurred
bool hasFatalErrorOccurred() const
Definition: Diagnostic.h:844
clang::Sema::DeviceDeferredDiags
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, std::vector< PartialDiagnosticAt > > DeviceDeferredDiags
Diagnostics that are emitted only if we discover that the given function must be codegen'ed.
Definition: Sema.h:12388
clang::Sema::SemaDiagnosticBuilder::isImmediate
bool isImmediate() const
Definition: Sema.h:1745
Id
int Id
Definition: ASTDiff.cpp:191
clang::Sema::hasUncompilableErrorOccurred
bool hasUncompilableErrorOccurred() const
Whether uncompilable error has occurred.
Definition: Sema.cpp:1579
clang::ASTContext::getUInt128Decl
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
Definition: ASTContext.cpp:1267
clang::Type::isNullPtrType
bool isNullPtrType() const
Definition: Type.h:7062
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::Sema::SemaDiagnosticBuilder::K_Nop
@ K_Nop
Emit no diagnostics.
Definition: Sema.h:1726
PrettyDeclStackTrace.h
MultiplexExternalSemaSource.h
clang::Sema::VisContext
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:731
clang::sema::FunctionScopeInfo::hasUnrecoverableErrorOccurred
bool hasUnrecoverableErrorOccurred() const
Determine whether an unrecoverable error has occurred within this function.
Definition: ScopeInfo.h:394
clang::Sema::SemaDiagnosticBuilder::K_Immediate
@ K_Immediate
Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
Definition: Sema.h:1728
clang::DiagnosticsEngine::hasErrorOccurred
bool hasErrorOccurred() const
Definition: Diagnostic.h:837
clang::DiagnosticIDs::isDefaultMappingAsError
static bool isDefaultMappingAsError(unsigned DiagID)
Return true if the specified diagnostic is mapped to errors by default.
Definition: DiagnosticIDs.cpp:455
clang::FPOptionsOverride
Represents difference between two FPOptions values.
Definition: LangOptions.h:713
clang::Sema::AccessCheckingSFINAE
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors.
Definition: Sema.h:7564
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:208
clang::ASTContext::getSizeType
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Definition: ASTContext.cpp:5823
clang::SourceManager::getMainFileID
FileID getMainFileID() const
Returns the FileID of the main source file.
Definition: SourceManager.h:841
clang::CPlusPlus
@ CPlusPlus
Definition: LangStandard.h:53
CXXFieldCollector.h
clang::Sema::getCurFunctionOrMethodDecl
NamedDecl * getCurFunctionOrMethodDecl()
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
Definition: Sema.cpp:1463
clang::DiagnosticsEngine::Clear
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:976
clang::LazyVector::end
iterator end()
Definition: ExternalASTSource.h:545
clang::DiagnosticsEngine::EmitCurrentDiagnostic
bool EmitCurrentDiagnostic(bool Force=false)
Emit the current diagnostic and clear the diagnostic state.
Definition: Diagnostic.cpp:527
clang::FunctionDecl::getBody
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:3092
Depth
int Depth
Definition: ASTDiff.cpp:191
clang::FunctionDecl::isCPUSpecificMultiVersion
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
Definition: Decl.cpp:3340
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7243
clang::Decl::isInvalidDecl
bool isInvalidDecl() const
Definition: DeclBase.h:553
clang::ASTConsumer
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.
Definition: ASTConsumer.h:33
clang::Sema::Initialize
void Initialize()
Perform initialization that occurs after the parser has been initialized but before it parses anythin...
Definition: Sema.cpp:278
clang::Sema::MaximumAlignment
static const uint64_t MaximumAlignment
Definition: Sema.h:399
clang::Sema::AlignPackInfo
Definition: Sema.h:488
clang::ASTMutationListener
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Definition: ASTMutationListener.h:46
TemplateInstCallback.h
clang::Module::GlobalModuleFragment
@ GlobalModuleFragment
This is a fragment of the global module within some C++ module.
Definition: Module.h:122
clang::TargetInfo::hasFloat128Type
virtual bool hasFloat128Type() const
Determine whether the __float128 type is supported on this target.
Definition: TargetInfo.h:610
clang::VarDecl::isEscapingByref
bool isEscapingByref() const
Indicates the capture is a __block variable that is captured by a block that can potentially escape (...
Definition: Decl.cpp:2570
clang::DiagnosticIDs::getDiagnosticSFINAEResponse
static SFINAEResponse getDiagnosticSFINAEResponse(unsigned DiagID)
Determines whether the given built-in diagnostic ID is for an error that is suppressed if it occurs d...
Definition: DiagnosticIDs.cpp:335
clang::runWithSufficientStackSpace
void runWithSufficientStackSpace(llvm::function_ref< void()> Diag, llvm::function_ref< void()> Fn)
Run a given function on a stack with "sufficient" space.
Definition: Stack.h:40
ObjCMethodList.h
clang::Sema::Diags
DiagnosticsEngine & Diags
Definition: Sema.h:412
clang::ExternalSemaSource
An abstract interface that should be implemented by external AST sources that also provide informatio...
Definition: ExternalSemaSource.h:50
clang::Sema::diagIfOpenMPHostCode
SemaDiagnosticBuilder diagIfOpenMPHostCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as host cod...
Definition: SemaOpenMP.cpp:1969
clang::Sema::PushBlockScope
void PushBlockScope(Scope *BlockScope, BlockDecl *Block)
Definition: Sema.cpp:2097
clang::MultiplexExternalSemaSource
An abstract interface that should be implemented by external AST sources that also provide informatio...
Definition: MultiplexExternalSemaSource.h:38
clang::DiagnosticIDs::SFINAE_Suppress
@ SFINAE_Suppress
The diagnostic should be suppressed entirely.
Definition: DiagnosticIDs.h:275
clang::DiagnosticsEngine::getCurrentDiagLoc
SourceLocation getCurrentDiagLoc() const
Definition: Diagnostic.h:1058
DelayedDiagnostic.h
clang::ComparisonCategoryType
ComparisonCategoryType
An enumeration representing the different comparison categories types.
Definition: ComparisonCategories.h:44
clang::isExternallyVisible
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:91
clang::DiagnosticsEngine::getDiagnosticIDs
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
Definition: Diagnostic.h:551
clang::DeclContext::decl_iterator
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:2088
clang::NSAPI
Definition: NSAPI.h:23
clang::Sema::PDiag
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
clang::ASTContext::getTypeSize
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2285
clang::Sema::NTCUK_Destruct
@ NTCUK_Destruct
Definition: Sema.h:2877
clang::CXXDestructorDecl
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2688
clang::ImplicitCastExpr::Create
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Definition: Expr.cpp:1974
clang::Sema::getCurLambda
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:2313
clang::Sema::IsLastErrorImmediate
bool IsLastErrorImmediate
Is the last error level diagnostic immediate.
Definition: Sema.h:1826
clang::CR_OpenMP
@ CR_OpenMP
Definition: CapturedStmt.h:19
Expr.h
llvm::SmallString< 16 >
clang::RawComment
Definition: RawCommentList.h:32
ASTContext.h
clang::UnresolvedSet
A set of unresolved declarations.
Definition: UnresolvedSet.h:148
clang::DiagnosticsEngine::overloadCandidatesShown
void overloadCandidatesShown(unsigned N)
Call this after showing N overload candidates.
Definition: Diagnostic.h:740
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::ASTContext::FloatTy
CanQualType FloatTy
Definition: ASTContext.h:1108
clang::Sema::ImmediateDiagBuilder
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1651
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:625
clang::Sema::deepTypeCheckForSYCLDevice
void deepTypeCheckForSYCLDevice(SourceLocation UsedAt, llvm::DenseSet< QualType > Visited, ValueDecl *DeclToCheck)
Definition: SemaSYCL.cpp:58
clang::DiagnosticIDs::SFINAE_SubstitutionFailure
@ SFINAE_SubstitutionFailure
The diagnostic should not be reported, but it should cause template argument deduction to fail.
Definition: DiagnosticIDs.h:270
clang::ASTContext::getBoolName
IdentifierInfo * getBoolName() const
Retrieve the identifier 'bool'.
Definition: ASTContext.h:1894
clang::ExternalSemaSource::ReadMethodPool
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:2377
clang::ASTContext::getDefaultOpenCLPointeeAddrSpace
LangAS getDefaultOpenCLPointeeAddrSpace()
Returns default address space based on OpenCL version and enabled features.
Definition: ASTContext.h:1397
clang::TTK_Class
@ TTK_Class
The "class" keyword.
Definition: Type.h:5395
clang::ASTContext::getCanonicalType
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2508
llvm::DenseSet
Definition: Sema.h:77
clang::Type::getAsCXXRecordDecl
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1759
clang::Preprocessor::getMacroInfo
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:1187
clang::TagDecl::isUnion
bool isUnion() const
Definition: Decl.h:3554
clang::Sema::getLocForEndOfToken
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:54
clang::SC_Register
@ SC_Register
Definition: Specifiers.h:242
clang::Sema::checkTypeSupport
void checkTypeSupport(QualType Ty, SourceLocation Loc, ValueDecl *D=nullptr)
Check if the type is allowed to be used for the current target.
Definition: Sema.cpp:1894
clang::SourceManager::isInSystemMacro
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
Definition: SourceManager.h:1503
clang::LangOptions::IsHeaderFile
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i....
Definition: LangOptions.h:447
clang::Sema::TentativeAnalysisScope
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Definition: Sema.h:9343
ExprCXX.h
clang::Sema::CUDADiagIfHostCode
SemaDiagnosticBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as host cod...
Definition: SemaCUDA.cpp:758
clang::Sema::canThrow
CanThrowResult canThrow(const Stmt *E)
Definition: SemaExceptionSpec.cpp:1124
clang::Sema::getDefaultCXXMethodAddrSpace
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
Definition: Sema.cpp:1470
clang::OverloadExpr::FindResult::HasFormOfMemberPointer
bool HasFormOfMemberPointer
Definition: ExprCXX.h:2949
clang::TagDecl::isCompleteDefinition
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3453
clang::ASTContext::getObjCProtocolDecl
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class.
Definition: ASTContext.cpp:8512
clang::Sema::ResolveExceptionSpec
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Definition: SemaExceptionSpec.cpp:209
checkUndefinedButUsed
static void checkUndefinedButUsed(Sema &S)
checkUndefinedButUsed - Check for undefined objects with internal linkage or that are inline.
Definition: Sema.cpp:863
clang::IdentifierResolver::end
iterator end()
end - Returns an iterator that has 'finished'.
Definition: IdentifierResolver.h:141
ASTDiagnostic.h
clang::Sema::InstantiatingSpecializations
llvm::DenseSet< std::pair< Decl *, unsigned > > InstantiatingSpecializations
Specializations whose definitions are currently being instantiated.
Definition: Sema.h:8985
clang::Sema::getASTMutationListener
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:548
clang::QualType::hasNonTrivialToPrimitiveDestructCUnion
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Definition: Type.h:6636
clang::Sema::NamedReturnInfo
Definition: Sema.h:4928
clang::Sema::getOpenCLOptions
OpenCLOptions & getOpenCLOptions()
Definition: Sema.h:1608
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:330
clang::sema::SemaPPCallbacks
Definition: Sema.cpp:131
clang::ModuleMap
Definition: ModuleMap.h:75
clang::ASTConsumer::CompleteTentativeDefinition
virtual void CompleteTentativeDefinition(VarDecl *D)
CompleteTentativeDefinition - Callback invoked at the end of a translation unit to notify the consume...
Definition: ASTConsumer.h:103
clang::Sema::PoppedFunctionScopeDeleter
Custom deleter to allow FunctionScopeInfos to be kept alive for a short time after they've been poppe...
Definition: Sema.h:1923
clang::Sema::addExternalSource
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:557
clang::IncompleteArrayType
Represents a C array with an unspecified size.
Definition: Type.h:3002
clang::SC_Static
@ SC_Static
Definition: Specifiers.h:237
clang::Sema::LangOpts
const LangOptions & LangOpts
Definition: Sema.h:408
clang::Sema::LoadExternalWeakUndeclaredIdentifiers
void LoadExternalWeakUndeclaredIdentifiers()
Load weak undeclared identifiers from the external source.
Definition: Sema.cpp:926
clang::QualType::getUnqualifiedType
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6580
clang::Sema::PushLambdaScope
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:2102
clang::NamedDecl::getMostRecentDecl
NamedDecl * getMostRecentDecl()
Definition: Decl.h:471
clang::VarDecl::getDescribedVarTemplate
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2682
clang::ExternalSemaSource::ReadUndefinedButUsed
virtual void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined)
Load the set of used but not defined functions or variables with internal linkage,...
Definition: Sema.cpp:2384
clang::OpaquePtr< QualType >
clang::SourceManager::getLocForStartOfFile
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file.
Definition: SourceManager.h:1123
clang::Sema::UnusedPrivateFields
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:833
clang::Sema::UnusedLocalTypedefNameCandidates
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition: Sema.h:837
clang::LangAS
LangAS
Defines the address space values used by the address space qualifier of QualType.
Definition: AddressSpaces.h:25
clang::NSAPI::NumNSNumberLiteralMethods
static const unsigned NumNSNumberLiteralMethods
Definition: NSAPI.h:191
clang::sema::FunctionScopeInfo
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:97
clang::Sema::SemaDiagnosticBuilder::K_Deferred
@ K_Deferred
Create a deferred diagnostic, which is emitted only if the function it's attached to is codegen'ed.
Definition: Sema.h:1736
clang::TargetInfo::hasIbm128Type
virtual bool hasIbm128Type() const
Determine whether the __ibm128 type is supported on this target.
Definition: TargetInfo.h:619
clang::VK_LValue
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:124
clang::LangOptions::FEM_UnsetOnCommandLine
@ FEM_UnsetOnCommandLine
Used only for FE option processing; this is only used to indicate that the user did not specify an ex...
Definition: LangOptions.h:290
clang::Sema::getCurGenericLambda
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:2338
clang::Sema::DeleteExprLoc
std::pair< SourceLocation, bool > DeleteExprLoc
Delete-expressions to be analyzed at the end of translation unit.
Definition: Sema.h:844
IsCPUDispatchCPUSpecificMultiVersion
static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E)
Definition: Sema.cpp:2566
clang::UnresolvedSetImpl::clear
void clear()
Definition: UnresolvedSet.h:123
clang::TargetInfo::getTriple
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1160
clang::LangOptions::FEM_Indeterminable
@ FEM_Indeterminable
The evaluation method cannot be determined or is inconsistent for this target.
Definition: LangOptions.h:279
clang::ASTContext::UnsignedLongTy
CanQualType UnsignedLongTy
Definition: ASTContext.h:1106
clang::Sema::PerformPendingInstantiations
void PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
Definition: SemaTemplateInstantiateDecl.cpp:6284
clang::Sema::DeviceKnownEmittedFns
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, FunctionDeclAndLoc > DeviceKnownEmittedFns
An inverse call graph, mapping known-emitted functions to one of their known-emitted callers (plus th...
Definition: Sema.h:12409
clang::sema::SemaPPCallbacks::FileChanged
virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID) override
Callback invoked whenever a source file is entered or exited.
Definition: Sema.cpp:140
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
clang::Sema::FPFeaturesStateRAII::FPFeaturesStateRAII
FPFeaturesStateRAII(Sema &S)
Definition: Sema.cpp:2661
clang::sema::AnalysisBasedWarnings::Policy
Definition: AnalysisBasedWarnings.h:33
clang::Sema::SYCLDiagIfDeviceCode
SemaDiagnosticBuilder SYCLDiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
Definition: SemaSYCL.cpp:21
clang::Sema::FPFeaturesStateRAII::~FPFeaturesStateRAII
~FPFeaturesStateRAII()
Definition: Sema.cpp:2667
clang::Sema::InventAbbreviatedTemplateParameterTypeName
IdentifierInfo * InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName, unsigned Index)
Invent a new identifier for parameters of abbreviated templates.
Definition: Sema.cpp:89
clang::Type::STK_CPointer
@ STK_CPointer
Definition: Type.h:2159
clang::Sema::UnusedFileScopedDecls
UnusedFileScopedDeclsType UnusedFileScopedDecls
The set of file scoped decls seen so far that have not been used and must warn if not used.
Definition: Sema.h:878
clang::Type::isDependentType
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2185
clang::VK_PRValue
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:120
clang::Sema::getCurBlock
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:2270
clang::ASTContext::UnsignedIntTy
CanQualType UnsignedIntTy
Definition: ASTContext.h:1106
clang::PPCallbacks::FileChangeReason
FileChangeReason
Definition: PPCallbacks.h:39
clang::VarDecl::setEscapingByref
void setEscapingByref()
Definition: Decl.h:1519
clang::Sema::getFloat128Identifier
IdentifierInfo * getFloat128Identifier() const
Definition: Sema.cpp:2632
clang::Sema::ImpCastExprToType
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Definition: Sema.cpp:632
clang::Sema::diagIfOpenMPDeviceCode
SemaDiagnosticBuilder diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
Definition: SemaOpenMP.cpp:1931
clang::ASTContext::DoubleTy
CanQualType DoubleTy
Definition: ASTContext.h:1108
clang::Scope::TemplateParamScope
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:77
clang::ASTContext::getCFConstantStringDecl
TypedefDecl * getCFConstantStringDecl() const
Definition: ASTContext.cpp:7074
clang::RawComment::RCK_OrdinaryC
@ RCK_OrdinaryC
Any normal C comment.
Definition: RawCommentList.h:37
false
#define false
Definition: stdbool.h:22
clang::NamedDecl::hasExternalFormalLinkage
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:401
ExternalSemaSource.h
clang::PartialDiagnostic::Emit
void Emit(const DiagnosticBuilder &DB) const
Definition: PartialDiagnostic.h:144
clang::Sema::PerformCopyInitialization
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:9928
clang::Sema::IdResolver
IdentifierResolver IdResolver
Definition: Sema.h:1113
clang::ActionResult::get
PtrTy get() const
Definition: Ownership.h:169
clang::Sema::PushCapturedRegionScope
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K, unsigned OpenMPCaptureLevel=0)
Definition: Sema.cpp:2638
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:674
clang::ASTContext::IntTy
CanQualType IntTy
Definition: ASTContext.h:1105
clang::Sema::tryToRecoverWithCall
bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain=false, bool(*IsPlausibleResult)(QualType)=nullptr)
Try to recover by turning the given expression into a call.
Definition: Sema.cpp:2581
clang::Sema::getMismatchingDeleteExpressions
const llvm::MapVector< FieldDecl *, DeleteLocs > & getMismatchingDeleteExpressions() const
Retrieves list of suspicious delete-expressions that will be checked at the end of translation unit.
Definition: Sema.cpp:2657
clang::Diagnostic::getLocation
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1571
clang::ASTContext::setBlockVarCopyInit
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy initialization expression of a block var decl.
Definition: ASTContext.cpp:2939
clang::Preprocessor::isCodeCompletionEnabled
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
Definition: Preprocessor.h:1713
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3898
clang::ASTConsumer::CompleteExternalDeclaration
virtual void CompleteExternalDeclaration(VarDecl *D)
CompleteExternalDeclaration - Callback invoked at the end of a translation unit to notify the consume...
Definition: ASTConsumer.h:108
clang::ASTContext::Idents
IdentifierTable & Idents
Definition: ASTContext.h:655
notePlausibleOverloads
static void notePlausibleOverloads(Sema &S, SourceLocation Loc, const UnresolvedSetImpl &Overloads, bool(*IsPlausibleResult)(QualType))
Definition: Sema.cpp:2537
clang::FunctionDecl::isMultiVersion
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Definition: Decl.h:2451
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1876
clang::Sema::shouldIgnoreInHostDeviceCheck
bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee)
Definition: SemaDecl.cpp:19119
clang::Expr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:247
clang::ASTContext::getPrintingPolicy
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:708
TemplateDeduction.h
clang::ASTContext::getIntPtrType
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
Definition: ASTContext.cpp:5857
clang::Sema::PerformMoveOrCopyInitialization
ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value, bool SupressSimplerImplicitMoves=false)
Perform the initialization of a potentially-movable value, which is the result of return value.
Definition: SemaStmt.cpp:3511
clang::VarDecl::getDefinition
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2271
clang::VarDecl::getActingDefinition
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
Definition: Decl.cpp:2250
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:740
clang::Sema::DiagnoseNonDefaultPragmaAlignPack
void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind, SourceLocation IncludeLoc)
Definition: SemaAttr.cpp:387
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::Sema::PopFunctionScopeInfo
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Definition: Sema.cpp:2202
Scope.h
clang::EnterExpressionEvaluationContext
RAII object that enters a new expression evaluation context.
Definition: Sema.h:13337
clang::DeclaratorDecl
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:726
clang::Expr::IgnoreParenImpCasts
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2947
clang::ASTContext::LongTy
CanQualType LongTy
Definition: ASTContext.h:1105
HeaderSearch.h
clang::Type::isFloat128Type
bool isFloat128Type() const
Definition: Type.h:7054
clang::Sema::Consumer
ASTConsumer & Consumer
Definition: Sema.h:411
clang::DarwinSDKInfo
The information about the darwin SDK that was used during this compilation.
Definition: DarwinSDKInfo.h:28
clang::Type::STK_Floating
@ STK_Floating
Definition: Type.h:2165
clang::Sema::ActOnComment
void ActOnComment(SourceRange Comment)
Definition: Sema.cpp:2347
clang::Module::PrivateModuleFragment
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
Definition: Module.h:125
clang::Sema::SemaDiagnosticBuilder::K_ImmediateWithCallStack
@ K_ImmediateWithCallStack
Emit the diagnostic immediately, and, if it's a warning or error, also emit a call stack showing how ...
Definition: Sema.h:1732
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:354
clang::ActionResult::isInvalid
bool isInvalid() const
Definition: Ownership.h:165
clang::sema::SemaPPCallbacks::set
void set(Sema &S)
Definition: Sema.cpp:136
clang::ASTContext::getDiagAllocator
PartialDiagnostic::DiagStorageAllocator & getDiagAllocator()
Definition: ASTContext.h:764
clang::CodeCompleteConsumer
Abstract interface for a consumer of code-completion information.
Definition: CodeCompleteConsumer.h:1003
clang::Sema::diagnoseNullableToNonnullConversion
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we're implicitly casting from a _Nullable pointer type to a _Nonnull one.
Definition: Sema.cpp:582
clang::Preprocessor::setCurrentFPEvalMethod
void setCurrentFPEvalMethod(SourceLocation PragmaLoc, LangOptions::FPEvalMethodKind Val)
Definition: Preprocessor.h:2114
clang::Sema::DiagnoseUseOfUnimplementedSelectors
void DiagnoseUseOfUnimplementedSelectors()
Definition: SemaDeclObjC.cpp:5242
clang::ASTContext::HalfTy
CanQualType HalfTy
Definition: ASTContext.h:1120
clang::LazyVector::begin
iterator begin(Source *source, bool LocalOnly=false)
Definition: ExternalASTSource.h:536
clang::Sema::~Sema
~Sema()
Definition: Sema.cpp:469
clang::Sema::DelayedDllExportClasses
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:13209
clang::Sema::DeleteExprs
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:846
clang::OverloadExpr
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
Definition: ExprCXX.h:2897
clang::ASTContext::setPrintingPolicy
void setPrintingPolicy(const clang::PrintingPolicy &Policy)
Definition: ASTContext.h:712
clang::Type::STK_MemberPointer
@ STK_MemberPointer
Definition: Type.h:2162
clang::CXXRecordDecl::friend_end
friend_iterator friend_end() const
Definition: DeclFriend.h:243
clang::Sema::PushOnScopeChains
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1509
clang::Preprocessor::getCurrentModule
Module * getCurrentModule()
Retrieves the module that we're currently building, if any.
Definition: Preprocessor.cpp:522
clang::Sema::emitDeferredDiags
void emitDeferredDiags()
Definition: Sema.cpp:1769
clang::Redeclarable::getMostRecentDecl
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:226
clang::Sema::LookupSingleName
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
Definition: SemaLookup.cpp:3051
clang::VarDecl::getInit
const Expr * getInit() const
Definition: Decl.h:1283
clang::Sema::getCurMethodDecl
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1456
clang::Sema::PrintStats
void PrintStats() const
Print out statistics about the semantic analysis.
Definition: Sema.cpp:574
clang::ExprValueKind
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:117
clang::ModuleLoader
Abstract interface for a module loader.
Definition: ModuleLoader.h:77
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::Sema::addImplicitTypedef
void addImplicitTypedef(StringRef Name, QualType T)
Definition: Sema.cpp:272
clang::Sema::getModuleLoader
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with the preprocessor.
Definition: Sema.cpp:58
clang::Sema::PrintContextStack
void PrintContextStack()
Definition: Sema.h:9263
clang::Sema::ActOnStartOfTranslationUnit
void ActOnStartOfTranslationUnit()
This is called before the very first declaration in the translation unit is parsed.
Definition: Sema.cpp:1033
clang::Sema::getFunctionLevelDeclContext
DeclContext * getFunctionLevelDeclContext(bool AllowLambda=false)
If AllowLambda is true, treat lambda as function.
Definition: Sema.cpp:1431
clang::ASTContext::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:768
clang::Sema::DiagnoseUnterminatedPragmaAlignPack
void DiagnoseUnterminatedPragmaAlignPack()
Definition: SemaAttr.cpp:426
clang::PartialDiagnostic::getDiagID
unsigned getDiagID() const
Definition: PartialDiagnostic.h:141
clang::SourceLocation::isMacroID
bool isMacroID() const
Definition: SourceLocation.h:103
clang::Sema::anchor
virtual void anchor()
This virtual key function only exists to limit the emission of debug info describing the Sema class.
Definition: Sema.cpp:270
clang::PartialDiagnostic
Definition: PartialDiagnostic.h:31
clang::Type::isStructureOrClassType
bool isStructureOrClassType() const
Definition: Type.cpp:581
clang::Type::getScalarTypeKind
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:2168
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::Sema::MaybeCreateExprWithCleanups
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups,...
Definition: SemaExprCXX.cpp:7264
clang::Sema::SemaDiagnosticBuilder
A generic diagnostic builder for errors which may or may not be deferred.
Definition: Sema.h:1722
clang::Sema::RecordParsingTemplateParameterDepth
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing.
Definition: Sema.cpp:2108
clang::ActionResult< Expr * >
clang::Sema::getPreprocessor
Preprocessor & getPreprocessor() const
Definition: Sema.h:1613
clang::Sema::DelayedDiagnostics::getCurrentPool
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:948
clang::Sema::getEmissionStatus
FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl, bool Final=false)
Definition: SemaDecl.cpp:19039
clang::UnresolvedSetImpl::end
iterator end()
Definition: UnresolvedSet.h:84
clang::Sema::targetDiag
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD=nullptr)
Definition: Sema.cpp:1855
clang::TranslationUnitKind
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:816
clang::sema::LambdaScopeInfo
Definition: ScopeInfo.h:825
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
clang::ModuleMap::resolveExports
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
Definition: ModuleMap.cpp:1324
clang::ASTContext::buildImplicitTypedef
TypedefDecl * buildImplicitTypedef(QualType T, StringRef Name) const
Create a new implicit TU-level typedef declaration.
Definition: ASTContext.cpp:1251
ScopeInfo.h
clang::LangAS::Default
@ Default
clang::Sema::emitAndClearUnusedLocalTypedefWarnings
void emitAndClearUnusedLocalTypedefWarnings()
Definition: Sema.cpp:1017
clang::Sema::finalizeOpenMPDelayedAnalysis
void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller, const FunctionDecl *Callee, SourceLocation Loc)
Finishes analysis of the deferred functions calls that may be declared as host/nohost during device/h...
Definition: SemaOpenMP.cpp:2518
clang::Sema::getCurScope
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:13167
clang::Sema::FunctionEmissionStatus::Emitted
@ Emitted
clang::IdentifierInfo::getName
StringRef getName() const
Return the actual identifier string.
Definition: IdentifierTable.h:195
clang::Sema::CheckCompleteVariableDeclaration
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:13378
clang::Expr::IgnoreParens
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:2943
PartialDiagnostic.h
clang
Definition: CalledOnceCheck.h:17
clang::Sema::PushFunctionScope
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:2085
clang::Preprocessor::addPPCallbacks
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:1092
clang::sema::FunctionScopeInfo::CompoundScopes
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound stamement scopes in the function.
Definition: ScopeInfo.h:214
clang::RawComment::isAlmostTrailingComment
bool isAlmostTrailingComment() const LLVM_READONLY
Returns true if it is a probable typo:
Definition: RawCommentList.h:83
clang::Sema::isConstantEvaluatedOverride
bool isConstantEvaluatedOverride
Used to change context to isConstantEvaluated without pushing a heavy ExpressionEvaluationContextReco...
Definition: Sema.h:1033
clang::VarDecl::DeclarationOnly
@ DeclarationOnly
This declaration is only a declaration.
Definition: Decl.h:1210
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:752
clang::sema::CompoundScopeInfo
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:67
clang::UnresolvedSetImpl::addDecl
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:91
clang::DeclaratorContext::Block
@ Block
clang::Sema::PragmaAlignPackDiagnoseKind::NonDefaultStateAtInclude
@ NonDefaultStateAtInclude
clang::Sema::getScopeForContext
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:2066
clang::ComparisonCategoryType::Last
@ Last
clang::Sema::TUFragmentKind
TUFragmentKind
Definition: Sema.h:1888
clang::threadSafety::threadSafetyCleanup
void threadSafetyCleanup(BeforeSet *Cache)
Definition: ThreadSafety.cpp:2479
clang::OverloadExpr::FindResult::Expression
OverloadExpr * Expression
Definition: ExprCXX.h:2947
clang::SourceManager::isInSystemHeader
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
Definition: SourceManager.h:1493
clang::ASTContext::getBuiltinMSVaListDecl
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type.
Definition: ASTContext.cpp:8930
clang::Sema::diagnoseZeroToNullptrConversion
void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E)
Warn when implicitly casting 0 to nullptr.
Definition: Sema.cpp:597
clang::FileEntry::getName
StringRef getName() const
Definition: FileEntry.h:361
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:38
clang::ASTContext::OCLClkEventTy
CanQualType OCLClkEventTy
Definition: ASTContext.h:1132
clang::Expr::getType
QualType getType() const
Definition: Expr.h:141
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:110
clang::NullabilityKind::NullableResult
@ NullableResult
noteOverloads
static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc)
Give notes for a set of overloads.
Definition: Sema.cpp:2508
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6471
clang::FunctionType::getReturnType
QualType getReturnType() const
Definition: Type.h:3822
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:311
clang::ExternalSemaSource::ReadPendingInstantiations
virtual void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending)
Read the set of pending instantiations known to the external Sema source.
Definition: ExternalSemaSource.h:180
clang::Sema::BumpAlloc
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1428
clang::Module::submodule_end
submodule_iterator submodule_end()
Definition: Module.h:681
unsigned
clang::Stmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:336
clang::Type::isIbm128Type
bool isIbm128Type() const
Definition: Type.h:7058
clang::Sema::checkNonTrivialCUnion
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
Definition: SemaDecl.cpp:12484
clang::Sema::PushCompoundScope
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:2233
clang::ASTContext::getPointerDiffType
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
Definition: ASTContext.cpp:5867
clang::Sema::isSFINAEContext
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
Definition: SemaTemplateInstantiate.cpp:849
MethodsAndNestedClassesComplete
static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, RecordCompleteMap &MNCComplete)
Returns true, if all methods and nested classes of the given CXXRecordDecl are defined in this transl...
Definition: Sema.cpp:944
clang::OMPTargetDirective
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:3008
clang::Sema::CodeSynthesisContext::RewritingOperatorAsSpaceship
@ RewritingOperatorAsSpaceship
We are rewriting a comparison operator in terms of an operator<=>.
Definition: Sema.h:8898
clang::TypedefNameDecl
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3200
clang::DiagnosticsEngine::getCurrentDiagID
unsigned getCurrentDiagID() const
Definition: Diagnostic.h:1056
IsCallableWithAppend
static bool IsCallableWithAppend(Expr *E)
Determine whether the given expression can be called by just putting parentheses after it.
Definition: Sema.cpp:2558
clang::NullabilityKind::Nullable
@ Nullable
Values of this type can be null.
DarwinSDKInfo.h
clang::InitializedEntity::InitializeBlock
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type)
Definition: Initialization.h:309
clang::TargetInfo::hasAArch64SVETypes
bool hasAArch64SVETypes() const
Returns whether or not the AArch64 SVE built-in types are available on this target.
Definition: TargetInfo.h:944
UsedDeclVisitor.h
DiagnosticOptions.h
clang::ASTContext::OCLQueueTy
CanQualType OCLQueueTy
Definition: ASTContext.h:1133
clang::ImplicitCastExpr
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3619
clang::Sema::MaxAlignmentExponent
static const unsigned MaxAlignmentExponent
The maximum alignment, same as in llvm::Value.
Definition: Sema.h:398
clang::Sema::WeakUndeclaredIdentifiers
llvm::MapVector< IdentifierInfo *, llvm::SetVector< WeakInfo, llvm::SmallVector< WeakInfo, 1u >, llvm::SmallDenseSet< WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly > > > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:1094
clang::OpenCLOptions::addSupport
void addSupport(const llvm::StringMap< bool > &FeaturesMap, const LangOptions &Opts)
Definition: OpenCLOptions.cpp:108
clang::ASTConsumer::GetASTMutationListener
virtual ASTMutationListener * GetASTMutationListener()
If the consumer is interested in entities getting modified after their initial creation,...
Definition: ASTConsumer.h:128
clang::CPlusPlus11
@ CPlusPlus11
Definition: LangStandard.h:54
clang::Sema::NTCUK_Copy
@ NTCUK_Copy
Definition: Sema.h:2878
clang::Sema::ShouldWarnIfUnusedFileScopedDecl
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
Definition: SemaDecl.cpp:1783
clang::LangOptions::CommentOpts
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:419
clang::Sema::getDarwinSDKInfoForAvailabilityChecking
DarwinSDKInfo * getDarwinSDKInfoForAvailabilityChecking()
Definition: Sema.cpp:72
clang::Sema::setFunctionHasBranchIntoScope
void setFunctionHasBranchIntoScope()
Definition: Sema.cpp:2250
clang::SourceManager::getExpansionLoc
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
Definition: SourceManager.h:1163
clang::Decl::setInvalidDecl
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
clang::Lexer::getLocForEndOfToken
static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)
Computes the source location just past the end of the token at this source location.
Definition: Lexer.cpp:788
clang::DiagnosticsEngine::getDiagnosticLevel
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:925
clang::Sema::LookupOrdinaryName
@ LookupOrdinaryName
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc....
Definition: Sema.h:4084
clang::Sema::NSNumberLiteralMethods
ObjCMethodDecl * NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]
The Objective-C NSNumber methods used to create NSNumber literals.
Definition: Sema.h:1173
clang::CastExpr::getCastKindName
const char * getCastKindName() const
Definition: Expr.h:3523
llvm::SmallVectorImpl
Definition: Randstruct.h:18
clang::TargetInfo::getFPEvalMethod
virtual LangOptions::FPEvalMethodKind getFPEvalMethod() const
Return the value for the C99 FLT_EVAL_METHOD macro.
Definition: TargetInfo.h:729
clang::Scope::DeclScope
@ DeclScope
This is a scope that can contain a declaration.
Definition: Scope.h:59
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:685
clang::FormatASTNodeDiagnosticArgument
void FormatASTNodeDiagnosticArgument(DiagnosticsEngine::ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< DiagnosticsEngine::ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, void *Cookie, ArrayRef< intptr_t > QualTypeVals)
DiagnosticsEngine argument formatting function for diagnostics that involve AST nodes.
Definition: ASTDiagnostic.cpp:356
clang::CastKind
CastKind
CastKind - The kind of operation required for a conversion.
Definition: OperationKinds.h:20
clang::Type::isIntegerType
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:7069
clang::VarTemplateDecl
Declaration of a variable template.
Definition: DeclTemplate.h:3096
clang::Sema::getPrintingPolicy
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:3100
clang::Type::STK_Bool
@ STK_Bool
Definition: Type.h:2163
clang::Sema::ExpressionEvaluationContextRecord::EK_Other
@ EK_Other
Definition: Sema.h:1316
clang::Sema::ParsingInitForAutoVars
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition: Sema.h:857
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:131
clang::CXXRecordDecl::friend_iterator
An iterator over the friend declarations of a class.
Definition: DeclFriend.h:187
SM
#define SM(sm)
Definition: Cuda.cpp:81
clang::sema::SemaPPCallbacks::reset
void reset()
Definition: Sema.cpp:138
clang::Preprocessor::getHeaderSearchInfo
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:999
clang::CleanupInfo
Definition: CleanupInfo.h:19
clang::BlockDecl::Capture
A class which contains all the information about a particular captured value.
Definition: Decl.h:4207
clang::Sema::DefineUsedVTables
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
Definition: SemaDeclCXX.cpp:17757
clang::transformer::name
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr, CxxCtorInitializer, and TypeLoc) selects th...
Definition: RangeSelector.cpp:200
clang::Sema::SemaDiagnosticBuilder::SemaDiagnosticBuilder
SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID, FunctionDecl *Fn, Sema &S)
Definition: Sema.cpp:1807
clang::Sema::PP
Preprocessor & PP
Definition: Sema.h:409
clang::Sema::EmitCurrentDiagnostic
void EmitCurrentDiagnostic(unsigned DiagID)
Cause the active diagnostic on the DiagosticsEngine to be emitted.
Definition: Sema.cpp:1476
clang::Type::STK_ObjCObjectPointer
@ STK_ObjCObjectPointer
Definition: Type.h:2161
clang::Sema::NamedReturnInfo::MoveEligible
@ MoveEligible
Definition: Sema.h:4931
clang::DiagnosticsEngine::Warning
@ Warning
Definition: Diagnostic.h:199
clang::Sema::CheckDelegatingCtorCycles
void CheckDelegatingCtorCycles()
Definition: SemaDeclCXX.cpp:18009
clang::ASTContext::getConstantArrayType
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
Definition: ASTContext.cpp:3488
clang::Sema::NSAPIObj
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:1158
clang::NullabilityKind::NonNull
@ NonNull
Values of this type can never be null.
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:425
SemaConsumer.h
clang::Sema::CheckedConversionKind
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:11643
clang::Decl::addAttr
void addAttr(Attr *A)
Definition: DeclBase.cpp:886
clang::TargetInfo::hasFPReturn
virtual bool hasFPReturn() const
Determine whether return of a floating point value is supported on this target.
Definition: TargetInfo.h:626
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1223
clang::ExternalSemaSource::ReadDeclsToCheckForDeferredDiags
virtual void ReadDeclsToCheckForDeferredDiags(llvm::SmallSetVector< Decl *, 4 > &Decls)
Read the set of decls to be checked for deferred diags.
Definition: ExternalSemaSource.h:201
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1872
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3901
clang::BlockDecl::getCaretLocation
SourceLocation getCaretLocation() const
Definition: Decl.h:4274
clang::Sema::UndefinedButUsed
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1451
clang::RawComment::RCK_OrdinaryBCPL
@ RCK_OrdinaryBCPL
Any normal BCPL comments.
Definition: RawCommentList.h:36
clang::Sema::OpaqueParser
void * OpaqueParser
Definition: Sema.h:912
clang::HeaderSearch::getModuleMap
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:777
StmtCXX.h
clang::CapturedDecl::getContextParam
ImplicitParamDecl * getContextParam() const
Retrieve the parameter containing captured variables.
Definition: Decl.h:4455
clang::Sema::PragmaAlignPackDiagnoseKind::ChangedStateAtExit
@ ChangedStateAtExit
clang::Sema::PoppedFunctionScopeDeleter::operator()
void operator()(sema::FunctionScopeInfo *Scope) const
Definition: Sema.cpp:2225
clang::ActionResult::isUsable
bool isUsable() const
Definition: Ownership.h:166
clang::ASTContext::getLangOpts
const LangOptions & getLangOpts() const
Definition: ASTContext.h:786
clang::Sema::setFunctionHasBranchProtectedScope
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:2255
clang::Preprocessor::getIdentifierInfo
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Definition: Preprocessor.h:1290
clang::LangOptions::CMK_HeaderUnit
@ CMK_HeaderUnit
Compiling a module header unit.
Definition: LangOptions.h:114
clang::Type::getLinkage
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3978
clang::FixItHint::CreateReplacement
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition: Diagnostic.h:134
clang::DiagnosticIDs::SFINAE_Report
@ SFINAE_Report
The diagnostic should be reported.
Definition: DiagnosticIDs.h:281
clang::DiagnosticsEngine::getSuppressSystemWarnings
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:684
clang::Sema::NumSFINAEErrors
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1431
clang::Sema::PoppedFunctionScopePtr
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
Definition: Sema.h:1932
clang::DiagnosticIDs::SFINAE_AccessControl
@ SFINAE_AccessControl
The diagnostic is an access-control diagnostic, which will be substitution failures in some contexts ...
Definition: DiagnosticIDs.h:285
clang::TargetInfo::hasBuiltinMSVaList
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
Definition: TargetInfo.h:937
Stack.h
clang::Sema::NTCUC_BlockCapture
@ NTCUC_BlockCapture
Definition: Sema.h:2863
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1536
clang::TargetInfo::hasRISCVVTypes
bool hasRISCVVTypes() const
Returns whether or not the RISC-V V built-in types are available on this target.
Definition: TargetInfo.h:948
clang::UnresolvedSetImpl::begin
iterator begin()
Definition: UnresolvedSet.h:83
clang::Sema::makeUnavailableInSystemHeader
bool makeUnavailableInSystemHeader(SourceLocation loc, UnavailableAttr::ImplicitReason reason)
makeUnavailableInSystemHeader - There is an error in the current context.
Definition: Sema.cpp:527
clang::ValueDecl::setType
void setType(QualType newType)
Definition: Decl.h:686
clang::parseDarwinSDKInfo
Expected< Optional< DarwinSDKInfo > > parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS, StringRef SDKRootPath)
Parse the SDK information from the SDKSettings.json file.
Definition: DarwinSDKInfo.cpp:130
clang::ExternalSemaSource::ReadWeakUndeclaredIdentifiers
virtual void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WI)
Read the set of weak, undeclared identifiers known to the external Sema source.
Definition: ExternalSemaSource.h:163
Initialization.h
clang::sema::AnalysisBasedWarnings::IssueWarnings
void IssueWarnings(Policy P, FunctionScopeInfo *fscope, const Decl *D, QualType BlockType)
Definition: AnalysisBasedWarnings.cpp:2206
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1968
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:434
clang::Sema::getASTConsumer
ASTConsumer & getASTConsumer() const
Definition: Sema.h:1615
clang::Sema::DelayedEquivalentExceptionSpecChecks
SmallVector< std::pair< FunctionDecl *, FunctionDecl * >, 2 > DelayedEquivalentExceptionSpecChecks
All the function redeclarations seen during a class definition that had their exception spec checks d...
Definition: Sema.h:900
ShouldRemoveFromUnused
static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D)
Used to prune the decls of Sema's UnusedFileScopedDecls vector.
Definition: Sema.cpp:730
clang::Sema::ExpressionEvaluationContext::PotentiallyEvaluated
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
clang::DeclContext::decls_begin
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1432