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