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