clang  10.0.0svn
Sema.cpp
Go to the documentation of this file.
1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the actions class which performs semantic analysis and
10 // builds an AST out of a parse stream.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclFriend.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/StmtCXX.h"
25 #include "clang/Basic/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  std::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 #define SVE_TYPE(Name, Id, SingletonId) \
342  addImplicitTypedef(Name, Context.SingletonId);
343 #include "clang/Basic/AArch64SVEACLETypes.def"
344  }
345 
347  DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
348  if (IdResolver.begin(MSVaList) == IdResolver.end())
350  }
351 
352  DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
353  if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
355 }
356 
358  if (VisContext) FreeVisContext();
359 
360  // Kill all the active scopes.
362  delete FSI;
363 
364  // Tell the SemaConsumer to forget about us; we're going out of scope.
365  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
366  SC->ForgetSema();
367 
368  // Detach from the external Sema source.
369  if (ExternalSemaSource *ExternalSema
370  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
371  ExternalSema->ForgetSema();
372 
373  // If Sema's ExternalSource is the multiplexer - we own it.
374  if (isMultiplexExternalSource)
375  delete ExternalSource;
376 
378 
379  // Destroys data sharing attributes stack for OpenMP
380  DestroyDataSharingAttributesStack();
381 
382  // Detach from the PP callback handler which outlives Sema since it's owned
383  // by the preprocessor.
384  SemaPPCallbackHandler->reset();
385 
386  assert(DelayedTypos.empty() && "Uncorrected typos!");
387 }
388 
389 /// makeUnavailableInSystemHeader - There is an error in the current
390 /// context. If we're still in a system header, and we can plausibly
391 /// make the relevant declaration unavailable instead of erroring, do
392 /// so and return true.
394  UnavailableAttr::ImplicitReason reason) {
395  // If we're not in a function, it's an error.
396  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
397  if (!fn) return false;
398 
399  // If we're in template instantiation, it's an error.
401  return false;
402 
403  // If that function's not in a system header, it's an error.
405  return false;
406 
407  // If the function is already unavailable, it's not an error.
408  if (fn->hasAttr<UnavailableAttr>()) return true;
409 
410  fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
411  return true;
412 }
413 
416 }
417 
418 ///Registers an external source. If an external source already exists,
419 /// creates a multiplex external source and appends to it.
420 ///
421 ///\param[in] E - A non-null external sema source.
422 ///
424  assert(E && "Cannot use with NULL ptr");
425 
426  if (!ExternalSource) {
427  ExternalSource = E;
428  return;
429  }
430 
431  if (isMultiplexExternalSource)
432  static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
433  else {
434  ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
435  isMultiplexExternalSource = true;
436  }
437 }
438 
439 /// Print out statistics about the semantic analysis.
440 void Sema::PrintStats() const {
441  llvm::errs() << "\n*** Semantic Analysis Stats:\n";
442  llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
443 
444  BumpAlloc.PrintStats();
446 }
447 
449  QualType SrcType,
450  SourceLocation Loc) {
451  Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
452  if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
453  return;
454 
455  Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
456  if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
457  return;
458 
459  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
460 }
461 
463  if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
464  E->getBeginLoc()))
465  return;
466  // nullptr only exists from C++11 on, so don't warn on its absence earlier.
467  if (!getLangOpts().CPlusPlus11)
468  return;
469 
470  if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
471  return;
473  return;
474 
475  // If it is a macro from system header, and if the macro name is not "NULL",
476  // do not warn.
477  SourceLocation MaybeMacroLoc = E->getBeginLoc();
479  SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
480  !findMacroSpelling(MaybeMacroLoc, "NULL"))
481  return;
482 
483  Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
484  << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
485 }
486 
487 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
488 /// If there is already an implicit cast, merge into the existing one.
489 /// The result is of the given category.
492  const CXXCastPath *BasePath,
493  CheckedConversionKind CCK) {
494 #ifndef NDEBUG
495  if (VK == VK_RValue && !E->isRValue()) {
496  switch (Kind) {
497  default:
498  llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
499  "kind");
500  case CK_Dependent:
501  case CK_LValueToRValue:
502  case CK_ArrayToPointerDecay:
503  case CK_FunctionToPointerDecay:
504  case CK_ToVoid:
505  case CK_NonAtomicToAtomic:
506  break;
507  }
508  }
509  assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) &&
510  "can't cast rvalue to lvalue");
511 #endif
512 
515 
516  QualType ExprTy = Context.getCanonicalType(E->getType());
518 
519  if (ExprTy == TypeTy)
520  return E;
521 
522  // C++1z [conv.array]: The temporary materialization conversion is applied.
523  // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
524  if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
525  E->getValueKind() == VK_RValue) {
526  // The temporary is an lvalue in C++98 and an xvalue otherwise.
528  E->getType(), E, !getLangOpts().CPlusPlus11);
529  if (Materialized.isInvalid())
530  return ExprError();
531  E = Materialized.get();
532  }
533 
534  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
535  if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
536  ImpCast->setType(Ty);
537  ImpCast->setValueKind(VK);
538  return E;
539  }
540  }
541 
542  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
543 }
544 
545 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
546 /// to the conversion from scalar type ScalarTy to the Boolean type.
548  switch (ScalarTy->getScalarTypeKind()) {
549  case Type::STK_Bool: return CK_NoOp;
550  case Type::STK_CPointer: return CK_PointerToBoolean;
551  case Type::STK_BlockPointer: return CK_PointerToBoolean;
552  case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
553  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
554  case Type::STK_Integral: return CK_IntegralToBoolean;
555  case Type::STK_Floating: return CK_FloatingToBoolean;
556  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
557  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
558  case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
559  }
560  llvm_unreachable("unknown scalar type kind");
561 }
562 
563 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
564 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
565  if (D->getMostRecentDecl()->isUsed())
566  return true;
567 
568  if (D->isExternallyVisible())
569  return true;
570 
571  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
572  // If this is a function template and none of its specializations is used,
573  // we should warn.
574  if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
575  for (const auto *Spec : Template->specializations())
576  if (ShouldRemoveFromUnused(SemaRef, Spec))
577  return true;
578 
579  // UnusedFileScopedDecls stores the first declaration.
580  // The declaration may have become definition so check again.
581  const FunctionDecl *DeclToCheck;
582  if (FD->hasBody(DeclToCheck))
583  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
584 
585  // Later redecls may add new information resulting in not having to warn,
586  // so check again.
587  DeclToCheck = FD->getMostRecentDecl();
588  if (DeclToCheck != FD)
589  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
590  }
591 
592  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
593  // If a variable usable in constant expressions is referenced,
594  // don't warn if it isn't used: if the value of a variable is required
595  // for the computation of a constant expression, it doesn't make sense to
596  // warn even if the variable isn't odr-used. (isReferenced doesn't
597  // precisely reflect that, but it's a decent approximation.)
598  if (VD->isReferenced() &&
599  VD->mightBeUsableInConstantExpressions(SemaRef->Context))
600  return true;
601 
602  if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
603  // If this is a variable template and none of its specializations is used,
604  // we should warn.
605  for (const auto *Spec : Template->specializations())
606  if (ShouldRemoveFromUnused(SemaRef, Spec))
607  return true;
608 
609  // UnusedFileScopedDecls stores the first declaration.
610  // The declaration may have become definition so check again.
611  const VarDecl *DeclToCheck = VD->getDefinition();
612  if (DeclToCheck)
613  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
614 
615  // Later redecls may add new information resulting in not having to warn,
616  // so check again.
617  DeclToCheck = VD->getMostRecentDecl();
618  if (DeclToCheck != VD)
619  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
620  }
621 
622  return false;
623 }
624 
626  if (auto *FD = dyn_cast<FunctionDecl>(ND))
627  return FD->isExternC();
628  return cast<VarDecl>(ND)->isExternC();
629 }
630 
631 /// Determine whether ND is an external-linkage function or variable whose
632 /// type has no linkage.
634  // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
635  // because we also want to catch the case where its type has VisibleNoLinkage,
636  // which does not affect the linkage of VD.
637  return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
640 }
641 
642 /// Obtains a sorted list of functions and variables that are undefined but
643 /// ODR-used.
645  SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
646  for (const auto &UndefinedUse : UndefinedButUsed) {
647  NamedDecl *ND = UndefinedUse.first;
648 
649  // Ignore attributes that have become invalid.
650  if (ND->isInvalidDecl()) continue;
651 
652  // __attribute__((weakref)) is basically a definition.
653  if (ND->hasAttr<WeakRefAttr>()) continue;
654 
655  if (isa<CXXDeductionGuideDecl>(ND))
656  continue;
657 
658  if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
659  // An exported function will always be emitted when defined, so even if
660  // the function is inline, it doesn't have to be emitted in this TU. An
661  // imported function implies that it has been exported somewhere else.
662  continue;
663  }
664 
665  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
666  if (FD->isDefined())
667  continue;
668  if (FD->isExternallyVisible() &&
670  !FD->getMostRecentDecl()->isInlined() &&
671  !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
672  continue;
673  if (FD->getBuiltinID())
674  continue;
675  } else {
676  auto *VD = cast<VarDecl>(ND);
677  if (VD->hasDefinition() != VarDecl::DeclarationOnly)
678  continue;
679  if (VD->isExternallyVisible() &&
681  !VD->getMostRecentDecl()->isInline() &&
682  !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
683  continue;
684 
685  // Skip VarDecls that lack formal definitions but which we know are in
686  // fact defined somewhere.
687  if (VD->isKnownToBeDefined())
688  continue;
689  }
690 
691  Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
692  }
693 }
694 
695 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
696 /// or that are inline.
697 static void checkUndefinedButUsed(Sema &S) {
698  if (S.UndefinedButUsed.empty()) return;
699 
700  // Collect all the still-undefined entities with internal linkage.
702  S.getUndefinedButUsed(Undefined);
703  if (Undefined.empty()) return;
704 
705  for (auto Undef : Undefined) {
706  ValueDecl *VD = cast<ValueDecl>(Undef.first);
707  SourceLocation UseLoc = Undef.second;
708 
709  if (S.isExternalWithNoLinkageType(VD)) {
710  // C++ [basic.link]p8:
711  // A type without linkage shall not be used as the type of a variable
712  // or function with external linkage unless
713  // -- the entity has C language linkage
714  // -- the entity is not odr-used or is defined in the same TU
715  //
716  // As an extension, accept this in cases where the type is externally
717  // visible, since the function or variable actually can be defined in
718  // another translation unit in that case.
720  ? diag::ext_undefined_internal_type
721  : diag::err_undefined_internal_type)
722  << isa<VarDecl>(VD) << VD;
723  } else if (!VD->isExternallyVisible()) {
724  // FIXME: We can promote this to an error. The function or variable can't
725  // be defined anywhere else, so the program must necessarily violate the
726  // one definition rule.
727  S.Diag(VD->getLocation(), diag::warn_undefined_internal)
728  << isa<VarDecl>(VD) << VD;
729  } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
730  (void)FD;
731  assert(FD->getMostRecentDecl()->isInlined() &&
732  "used object requires definition but isn't inline or internal?");
733  // FIXME: This is ill-formed; we should reject.
734  S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
735  } else {
736  assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
737  "used var requires definition but isn't inline or internal?");
738  S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
739  }
740  if (UseLoc.isValid())
741  S.Diag(UseLoc, diag::note_used_here);
742  }
743 
744  S.UndefinedButUsed.clear();
745 }
746 
748  if (!ExternalSource)
749  return;
750 
752  ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
753  for (auto &WeakID : WeakIDs)
754  WeakUndeclaredIdentifiers.insert(WeakID);
755 }
756 
757 
758 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
759 
760 /// Returns true, if all methods and nested classes of the given
761 /// CXXRecordDecl are defined in this translation unit.
762 ///
763 /// Should only be called from ActOnEndOfTranslationUnit so that all
764 /// definitions are actually read.
766  RecordCompleteMap &MNCComplete) {
767  RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
768  if (Cache != MNCComplete.end())
769  return Cache->second;
770  if (!RD->isCompleteDefinition())
771  return false;
772  bool Complete = true;
774  E = RD->decls_end();
775  I != E && Complete; ++I) {
776  if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
777  Complete = M->isDefined() || M->isDefaulted() ||
778  (M->isPure() && !isa<CXXDestructorDecl>(M));
779  else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
780  // If the template function is marked as late template parsed at this
781  // point, it has not been instantiated and therefore we have not
782  // performed semantic analysis on it yet, so we cannot know if the type
783  // can be considered complete.
784  Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
785  F->getTemplatedDecl()->isDefined();
786  else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
787  if (R->isInjectedClassName())
788  continue;
789  if (R->hasDefinition())
790  Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
791  MNCComplete);
792  else
793  Complete = false;
794  }
795  }
796  MNCComplete[RD] = Complete;
797  return Complete;
798 }
799 
800 /// Returns true, if the given CXXRecordDecl is fully defined in this
801 /// translation unit, i.e. all methods are defined or pure virtual and all
802 /// friends, friend functions and nested classes are fully defined in this
803 /// translation unit.
804 ///
805 /// Should only be called from ActOnEndOfTranslationUnit so that all
806 /// definitions are actually read.
807 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
808  RecordCompleteMap &RecordsComplete,
809  RecordCompleteMap &MNCComplete) {
810  RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
811  if (Cache != RecordsComplete.end())
812  return Cache->second;
813  bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
815  E = RD->friend_end();
816  I != E && Complete; ++I) {
817  // Check if friend classes and methods are complete.
818  if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
819  // Friend classes are available as the TypeSourceInfo of the FriendDecl.
820  if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
821  Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
822  else
823  Complete = false;
824  } else {
825  // Friend functions are available through the NamedDecl of FriendDecl.
826  if (const FunctionDecl *FD =
827  dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
828  Complete = FD->isDefined();
829  else
830  // This is a template friend, give up.
831  Complete = false;
832  }
833  }
834  RecordsComplete[RD] = Complete;
835  return Complete;
836 }
837 
839  if (ExternalSource)
840  ExternalSource->ReadUnusedLocalTypedefNameCandidates(
843  if (TD->isReferenced())
844  continue;
845  Diag(TD->getLocation(), diag::warn_unused_local_typedef)
846  << isa<TypeAliasDecl>(TD) << TD->getDeclName();
847  }
848  UnusedLocalTypedefNameCandidates.clear();
849 }
850 
851 /// This is called before the very first declaration in the translation unit
852 /// is parsed. Note that the ASTContext may have already injected some
853 /// declarations.
855  if (getLangOpts().ModulesTS &&
856  (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
857  getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
858  // We start in an implied global module fragment.
859  SourceLocation StartOfTU =
862  ModuleScopes.back().ImplicitGlobalModuleFragment = true;
863  }
864 }
865 
867  // No explicit actions are required at the end of the global module fragment.
868  if (Kind == TUFragmentKind::Global)
869  return;
870 
871  // Transfer late parsed template instantiations over to the pending template
872  // instantiation list. During normal compilation, the late template parser
873  // will be installed and instantiating these templates will succeed.
874  //
875  // If we are building a TU prefix for serialization, it is also safe to
876  // transfer these over, even though they are not parsed. The end of the TU
877  // should be outside of any eager template instantiation scope, so when this
878  // AST is deserialized, these templates will not be parsed until the end of
879  // the combined TU.
881  LateParsedInstantiations.begin(),
883  LateParsedInstantiations.clear();
884 
885  // If DefinedUsedVTables ends up marking any virtual member functions it
886  // might lead to more pending template instantiations, which we then need
887  // to instantiate.
889 
890  // C++: Perform implicit template instantiations.
891  //
892  // FIXME: When we perform these implicit instantiations, we do not
893  // carefully keep track of the point of instantiation (C++ [temp.point]).
894  // This means that name lookup that occurs within the template
895  // instantiation will always happen at the end of the translation unit,
896  // so it will find some names that are not required to be found. This is
897  // valid, but we could do better by diagnosing if an instantiation uses a
898  // name that was not visible at its first point of instantiation.
899  if (ExternalSource) {
900  // Load pending instantiations from the external source.
902  ExternalSource->ReadPendingInstantiations(Pending);
903  for (auto PII : Pending)
904  if (auto Func = dyn_cast<FunctionDecl>(PII.first))
905  Func->setInstantiationIsPending(true);
907  Pending.begin(), Pending.end());
908  }
909 
910  {
911  llvm::TimeTraceScope TimeScope("PerformPendingInstantiations",
912  StringRef(""));
914  }
915 
916  assert(LateParsedInstantiations.empty() &&
917  "end of TU template instantiation should not create more "
918  "late-parsed templates");
919 }
920 
921 /// ActOnEndOfTranslationUnit - This is called at the very end of the
922 /// translation unit when EOF is reached and all but the top-level scope is
923 /// popped.
925  assert(DelayedDiagnostics.getCurrentPool() == nullptr
926  && "reached end of translation unit with a pool attached?");
927 
928  // If code completion is enabled, don't perform any end-of-translation-unit
929  // work.
931  return;
932 
933  // Complete translation units and modules define vtables and perform implicit
934  // instantiations. PCH files do not.
935  if (TUKind != TU_Prefix) {
937 
939  !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
941  ? TUFragmentKind::Private
942  : TUFragmentKind::Normal);
943 
946 
948  } else {
949  // If we are building a TU prefix for serialization, it is safe to transfer
950  // these over, even though they are not parsed. The end of the TU should be
951  // outside of any eager template instantiation scope, so when this AST is
952  // deserialized, these templates will not be parsed until the end of the
953  // combined TU.
955  LateParsedInstantiations.begin(),
957  LateParsedInstantiations.clear();
958  }
959 
962 
963  // All delayed member exception specs should be checked or we end up accepting
964  // incompatible declarations.
965  assert(DelayedOverridingExceptionSpecChecks.empty());
966  assert(DelayedEquivalentExceptionSpecChecks.empty());
967 
968  // All dllexport classes should have been processed already.
969  assert(DelayedDllExportClasses.empty());
970  assert(DelayedDllExportMemberFunctions.empty());
971 
972  // Remove file scoped decls that turned out to be used.
974  std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
976  [this](const DeclaratorDecl *DD) {
977  return ShouldRemoveFromUnused(this, DD);
978  }),
980 
981  if (TUKind == TU_Prefix) {
982  // Translation unit prefixes don't need any of the checking below.
984  TUScope = nullptr;
985  return;
986  }
987 
988  // Check for #pragma weak identifiers that were never declared
990  for (auto WeakID : WeakUndeclaredIdentifiers) {
991  if (WeakID.second.getUsed())
992  continue;
993 
994  Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
996  if (PrevDecl != nullptr &&
997  !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
998  Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
999  << "'weak'" << ExpectedVariableOrFunction;
1000  else
1001  Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
1002  << WeakID.first;
1003  }
1004 
1005  if (LangOpts.CPlusPlus11 &&
1006  !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
1008 
1009  if (!Diags.hasErrorOccurred()) {
1010  if (ExternalSource)
1011  ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1012  checkUndefinedButUsed(*this);
1013  }
1014 
1015  // A global-module-fragment is only permitted within a module unit.
1016  bool DiagnosedMissingModuleDeclaration = false;
1017  if (!ModuleScopes.empty() &&
1018  ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1019  !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1020  Diag(ModuleScopes.back().BeginLoc,
1021  diag::err_module_declaration_missing_after_global_module_introducer);
1022  DiagnosedMissingModuleDeclaration = true;
1023  }
1024 
1025  if (TUKind == TU_Module) {
1026  // If we are building a module interface unit, we need to have seen the
1027  // module declaration by now.
1028  if (getLangOpts().getCompilingModule() ==
1030  (ModuleScopes.empty() ||
1031  !ModuleScopes.back().Module->isModulePurview()) &&
1032  !DiagnosedMissingModuleDeclaration) {
1033  // FIXME: Make a better guess as to where to put the module declaration.
1034  Diag(getSourceManager().getLocForStartOfFile(
1035  getSourceManager().getMainFileID()),
1036  diag::err_module_declaration_missing);
1037  }
1038 
1039  // If we are building a module, resolve all of the exported declarations
1040  // now.
1041  if (Module *CurrentModule = PP.getCurrentModule()) {
1043 
1045  Stack.push_back(CurrentModule);
1046  while (!Stack.empty()) {
1047  Module *Mod = Stack.pop_back_val();
1048 
1049  // Resolve the exported declarations and conflicts.
1050  // FIXME: Actually complain, once we figure out how to teach the
1051  // diagnostic client to deal with complaints in the module map at this
1052  // point.
1053  ModMap.resolveExports(Mod, /*Complain=*/false);
1054  ModMap.resolveUses(Mod, /*Complain=*/false);
1055  ModMap.resolveConflicts(Mod, /*Complain=*/false);
1056 
1057  // Queue the submodules, so their exports will also be resolved.
1058  Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1059  }
1060  }
1061 
1062  // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1063  // modules when they are built, not every time they are used.
1065  }
1066 
1067  // C99 6.9.2p2:
1068  // A declaration of an identifier for an object that has file
1069  // scope without an initializer, and without a storage-class
1070  // specifier or with the storage-class specifier static,
1071  // constitutes a tentative definition. If a translation unit
1072  // contains one or more tentative definitions for an identifier,
1073  // and the translation unit contains no external definition for
1074  // that identifier, then the behavior is exactly as if the
1075  // translation unit contains a file scope declaration of that
1076  // identifier, with the composite type as of the end of the
1077  // translation unit, with an initializer equal to 0.
1078  llvm::SmallSet<VarDecl *, 32> Seen;
1079  for (TentativeDefinitionsType::iterator
1080  T = TentativeDefinitions.begin(ExternalSource),
1081  TEnd = TentativeDefinitions.end();
1082  T != TEnd; ++T) {
1083  VarDecl *VD = (*T)->getActingDefinition();
1084 
1085  // If the tentative definition was completed, getActingDefinition() returns
1086  // null. If we've already seen this variable before, insert()'s second
1087  // return value is false.
1088  if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1089  continue;
1090 
1091  if (const IncompleteArrayType *ArrayT
1093  // Set the length of the array to 1 (C99 6.9.2p5).
1094  Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1095  llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
1096  QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1097  One, ArrayType::Normal, 0);
1098  VD->setType(T);
1099  } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1100  diag::err_tentative_def_incomplete_type))
1101  VD->setInvalidDecl();
1102 
1103  // No initialization is performed for a tentative definition.
1105 
1106  // Notify the consumer that we've completed a tentative definition.
1107  if (!VD->isInvalidDecl())
1109  }
1110 
1111  // If there were errors, disable 'unused' warnings since they will mostly be
1112  // noise. Don't warn for a use from a module: either we should warn on all
1113  // file-scope declarations in modules or not at all, but whether the
1114  // declaration is used is immaterial.
1115  if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1116  // Output warning for unused file scoped decls.
1117  for (UnusedFileScopedDeclsType::iterator
1118  I = UnusedFileScopedDecls.begin(ExternalSource),
1119  E = UnusedFileScopedDecls.end(); I != E; ++I) {
1120  if (ShouldRemoveFromUnused(this, *I))
1121  continue;
1122 
1123  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1124  const FunctionDecl *DiagD;
1125  if (!FD->hasBody(DiagD))
1126  DiagD = FD;
1127  if (DiagD->isDeleted())
1128  continue; // Deleted functions are supposed to be unused.
1129  if (DiagD->isReferenced()) {
1130  if (isa<CXXMethodDecl>(DiagD))
1131  Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1132  << DiagD->getDeclName();
1133  else {
1134  if (FD->getStorageClass() == SC_Static &&
1135  !FD->isInlineSpecified() &&
1137  SourceMgr.getExpansionLoc(FD->getLocation())))
1138  Diag(DiagD->getLocation(),
1139  diag::warn_unneeded_static_internal_decl)
1140  << DiagD->getDeclName();
1141  else
1142  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1143  << /*function*/0 << DiagD->getDeclName();
1144  }
1145  } else {
1146  if (FD->getDescribedFunctionTemplate())
1147  Diag(DiagD->getLocation(), diag::warn_unused_template)
1148  << /*function*/0 << DiagD->getDeclName();
1149  else
1150  Diag(DiagD->getLocation(),
1151  isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1152  : diag::warn_unused_function)
1153  << DiagD->getDeclName();
1154  }
1155  } else {
1156  const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1157  if (!DiagD)
1158  DiagD = cast<VarDecl>(*I);
1159  if (DiagD->isReferenced()) {
1160  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1161  << /*variable*/1 << DiagD->getDeclName();
1162  } else if (DiagD->getType().isConstQualified()) {
1163  const SourceManager &SM = SourceMgr;
1164  if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1166  Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1167  << DiagD->getDeclName();
1168  } else {
1169  if (DiagD->getDescribedVarTemplate())
1170  Diag(DiagD->getLocation(), diag::warn_unused_template)
1171  << /*variable*/1 << DiagD->getDeclName();
1172  else
1173  Diag(DiagD->getLocation(), diag::warn_unused_variable)
1174  << DiagD->getDeclName();
1175  }
1176  }
1177  }
1178 
1180  }
1181 
1182  if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1183  // FIXME: Load additional unused private field candidates from the external
1184  // source.
1185  RecordCompleteMap RecordsComplete;
1186  RecordCompleteMap MNCComplete;
1187  for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1188  E = UnusedPrivateFields.end(); I != E; ++I) {
1189  const NamedDecl *D = *I;
1190  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1191  if (RD && !RD->isUnion() &&
1192  IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1193  Diag(D->getLocation(), diag::warn_unused_private_field)
1194  << D->getDeclName();
1195  }
1196  }
1197  }
1198 
1199  if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1200  if (ExternalSource)
1202  for (const auto &DeletedFieldInfo : DeleteExprs) {
1203  for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1204  AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1205  DeleteExprLoc.second);
1206  }
1207  }
1208  }
1209 
1210  // Check we've noticed that we're no longer parsing the initializer for every
1211  // variable. If we miss cases, then at best we have a performance issue and
1212  // at worst a rejects-valid bug.
1213  assert(ParsingInitForAutoVars.empty() &&
1214  "Didn't unmark var as having its initializer parsed");
1215 
1217  TUScope = nullptr;
1218 }
1219 
1220 
1221 //===----------------------------------------------------------------------===//
1222 // Helper functions.
1223 //===----------------------------------------------------------------------===//
1224 
1226  DeclContext *DC = CurContext;
1227 
1228  while (true) {
1229  if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1230  DC = DC->getParent();
1231  } else if (isa<CXXMethodDecl>(DC) &&
1232  cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1233  cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1234  DC = DC->getParent()->getParent();
1235  }
1236  else break;
1237  }
1238 
1239  return DC;
1240 }
1241 
1242 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1243 /// to the function decl for the function being parsed. If we're currently
1244 /// in a 'block', this returns the containing context.
1247  return dyn_cast<FunctionDecl>(DC);
1248 }
1249 
1252  while (isa<RecordDecl>(DC))
1253  DC = DC->getParent();
1254  return dyn_cast<ObjCMethodDecl>(DC);
1255 }
1256 
1259  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1260  return cast<NamedDecl>(DC);
1261  return nullptr;
1262 }
1263 
1264 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1265  // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1266  // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1267  // been made more painfully obvious by the refactor that introduced this
1268  // function, but it is possible that the incoming argument can be
1269  // eliminated. If it truly cannot be (for example, there is some reentrancy
1270  // issue I am not seeing yet), then there should at least be a clarifying
1271  // comment somewhere.
1274  Diags.getCurrentDiagID())) {
1276  // We'll report the diagnostic below.
1277  break;
1278 
1280  // Count this failure so that we know that template argument deduction
1281  // has failed.
1282  ++NumSFINAEErrors;
1283 
1284  // Make a copy of this suppressed diagnostic and store it with the
1285  // template-deduction information.
1286  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1287  Diagnostic DiagInfo(&Diags);
1288  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1290  }
1291 
1293  Diags.Clear();
1294  return;
1295 
1297  // Per C++ Core Issue 1170, access control is part of SFINAE.
1298  // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1299  // make access control a part of SFINAE for the purposes of checking
1300  // type traits.
1302  break;
1303 
1305 
1306  // Suppress this diagnostic.
1307  ++NumSFINAEErrors;
1308 
1309  // Make a copy of this suppressed diagnostic and store it with the
1310  // template-deduction information.
1311  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1312  Diagnostic DiagInfo(&Diags);
1313  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1315  }
1316 
1318  Diags.Clear();
1319 
1320  // Now the diagnostic state is clear, produce a C++98 compatibility
1321  // warning.
1322  Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1323 
1324  // The last diagnostic which Sema produced was ignored. Suppress any
1325  // notes attached to it.
1327  return;
1328  }
1329 
1331  // Make a copy of this suppressed diagnostic and store it with the
1332  // template-deduction information;
1333  if (*Info) {
1334  Diagnostic DiagInfo(&Diags);
1335  (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1337  }
1338 
1339  // Suppress this diagnostic.
1341  Diags.Clear();
1342  return;
1343  }
1344  }
1345 
1346  // Copy the diagnostic printing policy over the ASTContext printing policy.
1347  // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1349 
1350  // Emit the diagnostic.
1352  return;
1353 
1354  // If this is not a note, and we're in a template instantiation
1355  // that is different from the last template instantiation where
1356  // we emitted an error, print a template instantiation
1357  // backtrace.
1358  if (!DiagnosticIDs::isBuiltinNote(DiagID))
1360 }
1361 
1364  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1365  PD.Emit(Builder);
1366 
1367  return Builder;
1368 }
1369 
1370 // Print notes showing how we can reach FD starting from an a priori
1371 // known-callable function.
1372 static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1373  auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1374  while (FnIt != S.DeviceKnownEmittedFns.end()) {
1375  DiagnosticBuilder Builder(
1376  S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1377  Builder << FnIt->second.FD;
1378  Builder.setForceEmit();
1379 
1380  FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1381  }
1382 }
1383 
1384 // Emit any deferred diagnostics for FD and erase them from the map in which
1385 // they're stored.
1386 static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack) {
1387  auto It = S.DeviceDeferredDiags.find(FD);
1388  if (It == S.DeviceDeferredDiags.end())
1389  return;
1390  bool HasWarningOrError = false;
1391  for (PartialDiagnosticAt &PDAt : It->second) {
1392  const SourceLocation &Loc = PDAt.first;
1393  const PartialDiagnostic &PD = PDAt.second;
1394  HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1395  PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1396  DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1397  Builder.setForceEmit();
1398  PD.Emit(Builder);
1399  }
1400  S.DeviceDeferredDiags.erase(It);
1401 
1402  // FIXME: Should this be called after every warning/error emitted in the loop
1403  // above, instead of just once per function? That would be consistent with
1404  // how we handle immediate errors, but it also seems like a bit much.
1405  if (HasWarningOrError && ShowCallStack)
1406  emitCallStackNotes(S, FD);
1407 }
1408 
1409 // In CUDA, there are some constructs which may appear in semantically-valid
1410 // code, but trigger errors if we ever generate code for the function in which
1411 // they appear. Essentially every construct you're not allowed to use on the
1412 // device falls into this category, because you are allowed to use these
1413 // constructs in a __host__ __device__ function, but only if that function is
1414 // never codegen'ed on the device.
1415 //
1416 // To handle semantic checking for these constructs, we keep track of the set of
1417 // functions we know will be emitted, either because we could tell a priori that
1418 // they would be emitted, or because they were transitively called by a
1419 // known-emitted function.
1420 //
1421 // We also keep a partial call graph of which not-known-emitted functions call
1422 // which other not-known-emitted functions.
1423 //
1424 // When we see something which is illegal if the current function is emitted
1425 // (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1426 // CheckCUDACall), we first check if the current function is known-emitted. If
1427 // so, we immediately output the diagnostic.
1428 //
1429 // Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1430 // until we discover that the function is known-emitted, at which point we take
1431 // it out of this map and emit the diagnostic.
1432 
1434  unsigned DiagID, FunctionDecl *Fn,
1435  Sema &S)
1436  : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1437  ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1438  switch (K) {
1439  case K_Nop:
1440  break;
1441  case K_Immediate:
1443  ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1444  break;
1445  case K_Deferred:
1446  assert(Fn && "Must have a function to attach the deferred diag to.");
1447  auto &Diags = S.DeviceDeferredDiags[Fn];
1448  PartialDiagId.emplace(Diags.size());
1449  Diags.emplace_back(Loc, S.PDiag(DiagID));
1450  break;
1451  }
1452 }
1453 
1455  : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1456  ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1457  PartialDiagId(D.PartialDiagId) {
1458  // Clean the previous diagnostics.
1459  D.ShowCallStack = false;
1460  D.ImmediateDiag.reset();
1461  D.PartialDiagId.reset();
1462 }
1463 
1465  if (ImmediateDiag) {
1466  // Emit our diagnostic and, if it was a warning or error, output a callstack
1467  // if Fn isn't a priori known-emitted.
1468  bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1469  DiagID, Loc) >= DiagnosticsEngine::Warning;
1470  ImmediateDiag.reset(); // Emit the immediate diag.
1471  if (IsWarningOrError && ShowCallStack)
1472  emitCallStackNotes(S, Fn);
1473  } else {
1474  assert((!PartialDiagId || ShowCallStack) &&
1475  "Must always show call stack for deferred diags.");
1476  }
1477 }
1478 
1479 // Indicate that this function (and thus everything it transtively calls) will
1480 // be codegen'ed, and emit any deferred diagnostics on this function and its
1481 // (transitive) callees.
1483  Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1484  SourceLocation OrigLoc,
1485  const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1486  // Nothing to do if we already know that FD is emitted.
1487  if (IsKnownEmitted(S, OrigCallee)) {
1488  assert(!S.DeviceCallGraph.count(OrigCallee));
1489  return;
1490  }
1491 
1492  // We've just discovered that OrigCallee is known-emitted. Walk our call
1493  // graph to see what else we can now discover also must be emitted.
1494 
1495  struct CallInfo {
1496  FunctionDecl *Caller;
1497  FunctionDecl *Callee;
1498  SourceLocation Loc;
1499  };
1500  llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1501  llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1502  Seen.insert(OrigCallee);
1503  while (!Worklist.empty()) {
1504  CallInfo C = Worklist.pop_back_val();
1505  assert(!IsKnownEmitted(S, C.Callee) &&
1506  "Worklist should not contain known-emitted functions.");
1507  S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
1508  emitDeferredDiags(S, C.Callee, C.Caller);
1509 
1510  // If this is a template instantiation, explore its callgraph as well:
1511  // Non-dependent calls are part of the template's callgraph, while dependent
1512  // calls are part of to the instantiation's call graph.
1513  if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1514  FunctionDecl *TemplFD = Templ->getAsFunction();
1515  if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1516  Seen.insert(TemplFD);
1517  Worklist.push_back(
1518  {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1519  }
1520  }
1521 
1522  // Add all functions called by Callee to our worklist.
1523  auto CGIt = S.DeviceCallGraph.find(C.Callee);
1524  if (CGIt == S.DeviceCallGraph.end())
1525  continue;
1526 
1527  for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1528  CGIt->second) {
1529  FunctionDecl *NewCallee = FDLoc.first;
1530  SourceLocation CallLoc = FDLoc.second;
1531  if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1532  continue;
1533  Seen.insert(NewCallee);
1534  Worklist.push_back(
1535  {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1536  }
1537 
1538  // C.Callee is now known-emitted, so we no longer need to maintain its list
1539  // of callees in DeviceCallGraph.
1540  S.DeviceCallGraph.erase(CGIt);
1541  }
1542 }
1543 
1545  if (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)
1546  return diagIfOpenMPDeviceCode(Loc, DiagID);
1547  if (getLangOpts().CUDA)
1548  return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1549  : CUDADiagIfHostCode(Loc, DiagID);
1551  getCurFunctionDecl(), *this);
1552 }
1553 
1554 /// Looks through the macro-expansion chain for the given
1555 /// location, looking for a macro expansion with the given name.
1556 /// If one is found, returns true and sets the location to that
1557 /// expansion loc.
1558 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1559  SourceLocation loc = locref;
1560  if (!loc.isMacroID()) return false;
1561 
1562  // There's no good way right now to look at the intermediate
1563  // expansions, so just jump to the expansion location.
1564  loc = getSourceManager().getExpansionLoc(loc);
1565 
1566  // If that's written with the name, stop here.
1567  SmallVector<char, 16> buffer;
1568  if (getPreprocessor().getSpelling(loc, buffer) == name) {
1569  locref = loc;
1570  return true;
1571  }
1572  return false;
1573 }
1574 
1575 /// Determines the active Scope associated with the given declaration
1576 /// context.
1577 ///
1578 /// This routine maps a declaration context to the active Scope object that
1579 /// represents that declaration context in the parser. It is typically used
1580 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1581 /// declarations) that injects a name for name-lookup purposes and, therefore,
1582 /// must update the Scope.
1583 ///
1584 /// \returns The scope corresponding to the given declaraion context, or NULL
1585 /// if no such scope is open.
1587 
1588  if (!Ctx)
1589  return nullptr;
1590 
1591  Ctx = Ctx->getPrimaryContext();
1592  for (Scope *S = getCurScope(); S; S = S->getParent()) {
1593  // Ignore scopes that cannot have declarations. This is important for
1594  // out-of-line definitions of static class members.
1595  if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1596  if (DeclContext *Entity = S->getEntity())
1597  if (Ctx == Entity->getPrimaryContext())
1598  return S;
1599  }
1600 
1601  return nullptr;
1602 }
1603 
1604 /// Enter a new function scope
1606  if (FunctionScopes.empty() && CachedFunctionScope) {
1607  // Use CachedFunctionScope to avoid allocating memory when possible.
1608  CachedFunctionScope->Clear();
1609  FunctionScopes.push_back(CachedFunctionScope.release());
1610  } else {
1612  }
1613  if (LangOpts.OpenMP)
1614  pushOpenMPFunctionRegion();
1615 }
1616 
1617 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1619  BlockScope, Block));
1620 }
1621 
1623  LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1624  FunctionScopes.push_back(LSI);
1625  return LSI;
1626 }
1627 
1629  if (LambdaScopeInfo *const LSI = getCurLambda()) {
1630  LSI->AutoTemplateParameterDepth = Depth;
1631  return;
1632  }
1633  llvm_unreachable(
1634  "Remove assertion if intentionally called in a non-lambda context.");
1635 }
1636 
1637 // Check that the type of the VarDecl has an accessible copy constructor and
1638 // resolve its destructor's exception specification.
1639 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1640  QualType T = VD->getType();
1643  SourceLocation Loc = VD->getLocation();
1644  Expr *VarRef =
1645  new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1647  InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1648  VarRef, /*AllowNRVO=*/true);
1649  if (!Result.isInvalid()) {
1650  Result = S.MaybeCreateExprWithCleanups(Result);
1651  Expr *Init = Result.getAs<Expr>();
1652  S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1653  }
1654 
1655  // The destructor's exception specification is needed when IRGen generates
1656  // block copy/destroy functions. Resolve it here.
1657  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1658  if (CXXDestructorDecl *DD = RD->getDestructor()) {
1659  auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1660  S.ResolveExceptionSpec(Loc, FPT);
1661  }
1662 }
1663 
1664 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1665  // Set the EscapingByref flag of __block variables captured by
1666  // escaping blocks.
1667  for (const BlockDecl *BD : FSI.Blocks) {
1668  if (BD->doesNotEscape())
1669  continue;
1670  for (const BlockDecl::Capture &BC : BD->captures()) {
1671  VarDecl *VD = BC.getVariable();
1672  if (VD->hasAttr<BlocksAttr>())
1673  VD->setEscapingByref();
1674  }
1675  }
1676 
1677  for (VarDecl *VD : FSI.ByrefBlockVars) {
1678  // __block variables might require us to capture a copy-initializer.
1679  if (!VD->isEscapingByref())
1680  continue;
1681  // It's currently invalid to ever have a __block variable with an
1682  // array type; should we diagnose that here?
1683  // Regardless, we don't want to ignore array nesting when
1684  // constructing this copy.
1685  if (VD->getType()->isStructureOrClassType())
1686  checkEscapingByref(VD, S);
1687  }
1688 }
1689 
1690 /// Pop a function (or block or lambda or captured region) scope from the stack.
1691 ///
1692 /// \param WP The warning policy to use for CFG-based warnings, or null if such
1693 /// warnings should not be produced.
1694 /// \param D The declaration corresponding to this function scope, if producing
1695 /// CFG-based warnings.
1696 /// \param BlockType The type of the block expression, if D is a BlockDecl.
1699  const Decl *D, QualType BlockType) {
1700  assert(!FunctionScopes.empty() && "mismatched push/pop!");
1701 
1702  markEscapingByrefs(*FunctionScopes.back(), *this);
1703 
1706 
1707  if (LangOpts.OpenMP)
1708  popOpenMPFunctionRegion(Scope.get());
1709 
1710  // Issue any analysis-based warnings.
1711  if (WP && D)
1712  AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
1713  else
1714  for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1715  Diag(PUD.Loc, PUD.PD);
1716 
1717  return Scope;
1718 }
1719 
1722  // Stash the function scope for later reuse if it's for a normal function.
1723  if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1724  Self->CachedFunctionScope.reset(Scope);
1725  else
1726  delete Scope;
1727 }
1728 
1729 void Sema::PushCompoundScope(bool IsStmtExpr) {
1730  getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1731 }
1732 
1734  FunctionScopeInfo *CurFunction = getCurFunction();
1735  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1736 
1737  CurFunction->CompoundScopes.pop_back();
1738 }
1739 
1740 /// Determine whether any errors occurred within this function/method/
1741 /// block.
1744 }
1745 
1747  if (!FunctionScopes.empty())
1748  FunctionScopes.back()->setHasBranchIntoScope();
1749 }
1750 
1752  if (!FunctionScopes.empty())
1753  FunctionScopes.back()->setHasBranchProtectedScope();
1754 }
1755 
1757  if (!FunctionScopes.empty())
1758  FunctionScopes.back()->setHasIndirectGoto();
1759 }
1760 
1762  if (FunctionScopes.empty())
1763  return nullptr;
1764 
1765  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1766  if (CurBSI && CurBSI->TheDecl &&
1767  !CurBSI->TheDecl->Encloses(CurContext)) {
1768  // We have switched contexts due to template instantiation.
1769  assert(!CodeSynthesisContexts.empty());
1770  return nullptr;
1771  }
1772 
1773  return CurBSI;
1774 }
1775 
1777  if (FunctionScopes.empty())
1778  return nullptr;
1779 
1780  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1781  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1782  continue;
1783  return FunctionScopes[e];
1784  }
1785  return nullptr;
1786 }
1787 
1788 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1789  if (FunctionScopes.empty())
1790  return nullptr;
1791 
1792  auto I = FunctionScopes.rbegin();
1793  if (IgnoreNonLambdaCapturingScope) {
1794  auto E = FunctionScopes.rend();
1795  while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1796  ++I;
1797  if (I == E)
1798  return nullptr;
1799  }
1800  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1801  if (CurLSI && CurLSI->Lambda &&
1802  !CurLSI->Lambda->Encloses(CurContext)) {
1803  // We have switched contexts due to template instantiation.
1804  assert(!CodeSynthesisContexts.empty());
1805  return nullptr;
1806  }
1807 
1808  return CurLSI;
1809 }
1810 // We have a generic lambda if we parsed auto parameters, or we have
1811 // an associated template parameter list.
1813  if (LambdaScopeInfo *LSI = getCurLambda()) {
1814  return (LSI->TemplateParams.size() ||
1815  LSI->GLTemplateParameterList) ? LSI : nullptr;
1816  }
1817  return nullptr;
1818 }
1819 
1820 
1822  if (!LangOpts.RetainCommentsFromSystemHeaders &&
1823  SourceMgr.isInSystemHeader(Comment.getBegin()))
1824  return;
1825  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1826  if (RC.isAlmostTrailingComment()) {
1827  SourceRange MagicMarkerRange(Comment.getBegin(),
1828  Comment.getBegin().getLocWithOffset(3));
1829  StringRef MagicMarkerText;
1830  switch (RC.getKind()) {
1832  MagicMarkerText = "///<";
1833  break;
1835  MagicMarkerText = "/**<";
1836  break;
1837  default:
1838  llvm_unreachable("if this is an almost Doxygen comment, "
1839  "it should be ordinary");
1840  }
1841  Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1842  FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1843  }
1844  Context.addComment(RC);
1845 }
1846 
1847 // Pin this vtable to this file.
1849 
1852 
1854  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1855 }
1856 
1858  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1859 
1861  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1862 
1863 /// Figure out if an expression could be turned into a call.
1864 ///
1865 /// Use this when trying to recover from an error where the programmer may have
1866 /// written just the name of a function instead of actually calling it.
1867 ///
1868 /// \param E - The expression to examine.
1869 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1870 /// with no arguments, this parameter is set to the type returned by such a
1871 /// call; otherwise, it is set to an empty QualType.
1872 /// \param OverloadSet - If the expression is an overloaded function
1873 /// name, this parameter is populated with the decls of the various overloads.
1874 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1875  UnresolvedSetImpl &OverloadSet) {
1876  ZeroArgCallReturnTy = QualType();
1877  OverloadSet.clear();
1878 
1879  const OverloadExpr *Overloads = nullptr;
1880  bool IsMemExpr = false;
1881  if (E.getType() == Context.OverloadTy) {
1882  OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1883 
1884  // Ignore overloads that are pointer-to-member constants.
1885  if (FR.HasFormOfMemberPointer)
1886  return false;
1887 
1888  Overloads = FR.Expression;
1889  } else if (E.getType() == Context.BoundMemberTy) {
1890  Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1891  IsMemExpr = true;
1892  }
1893 
1894  bool Ambiguous = false;
1895  bool IsMV = false;
1896 
1897  if (Overloads) {
1898  for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1899  DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1900  OverloadSet.addDecl(*it);
1901 
1902  // Check whether the function is a non-template, non-member which takes no
1903  // arguments.
1904  if (IsMemExpr)
1905  continue;
1906  if (const FunctionDecl *OverloadDecl
1907  = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1908  if (OverloadDecl->getMinRequiredArguments() == 0) {
1909  if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1910  (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1911  OverloadDecl->isCPUSpecificMultiVersion()))) {
1912  ZeroArgCallReturnTy = QualType();
1913  Ambiguous = true;
1914  } else {
1915  ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1916  IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1917  OverloadDecl->isCPUSpecificMultiVersion();
1918  }
1919  }
1920  }
1921  }
1922 
1923  // If it's not a member, use better machinery to try to resolve the call
1924  if (!IsMemExpr)
1925  return !ZeroArgCallReturnTy.isNull();
1926  }
1927 
1928  // Attempt to call the member with no arguments - this will correctly handle
1929  // member templates with defaults/deduction of template arguments, overloads
1930  // with default arguments, etc.
1931  if (IsMemExpr && !E.isTypeDependent()) {
1932  Sema::TentativeAnalysisScope Trap(*this);
1934  None, SourceLocation());
1935  if (R.isUsable()) {
1936  ZeroArgCallReturnTy = R.get()->getType();
1937  return true;
1938  }
1939  return false;
1940  }
1941 
1942  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1943  if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1944  if (Fun->getMinRequiredArguments() == 0)
1945  ZeroArgCallReturnTy = Fun->getReturnType();
1946  return true;
1947  }
1948  }
1949 
1950  // We don't have an expression that's convenient to get a FunctionDecl from,
1951  // but we can at least check if the type is "function of 0 arguments".
1952  QualType ExprTy = E.getType();
1953  const FunctionType *FunTy = nullptr;
1954  QualType PointeeTy = ExprTy->getPointeeType();
1955  if (!PointeeTy.isNull())
1956  FunTy = PointeeTy->getAs<FunctionType>();
1957  if (!FunTy)
1958  FunTy = ExprTy->getAs<FunctionType>();
1959 
1960  if (const FunctionProtoType *FPT =
1961  dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1962  if (FPT->getNumParams() == 0)
1963  ZeroArgCallReturnTy = FunTy->getReturnType();
1964  return true;
1965  }
1966  return false;
1967 }
1968 
1969 /// Give notes for a set of overloads.
1970 ///
1971 /// A companion to tryExprAsCall. In cases when the name that the programmer
1972 /// wrote was an overloaded function, we may be able to make some guesses about
1973 /// plausible overloads based on their return types; such guesses can be handed
1974 /// off to this method to be emitted as notes.
1975 ///
1976 /// \param Overloads - The overloads to note.
1977 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1978 /// -fshow-overloads=best, this is the location to attach to the note about too
1979 /// many candidates. Typically this will be the location of the original
1980 /// ill-formed expression.
1981 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1982  const SourceLocation FinalNoteLoc) {
1983  int ShownOverloads = 0;
1984  int SuppressedOverloads = 0;
1985  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1986  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1987  // FIXME: Magic number for max shown overloads stolen from
1988  // OverloadCandidateSet::NoteCandidates.
1989  if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1990  ++SuppressedOverloads;
1991  continue;
1992  }
1993 
1994  NamedDecl *Fn = (*It)->getUnderlyingDecl();
1995  // Don't print overloads for non-default multiversioned functions.
1996  if (const auto *FD = Fn->getAsFunction()) {
1997  if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1998  !FD->getAttr<TargetAttr>()->isDefaultVersion())
1999  continue;
2000  }
2001  S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
2002  ++ShownOverloads;
2003  }
2004 
2005  if (SuppressedOverloads)
2006  S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
2007  << SuppressedOverloads;
2008 }
2009 
2011  const UnresolvedSetImpl &Overloads,
2012  bool (*IsPlausibleResult)(QualType)) {
2013  if (!IsPlausibleResult)
2014  return noteOverloads(S, Overloads, Loc);
2015 
2016  UnresolvedSet<2> PlausibleOverloads;
2017  for (OverloadExpr::decls_iterator It = Overloads.begin(),
2018  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2019  const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
2020  QualType OverloadResultTy = OverloadDecl->getReturnType();
2021  if (IsPlausibleResult(OverloadResultTy))
2022  PlausibleOverloads.addDecl(It.getDecl());
2023  }
2024  noteOverloads(S, PlausibleOverloads, Loc);
2025 }
2026 
2027 /// Determine whether the given expression can be called by just
2028 /// putting parentheses after it. Notably, expressions with unary
2029 /// operators can't be because the unary operator will start parsing
2030 /// outside the call.
2031 static bool IsCallableWithAppend(Expr *E) {
2032  E = E->IgnoreImplicit();
2033  return (!isa<CStyleCastExpr>(E) &&
2034  !isa<UnaryOperator>(E) &&
2035  !isa<BinaryOperator>(E) &&
2036  !isa<CXXOperatorCallExpr>(E));
2037 }
2038 
2040  if (const auto *UO = dyn_cast<UnaryOperator>(E))
2041  E = UO->getSubExpr();
2042 
2043  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2044  if (ULE->getNumDecls() == 0)
2045  return false;
2046 
2047  const NamedDecl *ND = *ULE->decls_begin();
2048  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2049  return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2050  }
2051  return false;
2052 }
2053 
2055  bool ForceComplain,
2056  bool (*IsPlausibleResult)(QualType)) {
2057  SourceLocation Loc = E.get()->getExprLoc();
2058  SourceRange Range = E.get()->getSourceRange();
2059 
2060  QualType ZeroArgCallTy;
2061  UnresolvedSet<4> Overloads;
2062  if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
2063  !ZeroArgCallTy.isNull() &&
2064  (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2065  // At this point, we know E is potentially callable with 0
2066  // arguments and that it returns something of a reasonable type,
2067  // so we can emit a fixit and carry on pretending that E was
2068  // actually a CallExpr.
2069  SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
2070  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2071  Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2072  << (IsCallableWithAppend(E.get())
2073  ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2074  : FixItHint());
2075  if (!IsMV)
2076  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2077 
2078  // FIXME: Try this before emitting the fixit, and suppress diagnostics
2079  // while doing so.
2080  E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
2081  Range.getEnd().getLocWithOffset(1));
2082  return true;
2083  }
2084 
2085  if (!ForceComplain) return false;
2086 
2087  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2088  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2089  if (!IsMV)
2090  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2091  E = ExprError();
2092  return true;
2093 }
2094 
2096  if (!Ident_super)
2097  Ident_super = &Context.Idents.get("super");
2098  return Ident_super;
2099 }
2100 
2102  if (!Ident___float128)
2103  Ident___float128 = &Context.Idents.get("__float128");
2104  return Ident___float128;
2105 }
2106 
2109  unsigned OpenMPCaptureLevel) {
2110  auto *CSI = new CapturedRegionScopeInfo(
2111  getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2112  (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0,
2113  OpenMPCaptureLevel);
2114  CSI->ReturnType = Context.VoidTy;
2115  FunctionScopes.push_back(CSI);
2116 }
2117 
2119  if (FunctionScopes.empty())
2120  return nullptr;
2121 
2122  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2123 }
2124 
2125 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2127  return DeleteExprs;
2128 }
2129 
2130 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2131  if (ExtStr.empty())
2132  return;
2134  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2135  auto CanT = T.getCanonicalType().getTypePtr();
2136  for (auto &I : Exts)
2137  OpenCLTypeExtMap[CanT].insert(I.str());
2138 }
2139 
2140 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2142  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2143  if (Exts.empty())
2144  return;
2145  for (auto &I : Exts)
2146  OpenCLDeclExtMap[FD].insert(I.str());
2147 }
2148 
2150  if (CurrOpenCLExtension.empty())
2151  return;
2152  setOpenCLExtensionForType(T, CurrOpenCLExtension);
2153 }
2154 
2156  if (CurrOpenCLExtension.empty())
2157  return;
2158  setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2159 }
2160 
2162  if (!OpenCLDeclExtMap.empty())
2163  return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2164 
2165  return "";
2166 }
2167 
2169  if (!OpenCLTypeExtMap.empty())
2170  return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2171 
2172  return "";
2173 }
2174 
2175 template <typename T, typename MapT>
2176 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2177  std::string ExtensionNames = "";
2178  auto Loc = Map.find(FDT);
2179 
2180  for (auto const& I : Loc->second) {
2181  ExtensionNames += I;
2182  ExtensionNames += " ";
2183  }
2184  ExtensionNames.pop_back();
2185 
2186  return ExtensionNames;
2187 }
2188 
2190  auto Loc = OpenCLDeclExtMap.find(FD);
2191  if (Loc == OpenCLDeclExtMap.end())
2192  return false;
2193  for (auto &I : Loc->second) {
2194  if (!getOpenCLOptions().isEnabled(I))
2195  return true;
2196  }
2197  return false;
2198 }
2199 
2200 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2201 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2202  DiagInfoT DiagInfo, MapT &Map,
2203  unsigned Selector,
2204  SourceRange SrcRange) {
2205  auto Loc = Map.find(D);
2206  if (Loc == Map.end())
2207  return false;
2208  bool Disabled = false;
2209  for (auto &I : Loc->second) {
2210  if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2211  Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2212  << I << SrcRange;
2213  Disabled = true;
2214  }
2215  }
2216  return Disabled;
2217 }
2218 
2220  // Check extensions for declared types.
2221  Decl *Decl = nullptr;
2222  if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2223  Decl = TypedefT->getDecl();
2224  if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2225  Decl = TagT->getDecl();
2226  auto Loc = DS.getTypeSpecTypeLoc();
2227 
2228  // Check extensions for vector types.
2229  // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2230  if (QT->isExtVectorType()) {
2231  auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2232  return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2233  }
2234 
2235  if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2236  return true;
2237 
2238  // Check extensions for builtin types.
2239  return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2240  QT, OpenCLTypeExtMap);
2241 }
2242 
2244  IdentifierInfo *FnName = D.getIdentifier();
2245  return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2246  OpenCLDeclExtMap, 1, D.getSourceRange());
2247 }
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:2438
Defines the clang::ASTContext interface.
ObjCInterfaceDecl * NSStringDecl
The declaration of the Objective-C NSString class.
Definition: Sema.h:933
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:667
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:629
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:789
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
CanQualType OCLQueueTy
Definition: ASTContext.h:1040
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:3897
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
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:699
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:1433
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:1225
RecordDecl * MSVCGuidDecl
The MSVC "_GUID" struct, which is defined in MSVC header files.
Definition: Sema.h:912
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:10444
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3196
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:722
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:11874
void getUndefinedButUsed(SmallVectorImpl< std::pair< NamedDecl *, SourceLocation > > &Undefined)
Obtain a sorted list of functions that are undefined but ODR-used.
Definition: Sema.cpp:644
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:3378
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:2010
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:681
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:1368
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
Module * getCurrentModule()
Retrieves the module that we&#39;re currently building, if any.
static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack)
Definition: Sema.cpp:1386
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:6453
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:7931
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:883
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:7568
virtual void updateOutOfDateSelector(Selector Sel)
Load the contents of the global method pool for a given selector if necessary.
Definition: Sema.cpp:1851
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:1850
CanQualType LongTy
Definition: ASTContext.h:1011
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:2039
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:47
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:693
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:3696
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:628
IdentifierInfo * getSuperIdentifier() const
Definition: Sema.cpp:2095
The diagnostic should not be reported, but it should cause template argument deduction to fail...
void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind)
Definition: Sema.cpp:866
void LoadExternalWeakUndeclaredIdentifiers()
Load weak undeclared identifiers from the external source.
Definition: Sema.cpp:747
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:7609
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1280
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3202
IdentifierInfo * getFloat128Identifier() const
Definition: Sema.cpp:2101
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:7902
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:2168
RAII object that enters a new expression evaluation context.
Definition: Sema.h:11252
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:6824
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2310
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:11160
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1190
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:942
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:1292
Defines the clang::Expr interface and subclasses for C++ expressions.
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
Definition: Sema.h:951
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:2126
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:1039
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:895
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:915
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7898
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:4042
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:689
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.cpp:1776
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
Definition: ModuleMap.cpp:1293
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1812
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:7802
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:505
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1761
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:2149
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:4149
void setEscapingByref()
Definition: Decl.h:1428
std::unique_ptr< sema::FunctionScopeInfo > CachedFunctionScope
Definition: Sema.h:604
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:7917
ObjCInterfaceDecl * NSValueDecl
The declaration of the Objective-C NSValue class.
Definition: Sema.h:921
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
Definition: Sema.cpp:924
CanQualType OCLEventTy
Definition: ASTContext.h:1039
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:31
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:417
bool hasAArch64SVETypes() const
Returns whether or not the AArch64 SVE built-in types are available on this target.
Definition: TargetInfo.h:796
llvm::SmallPtrSet< const BlockDecl *, 1 > Blocks
The set of blocks that are introduced in this function.
Definition: ScopeInfo.h:207
void setFunctionHasBranchIntoScope()
Definition: Sema.cpp:1746
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3677
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:2189
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1040
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:903
Describes a module or submodule.
Definition: Module.h:64
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1167
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:1981
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors...
Definition: Sema.h:6345
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:7905
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:765
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:1558
PtrTy get() const
Definition: Ownership.h:170
DeviceDiagBuilder targetDiag(SourceLocation Loc, unsigned DiagID)
Definition: Sema.cpp:1544
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Definition: Sema.h:7880
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1250
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:2219
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:636
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...
A set of unresolved declarations.
Definition: UnresolvedSet.h:60
void CheckDelegatingCtorCycles()
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:9733
friend_iterator friend_end() const
Definition: DeclFriend.h:243
~ExternalSemaSource() override
Definition: Sema.cpp:1848
Values of this type can never be null.
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:423
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:6133
static const unsigned NumNSNumberLiteralMethods
Definition: NSAPI.h:194
Emit no diagnostics.
Definition: Sema.h:10438
submodule_iterator submodule_end()
Definition: Module.h:565
void PrintStats() const
Print out statistics about the semantic analysis.
Definition: Sema.cpp:440
void emitAndClearUnusedLocalTypedefWarnings()
Definition: Sema.cpp:838
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:918
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:1853
const LangOptions & getLangOpts() const
Definition: Sema.h:1291
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:7916
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4084
NamespaceDecl * StdExperimentalNamespaceCache
The C++ "std::experimental" namespace, where the experimental parts of the standard library resides...
Definition: Sema.h:898
ObjCMethodDecl * StringWithUTF8StringMethod
The declaration of the stringWithUTF8String: method.
Definition: Sema.h:939
void DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc)
Definition: SemaAttr.cpp:335
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:2243
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:1295
static bool IsCallableWithAppend(Expr *E)
Determine whether the given expression can be called by just putting parentheses after it...
Definition: Sema.cpp:2031
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K, unsigned OpenMPCaptureLevel=0)
Definition: Sema.cpp:2107
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:3710
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:659
Retains information about a captured region.
Definition: ScopeInfo.h:741
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:1729
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:1733
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:1860
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:1751
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:39
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:11125
unsigned Offset
Definition: Format.cpp:1728
TUFragmentKind
Definition: Sema.h:1394
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:7935
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:3891
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:564
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:2140
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:649
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:2810
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:5583
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6889
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2838
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:7600
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
Definition: Type.h:6641
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:859
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Not compiling a module interface at all.
Definition: LangOptions.h:75
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy initialization expression of a block var decl.
DeclContext * getDeclContext()
Definition: DeclBase.h:438
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
Definition: ModuleMap.cpp:1267
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:1998
decls_iterator decls_begin() const
Definition: ExprCXX.h:2842
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7821
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:608
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:1772
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:85
bool isInvalid() const
Definition: Ownership.h:166
SourceLocation getEnd() const
Preprocessor & getPreprocessor() const
Definition: Sema.h:1297
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:948
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1369
bool isUsable() const
Definition: Ownership.h:167
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1622
The result type of a method or function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
void DiagnoseUnterminatedPragmaPack()
Definition: SemaAttr.cpp:369
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:708
const SourceManager & SM
Definition: Format.cpp:1586
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:662
SmallVector< CXXMethodDecl *, 4 > DelayedDllExportMemberFunctions
Definition: Sema.h:11161
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1170
llvm::DenseMap< const CXXRecordDecl *, bool > RecordCompleteMap
Definition: Sema.cpp:758
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:6192
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:1617
CanQualType OverloadTy
Definition: ASTContext.h:1031
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:909
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2750
QualType getCanonicalType() const
Definition: Type.h:6172
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:3636
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:2155
Diagnostic builder for CUDA/OpenMP devices errors which may or may not be deferred.
Definition: Sema.h:10434
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:393
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:2161
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:633
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>. ...
Definition: Sema.h:902
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:1014
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:1372
CanQualType VoidTy
Definition: ASTContext.h:1002
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:1482
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:1857
void EmitCurrentDiagnostic(unsigned DiagID)
Cause the active diagnostic on the DiagosticsEngine to be emitted.
Definition: Sema.cpp:1264
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:3244
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:807
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:620
Create a deferred diagnostic, which is emitted only if the function it&#39;s attached to is codegen&#39;ed...
Definition: Sema.h:10448
static bool isFunctionOrVarDeclExternC(NamedDecl *ND)
Definition: Sema.cpp:625
sema::CapturedRegionScopeInfo * getCurCapturedRegion()
Retrieve the current captured region, if any.
Definition: Sema.cpp:2118
void operator()(sema::FunctionScopeInfo *Scope) const
Definition: Sema.cpp:1721
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:854
ASTConsumer & getASTConsumer() const
Definition: Sema.h:1299
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:2130
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1978
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:700
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:7633
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:930
static void checkEscapingByref(VarDecl *VD, Sema &S)
Definition: Sema.cpp:1639
ArrayRef< Capture > captures() const
Definition: Decl.h:4018
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:414
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:490
void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E)
Warn when implicitly casting 0 to nullptr.
Definition: Sema.cpp:462
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing.
Definition: Sema.cpp:1628
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
Definition: SemaDecl.cpp:1582
Custom deleter to allow FunctionScopeInfos to be kept alive for a short time after they&#39;ve been poppe...
Definition: Sema.h:1429
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:906
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:964
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:2054
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:10440
IdentifierResolver IdResolver
Definition: Sema.h:878
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:547
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:1072
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:1257
std::string getOpenCLExtensionsFromExtMap(T *FT, MapT &Map)
Find an extension in an appropriate extension map and return its name.
Definition: Sema.cpp:2176
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
Definition: Sema.cpp:1742
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2960
bool isMacroID() const
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:638
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:838
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:2952
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:1012
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1245
static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S)
Definition: Sema.cpp:1664
void * OpaqueParser
Definition: Sema.h:701
ExtVectorType - Extended vector type.
Definition: Type.h:3310
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:7514
CanQualType BoundMemberTy
Definition: ASTContext.h:1031
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1096
void addComment(const RawComment &RC)
Definition: ASTContext.h:784
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:945
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:3803
The "class" keyword.
Definition: Type.h:5103
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:522
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:2070
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:3555
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:1586
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2271
bool isConstantEvaluatedOverride
Used to change context to isConstantEvaluated without pushing a heavy ExpressionEvaluationContextReco...
Definition: Sema.h:808
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:10384
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:3117
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:995
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:552
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:737
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:1756
Represents a C array with an unspecified size.
Definition: Type.h:2949
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1445
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:1698
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
Definition: Sema.h:1438
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:1296
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:1874
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:1165
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:1011
void ActOnComment(SourceRange Comment)
Definition: Sema.cpp:1821
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:10405
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:448
This represents a decl that may have a name.
Definition: Decl.h:248
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1788
CanQualType DoubleTy
Definition: ASTContext.h:1014
IdentifierInfo * getBoolName() const
Retrieve the identifier &#39;bool&#39;.
Definition: ASTContext.h:1706
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:697
decls_iterator decls_end() const
Definition: ExprCXX.h:2845
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:7806
OpenCLOptions & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1323
Declaration of a template function.
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1605
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:625
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:10417
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:1039
ObjCMethodDecl * DictionaryWithObjectsMethod
The declaration of the dictionaryWithObjects:forKeys:count: method.
Definition: Sema.h:954
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1321
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2956
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:124
CanQualType UnsignedIntTy
Definition: ASTContext.h:1012
decl_iterator decls_end() const
Definition: DeclBase.h:2023
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