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