clang  10.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 "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclFriend.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/StmtCXX.h"
25 #include "clang/Basic/Stack.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Lex/HeaderSearch.h"
28 #include "clang/Lex/Preprocessor.h"
35 #include "clang/Sema/Scope.h"
36 #include "clang/Sema/ScopeInfo.h"
42 #include "llvm/ADT/DenseMap.h"
43 #include "llvm/ADT/SmallSet.h"
44 #include "llvm/Support/TimeProfiler.h"
45 
46 using namespace clang;
47 using namespace sema;
48 
50  return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
51 }
52 
53 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
54 
57  unsigned int Index) {
58  std::string InventedName;
59  llvm::raw_string_ostream OS(InventedName);
60 
61  if (!ParamName)
62  OS << "auto:" << Index + 1;
63  else
64  OS << ParamName->getName() << ":auto";
65 
66  OS.flush();
67  return &Context.Idents.get(OS.str());
68 }
69 
71  const Preprocessor &PP) {
72  PrintingPolicy Policy = Context.getPrintingPolicy();
73  // In diagnostics, we print _Bool as bool if the latter is defined as the
74  // former.
75  Policy.Bool = Context.getLangOpts().Bool;
76  if (!Policy.Bool) {
77  if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
78  Policy.Bool = BoolMacro->isObjectLike() &&
79  BoolMacro->getNumTokens() == 1 &&
80  BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
81  }
82  }
83 
84  return Policy;
85 }
86 
88  TUScope = S;
89  PushDeclContext(S, Context.getTranslationUnitDecl());
90 }
91 
92 namespace clang {
93 namespace sema {
94 
95 class SemaPPCallbacks : public PPCallbacks {
96  Sema *S = nullptr;
98 
99 public:
100  void set(Sema &S) { this->S = &S; }
101 
102  void reset() { S = nullptr; }
103 
104  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
106  FileID PrevFID) override {
107  if (!S)
108  return;
109  switch (Reason) {
110  case EnterFile: {
112  SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
113  if (IncludeLoc.isValid()) {
114  if (llvm::timeTraceProfilerEnabled()) {
115  const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
116  llvm::timeTraceProfilerBegin(
117  "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));
118  }
119 
120  IncludeStack.push_back(IncludeLoc);
123  }
124  break;
125  }
126  case ExitFile:
127  if (!IncludeStack.empty()) {
128  if (llvm::timeTraceProfilerEnabled())
129  llvm::timeTraceProfilerEnd();
130 
133  IncludeStack.pop_back_val());
134  }
135  break;
136  default:
137  break;
138  }
139  }
140 };
141 
142 } // end namespace sema
143 } // end namespace clang
144 
145 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
146  TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
147  : ExternalSource(nullptr), isMultiplexExternalSource(false),
148  FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
149  Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
150  SourceMgr(PP.getSourceManager()), CollectStats(false),
151  CodeCompleter(CodeCompleter), CurContext(nullptr),
152  OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
153  MSPointerToMemberRepresentationMethod(
154  LangOpts.getMSPointerToMemberRepresentationMethod()),
155  VtorDispStack(LangOpts.getVtorDispMode()), PackStack(0),
156  DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
157  CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
158  PragmaAttributeCurrentTargetDecl(nullptr),
159  IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
160  LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
162  StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
163  MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
164  NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
165  ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
166  ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
169  FullyCheckedComparisonCategories(
170  static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
171  SatisfactionCache(Context), AccessCheckingSFINAE(false),
175  ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
176  CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
177  TUScope = nullptr;
179 
180  LoadedExternalKnownNamespaces = false;
181  for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
182  NSNumberLiteralMethods[I] = nullptr;
183 
184  if (getLangOpts().ObjC)
185  NSAPIObj.reset(new NSAPI(Context));
186 
187  if (getLangOpts().CPlusPlus)
188  FieldCollector.reset(new CXXFieldCollector());
189 
190  // Tell diagnostics how to render things from the AST library.
192 
193  ExprEvalContexts.emplace_back(
196 
197  // Initialization of data sharing attributes stack for OpenMP
198  InitDataSharingAttributesStack();
199 
200  std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
201  std::make_unique<sema::SemaPPCallbacks>();
202  SemaPPCallbackHandler = Callbacks.get();
203  PP.addPPCallbacks(std::move(Callbacks));
204  SemaPPCallbackHandler->set(*this);
205 }
206 
207 // Anchor Sema's type info to this TU.
208 void Sema::anchor() {}
209 
210 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
211  DeclarationName DN = &Context.Idents.get(Name);
212  if (IdResolver.begin(DN) == IdResolver.end())
214 }
215 
217  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
218  SC->InitializeSema(*this);
219 
220  // Tell the external Sema source about this Sema object.
221  if (ExternalSemaSource *ExternalSema
222  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
223  ExternalSema->InitializeSema(*this);
224 
225  // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
226  // will not be able to merge any duplicate __va_list_tag decls correctly.
227  VAListTagName = PP.getIdentifierInfo("__va_list_tag");
228 
229  if (!TUScope)
230  return;
231 
232  // Initialize predefined 128-bit integer types, if needed.
234  // If either of the 128-bit integer types are unavailable to name lookup,
235  // define them now.
236  DeclarationName Int128 = &Context.Idents.get("__int128_t");
237  if (IdResolver.begin(Int128) == IdResolver.end())
239 
240  DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
241  if (IdResolver.begin(UInt128) == IdResolver.end())
243  }
244 
245 
246  // Initialize predefined Objective-C types:
247  if (getLangOpts().ObjC) {
248  // If 'SEL' does not yet refer to any declarations, make it refer to the
249  // predefined 'SEL'.
250  DeclarationName SEL = &Context.Idents.get("SEL");
251  if (IdResolver.begin(SEL) == IdResolver.end())
253 
254  // If 'id' does not yet refer to any declarations, make it refer to the
255  // predefined 'id'.
257  if (IdResolver.begin(Id) == IdResolver.end())
259 
260  // Create the built-in typedef for 'Class'.
261  DeclarationName Class = &Context.Idents.get("Class");
262  if (IdResolver.begin(Class) == IdResolver.end())
264 
265  // Create the built-in forward declaratino for 'Protocol'.
266  DeclarationName Protocol = &Context.Idents.get("Protocol");
267  if (IdResolver.begin(Protocol) == IdResolver.end())
269  }
270 
271  // Create the internal type for the *StringMakeConstantString builtins.
272  DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
273  if (IdResolver.begin(ConstantString) == IdResolver.end())
275 
276  // Initialize Microsoft "predefined C++ types".
277  if (getLangOpts().MSVCCompat) {
278  if (getLangOpts().CPlusPlus &&
279  IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
281  TUScope);
282 
284  }
285 
286  // Initialize predefined OpenCL types and supported extensions and (optional)
287  // core features.
288  if (getLangOpts().OpenCL) {
294  if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
295  addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
297  addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
299  addImplicitTypedef("atomic_uint",
301  auto AtomicLongT = Context.getAtomicType(Context.LongTy);
302  addImplicitTypedef("atomic_long", AtomicLongT);
303  auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
304  addImplicitTypedef("atomic_ulong", AtomicULongT);
305  addImplicitTypedef("atomic_float",
307  auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
308  addImplicitTypedef("atomic_double", AtomicDoubleT);
309  // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
310  // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
312  auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
313  addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
314  auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
315  addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
316  auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
317  addImplicitTypedef("atomic_size_t", AtomicSizeT);
318  auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
319  addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
320 
321  // OpenCL v2.0 s6.13.11.6:
322  // - The atomic_long and atomic_ulong types are supported if the
323  // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
324  // extensions are supported.
325  // - The atomic_double type is only supported if double precision
326  // is supported and the cl_khr_int64_base_atomics and
327  // cl_khr_int64_extended_atomics extensions are supported.
328  // - If the device address space is 64-bits, the data types
329  // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
330  // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
331  // cl_khr_int64_extended_atomics extensions are supported.
332  std::vector<QualType> Atomic64BitTypes;
333  Atomic64BitTypes.push_back(AtomicLongT);
334  Atomic64BitTypes.push_back(AtomicULongT);
335  Atomic64BitTypes.push_back(AtomicDoubleT);
336  if (Context.getTypeSize(AtomicSizeT) == 64) {
337  Atomic64BitTypes.push_back(AtomicSizeT);
338  Atomic64BitTypes.push_back(AtomicIntPtrT);
339  Atomic64BitTypes.push_back(AtomicUIntPtrT);
340  Atomic64BitTypes.push_back(AtomicPtrDiffT);
341  }
342  for (auto &I : Atomic64BitTypes)
344  "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
345 
346  setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
347  }
348 
350 
351 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
352  setOpenCLExtensionForType(Context.Id, Ext);
353 #include "clang/Basic/OpenCLImageTypes.def"
354 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
355  addImplicitTypedef(#ExtType, Context.Id##Ty); \
356  setOpenCLExtensionForType(Context.Id##Ty, #Ext);
357 #include "clang/Basic/OpenCLExtensionTypes.def"
358  }
359 
361 #define SVE_TYPE(Name, Id, SingletonId) \
362  addImplicitTypedef(Name, Context.SingletonId);
363 #include "clang/Basic/AArch64SVEACLETypes.def"
364  }
365 
367  DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
368  if (IdResolver.begin(MSVaList) == IdResolver.end())
370  }
371 
372  DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
373  if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
375 }
376 
378  if (VisContext) FreeVisContext();
379 
380  // Kill all the active scopes.
382  delete FSI;
383 
384  // Tell the SemaConsumer to forget about us; we're going out of scope.
385  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
386  SC->ForgetSema();
387 
388  // Detach from the external Sema source.
389  if (ExternalSemaSource *ExternalSema
390  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
391  ExternalSema->ForgetSema();
392 
393  // If Sema's ExternalSource is the multiplexer - we own it.
394  if (isMultiplexExternalSource)
395  delete ExternalSource;
396 
397  // Delete cached satisfactions.
398  std::vector<ConstraintSatisfaction *> Satisfactions;
399  Satisfactions.reserve(Satisfactions.size());
400  for (auto &Node : SatisfactionCache)
401  Satisfactions.push_back(&Node);
402  for (auto *Node : Satisfactions)
403  delete Node;
404 
406 
407  // Destroys data sharing attributes stack for OpenMP
408  DestroyDataSharingAttributesStack();
409 
410  // Detach from the PP callback handler which outlives Sema since it's owned
411  // by the preprocessor.
412  SemaPPCallbackHandler->reset();
413 }
414 
416  // Only warn about this once.
417  if (!WarnedStackExhausted) {
418  Diag(Loc, diag::warn_stack_exhausted);
419  WarnedStackExhausted = true;
420  }
421 }
422 
424  llvm::function_ref<void()> Fn) {
426 }
427 
428 /// makeUnavailableInSystemHeader - There is an error in the current
429 /// context. If we're still in a system header, and we can plausibly
430 /// make the relevant declaration unavailable instead of erroring, do
431 /// so and return true.
433  UnavailableAttr::ImplicitReason reason) {
434  // If we're not in a function, it's an error.
435  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
436  if (!fn) return false;
437 
438  // If we're in template instantiation, it's an error.
440  return false;
441 
442  // If that function's not in a system header, it's an error.
444  return false;
445 
446  // If the function is already unavailable, it's not an error.
447  if (fn->hasAttr<UnavailableAttr>()) return true;
448 
449  fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
450  return true;
451 }
452 
455 }
456 
457 ///Registers an external source. If an external source already exists,
458 /// creates a multiplex external source and appends to it.
459 ///
460 ///\param[in] E - A non-null external sema source.
461 ///
463  assert(E && "Cannot use with NULL ptr");
464 
465  if (!ExternalSource) {
466  ExternalSource = E;
467  return;
468  }
469 
470  if (isMultiplexExternalSource)
471  static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
472  else {
473  ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
474  isMultiplexExternalSource = true;
475  }
476 }
477 
478 /// Print out statistics about the semantic analysis.
479 void Sema::PrintStats() const {
480  llvm::errs() << "\n*** Semantic Analysis Stats:\n";
481  llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
482 
483  BumpAlloc.PrintStats();
485 }
486 
488  QualType SrcType,
489  SourceLocation Loc) {
490  Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
491  if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
492  return;
493 
494  Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
495  if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
496  return;
497 
498  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
499 }
500 
502  if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
503  E->getBeginLoc()))
504  return;
505  // nullptr only exists from C++11 on, so don't warn on its absence earlier.
506  if (!getLangOpts().CPlusPlus11)
507  return;
508 
509  if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
510  return;
512  return;
513 
514  // If it is a macro from system header, and if the macro name is not "NULL",
515  // do not warn.
516  SourceLocation MaybeMacroLoc = E->getBeginLoc();
518  SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
519  !findMacroSpelling(MaybeMacroLoc, "NULL"))
520  return;
521 
522  Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
523  << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
524 }
525 
526 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
527 /// If there is already an implicit cast, merge into the existing one.
528 /// The result is of the given category.
531  const CXXCastPath *BasePath,
532  CheckedConversionKind CCK) {
533 #ifndef NDEBUG
534  if (VK == VK_RValue && !E->isRValue()) {
535  switch (Kind) {
536  default:
537  llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
538  "kind");
539  case CK_Dependent:
540  case CK_LValueToRValue:
541  case CK_ArrayToPointerDecay:
542  case CK_FunctionToPointerDecay:
543  case CK_ToVoid:
544  case CK_NonAtomicToAtomic:
545  break;
546  }
547  }
548  assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) &&
549  "can't cast rvalue to lvalue");
550 #endif
551 
554 
555  QualType ExprTy = Context.getCanonicalType(E->getType());
557 
558  if (ExprTy == TypeTy)
559  return E;
560 
561  // C++1z [conv.array]: The temporary materialization conversion is applied.
562  // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
563  if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
564  E->getValueKind() == VK_RValue) {
565  // The temporary is an lvalue in C++98 and an xvalue otherwise.
567  E->getType(), E, !getLangOpts().CPlusPlus11);
568  if (Materialized.isInvalid())
569  return ExprError();
570  E = Materialized.get();
571  }
572 
573  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
574  if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
575  ImpCast->setType(Ty);
576  ImpCast->setValueKind(VK);
577  return E;
578  }
579  }
580 
581  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
582 }
583 
584 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
585 /// to the conversion from scalar type ScalarTy to the Boolean type.
587  switch (ScalarTy->getScalarTypeKind()) {
588  case Type::STK_Bool: return CK_NoOp;
589  case Type::STK_CPointer: return CK_PointerToBoolean;
590  case Type::STK_BlockPointer: return CK_PointerToBoolean;
591  case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
592  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
593  case Type::STK_Integral: return CK_IntegralToBoolean;
594  case Type::STK_Floating: return CK_FloatingToBoolean;
595  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
596  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
597  case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
598  }
599  llvm_unreachable("unknown scalar type kind");
600 }
601 
602 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
603 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
604  if (D->getMostRecentDecl()->isUsed())
605  return true;
606 
607  if (D->isExternallyVisible())
608  return true;
609 
610  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
611  // If this is a function template and none of its specializations is used,
612  // we should warn.
613  if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
614  for (const auto *Spec : Template->specializations())
615  if (ShouldRemoveFromUnused(SemaRef, Spec))
616  return true;
617 
618  // UnusedFileScopedDecls stores the first declaration.
619  // The declaration may have become definition so check again.
620  const FunctionDecl *DeclToCheck;
621  if (FD->hasBody(DeclToCheck))
622  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
623 
624  // Later redecls may add new information resulting in not having to warn,
625  // so check again.
626  DeclToCheck = FD->getMostRecentDecl();
627  if (DeclToCheck != FD)
628  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
629  }
630 
631  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
632  // If a variable usable in constant expressions is referenced,
633  // don't warn if it isn't used: if the value of a variable is required
634  // for the computation of a constant expression, it doesn't make sense to
635  // warn even if the variable isn't odr-used. (isReferenced doesn't
636  // precisely reflect that, but it's a decent approximation.)
637  if (VD->isReferenced() &&
638  VD->mightBeUsableInConstantExpressions(SemaRef->Context))
639  return true;
640 
641  if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
642  // If this is a variable template and none of its specializations is used,
643  // we should warn.
644  for (const auto *Spec : Template->specializations())
645  if (ShouldRemoveFromUnused(SemaRef, Spec))
646  return true;
647 
648  // UnusedFileScopedDecls stores the first declaration.
649  // The declaration may have become definition so check again.
650  const VarDecl *DeclToCheck = VD->getDefinition();
651  if (DeclToCheck)
652  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
653 
654  // Later redecls may add new information resulting in not having to warn,
655  // so check again.
656  DeclToCheck = VD->getMostRecentDecl();
657  if (DeclToCheck != VD)
658  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
659  }
660 
661  return false;
662 }
663 
665  if (auto *FD = dyn_cast<FunctionDecl>(ND))
666  return FD->isExternC();
667  return cast<VarDecl>(ND)->isExternC();
668 }
669 
670 /// Determine whether ND is an external-linkage function or variable whose
671 /// type has no linkage.
673  // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
674  // because we also want to catch the case where its type has VisibleNoLinkage,
675  // which does not affect the linkage of VD.
676  return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
679 }
680 
681 /// Obtains a sorted list of functions and variables that are undefined but
682 /// ODR-used.
684  SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
685  for (const auto &UndefinedUse : UndefinedButUsed) {
686  NamedDecl *ND = UndefinedUse.first;
687 
688  // Ignore attributes that have become invalid.
689  if (ND->isInvalidDecl()) continue;
690 
691  // __attribute__((weakref)) is basically a definition.
692  if (ND->hasAttr<WeakRefAttr>()) continue;
693 
694  if (isa<CXXDeductionGuideDecl>(ND))
695  continue;
696 
697  if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
698  // An exported function will always be emitted when defined, so even if
699  // the function is inline, it doesn't have to be emitted in this TU. An
700  // imported function implies that it has been exported somewhere else.
701  continue;
702  }
703 
704  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
705  if (FD->isDefined())
706  continue;
707  if (FD->isExternallyVisible() &&
709  !FD->getMostRecentDecl()->isInlined() &&
710  !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
711  continue;
712  if (FD->getBuiltinID())
713  continue;
714  } else {
715  auto *VD = cast<VarDecl>(ND);
716  if (VD->hasDefinition() != VarDecl::DeclarationOnly)
717  continue;
718  if (VD->isExternallyVisible() &&
720  !VD->getMostRecentDecl()->isInline() &&
721  !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
722  continue;
723 
724  // Skip VarDecls that lack formal definitions but which we know are in
725  // fact defined somewhere.
726  if (VD->isKnownToBeDefined())
727  continue;
728  }
729 
730  Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
731  }
732 }
733 
734 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
735 /// or that are inline.
736 static void checkUndefinedButUsed(Sema &S) {
737  if (S.UndefinedButUsed.empty()) return;
738 
739  // Collect all the still-undefined entities with internal linkage.
741  S.getUndefinedButUsed(Undefined);
742  if (Undefined.empty()) return;
743 
744  for (auto Undef : Undefined) {
745  ValueDecl *VD = cast<ValueDecl>(Undef.first);
746  SourceLocation UseLoc = Undef.second;
747 
748  if (S.isExternalWithNoLinkageType(VD)) {
749  // C++ [basic.link]p8:
750  // A type without linkage shall not be used as the type of a variable
751  // or function with external linkage unless
752  // -- the entity has C language linkage
753  // -- the entity is not odr-used or is defined in the same TU
754  //
755  // As an extension, accept this in cases where the type is externally
756  // visible, since the function or variable actually can be defined in
757  // another translation unit in that case.
759  ? diag::ext_undefined_internal_type
760  : diag::err_undefined_internal_type)
761  << isa<VarDecl>(VD) << VD;
762  } else if (!VD->isExternallyVisible()) {
763  // FIXME: We can promote this to an error. The function or variable can't
764  // be defined anywhere else, so the program must necessarily violate the
765  // one definition rule.
766  S.Diag(VD->getLocation(), diag::warn_undefined_internal)
767  << isa<VarDecl>(VD) << VD;
768  } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
769  (void)FD;
770  assert(FD->getMostRecentDecl()->isInlined() &&
771  "used object requires definition but isn't inline or internal?");
772  // FIXME: This is ill-formed; we should reject.
773  S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
774  } else {
775  assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
776  "used var requires definition but isn't inline or internal?");
777  S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
778  }
779  if (UseLoc.isValid())
780  S.Diag(UseLoc, diag::note_used_here);
781  }
782 
783  S.UndefinedButUsed.clear();
784 }
785 
787  if (!ExternalSource)
788  return;
789 
791  ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
792  for (auto &WeakID : WeakIDs)
793  WeakUndeclaredIdentifiers.insert(WeakID);
794 }
795 
796 
797 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
798 
799 /// Returns true, if all methods and nested classes of the given
800 /// CXXRecordDecl are defined in this translation unit.
801 ///
802 /// Should only be called from ActOnEndOfTranslationUnit so that all
803 /// definitions are actually read.
805  RecordCompleteMap &MNCComplete) {
806  RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
807  if (Cache != MNCComplete.end())
808  return Cache->second;
809  if (!RD->isCompleteDefinition())
810  return false;
811  bool Complete = true;
813  E = RD->decls_end();
814  I != E && Complete; ++I) {
815  if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
816  Complete = M->isDefined() || M->isDefaulted() ||
817  (M->isPure() && !isa<CXXDestructorDecl>(M));
818  else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
819  // If the template function is marked as late template parsed at this
820  // point, it has not been instantiated and therefore we have not
821  // performed semantic analysis on it yet, so we cannot know if the type
822  // can be considered complete.
823  Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
824  F->getTemplatedDecl()->isDefined();
825  else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
826  if (R->isInjectedClassName())
827  continue;
828  if (R->hasDefinition())
829  Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
830  MNCComplete);
831  else
832  Complete = false;
833  }
834  }
835  MNCComplete[RD] = Complete;
836  return Complete;
837 }
838 
839 /// Returns true, if the given CXXRecordDecl is fully defined in this
840 /// translation unit, i.e. all methods are defined or pure virtual and all
841 /// friends, friend functions and nested classes are fully defined in this
842 /// translation unit.
843 ///
844 /// Should only be called from ActOnEndOfTranslationUnit so that all
845 /// definitions are actually read.
846 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
847  RecordCompleteMap &RecordsComplete,
848  RecordCompleteMap &MNCComplete) {
849  RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
850  if (Cache != RecordsComplete.end())
851  return Cache->second;
852  bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
854  E = RD->friend_end();
855  I != E && Complete; ++I) {
856  // Check if friend classes and methods are complete.
857  if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
858  // Friend classes are available as the TypeSourceInfo of the FriendDecl.
859  if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
860  Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
861  else
862  Complete = false;
863  } else {
864  // Friend functions are available through the NamedDecl of FriendDecl.
865  if (const FunctionDecl *FD =
866  dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
867  Complete = FD->isDefined();
868  else
869  // This is a template friend, give up.
870  Complete = false;
871  }
872  }
873  RecordsComplete[RD] = Complete;
874  return Complete;
875 }
876 
878  if (ExternalSource)
879  ExternalSource->ReadUnusedLocalTypedefNameCandidates(
882  if (TD->isReferenced())
883  continue;
884  Diag(TD->getLocation(), diag::warn_unused_local_typedef)
885  << isa<TypeAliasDecl>(TD) << TD->getDeclName();
886  }
887  UnusedLocalTypedefNameCandidates.clear();
888 }
889 
890 /// This is called before the very first declaration in the translation unit
891 /// is parsed. Note that the ASTContext may have already injected some
892 /// declarations.
894  if (getLangOpts().ModulesTS &&
895  (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
896  getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
897  // We start in an implied global module fragment.
898  SourceLocation StartOfTU =
901  ModuleScopes.back().ImplicitGlobalModuleFragment = true;
902  }
903 }
904 
906  // No explicit actions are required at the end of the global module fragment.
907  if (Kind == TUFragmentKind::Global)
908  return;
909 
910  // Transfer late parsed template instantiations over to the pending template
911  // instantiation list. During normal compilation, the late template parser
912  // will be installed and instantiating these templates will succeed.
913  //
914  // If we are building a TU prefix for serialization, it is also safe to
915  // transfer these over, even though they are not parsed. The end of the TU
916  // should be outside of any eager template instantiation scope, so when this
917  // AST is deserialized, these templates will not be parsed until the end of
918  // the combined TU.
920  LateParsedInstantiations.begin(),
922  LateParsedInstantiations.clear();
923 
924  // If DefinedUsedVTables ends up marking any virtual member functions it
925  // might lead to more pending template instantiations, which we then need
926  // to instantiate.
928 
929  // C++: Perform implicit template instantiations.
930  //
931  // FIXME: When we perform these implicit instantiations, we do not
932  // carefully keep track of the point of instantiation (C++ [temp.point]).
933  // This means that name lookup that occurs within the template
934  // instantiation will always happen at the end of the translation unit,
935  // so it will find some names that are not required to be found. This is
936  // valid, but we could do better by diagnosing if an instantiation uses a
937  // name that was not visible at its first point of instantiation.
938  if (ExternalSource) {
939  // Load pending instantiations from the external source.
941  ExternalSource->ReadPendingInstantiations(Pending);
942  for (auto PII : Pending)
943  if (auto Func = dyn_cast<FunctionDecl>(PII.first))
944  Func->setInstantiationIsPending(true);
946  Pending.begin(), Pending.end());
947  }
948 
949  {
950  llvm::TimeTraceScope TimeScope("PerformPendingInstantiations");
952  }
953 
954  // Finalize analysis of OpenMP-specific constructs.
955  if (LangOpts.OpenMP)
956  finalizeOpenMPDelayedAnalysis();
957 
958  assert(LateParsedInstantiations.empty() &&
959  "end of TU template instantiation should not create more "
960  "late-parsed templates");
961 
962  // Report diagnostics for uncorrected delayed typos. Ideally all of them
963  // should have been corrected by that time, but it is very hard to cover all
964  // cases in practice.
965  for (const auto &Typo : DelayedTypos) {
966  // We pass an empty TypoCorrection to indicate no correction was performed.
967  Typo.second.DiagHandler(TypoCorrection());
968  }
969  DelayedTypos.clear();
970 }
971 
972 /// ActOnEndOfTranslationUnit - This is called at the very end of the
973 /// translation unit when EOF is reached and all but the top-level scope is
974 /// popped.
976  assert(DelayedDiagnostics.getCurrentPool() == nullptr
977  && "reached end of translation unit with a pool attached?");
978 
979  // If code completion is enabled, don't perform any end-of-translation-unit
980  // work.
982  return;
983 
984  // Complete translation units and modules define vtables and perform implicit
985  // instantiations. PCH files do not.
986  if (TUKind != TU_Prefix) {
988 
990  !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
992  ? TUFragmentKind::Private
994 
997 
999  } else {
1000  // If we are building a TU prefix for serialization, it is safe to transfer
1001  // these over, even though they are not parsed. The end of the TU should be
1002  // outside of any eager template instantiation scope, so when this AST is
1003  // deserialized, these templates will not be parsed until the end of the
1004  // combined TU.
1006  LateParsedInstantiations.begin(),
1007  LateParsedInstantiations.end());
1008  LateParsedInstantiations.clear();
1009  }
1010 
1013 
1014  // All delayed member exception specs should be checked or we end up accepting
1015  // incompatible declarations.
1016  assert(DelayedOverridingExceptionSpecChecks.empty());
1017  assert(DelayedEquivalentExceptionSpecChecks.empty());
1018 
1019  // All dllexport classes should have been processed already.
1020  assert(DelayedDllExportClasses.empty());
1021  assert(DelayedDllExportMemberFunctions.empty());
1022 
1023  // Remove file scoped decls that turned out to be used.
1025  std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
1027  [this](const DeclaratorDecl *DD) {
1028  return ShouldRemoveFromUnused(this, DD);
1029  }),
1031 
1032  if (TUKind == TU_Prefix) {
1033  // Translation unit prefixes don't need any of the checking below.
1035  TUScope = nullptr;
1036  return;
1037  }
1038 
1039  // Check for #pragma weak identifiers that were never declared
1041  for (auto WeakID : WeakUndeclaredIdentifiers) {
1042  if (WeakID.second.getUsed())
1043  continue;
1044 
1045  Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
1047  if (PrevDecl != nullptr &&
1048  !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
1049  Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
1050  << "'weak'" << ExpectedVariableOrFunction;
1051  else
1052  Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
1053  << WeakID.first;
1054  }
1055 
1056  if (LangOpts.CPlusPlus11 &&
1057  !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
1059 
1060  if (!Diags.hasErrorOccurred()) {
1061  if (ExternalSource)
1062  ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1063  checkUndefinedButUsed(*this);
1064  }
1065 
1066  // A global-module-fragment is only permitted within a module unit.
1067  bool DiagnosedMissingModuleDeclaration = false;
1068  if (!ModuleScopes.empty() &&
1069  ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1070  !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1071  Diag(ModuleScopes.back().BeginLoc,
1072  diag::err_module_declaration_missing_after_global_module_introducer);
1073  DiagnosedMissingModuleDeclaration = true;
1074  }
1075 
1076  if (TUKind == TU_Module) {
1077  // If we are building a module interface unit, we need to have seen the
1078  // module declaration by now.
1079  if (getLangOpts().getCompilingModule() ==
1081  (ModuleScopes.empty() ||
1082  !ModuleScopes.back().Module->isModulePurview()) &&
1083  !DiagnosedMissingModuleDeclaration) {
1084  // FIXME: Make a better guess as to where to put the module declaration.
1085  Diag(getSourceManager().getLocForStartOfFile(
1086  getSourceManager().getMainFileID()),
1087  diag::err_module_declaration_missing);
1088  }
1089 
1090  // If we are building a module, resolve all of the exported declarations
1091  // now.
1092  if (Module *CurrentModule = PP.getCurrentModule()) {
1094 
1096  Stack.push_back(CurrentModule);
1097  while (!Stack.empty()) {
1098  Module *Mod = Stack.pop_back_val();
1099 
1100  // Resolve the exported declarations and conflicts.
1101  // FIXME: Actually complain, once we figure out how to teach the
1102  // diagnostic client to deal with complaints in the module map at this
1103  // point.
1104  ModMap.resolveExports(Mod, /*Complain=*/false);
1105  ModMap.resolveUses(Mod, /*Complain=*/false);
1106  ModMap.resolveConflicts(Mod, /*Complain=*/false);
1107 
1108  // Queue the submodules, so their exports will also be resolved.
1109  Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1110  }
1111  }
1112 
1113  // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1114  // modules when they are built, not every time they are used.
1116  }
1117 
1118  // C99 6.9.2p2:
1119  // A declaration of an identifier for an object that has file
1120  // scope without an initializer, and without a storage-class
1121  // specifier or with the storage-class specifier static,
1122  // constitutes a tentative definition. If a translation unit
1123  // contains one or more tentative definitions for an identifier,
1124  // and the translation unit contains no external definition for
1125  // that identifier, then the behavior is exactly as if the
1126  // translation unit contains a file scope declaration of that
1127  // identifier, with the composite type as of the end of the
1128  // translation unit, with an initializer equal to 0.
1129  llvm::SmallSet<VarDecl *, 32> Seen;
1130  for (TentativeDefinitionsType::iterator
1131  T = TentativeDefinitions.begin(ExternalSource),
1132  TEnd = TentativeDefinitions.end();
1133  T != TEnd; ++T) {
1134  VarDecl *VD = (*T)->getActingDefinition();
1135 
1136  // If the tentative definition was completed, getActingDefinition() returns
1137  // null. If we've already seen this variable before, insert()'s second
1138  // return value is false.
1139  if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1140  continue;
1141 
1142  if (const IncompleteArrayType *ArrayT
1144  // Set the length of the array to 1 (C99 6.9.2p5).
1145  Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1147  QualType T = Context.getConstantArrayType(ArrayT->getElementType(), One,
1148  nullptr, ArrayType::Normal, 0);
1149  VD->setType(T);
1150  } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1151  diag::err_tentative_def_incomplete_type))
1152  VD->setInvalidDecl();
1153 
1154  // No initialization is performed for a tentative definition.
1156 
1157  // Notify the consumer that we've completed a tentative definition.
1158  if (!VD->isInvalidDecl())
1160  }
1161 
1162  for (auto D : ExternalDeclarations) {
1163  if (!D || D->isInvalidDecl() || D->getPreviousDecl() || !D->isUsed())
1164  continue;
1165 
1167  }
1168 
1169  // If there were errors, disable 'unused' warnings since they will mostly be
1170  // noise. Don't warn for a use from a module: either we should warn on all
1171  // file-scope declarations in modules or not at all, but whether the
1172  // declaration is used is immaterial.
1173  if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1174  // Output warning for unused file scoped decls.
1175  for (UnusedFileScopedDeclsType::iterator
1176  I = UnusedFileScopedDecls.begin(ExternalSource),
1177  E = UnusedFileScopedDecls.end(); I != E; ++I) {
1178  if (ShouldRemoveFromUnused(this, *I))
1179  continue;
1180 
1181  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1182  const FunctionDecl *DiagD;
1183  if (!FD->hasBody(DiagD))
1184  DiagD = FD;
1185  if (DiagD->isDeleted())
1186  continue; // Deleted functions are supposed to be unused.
1187  if (DiagD->isReferenced()) {
1188  if (isa<CXXMethodDecl>(DiagD))
1189  Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1190  << DiagD->getDeclName();
1191  else {
1192  if (FD->getStorageClass() == SC_Static &&
1193  !FD->isInlineSpecified() &&
1195  SourceMgr.getExpansionLoc(FD->getLocation())))
1196  Diag(DiagD->getLocation(),
1197  diag::warn_unneeded_static_internal_decl)
1198  << DiagD->getDeclName();
1199  else
1200  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1201  << /*function*/0 << DiagD->getDeclName();
1202  }
1203  } else {
1204  if (FD->getDescribedFunctionTemplate())
1205  Diag(DiagD->getLocation(), diag::warn_unused_template)
1206  << /*function*/0 << DiagD->getDeclName();
1207  else
1208  Diag(DiagD->getLocation(),
1209  isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1210  : diag::warn_unused_function)
1211  << DiagD->getDeclName();
1212  }
1213  } else {
1214  const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1215  if (!DiagD)
1216  DiagD = cast<VarDecl>(*I);
1217  if (DiagD->isReferenced()) {
1218  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1219  << /*variable*/1 << DiagD->getDeclName();
1220  } else if (DiagD->getType().isConstQualified()) {
1221  const SourceManager &SM = SourceMgr;
1222  if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1224  Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1225  << DiagD->getDeclName();
1226  } else {
1227  if (DiagD->getDescribedVarTemplate())
1228  Diag(DiagD->getLocation(), diag::warn_unused_template)
1229  << /*variable*/1 << DiagD->getDeclName();
1230  else
1231  Diag(DiagD->getLocation(), diag::warn_unused_variable)
1232  << DiagD->getDeclName();
1233  }
1234  }
1235  }
1236 
1238  }
1239 
1240  if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1241  // FIXME: Load additional unused private field candidates from the external
1242  // source.
1243  RecordCompleteMap RecordsComplete;
1244  RecordCompleteMap MNCComplete;
1245  for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1246  E = UnusedPrivateFields.end(); I != E; ++I) {
1247  const NamedDecl *D = *I;
1248  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1249  if (RD && !RD->isUnion() &&
1250  IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1251  Diag(D->getLocation(), diag::warn_unused_private_field)
1252  << D->getDeclName();
1253  }
1254  }
1255  }
1256 
1257  if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1258  if (ExternalSource)
1260  for (const auto &DeletedFieldInfo : DeleteExprs) {
1261  for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1262  AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1263  DeleteExprLoc.second);
1264  }
1265  }
1266  }
1267 
1268  // Check we've noticed that we're no longer parsing the initializer for every
1269  // variable. If we miss cases, then at best we have a performance issue and
1270  // at worst a rejects-valid bug.
1271  assert(ParsingInitForAutoVars.empty() &&
1272  "Didn't unmark var as having its initializer parsed");
1273 
1275  TUScope = nullptr;
1276 }
1277 
1278 
1279 //===----------------------------------------------------------------------===//
1280 // Helper functions.
1281 //===----------------------------------------------------------------------===//
1282 
1284  DeclContext *DC = CurContext;
1285 
1286  while (true) {
1287  if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC) ||
1288  isa<RequiresExprBodyDecl>(DC)) {
1289  DC = DC->getParent();
1290  } else if (isa<CXXMethodDecl>(DC) &&
1291  cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1292  cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1293  DC = DC->getParent()->getParent();
1294  }
1295  else break;
1296  }
1297 
1298  return DC;
1299 }
1300 
1301 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1302 /// to the function decl for the function being parsed. If we're currently
1303 /// in a 'block', this returns the containing context.
1306  return dyn_cast<FunctionDecl>(DC);
1307 }
1308 
1311  while (isa<RecordDecl>(DC))
1312  DC = DC->getParent();
1313  return dyn_cast<ObjCMethodDecl>(DC);
1314 }
1315 
1318  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1319  return cast<NamedDecl>(DC);
1320  return nullptr;
1321 }
1322 
1324  if (getLangOpts().OpenCL)
1325  return LangAS::opencl_generic;
1326  return LangAS::Default;
1327 }
1328 
1329 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1330  // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1331  // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1332  // been made more painfully obvious by the refactor that introduced this
1333  // function, but it is possible that the incoming argument can be
1334  // eliminated. If it truly cannot be (for example, there is some reentrancy
1335  // issue I am not seeing yet), then there should at least be a clarifying
1336  // comment somewhere.
1339  Diags.getCurrentDiagID())) {
1341  // We'll report the diagnostic below.
1342  break;
1343 
1345  // Count this failure so that we know that template argument deduction
1346  // has failed.
1347  ++NumSFINAEErrors;
1348 
1349  // Make a copy of this suppressed diagnostic and store it with the
1350  // template-deduction information.
1351  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1352  Diagnostic DiagInfo(&Diags);
1353  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1355  }
1356 
1358  Diags.Clear();
1359  return;
1360 
1362  // Per C++ Core Issue 1170, access control is part of SFINAE.
1363  // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1364  // make access control a part of SFINAE for the purposes of checking
1365  // type traits.
1367  break;
1368 
1370 
1371  // Suppress this diagnostic.
1372  ++NumSFINAEErrors;
1373 
1374  // Make a copy of this suppressed diagnostic and store it with the
1375  // template-deduction information.
1376  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1377  Diagnostic DiagInfo(&Diags);
1378  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1380  }
1381 
1383  Diags.Clear();
1384 
1385  // Now the diagnostic state is clear, produce a C++98 compatibility
1386  // warning.
1387  Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1388 
1389  // The last diagnostic which Sema produced was ignored. Suppress any
1390  // notes attached to it.
1392  return;
1393  }
1394 
1396  // Make a copy of this suppressed diagnostic and store it with the
1397  // template-deduction information;
1398  if (*Info) {
1399  Diagnostic DiagInfo(&Diags);
1400  (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1402  }
1403 
1404  // Suppress this diagnostic.
1406  Diags.Clear();
1407  return;
1408  }
1409  }
1410 
1411  // Copy the diagnostic printing policy over the ASTContext printing policy.
1412  // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1414 
1415  // Emit the diagnostic.
1417  return;
1418 
1419  // If this is not a note, and we're in a template instantiation
1420  // that is different from the last template instantiation where
1421  // we emitted an error, print a template instantiation
1422  // backtrace.
1423  if (!DiagnosticIDs::isBuiltinNote(DiagID))
1425 }
1426 
1429  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1430  PD.Emit(Builder);
1431 
1432  return Builder;
1433 }
1434 
1435 // Print notes showing how we can reach FD starting from an a priori
1436 // known-callable function.
1437 static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1438  auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1439  while (FnIt != S.DeviceKnownEmittedFns.end()) {
1440  DiagnosticBuilder Builder(
1441  S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1442  Builder << FnIt->second.FD;
1443  Builder.setForceEmit();
1444 
1445  FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1446  }
1447 }
1448 
1449 // Emit any deferred diagnostics for FD and erase them from the map in which
1450 // they're stored.
1451 static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack) {
1452  auto It = S.DeviceDeferredDiags.find(FD);
1453  if (It == S.DeviceDeferredDiags.end())
1454  return;
1455  bool HasWarningOrError = false;
1456  for (PartialDiagnosticAt &PDAt : It->second) {
1457  const SourceLocation &Loc = PDAt.first;
1458  const PartialDiagnostic &PD = PDAt.second;
1459  HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1460  PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1461  DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1462  Builder.setForceEmit();
1463  PD.Emit(Builder);
1464  }
1465  S.DeviceDeferredDiags.erase(It);
1466 
1467  // FIXME: Should this be called after every warning/error emitted in the loop
1468  // above, instead of just once per function? That would be consistent with
1469  // how we handle immediate errors, but it also seems like a bit much.
1470  if (HasWarningOrError && ShowCallStack)
1471  emitCallStackNotes(S, FD);
1472 }
1473 
1474 // In CUDA, there are some constructs which may appear in semantically-valid
1475 // code, but trigger errors if we ever generate code for the function in which
1476 // they appear. Essentially every construct you're not allowed to use on the
1477 // device falls into this category, because you are allowed to use these
1478 // constructs in a __host__ __device__ function, but only if that function is
1479 // never codegen'ed on the device.
1480 //
1481 // To handle semantic checking for these constructs, we keep track of the set of
1482 // functions we know will be emitted, either because we could tell a priori that
1483 // they would be emitted, or because they were transitively called by a
1484 // known-emitted function.
1485 //
1486 // We also keep a partial call graph of which not-known-emitted functions call
1487 // which other not-known-emitted functions.
1488 //
1489 // When we see something which is illegal if the current function is emitted
1490 // (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1491 // CheckCUDACall), we first check if the current function is known-emitted. If
1492 // so, we immediately output the diagnostic.
1493 //
1494 // Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1495 // until we discover that the function is known-emitted, at which point we take
1496 // it out of this map and emit the diagnostic.
1497 
1499  unsigned DiagID, FunctionDecl *Fn,
1500  Sema &S)
1501  : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1502  ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1503  switch (K) {
1504  case K_Nop:
1505  break;
1506  case K_Immediate:
1508  ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1509  break;
1510  case K_Deferred:
1511  assert(Fn && "Must have a function to attach the deferred diag to.");
1512  auto &Diags = S.DeviceDeferredDiags[Fn];
1513  PartialDiagId.emplace(Diags.size());
1514  Diags.emplace_back(Loc, S.PDiag(DiagID));
1515  break;
1516  }
1517 }
1518 
1520  : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1521  ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1522  PartialDiagId(D.PartialDiagId) {
1523  // Clean the previous diagnostics.
1524  D.ShowCallStack = false;
1525  D.ImmediateDiag.reset();
1526  D.PartialDiagId.reset();
1527 }
1528 
1530  if (ImmediateDiag) {
1531  // Emit our diagnostic and, if it was a warning or error, output a callstack
1532  // if Fn isn't a priori known-emitted.
1533  bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1534  DiagID, Loc) >= DiagnosticsEngine::Warning;
1535  ImmediateDiag.reset(); // Emit the immediate diag.
1536  if (IsWarningOrError && ShowCallStack)
1537  emitCallStackNotes(S, Fn);
1538  } else {
1539  assert((!PartialDiagId || ShowCallStack) &&
1540  "Must always show call stack for deferred diags.");
1541  }
1542 }
1543 
1544 // Indicate that this function (and thus everything it transtively calls) will
1545 // be codegen'ed, and emit any deferred diagnostics on this function and its
1546 // (transitive) callees.
1548  Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1549  SourceLocation OrigLoc,
1550  const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1551  // Nothing to do if we already know that FD is emitted.
1552  if (IsKnownEmitted(S, OrigCallee)) {
1553  assert(!S.DeviceCallGraph.count(OrigCallee));
1554  return;
1555  }
1556 
1557  // We've just discovered that OrigCallee is known-emitted. Walk our call
1558  // graph to see what else we can now discover also must be emitted.
1559 
1560  struct CallInfo {
1561  FunctionDecl *Caller;
1562  FunctionDecl *Callee;
1563  SourceLocation Loc;
1564  };
1565  llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1566  llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1567  Seen.insert(OrigCallee);
1568  while (!Worklist.empty()) {
1569  CallInfo C = Worklist.pop_back_val();
1570  assert(!IsKnownEmitted(S, C.Callee) &&
1571  "Worklist should not contain known-emitted functions.");
1572  S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
1573  emitDeferredDiags(S, C.Callee, C.Caller);
1574 
1575  // If this is a template instantiation, explore its callgraph as well:
1576  // Non-dependent calls are part of the template's callgraph, while dependent
1577  // calls are part of to the instantiation's call graph.
1578  if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1579  FunctionDecl *TemplFD = Templ->getAsFunction();
1580  if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1581  Seen.insert(TemplFD);
1582  Worklist.push_back(
1583  {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1584  }
1585  }
1586 
1587  // Add all functions called by Callee to our worklist.
1588  auto CGIt = S.DeviceCallGraph.find(C.Callee);
1589  if (CGIt == S.DeviceCallGraph.end())
1590  continue;
1591 
1592  for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1593  CGIt->second) {
1594  FunctionDecl *NewCallee = FDLoc.first;
1595  SourceLocation CallLoc = FDLoc.second;
1596  if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1597  continue;
1598  Seen.insert(NewCallee);
1599  Worklist.push_back(
1600  {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1601  }
1602 
1603  // C.Callee is now known-emitted, so we no longer need to maintain its list
1604  // of callees in DeviceCallGraph.
1605  S.DeviceCallGraph.erase(CGIt);
1606  }
1607 }
1608 
1610  if (LangOpts.OpenMP)
1611  return LangOpts.OpenMPIsDevice ? diagIfOpenMPDeviceCode(Loc, DiagID)
1612  : diagIfOpenMPHostCode(Loc, DiagID);
1613  if (getLangOpts().CUDA)
1614  return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1615  : CUDADiagIfHostCode(Loc, DiagID);
1617  getCurFunctionDecl(), *this);
1618 }
1619 
1620 /// Looks through the macro-expansion chain for the given
1621 /// location, looking for a macro expansion with the given name.
1622 /// If one is found, returns true and sets the location to that
1623 /// expansion loc.
1624 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1625  SourceLocation loc = locref;
1626  if (!loc.isMacroID()) return false;
1627 
1628  // There's no good way right now to look at the intermediate
1629  // expansions, so just jump to the expansion location.
1630  loc = getSourceManager().getExpansionLoc(loc);
1631 
1632  // If that's written with the name, stop here.
1633  SmallVector<char, 16> buffer;
1634  if (getPreprocessor().getSpelling(loc, buffer) == name) {
1635  locref = loc;
1636  return true;
1637  }
1638  return false;
1639 }
1640 
1641 /// Determines the active Scope associated with the given declaration
1642 /// context.
1643 ///
1644 /// This routine maps a declaration context to the active Scope object that
1645 /// represents that declaration context in the parser. It is typically used
1646 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1647 /// declarations) that injects a name for name-lookup purposes and, therefore,
1648 /// must update the Scope.
1649 ///
1650 /// \returns The scope corresponding to the given declaraion context, or NULL
1651 /// if no such scope is open.
1653 
1654  if (!Ctx)
1655  return nullptr;
1656 
1657  Ctx = Ctx->getPrimaryContext();
1658  for (Scope *S = getCurScope(); S; S = S->getParent()) {
1659  // Ignore scopes that cannot have declarations. This is important for
1660  // out-of-line definitions of static class members.
1661  if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1662  if (DeclContext *Entity = S->getEntity())
1663  if (Ctx == Entity->getPrimaryContext())
1664  return S;
1665  }
1666 
1667  return nullptr;
1668 }
1669 
1670 /// Enter a new function scope
1672  if (FunctionScopes.empty() && CachedFunctionScope) {
1673  // Use CachedFunctionScope to avoid allocating memory when possible.
1674  CachedFunctionScope->Clear();
1675  FunctionScopes.push_back(CachedFunctionScope.release());
1676  } else {
1678  }
1679  if (LangOpts.OpenMP)
1680  pushOpenMPFunctionRegion();
1681 }
1682 
1683 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1685  BlockScope, Block));
1686 }
1687 
1689  LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1690  FunctionScopes.push_back(LSI);
1691  return LSI;
1692 }
1693 
1695  if (LambdaScopeInfo *const LSI = getCurLambda()) {
1696  LSI->AutoTemplateParameterDepth = Depth;
1697  return;
1698  }
1699  llvm_unreachable(
1700  "Remove assertion if intentionally called in a non-lambda context.");
1701 }
1702 
1703 // Check that the type of the VarDecl has an accessible copy constructor and
1704 // resolve its destructor's exception specification.
1705 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1706  QualType T = VD->getType();
1709  SourceLocation Loc = VD->getLocation();
1710  Expr *VarRef =
1711  new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1713  InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1714  VarRef, /*AllowNRVO=*/true);
1715  if (!Result.isInvalid()) {
1716  Result = S.MaybeCreateExprWithCleanups(Result);
1717  Expr *Init = Result.getAs<Expr>();
1718  S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1719  }
1720 
1721  // The destructor's exception specification is needed when IRGen generates
1722  // block copy/destroy functions. Resolve it here.
1723  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1724  if (CXXDestructorDecl *DD = RD->getDestructor()) {
1725  auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1726  S.ResolveExceptionSpec(Loc, FPT);
1727  }
1728 }
1729 
1730 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1731  // Set the EscapingByref flag of __block variables captured by
1732  // escaping blocks.
1733  for (const BlockDecl *BD : FSI.Blocks) {
1734  for (const BlockDecl::Capture &BC : BD->captures()) {
1735  VarDecl *VD = BC.getVariable();
1736  if (VD->hasAttr<BlocksAttr>()) {
1737  // Nothing to do if this is a __block variable captured by a
1738  // non-escaping block.
1739  if (BD->doesNotEscape())
1740  continue;
1741  VD->setEscapingByref();
1742  }
1743  // Check whether the captured variable is or contains an object of
1744  // non-trivial C union type.
1745  QualType CapType = BC.getVariable()->getType();
1748  S.checkNonTrivialCUnion(BC.getVariable()->getType(),
1749  BD->getCaretLocation(),
1752  }
1753  }
1754 
1755  for (VarDecl *VD : FSI.ByrefBlockVars) {
1756  // __block variables might require us to capture a copy-initializer.
1757  if (!VD->isEscapingByref())
1758  continue;
1759  // It's currently invalid to ever have a __block variable with an
1760  // array type; should we diagnose that here?
1761  // Regardless, we don't want to ignore array nesting when
1762  // constructing this copy.
1763  if (VD->getType()->isStructureOrClassType())
1764  checkEscapingByref(VD, S);
1765  }
1766 }
1767 
1768 /// Pop a function (or block or lambda or captured region) scope from the stack.
1769 ///
1770 /// \param WP The warning policy to use for CFG-based warnings, or null if such
1771 /// warnings should not be produced.
1772 /// \param D The declaration corresponding to this function scope, if producing
1773 /// CFG-based warnings.
1774 /// \param BlockType The type of the block expression, if D is a BlockDecl.
1777  const Decl *D, QualType BlockType) {
1778  assert(!FunctionScopes.empty() && "mismatched push/pop!");
1779 
1780  markEscapingByrefs(*FunctionScopes.back(), *this);
1781 
1784 
1785  if (LangOpts.OpenMP)
1786  popOpenMPFunctionRegion(Scope.get());
1787 
1788  // Issue any analysis-based warnings.
1789  if (WP && D)
1790  AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
1791  else
1792  for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1793  Diag(PUD.Loc, PUD.PD);
1794 
1795  return Scope;
1796 }
1797 
1800  // Stash the function scope for later reuse if it's for a normal function.
1801  if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1802  Self->CachedFunctionScope.reset(Scope);
1803  else
1804  delete Scope;
1805 }
1806 
1807 void Sema::PushCompoundScope(bool IsStmtExpr) {
1808  getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1809 }
1810 
1812  FunctionScopeInfo *CurFunction = getCurFunction();
1813  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1814 
1815  CurFunction->CompoundScopes.pop_back();
1816 }
1817 
1818 /// Determine whether any errors occurred within this function/method/
1819 /// block.
1822 }
1823 
1825  if (!FunctionScopes.empty())
1826  FunctionScopes.back()->setHasBranchIntoScope();
1827 }
1828 
1830  if (!FunctionScopes.empty())
1831  FunctionScopes.back()->setHasBranchProtectedScope();
1832 }
1833 
1835  if (!FunctionScopes.empty())
1836  FunctionScopes.back()->setHasIndirectGoto();
1837 }
1838 
1840  if (FunctionScopes.empty())
1841  return nullptr;
1842 
1843  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1844  if (CurBSI && CurBSI->TheDecl &&
1845  !CurBSI->TheDecl->Encloses(CurContext)) {
1846  // We have switched contexts due to template instantiation.
1847  assert(!CodeSynthesisContexts.empty());
1848  return nullptr;
1849  }
1850 
1851  return CurBSI;
1852 }
1853 
1855  if (FunctionScopes.empty())
1856  return nullptr;
1857 
1858  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1859  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1860  continue;
1861  return FunctionScopes[e];
1862  }
1863  return nullptr;
1864 }
1865 
1867  for (auto *Scope : llvm::reverse(FunctionScopes)) {
1868  if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Scope)) {
1869  if (LSI->Lambda && !LSI->Lambda->Encloses(CurContext)) {
1870  // We have switched contexts due to template instantiation.
1871  // FIXME: We should swap out the FunctionScopes during code synthesis
1872  // so that we don't need to check for this.
1873  assert(!CodeSynthesisContexts.empty());
1874  return nullptr;
1875  }
1876  return LSI;
1877  }
1878  }
1879  return nullptr;
1880 }
1881 
1882 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1883  if (FunctionScopes.empty())
1884  return nullptr;
1885 
1886  auto I = FunctionScopes.rbegin();
1887  if (IgnoreNonLambdaCapturingScope) {
1888  auto E = FunctionScopes.rend();
1889  while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1890  ++I;
1891  if (I == E)
1892  return nullptr;
1893  }
1894  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1895  if (CurLSI && CurLSI->Lambda &&
1896  !CurLSI->Lambda->Encloses(CurContext)) {
1897  // We have switched contexts due to template instantiation.
1898  assert(!CodeSynthesisContexts.empty());
1899  return nullptr;
1900  }
1901 
1902  return CurLSI;
1903 }
1904 
1905 // We have a generic lambda if we parsed auto parameters, or we have
1906 // an associated template parameter list.
1908  if (LambdaScopeInfo *LSI = getCurLambda()) {
1909  return (LSI->TemplateParams.size() ||
1910  LSI->GLTemplateParameterList) ? LSI : nullptr;
1911  }
1912  return nullptr;
1913 }
1914 
1915 
1917  if (!LangOpts.RetainCommentsFromSystemHeaders &&
1918  SourceMgr.isInSystemHeader(Comment.getBegin()))
1919  return;
1920  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1921  if (RC.isAlmostTrailingComment()) {
1922  SourceRange MagicMarkerRange(Comment.getBegin(),
1923  Comment.getBegin().getLocWithOffset(3));
1924  StringRef MagicMarkerText;
1925  switch (RC.getKind()) {
1927  MagicMarkerText = "///<";
1928  break;
1930  MagicMarkerText = "/**<";
1931  break;
1932  default:
1933  llvm_unreachable("if this is an almost Doxygen comment, "
1934  "it should be ordinary");
1935  }
1936  Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1937  FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1938  }
1939  Context.addComment(RC);
1940 }
1941 
1942 // Pin this vtable to this file.
1944 char ExternalSemaSource::ID;
1945 
1948 
1950  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1951 }
1952 
1954  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1955 
1957  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1958 
1959 /// Figure out if an expression could be turned into a call.
1960 ///
1961 /// Use this when trying to recover from an error where the programmer may have
1962 /// written just the name of a function instead of actually calling it.
1963 ///
1964 /// \param E - The expression to examine.
1965 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1966 /// with no arguments, this parameter is set to the type returned by such a
1967 /// call; otherwise, it is set to an empty QualType.
1968 /// \param OverloadSet - If the expression is an overloaded function
1969 /// name, this parameter is populated with the decls of the various overloads.
1970 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1971  UnresolvedSetImpl &OverloadSet) {
1972  ZeroArgCallReturnTy = QualType();
1973  OverloadSet.clear();
1974 
1975  const OverloadExpr *Overloads = nullptr;
1976  bool IsMemExpr = false;
1977  if (E.getType() == Context.OverloadTy) {
1978  OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1979 
1980  // Ignore overloads that are pointer-to-member constants.
1981  if (FR.HasFormOfMemberPointer)
1982  return false;
1983 
1984  Overloads = FR.Expression;
1985  } else if (E.getType() == Context.BoundMemberTy) {
1986  Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1987  IsMemExpr = true;
1988  }
1989 
1990  bool Ambiguous = false;
1991  bool IsMV = false;
1992 
1993  if (Overloads) {
1994  for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1995  DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1996  OverloadSet.addDecl(*it);
1997 
1998  // Check whether the function is a non-template, non-member which takes no
1999  // arguments.
2000  if (IsMemExpr)
2001  continue;
2002  if (const FunctionDecl *OverloadDecl
2003  = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
2004  if (OverloadDecl->getMinRequiredArguments() == 0) {
2005  if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
2006  (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
2007  OverloadDecl->isCPUSpecificMultiVersion()))) {
2008  ZeroArgCallReturnTy = QualType();
2009  Ambiguous = true;
2010  } else {
2011  ZeroArgCallReturnTy = OverloadDecl->getReturnType();
2012  IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
2013  OverloadDecl->isCPUSpecificMultiVersion();
2014  }
2015  }
2016  }
2017  }
2018 
2019  // If it's not a member, use better machinery to try to resolve the call
2020  if (!IsMemExpr)
2021  return !ZeroArgCallReturnTy.isNull();
2022  }
2023 
2024  // Attempt to call the member with no arguments - this will correctly handle
2025  // member templates with defaults/deduction of template arguments, overloads
2026  // with default arguments, etc.
2027  if (IsMemExpr && !E.isTypeDependent()) {
2028  Sema::TentativeAnalysisScope Trap(*this);
2030  None, SourceLocation());
2031  if (R.isUsable()) {
2032  ZeroArgCallReturnTy = R.get()->getType();
2033  return true;
2034  }
2035  return false;
2036  }
2037 
2038  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
2039  if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
2040  if (Fun->getMinRequiredArguments() == 0)
2041  ZeroArgCallReturnTy = Fun->getReturnType();
2042  return true;
2043  }
2044  }
2045 
2046  // We don't have an expression that's convenient to get a FunctionDecl from,
2047  // but we can at least check if the type is "function of 0 arguments".
2048  QualType ExprTy = E.getType();
2049  const FunctionType *FunTy = nullptr;
2050  QualType PointeeTy = ExprTy->getPointeeType();
2051  if (!PointeeTy.isNull())
2052  FunTy = PointeeTy->getAs<FunctionType>();
2053  if (!FunTy)
2054  FunTy = ExprTy->getAs<FunctionType>();
2055 
2056  if (const FunctionProtoType *FPT =
2057  dyn_cast_or_null<FunctionProtoType>(FunTy)) {
2058  if (FPT->getNumParams() == 0)
2059  ZeroArgCallReturnTy = FunTy->getReturnType();
2060  return true;
2061  }
2062  return false;
2063 }
2064 
2065 /// Give notes for a set of overloads.
2066 ///
2067 /// A companion to tryExprAsCall. In cases when the name that the programmer
2068 /// wrote was an overloaded function, we may be able to make some guesses about
2069 /// plausible overloads based on their return types; such guesses can be handed
2070 /// off to this method to be emitted as notes.
2071 ///
2072 /// \param Overloads - The overloads to note.
2073 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
2074 /// -fshow-overloads=best, this is the location to attach to the note about too
2075 /// many candidates. Typically this will be the location of the original
2076 /// ill-formed expression.
2077 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
2078  const SourceLocation FinalNoteLoc) {
2079  int ShownOverloads = 0;
2080  int SuppressedOverloads = 0;
2081  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
2082  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2083  // FIXME: Magic number for max shown overloads stolen from
2084  // OverloadCandidateSet::NoteCandidates.
2085  if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
2086  ++SuppressedOverloads;
2087  continue;
2088  }
2089 
2090  NamedDecl *Fn = (*It)->getUnderlyingDecl();
2091  // Don't print overloads for non-default multiversioned functions.
2092  if (const auto *FD = Fn->getAsFunction()) {
2093  if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
2094  !FD->getAttr<TargetAttr>()->isDefaultVersion())
2095  continue;
2096  }
2097  S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
2098  ++ShownOverloads;
2099  }
2100 
2101  if (SuppressedOverloads)
2102  S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
2103  << SuppressedOverloads;
2104 }
2105 
2107  const UnresolvedSetImpl &Overloads,
2108  bool (*IsPlausibleResult)(QualType)) {
2109  if (!IsPlausibleResult)
2110  return noteOverloads(S, Overloads, Loc);
2111 
2112  UnresolvedSet<2> PlausibleOverloads;
2113  for (OverloadExpr::decls_iterator It = Overloads.begin(),
2114  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2115  const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
2116  QualType OverloadResultTy = OverloadDecl->getReturnType();
2117  if (IsPlausibleResult(OverloadResultTy))
2118  PlausibleOverloads.addDecl(It.getDecl());
2119  }
2120  noteOverloads(S, PlausibleOverloads, Loc);
2121 }
2122 
2123 /// Determine whether the given expression can be called by just
2124 /// putting parentheses after it. Notably, expressions with unary
2125 /// operators can't be because the unary operator will start parsing
2126 /// outside the call.
2127 static bool IsCallableWithAppend(Expr *E) {
2128  E = E->IgnoreImplicit();
2129  return (!isa<CStyleCastExpr>(E) &&
2130  !isa<UnaryOperator>(E) &&
2131  !isa<BinaryOperator>(E) &&
2132  !isa<CXXOperatorCallExpr>(E));
2133 }
2134 
2136  if (const auto *UO = dyn_cast<UnaryOperator>(E))
2137  E = UO->getSubExpr();
2138 
2139  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2140  if (ULE->getNumDecls() == 0)
2141  return false;
2142 
2143  const NamedDecl *ND = *ULE->decls_begin();
2144  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2145  return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2146  }
2147  return false;
2148 }
2149 
2151  bool ForceComplain,
2152  bool (*IsPlausibleResult)(QualType)) {
2153  SourceLocation Loc = E.get()->getExprLoc();
2154  SourceRange Range = E.get()->getSourceRange();
2155 
2156  QualType ZeroArgCallTy;
2157  UnresolvedSet<4> Overloads;
2158  if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
2159  !ZeroArgCallTy.isNull() &&
2160  (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2161  // At this point, we know E is potentially callable with 0
2162  // arguments and that it returns something of a reasonable type,
2163  // so we can emit a fixit and carry on pretending that E was
2164  // actually a CallExpr.
2165  SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
2166  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2167  Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2168  << (IsCallableWithAppend(E.get())
2169  ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2170  : FixItHint());
2171  if (!IsMV)
2172  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2173 
2174  // FIXME: Try this before emitting the fixit, and suppress diagnostics
2175  // while doing so.
2176  E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
2177  Range.getEnd().getLocWithOffset(1));
2178  return true;
2179  }
2180 
2181  if (!ForceComplain) return false;
2182 
2183  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2184  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2185  if (!IsMV)
2186  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2187  E = ExprError();
2188  return true;
2189 }
2190 
2192  if (!Ident_super)
2193  Ident_super = &Context.Idents.get("super");
2194  return Ident_super;
2195 }
2196 
2198  if (!Ident___float128)
2199  Ident___float128 = &Context.Idents.get("__float128");
2200  return Ident___float128;
2201 }
2202 
2205  unsigned OpenMPCaptureLevel) {
2206  auto *CSI = new CapturedRegionScopeInfo(
2207  getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2208  (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0,
2209  OpenMPCaptureLevel);
2210  CSI->ReturnType = Context.VoidTy;
2211  FunctionScopes.push_back(CSI);
2212 }
2213 
2215  if (FunctionScopes.empty())
2216  return nullptr;
2217 
2218  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2219 }
2220 
2221 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2223  return DeleteExprs;
2224 }
2225 
2226 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2227  if (ExtStr.empty())
2228  return;
2230  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2231  auto CanT = T.getCanonicalType().getTypePtr();
2232  for (auto &I : Exts)
2233  OpenCLTypeExtMap[CanT].insert(I.str());
2234 }
2235 
2236 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2238  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2239  if (Exts.empty())
2240  return;
2241  for (auto &I : Exts)
2242  OpenCLDeclExtMap[FD].insert(I.str());
2243 }
2244 
2246  if (CurrOpenCLExtension.empty())
2247  return;
2248  setOpenCLExtensionForType(T, CurrOpenCLExtension);
2249 }
2250 
2252  if (CurrOpenCLExtension.empty())
2253  return;
2254  setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2255 }
2256 
2258  if (!OpenCLDeclExtMap.empty())
2259  return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2260 
2261  return "";
2262 }
2263 
2265  if (!OpenCLTypeExtMap.empty())
2266  return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2267 
2268  return "";
2269 }
2270 
2271 template <typename T, typename MapT>
2272 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2273  std::string ExtensionNames = "";
2274  auto Loc = Map.find(FDT);
2275 
2276  for (auto const& I : Loc->second) {
2277  ExtensionNames += I;
2278  ExtensionNames += " ";
2279  }
2280  ExtensionNames.pop_back();
2281 
2282  return ExtensionNames;
2283 }
2284 
2286  auto Loc = OpenCLDeclExtMap.find(FD);
2287  if (Loc == OpenCLDeclExtMap.end())
2288  return false;
2289  for (auto &I : Loc->second) {
2290  if (!getOpenCLOptions().isEnabled(I))
2291  return true;
2292  }
2293  return false;
2294 }
2295 
2296 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2297 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2298  DiagInfoT DiagInfo, MapT &Map,
2299  unsigned Selector,
2300  SourceRange SrcRange) {
2301  auto Loc = Map.find(D);
2302  if (Loc == Map.end())
2303  return false;
2304  bool Disabled = false;
2305  for (auto &I : Loc->second) {
2306  if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2307  Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2308  << I << SrcRange;
2309  Disabled = true;
2310  }
2311  }
2312  return Disabled;
2313 }
2314 
2316  // Check extensions for declared types.
2317  Decl *Decl = nullptr;
2318  if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2319  Decl = TypedefT->getDecl();
2320  if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2321  Decl = TagT->getDecl();
2322  auto Loc = DS.getTypeSpecTypeLoc();
2323 
2324  // Check extensions for vector types.
2325  // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2326  if (QT->isExtVectorType()) {
2327  auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2328  return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2329  }
2330 
2331  if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2332  return true;
2333 
2334  // Check extensions for builtin types.
2335  return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2336  QT, OpenCLTypeExtMap);
2337 }
2338 
2340  IdentifierInfo *FnName = D.getIdentifier();
2341  return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2342  OpenCLDeclExtMap, 1, D.getSourceRange());
2343 }
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=TTK_Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2580
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2472
Defines the clang::ASTContext interface.
ObjCInterfaceDecl * NSStringDecl
The declaration of the Objective-C NSString class.
Definition: Sema.h:956
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:690
Represents a function declaration or definition.
Definition: Decl.h:1783
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition: Sema.h:649
bool hasErrorOccurred() const
Definition: Diagnostic.h:753
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
Definition: TargetInfo.h:790
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
CanQualType OCLQueueTy
Definition: ASTContext.h:1054
Smart pointer class that efficiently represents Objective-C method names.
A class which contains all the information about a particular captured value.
Definition: Decl.h:4043
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
TypedefDecl * getCFConstantStringDecl() const
A (possibly-)qualified type.
Definition: Type.h:654
ASTConsumer & Consumer
Definition: Sema.h:386
Simple class containing the result of Sema::CorrectTypo.
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:6398
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:722
void Initialize()
Perform initialization that occurs after the parser has been initialized but before it parses anythin...
Definition: Sema.cpp:216
DeviceDiagBuilder(Kind K, SourceLocation Loc, unsigned DiagID, FunctionDecl *Fn, Sema &S)
Definition: Sema.cpp:1498
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:33
DeclContext * getFunctionLevelDeclContext()
Definition: Sema.cpp:1283
RecordDecl * MSVCGuidDecl
The MSVC "_GUID" struct, which is defined in MSVC header files.
Definition: Sema.h:935
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Emit the diagnostic immediately, and, if it&#39;s a warning or error, also emit a call stack showing how ...
Definition: Sema.h:11200
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3435
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:745
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:12484
void getUndefinedButUsed(SmallVectorImpl< std::pair< NamedDecl *, SourceLocation > > &Undefined)
Obtain a sorted list of functions that are undefined but ODR-used.
Definition: Sema.cpp:683
submodule_iterator submodule_begin()
Definition: Module.h:563
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
CXXFieldCollector - Used to keep track of CXXFieldDecls during parsing of C++ classes.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:659
static void notePlausibleOverloads(Sema &S, SourceLocation Loc, const UnresolvedSetImpl &Overloads, bool(*IsPlausibleResult)(QualType))
Definition: Sema.cpp:2106
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:704
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:104
IdentifierInfo * InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName, unsigned Index)
Invent a new identifier for parameters of abbreviated templates.
Definition: Sema.cpp:56
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1411
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
Module * getCurrentModule()
Retrieves the module that we&#39;re currently building, if any.
static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack)
Definition: Sema.cpp:1451
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
bool isExtVectorType() const
Definition: Type.h:6610
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2194
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed...
Definition: Sema.h:8541
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with the preprocessor.
Definition: Sema.cpp:53
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:906
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:418
LangAS getDefaultCXXMethodAddrSpace() const
Returns default addr space for method qualifiers.
Definition: Sema.cpp:1323
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:8135
virtual void updateOutOfDateSelector(Selector Sel)
Load the contents of the global method pool for a given selector if necessary.
Definition: Sema.cpp:1947
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:1946
CanQualType LongTy
Definition: ASTContext.h:1025
const DiagnosticBuilder & setForceEmit() const
Forces the diagnostic to be emitted.
Definition: Diagnostic.h:1139
Any normal BCPL comments.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1300
Declaration of a variable template.
static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E)
Definition: Sema.cpp:2135
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:49
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:707
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:11665
A container of type source information.
Definition: Type.h:6227
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3721
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:634
IdentifierInfo * getSuperIdentifier() const
Definition: Sema.cpp:2191
The diagnostic should not be reported, but it should cause template argument deduction to fail...
void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind)
Definition: Sema.cpp:905
void LoadExternalWeakUndeclaredIdentifiers()
Load weak undeclared identifiers from the external source.
Definition: Sema.cpp:786
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
unsigned NonInstantiationEntries
The number of CodeSynthesisContexts that are not template instantiations and, therefore, should not be counted as part of the instantiation depth.
Definition: Sema.h:8176
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1280
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3324
IdentifierInfo * getFloat128Identifier() const
Definition: Sema.cpp:2197
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:8512
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:98
std::string getOpenCLExtensionsFromTypeExtMap(FunctionType *FT)
Check if a function type FT associates with any extensions present in OpenCLTypeExtMap and if so retu...
Definition: Sema.cpp:2264
RAII object that enters a new expression evaluation context.
Definition: Sema.h:12029
Compiling a C++ modules TS module interface unit.
Definition: LangOptions.h:88
Represents a variable declaration or definition.
Definition: Decl.h:820
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
QualType getReturnType() const
Definition: Decl.h:2445
DiagnosticsEngine & Diags
Definition: Sema.h:387
virtual void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WI)
Read the set of weak, undeclared identifiers known to the external Sema source.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2487
void enableSupportedCore(LangOptions LO)
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:25
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:414
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:11939
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1203
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:77
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:652
bool isInvalidDecl() const
Definition: DeclBase.h:553
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:47
ObjCMethodDecl * ValueWithBytesObjCTypeMethod
The declaration of the valueWithBytes:objCType: method.
Definition: Sema.h:965
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:35
OpenCLOptions & getOpenCLOptions()
Definition: Sema.h:1325
Defines the clang::Expr interface and subclasses for C++ expressions.
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
Definition: Sema.h:974
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:2222
iterator begin(Source *source, bool LocalOnly=false)
iterator begin(DeclarationName Name)
begin - Returns an iterator for decls with the name &#39;Name&#39;.
void threadSafetyCleanup(BeforeSet *Cache)
CanQualType OCLSamplerTy
Definition: ASTContext.h:1053
void CheckDelayedMemberExceptionSpecs()
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:244
Represents a struct/union/class.
Definition: Decl.h:3748
void FreeVisContext()
FreeVisContext - Deallocate and null out VisContext.
Definition: SemaAttr.cpp:900
An iterator over the friend declarations of a class.
Definition: DeclFriend.h:187
This is the private module fragment within some C++ module.
Definition: Module.h:84
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:272
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
One of these records is kept for each identifier that is lexed.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:938
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:8508
virtual void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls)
Read the set of potentially unused typedefs known to the source.
bool doesNotEscape() const
Definition: Decl.h:4188
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:712
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.cpp:1854
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
Definition: ModuleMap.cpp:1293
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1907
unsigned getCurrentDiagID() const
Definition: Diagnostic.h:999
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:8412
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:517
DeviceDiagBuilder diagIfOpenMPHostCode(SourceLocation Loc, unsigned DiagID)
Creates a DeviceDiagBuilder that emits the diagnostic if the current context is "used as host code"...
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1839
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:275
void setCurrentOpenCLExtensionForType(QualType T)
Set current OpenCL extensions for a type which can only be used when these OpenCL extensions are enab...
Definition: Sema.cpp:2245
Represents a member of a struct/union/class.
Definition: Decl.h:2729
void erase(iterator From, iterator To)
The current expression is potentially evaluated at run time, which means that code may be generated t...
ImplicitParamDecl * getContextParam() const
Retrieve the parameter containing captured variables.
Definition: Decl.h:4291
void setEscapingByref()
Definition: Decl.h:1454
std::unique_ptr< sema::FunctionScopeInfo > CachedFunctionScope
Definition: Sema.h:617
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:8527
ObjCInterfaceDecl * NSValueDecl
The declaration of the Objective-C NSValue class.
Definition: Sema.h:944
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
Definition: Sema.cpp:975
CanQualType OCLEventTy
Definition: ASTContext.h:1053
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:417
bool hasAArch64SVETypes() const
Returns whether or not the AArch64 SVE built-in types are available on this target.
Definition: TargetInfo.h:797
llvm::SmallPtrSet< const BlockDecl *, 1 > Blocks
The set of blocks that are introduced in this function.
Definition: ScopeInfo.h:208
void setFunctionHasBranchIntoScope()
Definition: Sema.cpp:1824
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3771
void setPrintingPolicy(const clang::PrintingPolicy &Policy)
Definition: ASTContext.h:675
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
bool isOpenCLDisabledDecl(Decl *FD)
Definition: Sema.cpp:2285
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1054
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:907
Describes a module or submodule.
Definition: Module.h:64
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1180
IdentifierTable & Idents
Definition: ASTContext.h:580
static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc)
Give notes for a set of overloads.
Definition: Sema.cpp:2077
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors...
Definition: Sema.h:6791
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:125
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type, bool NRVO)
Values of this type can be null.
iterator end()
end - Returns an iterator that has &#39;finished&#39;.
DiagnosticErrorTrap ErrorTrap
Used to determine if errors occurred in this function or block.
Definition: ScopeInfo.h:178
An abstract interface that should be implemented by clients that read ASTs and then require further s...
Definition: SemaConsumer.h:25
DeviceDiagBuilder CUDADiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a DeviceDiagBuilder that emits the diagnostic if the current context is "used as device code"...
Definition: SemaCUDA.cpp:605
unsigned TyposCorrected
The number of typos corrected by CorrectTypo.
Definition: Sema.h:8515
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
Definition: Decl.cpp:2177
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:804
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:1624
PtrTy get() const
Definition: Ownership.h:170
DeviceDiagBuilder targetDiag(SourceLocation Loc, unsigned DiagID)
Definition: Sema.cpp:1609
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Definition: Sema.h:8490
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1309
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:423
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:912
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1338
bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T)
Check if type T corresponding to declaration specifier DS is disabled due to required OpenCL extensio...
Definition: Sema.cpp:2315
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined &#39;SEL&#39; type in Objective-C.
CanThrowResult canThrow(const Stmt *E)
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:414
std::pair< SourceLocation, bool > DeleteExprLoc
Delete-expressions to be analyzed at the end of translation unit.
Definition: Sema.h:656
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:671
void PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
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:6392
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
SmallVector< VarDecl *, 4 > ExternalDeclarations
All the external declarations encoutered and used in the TU.
Definition: Sema.h:682
void CheckDelegatingCtorCycles()
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:10456
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
friend_iterator friend_end() const
Definition: DeclFriend.h:243
~ExternalSemaSource() override
Definition: Sema.cpp:1943
Values of this type can never be null.
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:462
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6256
static const unsigned NumNSNumberLiteralMethods
Definition: NSAPI.h:191
Emit no diagnostics.
Definition: Sema.h:11194
submodule_iterator submodule_end()
Definition: Module.h:565
void PrintStats() const
Print out statistics about the semantic analysis.
Definition: Sema.cpp:479
void emitAndClearUnusedLocalTypedefWarnings()
Definition: Sema.cpp:877
SourceLocation getCurrentDiagLoc() const
Definition: Diagnostic.h:1001
virtual ASTMutationListener * GetASTMutationListener()
If the consumer is interested in entities getting modified after their initial creation, it should return a pointer to an ASTMutationListener here.
Definition: ASTConsumer.h:128
Preprocessor & PP
Definition: Sema.h:384
ObjCInterfaceDecl * NSNumberDecl
The declaration of the Objective-C NSNumber class.
Definition: Sema.h:941
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:1949
const LangOptions & getLangOpts() const
Definition: Sema.h:1324
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:176
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
Definition: Sema.h:8526
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4226
NamespaceDecl * StdExperimentalNamespaceCache
The C++ "std::experimental" namespace, where the experimental parts of the standard library resides...
Definition: Sema.h:921
ObjCMethodDecl * StringWithUTF8StringMethod
The declaration of the stringWithUTF8String: method.
Definition: Sema.h:962
void DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc)
Definition: SemaAttr.cpp:335
const LangOptions & LangOpts
Definition: Sema.h:383
bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E)
Check if declaration D used by expression E is disabled due to required OpenCL extensions being disab...
Definition: Sema.cpp:2339
void warnStackExhausted(SourceLocation Loc)
Warn that the stack is nearly exhausted.
Definition: Sema.cpp:415
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:68
bool EmitCurrentDiagnostic(bool Force=false)
Emit the current diagnostic and clear the diagnostic state.
Definition: Diagnostic.cpp:498
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1328
static bool IsCallableWithAppend(Expr *E)
Determine whether the given expression can be called by just putting parentheses after it...
Definition: Sema.cpp:2127
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K, unsigned OpenMPCaptureLevel=0)
Definition: Sema.cpp:2203
bool hasAttr() const
Definition: DeclBase.h:542
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:108
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:336
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1053
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1690
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:679
Retains information about a captured region.
Definition: ScopeInfo.h:742
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:1807
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:671
CastKind
CastKind - The kind of operation required for a conversion.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1998
void PopCompoundScope()
Definition: Sema.cpp:1811
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type...
virtual void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 >> &)
Definition: Sema.cpp:1956
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:1829
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:39
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:11904
unsigned Offset
Definition: Format.cpp:1827
TUFragmentKind
Definition: Sema.h:1442
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
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:286
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
Definition: Sema.h:8545
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:716
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
Any normal C comment.
An abstract interface that should be implemented by external AST sources that also provide informatio...
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4037
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D)
Used to prune the decls of Sema&#39;s UnusedFileScopedDecls vector.
Definition: Sema.cpp:603
This represents one expression.
Definition: Expr.h:108
void setOpenCLExtensionForDecl(Decl *FD, llvm::StringRef Exts)
Set OpenCL extensions for a declaration which can only be used when these OpenCL extensions are enabl...
Definition: Sema.cpp:2236
Show just the "best" overload candidates.
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:778
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:122
bool isAlmostTrailingComment() const LLVM_READONLY
Returns true if it is a probable typo:
int Id
Definition: ASTDiff.cpp:190
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition: Sema.h:669
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2904
TypedefDecl * buildImplicitTypedef(QualType T, StringRef Name) const
Create a new implicit TU-level typedef declaration.
void addImplicitTypedef(StringRef Name, QualType T)
Definition: Sema.cpp:210
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5732
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2649
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
Definition: Sema.h:8167
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
Definition: Type.h:6802
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:882
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Not compiling a module interface at all.
Definition: LangOptions.h:79
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy initialization expression of a block var decl.
DeclContext * getDeclContext()
Definition: DeclBase.h:438
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
Definition: ModuleMap.cpp:1267
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:2051
decls_iterator decls_begin() const
Definition: ExprCXX.h:2936
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7919
int Depth
Definition: ASTDiff.cpp:190
bool WarnedStackExhausted
Definition: Sema.h:1312
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
QualType getType() const
Definition: Expr.h:137
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:891
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:621
PartialDiagnostic::StorageAllocator & getDiagAllocator()
Definition: ASTContext.h:703
virtual void CompleteExternalDeclaration(VarDecl *D)
CompleteExternalDeclaration - Callback invoked at the end of a translation unit to notify the consume...
Definition: ASTConsumer.h:108
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1784
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:91
bool isInvalid() const
Definition: Ownership.h:166
SourceLocation getEnd() const
Preprocessor & getPreprocessor() const
Definition: Sema.h:1330
SourceLocation getCaretLocation() const
Definition: Decl.h:4110
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type...
ObjCMethodDecl * ArrayWithObjectsMethod
The declaration of the arrayWithObjects:count: method.
Definition: Sema.h:971
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1430
bool isUsable() const
Definition: Ownership.h:167
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1688
The result type of a method or function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
void DiagnoseUnterminatedPragmaPack()
Definition: SemaAttr.cpp:369
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
const SourceManager & SM
Definition: Format.cpp:1685
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:666
SmallVector< CXXMethodDecl *, 4 > DelayedDllExportMemberFunctions
Definition: Sema.h:11940
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1183
llvm::DenseMap< const CXXRecordDecl *, bool > RecordCompleteMap
Definition: Sema.cpp:797
An abstract interface that should be implemented by external AST sources that also provide informatio...
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6315
unsigned Bool
Whether we can use &#39;bool&#39; rather than &#39;_Bool&#39; (even if the language doesn&#39;t actually have &#39;bool&#39;...
bool isStructureOrClassType() const
Definition: Type.cpp:513
void PushBlockScope(Scope *BlockScope, BlockDecl *Block)
Definition: Sema.cpp:1683
CanQualType OverloadTy
Definition: ASTContext.h:1045
void Emit(const DiagnosticBuilder &DB) const
#define false
Definition: stdbool.h:17
RecordDecl * CXXTypeInfoDecl
The C++ "type_info" declaration, which is defined in <typeinfo>.
Definition: Sema.h:932
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2844
QualType getCanonicalType() const
Definition: Type.h:6295
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
Definition: Sema.cpp:423
Encodes a location in the source.
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
QualType getReturnType() const
Definition: Type.h:3680
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setCurrentOpenCLExtensionForDecl(Decl *FD)
Set current OpenCL extensions for a declaration which can only be used when these OpenCL extensions a...
Definition: Sema.cpp:2251
Diagnostic builder for CUDA/OpenMP devices errors which may or may not be deferred.
Definition: Sema.h:11190
StringRef getName() const
Definition: FileManager.h:102
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1388
bool makeUnavailableInSystemHeader(SourceLocation loc, UnavailableAttr::ImplicitReason reason)
makeUnavailableInSystemHeader - There is an error in the current context.
Definition: Sema.cpp:432
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:78
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class...
std::string getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD)
Check if a function declaration FD associates with any extensions present in OpenCLDeclExtMap and if ...
Definition: Sema.cpp:2257
bool isExternalWithNoLinkageType(ValueDecl *VD)
Determine if VD, which must be a variable or function, is an external symbol that nonetheless can&#39;t b...
Definition: Sema.cpp:672
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>. ...
Definition: Sema.h:925
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
void DiagnoseUseOfUnimplementedSelectors()
CanQualType FloatTy
Definition: ASTContext.h:1028
DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc)
The parser has processed a global-module-fragment declaration that begins the definition of the globa...
Definition: SemaModule.cpp:58
This is a fragment of the global module within some C++ module.
Definition: Module.h:81
static void emitCallStackNotes(Sema &S, FunctionDecl *FD)
Definition: Sema.cpp:1437
CanQualType VoidTy
Definition: ASTContext.h:1016
void markKnownEmitted(Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee, SourceLocation OrigLoc, const llvm::function_ref< bool(Sema &, FunctionDecl *)> IsKnownEmitted)
Indicate that this function (and thus everything it transtively calls) will be codegen&#39;ed, and emit any deferred diagnostics on this function and its (transitive) callees.
Definition: Sema.cpp:1547
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:91
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie)
Definition: Diagnostic.h:798
virtual void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined)
Load the set of used but not defined functions or variables with internal linkage, or used but not defined internal functions.
Definition: Sema.cpp:1953
void EmitCurrentDiagnostic(unsigned DiagID)
Cause the active diagnostic on the DiagosticsEngine to be emitted.
Definition: Sema.cpp:1329
This declaration is only a declaration.
Definition: Decl.h:1156
void addSupport(const OpenCLOptions &Opts)
llvm::APInt APInt
Definition: Integral.h:27
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3274
The diagnostic should be suppressed entirely.
static bool IsRecordFullyDefined(const CXXRecordDecl *RD, RecordCompleteMap &RecordsComplete, RecordCompleteMap &MNCComplete)
Returns true, if the given CXXRecordDecl is fully defined in this translation unit, i.e.
Definition: Sema.cpp:846
friend_iterator friend_begin() const
Definition: DeclFriend.h:239
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:398
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition: Sema.h:640
Create a deferred diagnostic, which is emitted only if the function it&#39;s attached to is codegen&#39;ed...
Definition: Sema.h:11204
static bool isFunctionOrVarDeclExternC(NamedDecl *ND)
Definition: Sema.cpp:664
sema::CapturedRegionScopeInfo * getCurCapturedRegion()
Retrieve the current captured region, if any.
Definition: Sema.cpp:2214
void operator()(sema::FunctionScopeInfo *Scope) const
Definition: Sema.cpp:1799
static bool isBuiltinNote(unsigned DiagID)
Determine whether the given built-in diagnostic ID is a Note.
void ActOnStartOfTranslationUnit()
This is called before the very first declaration in the translation unit is parsed.
Definition: Sema.cpp:893
void setLastDiagnosticIgnored(bool Ignored)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:674
ASTConsumer & getASTConsumer() const
Definition: Sema.h:1332
void setOpenCLExtensionForType(QualType T, llvm::StringRef Exts)
Set OpenCL extensions for a type which can only be used when these OpenCL extensions are enabled...
Definition: Sema.cpp:2226
StringRef getName() const
Return the actual identifier string.
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1990
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3071
ast_type_traits::DynTypedNode Node
Abstract interface for a consumer of code-completion information.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Dataflow Directional Tag Classes.
LateTemplateParserCleanupCB * LateTemplateParserCleanup
Definition: Sema.h:723
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:840
bool isValid() const
Return true if this is a valid SourceLocation object.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
Definition: Sema.h:8200
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
ObjCMethodDecl * NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]
The Objective-C NSNumber methods used to create NSNumber literals.
Definition: Sema.h:953
static void checkEscapingByref(VarDecl *VD, Sema &S)
Definition: Sema.cpp:1705
ArrayRef< Capture > captures() const
Definition: Decl.h:4164
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:453
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:529
void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E)
Warn when implicitly casting 0 to nullptr.
Definition: Sema.cpp:501
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing.
Definition: Sema.cpp:1694
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
Definition: SemaDecl.cpp:1643
Custom deleter to allow FunctionScopeInfos to be kept alive for a short time after they&#39;ve been poppe...
Definition: Sema.h:1477
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include&#39;d file otherwise it returns an invalid location...
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:77
ClassTemplateDecl * StdCoroutineTraitsCache
The C++ "std::coroutine_traits" template, which is defined in <coroutine_traits>
Definition: Sema.h:929
FileID getMainFileID() const
Returns the FileID of the main source file.
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared...
Definition: Sema.h:987
The name of a declaration.
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:2150
A set of unresolved declarations.
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created...
Definition: Diagnostic.h:1026
Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
Definition: Sema.h:11196
IdentifierResolver IdResolver
Definition: Sema.h:901
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool isEscapingByref() const
Indicates the capture is a __block variable that is captured by a block that can potentially escape (...
Definition: Decl.cpp:2476
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i...
Definition: LangOptions.h:301
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
Definition: Sema.cpp:586
DeviceDiagBuilder diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a DeviceDiagBuilder that emits the diagnostic if the current context is "used as device code"...
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1086
Abstract interface for a module loader.
Definition: ModuleLoader.h:80
NamedDecl * getCurFunctionOrMethodDecl()
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we&#39;re in...
Definition: Sema.cpp:1316
std::string getOpenCLExtensionsFromExtMap(T *FT, MapT &Map)
Find an extension in an appropriate extension map and return its name.
Definition: Sema.cpp:2272
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
Definition: Sema.cpp:1820
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2995
bool isMacroID() const
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:658
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:843
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2983
DeclarationName VAListTagName
VAListTagName - The declaration name corresponding to __va_list_tag.
Definition: Sema.h:405
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.
CanQualType UnsignedLongTy
Definition: ASTContext.h:1026
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1304
static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S)
Definition: Sema.cpp:1730
void * OpaqueParser
Definition: Sema.h:724
ExtVectorType - Extended vector type.
Definition: Type.h:3354
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:7698
CanQualType BoundMemberTy
Definition: ASTContext.h:1045
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1112
void addComment(const RawComment &RC)
Definition: ASTContext.h:798
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...
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:92
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
Definition: Sema.h:968
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3828
The "class" keyword.
Definition: Type.h:5198
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:523
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2104
This is a scope that can contain a declaration.
Definition: Scope.h:59
SourceManager & getSourceManager()
Definition: ASTContext.h:679
The type-property cache.
Definition: Type.cpp:3579
void ActOnTranslationUnitScope(Scope *S)
Definition: Sema.cpp:87
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:1652
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2305
bool isConstantEvaluatedOverride
Used to change context to isConstantEvaluated without pushing a heavy ExpressionEvaluationContextReco...
Definition: Sema.h:831
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, std::vector< PartialDiagnosticAt > > DeviceDeferredDiags
Diagnostics that are emitted only if we discover that the given function must be codegen&#39;ed.
Definition: Sema.h:11140
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups, surround it with a ExprWithCleanups node.
ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const VarDecl *NRVOCandidate, QualType ResultType, Expr *Value, bool AllowNRVO=true)
Perform the initialization of a potentially-movable value, which is the result of return value...
Definition: SemaStmt.cpp:3144
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1009
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
Definition: Sema.cpp:1866
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:565
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:760
static SFINAEResponse getDiagnosticSFINAEResponse(unsigned DiagID)
Determines whether the given built-in diagnostic ID is for an error that is suppressed if it occurs d...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
CommentKind getKind() const LLVM_READONLY
void setFunctionHasIndirectGoto()
Definition: Sema.cpp:1834
Represents a C array with an unspecified size.
Definition: Type.h:2995
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1493
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:1776
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
Definition: Sema.h:1486
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:397
bool isRValue() const
Definition: Expr.h:259
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:412
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:129
void addAttr(Attr *A)
Definition: DeclBase.cpp:832
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C &#39;Class&#39; type...
SourceManager & getSourceManager() const
Definition: Sema.h:1329
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:263
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
Definition: Sema.cpp:1970
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1327
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:1178
Defines the clang::TargetInfo interface.
bool isIncrementalProcessingEnabled() const
Returns true if incremental processing is enabled.
ExprResult ExprError()
Definition: Ownership.h:279
The diagnostic should be reported.
CanQualType IntTy
Definition: ASTContext.h:1025
void ActOnComment(SourceRange Comment)
Definition: Sema.cpp:1916
virtual void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending)
Read the set of pending instantiations known to the external Sema source.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:225
The diagnostic is an access-control diagnostic, which will be substitution failures in some contexts ...
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1171
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:825
bool isUnion() const
Definition: Decl.h:3407
Defines utilities for dealing with stack allocation and stack space.
NamedDecl * getMostRecentDecl()
Definition: Decl.h:428
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2259
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1171
SourceManager & SourceMgr
Definition: Sema.h:388
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
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:11161
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound stamement scopes in the function.
Definition: ScopeInfo.h:205
QualType getType() const
Definition: Decl.h:630
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:129
virtual void CompleteTentativeDefinition(VarDecl *D)
CompleteTentativeDefinition - Callback invoked at the end of a translation unit to notify the consume...
Definition: ASTConsumer.h:103
A wrapper class around a pointer that always points to its canonical declaration. ...
Definition: Redeclarable.h:347
A trivial tuple used to represent a source range.
llvm::TinyPtrVector< VarDecl * > ByrefBlockVars
The set of __block variables that are introduced in this function.
Definition: ScopeInfo.h:211
ASTContext & Context
Definition: Sema.h:385
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we&#39;re implicitly casting from a _Nullable pointer type to a _Nonnull one. ...
Definition: Sema.cpp:487
This represents a decl that may have a name.
Definition: Decl.h:223
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1882
CanQualType DoubleTy
Definition: ASTContext.h:1028
IdentifierInfo * getBoolName() const
Retrieve the identifier &#39;bool&#39;.
Definition: ASTContext.h:1735
void IssueWarnings(Policy P, FunctionScopeInfo *fscope, const Decl *D, QualType BlockType)
void setType(QualType newType)
Definition: Decl.h:631
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:724
static void checkUndefinedButUsed(Sema &S)
checkUndefinedButUsed - Check for undefined objects with internal linkage or that are inline...
Definition: Sema.cpp:736
decls_iterator decls_end() const
Definition: ExprCXX.h:2939
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
This class handles loading and caching of source files into memory.
void PrintContextStack()
Definition: Sema.h:8416
OpenCLOptions & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1339
Declaration of a template function.
Definition: DeclTemplate.h:977
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1671
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:645
SourceLocation getLocation() const
Definition: DeclBase.h:429
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, llvm::MapVector< CanonicalDeclPtr< FunctionDecl >, SourceLocation > > DeviceCallGraph
A partial call graph maintained during CUDA/OpenMP device code compilation to support deferred diagno...
Definition: Sema.h:11173
DeviceDiagBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID)
Creates a DeviceDiagBuilder that emits the diagnostic if the current context is "used as host code"...
Definition: SemaCUDA.cpp:633
bool isExternallyVisible() const
Definition: Decl.h:362
CanQualType OCLClkEventTy
Definition: ASTContext.h:1053
ObjCMethodDecl * DictionaryWithObjectsMethod
The declaration of the dictionaryWithObjects:forKeys:count: method.
Definition: Sema.h:977
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1364
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2991
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:128
CanQualType UnsignedIntTy
Definition: ASTContext.h:1026
decl_iterator decls_end() const
Definition: DeclBase.h:2035
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:358
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static bool isExternC(const NamedDecl *ND)
Definition: Mangle.cpp:56
The translation unit is a module.
Definition: LangOptions.h:421