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