clang  8.0.0
Sema.cpp
Go to the documentation of this file.
1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the actions class which performs semantic analysis and
11 // builds an AST out of a parse stream.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclFriend.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/StmtCXX.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Lex/HeaderSearch.h"
28 #include "clang/Lex/Preprocessor.h"
35 #include "clang/Sema/Scope.h"
36 #include "clang/Sema/ScopeInfo.h"
41 #include "llvm/ADT/DenseMap.h"
42 #include "llvm/ADT/SmallSet.h"
43 using namespace clang;
44 using namespace sema;
45 
47  return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
48 }
49 
50 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
51 
53  const Preprocessor &PP) {
54  PrintingPolicy Policy = Context.getPrintingPolicy();
55  // In diagnostics, we print _Bool as bool if the latter is defined as the
56  // former.
57  Policy.Bool = Context.getLangOpts().Bool;
58  if (!Policy.Bool) {
59  if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
60  Policy.Bool = BoolMacro->isObjectLike() &&
61  BoolMacro->getNumTokens() == 1 &&
62  BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
63  }
64  }
65 
66  return Policy;
67 }
68 
70  TUScope = S;
71  PushDeclContext(S, Context.getTranslationUnitDecl());
72 }
73 
74 namespace clang {
75 namespace sema {
76 
77 class SemaPPCallbacks : public PPCallbacks {
78  Sema *S = nullptr;
80 
81 public:
82  void set(Sema &S) { this->S = &S; }
83 
84  void reset() { S = nullptr; }
85 
86  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
88  FileID PrevFID) override {
89  if (!S)
90  return;
91  switch (Reason) {
92  case EnterFile: {
94  SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
95  if (IncludeLoc.isValid()) {
96  IncludeStack.push_back(IncludeLoc);
99  }
100  break;
101  }
102  case ExitFile:
103  if (!IncludeStack.empty())
106  IncludeStack.pop_back_val());
107  break;
108  default:
109  break;
110  }
111  }
112 };
113 
114 } // end namespace sema
115 } // end namespace clang
116 
117 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
118  TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
119  : ExternalSource(nullptr), isMultiplexExternalSource(false),
120  FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
121  Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
122  SourceMgr(PP.getSourceManager()), CollectStats(false),
123  CodeCompleter(CodeCompleter), CurContext(nullptr),
124  OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
125  MSPointerToMemberRepresentationMethod(
126  LangOpts.getMSPointerToMemberRepresentationMethod()),
127  VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),
128  DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
129  CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
130  PragmaAttributeCurrentTargetDecl(nullptr),
131  IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
132  LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
134  StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
135  MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
136  NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
137  ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
138  ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
141  FullyCheckedComparisonCategories(
142  static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
146  TyposCorrected(0), AnalysisWarnings(*this),
147  ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
148  CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
149  TUScope = nullptr;
150 
151  LoadedExternalKnownNamespaces = false;
152  for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
153  NSNumberLiteralMethods[I] = nullptr;
154 
155  if (getLangOpts().ObjC)
156  NSAPIObj.reset(new NSAPI(Context));
157 
158  if (getLangOpts().CPlusPlus)
159  FieldCollector.reset(new CXXFieldCollector());
160 
161  // Tell diagnostics how to render things from the AST library.
163 
164  ExprEvalContexts.emplace_back(
167 
169 
170  // Initialization of data sharing attributes stack for OpenMP
171  InitDataSharingAttributesStack();
172 
173  std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
174  llvm::make_unique<sema::SemaPPCallbacks>();
175  SemaPPCallbackHandler = Callbacks.get();
176  PP.addPPCallbacks(std::move(Callbacks));
177  SemaPPCallbackHandler->set(*this);
178 }
179 
180 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
181  DeclarationName DN = &Context.Idents.get(Name);
182  if (IdResolver.begin(DN) == IdResolver.end())
184 }
185 
187  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
188  SC->InitializeSema(*this);
189 
190  // Tell the external Sema source about this Sema object.
191  if (ExternalSemaSource *ExternalSema
192  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
193  ExternalSema->InitializeSema(*this);
194 
195  // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
196  // will not be able to merge any duplicate __va_list_tag decls correctly.
197  VAListTagName = PP.getIdentifierInfo("__va_list_tag");
198 
199  if (!TUScope)
200  return;
201 
202  // Initialize predefined 128-bit integer types, if needed.
204  // If either of the 128-bit integer types are unavailable to name lookup,
205  // define them now.
206  DeclarationName Int128 = &Context.Idents.get("__int128_t");
207  if (IdResolver.begin(Int128) == IdResolver.end())
209 
210  DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
211  if (IdResolver.begin(UInt128) == IdResolver.end())
213  }
214 
215 
216  // Initialize predefined Objective-C types:
217  if (getLangOpts().ObjC) {
218  // If 'SEL' does not yet refer to any declarations, make it refer to the
219  // predefined 'SEL'.
220  DeclarationName SEL = &Context.Idents.get("SEL");
221  if (IdResolver.begin(SEL) == IdResolver.end())
223 
224  // If 'id' does not yet refer to any declarations, make it refer to the
225  // predefined 'id'.
227  if (IdResolver.begin(Id) == IdResolver.end())
229 
230  // Create the built-in typedef for 'Class'.
231  DeclarationName Class = &Context.Idents.get("Class");
232  if (IdResolver.begin(Class) == IdResolver.end())
234 
235  // Create the built-in forward declaratino for 'Protocol'.
236  DeclarationName Protocol = &Context.Idents.get("Protocol");
237  if (IdResolver.begin(Protocol) == IdResolver.end())
239  }
240 
241  // Create the internal type for the *StringMakeConstantString builtins.
242  DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
243  if (IdResolver.begin(ConstantString) == IdResolver.end())
245 
246  // Initialize Microsoft "predefined C++ types".
247  if (getLangOpts().MSVCCompat) {
248  if (getLangOpts().CPlusPlus &&
249  IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
251  TUScope);
252 
254  }
255 
256  // Initialize predefined OpenCL types and supported extensions and (optional)
257  // core features.
258  if (getLangOpts().OpenCL) {
263  if (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 /// Looks through the macro-expansion chain for the given
1329 /// location, looking for a macro expansion with the given name.
1330 /// If one is found, returns true and sets the location to that
1331 /// expansion loc.
1332 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1333  SourceLocation loc = locref;
1334  if (!loc.isMacroID()) return false;
1335 
1336  // There's no good way right now to look at the intermediate
1337  // expansions, so just jump to the expansion location.
1338  loc = getSourceManager().getExpansionLoc(loc);
1339 
1340  // If that's written with the name, stop here.
1341  SmallVector<char, 16> buffer;
1342  if (getPreprocessor().getSpelling(loc, buffer) == name) {
1343  locref = loc;
1344  return true;
1345  }
1346  return false;
1347 }
1348 
1349 /// Determines the active Scope associated with the given declaration
1350 /// context.
1351 ///
1352 /// This routine maps a declaration context to the active Scope object that
1353 /// represents that declaration context in the parser. It is typically used
1354 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1355 /// declarations) that injects a name for name-lookup purposes and, therefore,
1356 /// must update the Scope.
1357 ///
1358 /// \returns The scope corresponding to the given declaraion context, or NULL
1359 /// if no such scope is open.
1361 
1362  if (!Ctx)
1363  return nullptr;
1364 
1365  Ctx = Ctx->getPrimaryContext();
1366  for (Scope *S = getCurScope(); S; S = S->getParent()) {
1367  // Ignore scopes that cannot have declarations. This is important for
1368  // out-of-line definitions of static class members.
1369  if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1370  if (DeclContext *Entity = S->getEntity())
1371  if (Ctx == Entity->getPrimaryContext())
1372  return S;
1373  }
1374 
1375  return nullptr;
1376 }
1377 
1378 /// Enter a new function scope
1380  if (FunctionScopes.empty()) {
1381  // Use PreallocatedFunctionScope to avoid allocating memory when possible.
1382  PreallocatedFunctionScope->Clear();
1383  FunctionScopes.push_back(PreallocatedFunctionScope.get());
1384  } else {
1386  }
1387  if (LangOpts.OpenMP)
1388  pushOpenMPFunctionRegion();
1389 }
1390 
1391 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1393  BlockScope, Block));
1394 }
1395 
1397  LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1398  FunctionScopes.push_back(LSI);
1399  return LSI;
1400 }
1401 
1403  if (LambdaScopeInfo *const LSI = getCurLambda()) {
1404  LSI->AutoTemplateParameterDepth = Depth;
1405  return;
1406  }
1407  llvm_unreachable(
1408  "Remove assertion if intentionally called in a non-lambda context.");
1409 }
1410 
1411 // Check that the type of the VarDecl has an accessible copy constructor and
1412 // resolve its destructor's exception spefication.
1413 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1414  QualType T = VD->getType();
1417  SourceLocation Loc = VD->getLocation();
1418  Expr *VarRef =
1419  new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1421  InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1422  VarRef, /*AllowNRVO=*/true);
1423  if (!Result.isInvalid()) {
1424  Result = S.MaybeCreateExprWithCleanups(Result);
1425  Expr *Init = Result.getAs<Expr>();
1426  S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1427  }
1428 
1429  // The destructor's exception spefication is needed when IRGen generates
1430  // block copy/destroy functions. Resolve it here.
1431  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1432  if (CXXDestructorDecl *DD = RD->getDestructor()) {
1433  auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1434  S.ResolveExceptionSpec(Loc, FPT);
1435  }
1436 }
1437 
1438 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1439  // Set the EscapingByref flag of __block variables captured by
1440  // escaping blocks.
1441  for (const BlockDecl *BD : FSI.Blocks) {
1442  if (BD->doesNotEscape())
1443  continue;
1444  for (const BlockDecl::Capture &BC : BD->captures()) {
1445  VarDecl *VD = BC.getVariable();
1446  if (VD->hasAttr<BlocksAttr>())
1447  VD->setEscapingByref();
1448  }
1449  }
1450 
1451  for (VarDecl *VD : FSI.ByrefBlockVars) {
1452  // __block variables might require us to capture a copy-initializer.
1453  if (!VD->isEscapingByref())
1454  continue;
1455  // It's currently invalid to ever have a __block variable with an
1456  // array type; should we diagnose that here?
1457  // Regardless, we don't want to ignore array nesting when
1458  // constructing this copy.
1459  if (VD->getType()->isStructureOrClassType())
1460  checkEscapingByref(VD, S);
1461  }
1462 }
1463 
1465  const Decl *D, const BlockExpr *blkExpr) {
1466  assert(!FunctionScopes.empty() && "mismatched push/pop!");
1467 
1468  // This function shouldn't be called after popping the current function scope.
1469  // markEscapingByrefs calls PerformMoveOrCopyInitialization, which can call
1470  // PushFunctionScope, which can cause clearing out PreallocatedFunctionScope
1471  // when FunctionScopes is empty.
1472  markEscapingByrefs(*FunctionScopes.back(), *this);
1473 
1474  FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
1475 
1476  if (LangOpts.OpenMP)
1477  popOpenMPFunctionRegion(Scope);
1478 
1479  // Issue any analysis-based warnings.
1480  if (WP && D)
1481  AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
1482  else
1483  for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1484  Diag(PUD.Loc, PUD.PD);
1485 
1486  // Delete the scope unless its our preallocated scope.
1487  if (Scope != PreallocatedFunctionScope.get())
1488  delete Scope;
1489 }
1490 
1491 void Sema::PushCompoundScope(bool IsStmtExpr) {
1492  getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1493 }
1494 
1496  FunctionScopeInfo *CurFunction = getCurFunction();
1497  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1498 
1499  CurFunction->CompoundScopes.pop_back();
1500 }
1501 
1502 /// Determine whether any errors occurred within this function/method/
1503 /// block.
1506 }
1507 
1509  if (!FunctionScopes.empty())
1510  FunctionScopes.back()->setHasBranchIntoScope();
1511 }
1512 
1514  if (!FunctionScopes.empty())
1515  FunctionScopes.back()->setHasBranchProtectedScope();
1516 }
1517 
1519  if (!FunctionScopes.empty())
1520  FunctionScopes.back()->setHasIndirectGoto();
1521 }
1522 
1524  if (FunctionScopes.empty())
1525  return nullptr;
1526 
1527  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1528  if (CurBSI && CurBSI->TheDecl &&
1529  !CurBSI->TheDecl->Encloses(CurContext)) {
1530  // We have switched contexts due to template instantiation.
1531  assert(!CodeSynthesisContexts.empty());
1532  return nullptr;
1533  }
1534 
1535  return CurBSI;
1536 }
1537 
1539  if (FunctionScopes.empty())
1540  return nullptr;
1541 
1542  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1543  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1544  continue;
1545  return FunctionScopes[e];
1546  }
1547  return nullptr;
1548 }
1549 
1550 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1551  if (FunctionScopes.empty())
1552  return nullptr;
1553 
1554  auto I = FunctionScopes.rbegin();
1555  if (IgnoreNonLambdaCapturingScope) {
1556  auto E = FunctionScopes.rend();
1557  while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1558  ++I;
1559  if (I == E)
1560  return nullptr;
1561  }
1562  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1563  if (CurLSI && CurLSI->Lambda &&
1564  !CurLSI->Lambda->Encloses(CurContext)) {
1565  // We have switched contexts due to template instantiation.
1566  assert(!CodeSynthesisContexts.empty());
1567  return nullptr;
1568  }
1569 
1570  return CurLSI;
1571 }
1572 // We have a generic lambda if we parsed auto parameters, or we have
1573 // an associated template parameter list.
1575  if (LambdaScopeInfo *LSI = getCurLambda()) {
1576  return (LSI->AutoTemplateParams.size() ||
1577  LSI->GLTemplateParameterList) ? LSI : nullptr;
1578  }
1579  return nullptr;
1580 }
1581 
1582 
1584  if (!LangOpts.RetainCommentsFromSystemHeaders &&
1585  SourceMgr.isInSystemHeader(Comment.getBegin()))
1586  return;
1587  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1588  if (RC.isAlmostTrailingComment()) {
1589  SourceRange MagicMarkerRange(Comment.getBegin(),
1590  Comment.getBegin().getLocWithOffset(3));
1591  StringRef MagicMarkerText;
1592  switch (RC.getKind()) {
1594  MagicMarkerText = "///<";
1595  break;
1597  MagicMarkerText = "/**<";
1598  break;
1599  default:
1600  llvm_unreachable("if this is an almost Doxygen comment, "
1601  "it should be ordinary");
1602  }
1603  Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1604  FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1605  }
1606  Context.addComment(RC);
1607 }
1608 
1609 // Pin this vtable to this file.
1611 
1614 
1616  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1617 }
1618 
1620  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1621 
1623  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1624 
1625 /// Figure out if an expression could be turned into a call.
1626 ///
1627 /// Use this when trying to recover from an error where the programmer may have
1628 /// written just the name of a function instead of actually calling it.
1629 ///
1630 /// \param E - The expression to examine.
1631 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1632 /// with no arguments, this parameter is set to the type returned by such a
1633 /// call; otherwise, it is set to an empty QualType.
1634 /// \param OverloadSet - If the expression is an overloaded function
1635 /// name, this parameter is populated with the decls of the various overloads.
1636 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1637  UnresolvedSetImpl &OverloadSet) {
1638  ZeroArgCallReturnTy = QualType();
1639  OverloadSet.clear();
1640 
1641  const OverloadExpr *Overloads = nullptr;
1642  bool IsMemExpr = false;
1643  if (E.getType() == Context.OverloadTy) {
1644  OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1645 
1646  // Ignore overloads that are pointer-to-member constants.
1647  if (FR.HasFormOfMemberPointer)
1648  return false;
1649 
1650  Overloads = FR.Expression;
1651  } else if (E.getType() == Context.BoundMemberTy) {
1652  Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1653  IsMemExpr = true;
1654  }
1655 
1656  bool Ambiguous = false;
1657  bool IsMV = false;
1658 
1659  if (Overloads) {
1660  for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1661  DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1662  OverloadSet.addDecl(*it);
1663 
1664  // Check whether the function is a non-template, non-member which takes no
1665  // arguments.
1666  if (IsMemExpr)
1667  continue;
1668  if (const FunctionDecl *OverloadDecl
1669  = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1670  if (OverloadDecl->getMinRequiredArguments() == 0) {
1671  if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1672  (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1673  OverloadDecl->isCPUSpecificMultiVersion()))) {
1674  ZeroArgCallReturnTy = QualType();
1675  Ambiguous = true;
1676  } else {
1677  ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1678  IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1679  OverloadDecl->isCPUSpecificMultiVersion();
1680  }
1681  }
1682  }
1683  }
1684 
1685  // If it's not a member, use better machinery to try to resolve the call
1686  if (!IsMemExpr)
1687  return !ZeroArgCallReturnTy.isNull();
1688  }
1689 
1690  // Attempt to call the member with no arguments - this will correctly handle
1691  // member templates with defaults/deduction of template arguments, overloads
1692  // with default arguments, etc.
1693  if (IsMemExpr && !E.isTypeDependent()) {
1694  bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1697  None, SourceLocation());
1699  if (R.isUsable()) {
1700  ZeroArgCallReturnTy = R.get()->getType();
1701  return true;
1702  }
1703  return false;
1704  }
1705 
1706  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1707  if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1708  if (Fun->getMinRequiredArguments() == 0)
1709  ZeroArgCallReturnTy = Fun->getReturnType();
1710  return true;
1711  }
1712  }
1713 
1714  // We don't have an expression that's convenient to get a FunctionDecl from,
1715  // but we can at least check if the type is "function of 0 arguments".
1716  QualType ExprTy = E.getType();
1717  const FunctionType *FunTy = nullptr;
1718  QualType PointeeTy = ExprTy->getPointeeType();
1719  if (!PointeeTy.isNull())
1720  FunTy = PointeeTy->getAs<FunctionType>();
1721  if (!FunTy)
1722  FunTy = ExprTy->getAs<FunctionType>();
1723 
1724  if (const FunctionProtoType *FPT =
1725  dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1726  if (FPT->getNumParams() == 0)
1727  ZeroArgCallReturnTy = FunTy->getReturnType();
1728  return true;
1729  }
1730  return false;
1731 }
1732 
1733 /// Give notes for a set of overloads.
1734 ///
1735 /// A companion to tryExprAsCall. In cases when the name that the programmer
1736 /// wrote was an overloaded function, we may be able to make some guesses about
1737 /// plausible overloads based on their return types; such guesses can be handed
1738 /// off to this method to be emitted as notes.
1739 ///
1740 /// \param Overloads - The overloads to note.
1741 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1742 /// -fshow-overloads=best, this is the location to attach to the note about too
1743 /// many candidates. Typically this will be the location of the original
1744 /// ill-formed expression.
1745 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1746  const SourceLocation FinalNoteLoc) {
1747  int ShownOverloads = 0;
1748  int SuppressedOverloads = 0;
1749  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1750  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1751  // FIXME: Magic number for max shown overloads stolen from
1752  // OverloadCandidateSet::NoteCandidates.
1753  if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1754  ++SuppressedOverloads;
1755  continue;
1756  }
1757 
1758  NamedDecl *Fn = (*It)->getUnderlyingDecl();
1759  // Don't print overloads for non-default multiversioned functions.
1760  if (const auto *FD = Fn->getAsFunction()) {
1761  if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1762  !FD->getAttr<TargetAttr>()->isDefaultVersion())
1763  continue;
1764  }
1765  S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1766  ++ShownOverloads;
1767  }
1768 
1769  if (SuppressedOverloads)
1770  S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1771  << SuppressedOverloads;
1772 }
1773 
1775  const UnresolvedSetImpl &Overloads,
1776  bool (*IsPlausibleResult)(QualType)) {
1777  if (!IsPlausibleResult)
1778  return noteOverloads(S, Overloads, Loc);
1779 
1780  UnresolvedSet<2> PlausibleOverloads;
1781  for (OverloadExpr::decls_iterator It = Overloads.begin(),
1782  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1783  const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1784  QualType OverloadResultTy = OverloadDecl->getReturnType();
1785  if (IsPlausibleResult(OverloadResultTy))
1786  PlausibleOverloads.addDecl(It.getDecl());
1787  }
1788  noteOverloads(S, PlausibleOverloads, Loc);
1789 }
1790 
1791 /// Determine whether the given expression can be called by just
1792 /// putting parentheses after it. Notably, expressions with unary
1793 /// operators can't be because the unary operator will start parsing
1794 /// outside the call.
1795 static bool IsCallableWithAppend(Expr *E) {
1796  E = E->IgnoreImplicit();
1797  return (!isa<CStyleCastExpr>(E) &&
1798  !isa<UnaryOperator>(E) &&
1799  !isa<BinaryOperator>(E) &&
1800  !isa<CXXOperatorCallExpr>(E));
1801 }
1802 
1804  if (const auto *UO = dyn_cast<UnaryOperator>(E))
1805  E = UO->getSubExpr();
1806 
1807  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
1808  if (ULE->getNumDecls() == 0)
1809  return false;
1810 
1811  const NamedDecl *ND = *ULE->decls_begin();
1812  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
1813  return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
1814  }
1815  return false;
1816 }
1817 
1819  bool ForceComplain,
1820  bool (*IsPlausibleResult)(QualType)) {
1821  SourceLocation Loc = E.get()->getExprLoc();
1822  SourceRange Range = E.get()->getSourceRange();
1823 
1824  QualType ZeroArgCallTy;
1825  UnresolvedSet<4> Overloads;
1826  if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
1827  !ZeroArgCallTy.isNull() &&
1828  (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1829  // At this point, we know E is potentially callable with 0
1830  // arguments and that it returns something of a reasonable type,
1831  // so we can emit a fixit and carry on pretending that E was
1832  // actually a CallExpr.
1833  SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
1834  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1835  Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
1836  << (IsCallableWithAppend(E.get())
1837  ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1838  : FixItHint());
1839  if (!IsMV)
1840  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1841 
1842  // FIXME: Try this before emitting the fixit, and suppress diagnostics
1843  // while doing so.
1844  E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None,
1845  Range.getEnd().getLocWithOffset(1));
1846  return true;
1847  }
1848 
1849  if (!ForceComplain) return false;
1850 
1851  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1852  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
1853  if (!IsMV)
1854  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1855  E = ExprError();
1856  return true;
1857 }
1858 
1860  if (!Ident_super)
1861  Ident_super = &Context.Idents.get("super");
1862  return Ident_super;
1863 }
1864 
1866  if (!Ident___float128)
1867  Ident___float128 = &Context.Idents.get("__float128");
1868  return Ident___float128;
1869 }
1870 
1872  CapturedRegionKind K) {
1874  getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
1875  (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
1876  CSI->ReturnType = Context.VoidTy;
1877  FunctionScopes.push_back(CSI);
1878 }
1879 
1881  if (FunctionScopes.empty())
1882  return nullptr;
1883 
1884  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1885 }
1886 
1887 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
1889  return DeleteExprs;
1890 }
1891 
1892 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
1893  if (ExtStr.empty())
1894  return;
1896  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1897  auto CanT = T.getCanonicalType().getTypePtr();
1898  for (auto &I : Exts)
1899  OpenCLTypeExtMap[CanT].insert(I.str());
1900 }
1901 
1902 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
1904  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1905  if (Exts.empty())
1906  return;
1907  for (auto &I : Exts)
1908  OpenCLDeclExtMap[FD].insert(I.str());
1909 }
1910 
1912  if (CurrOpenCLExtension.empty())
1913  return;
1914  setOpenCLExtensionForType(T, CurrOpenCLExtension);
1915 }
1916 
1918  if (CurrOpenCLExtension.empty())
1919  return;
1920  setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
1921 }
1922 
1924  if (!OpenCLDeclExtMap.empty())
1925  return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
1926 
1927  return "";
1928 }
1929 
1931  if (!OpenCLTypeExtMap.empty())
1932  return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
1933 
1934  return "";
1935 }
1936 
1937 template <typename T, typename MapT>
1938 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
1939  std::string ExtensionNames = "";
1940  auto Loc = Map.find(FDT);
1941 
1942  for (auto const& I : Loc->second) {
1943  ExtensionNames += I;
1944  ExtensionNames += " ";
1945  }
1946  ExtensionNames.pop_back();
1947 
1948  return ExtensionNames;
1949 }
1950 
1952  auto Loc = OpenCLDeclExtMap.find(FD);
1953  if (Loc == OpenCLDeclExtMap.end())
1954  return false;
1955  for (auto &I : Loc->second) {
1956  if (!getOpenCLOptions().isEnabled(I))
1957  return true;
1958  }
1959  return false;
1960 }
1961 
1962 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
1963 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
1964  DiagInfoT DiagInfo, MapT &Map,
1965  unsigned Selector,
1966  SourceRange SrcRange) {
1967  auto Loc = Map.find(D);
1968  if (Loc == Map.end())
1969  return false;
1970  bool Disabled = false;
1971  for (auto &I : Loc->second) {
1972  if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
1973  Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
1974  << I << SrcRange;
1975  Disabled = true;
1976  }
1977  }
1978  return Disabled;
1979 }
1980 
1982  // Check extensions for declared types.
1983  Decl *Decl = nullptr;
1984  if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
1985  Decl = TypedefT->getDecl();
1986  if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
1987  Decl = TagT->getDecl();
1988  auto Loc = DS.getTypeSpecTypeLoc();
1989 
1990  // Check extensions for vector types.
1991  // e.g. double4 is not allowed when cl_khr_fp64 is absent.
1992  if (QT->isExtVectorType()) {
1993  auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
1994  return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
1995  }
1996 
1997  if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
1998  return true;
1999 
2000  // Check extensions for builtin types.
2001  return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2002  QT, OpenCLTypeExtMap);
2003 }
2004 
2006  IdentifierInfo *FnName = D.getIdentifier();
2007  return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2008  OpenCLDeclExtMap, 1, D.getSourceRange());
2009 }
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:2454
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:2419
Defines the clang::ASTContext interface.
ObjCInterfaceDecl * NSStringDecl
The declaration of the Objective-C NSString class.
Definition: Sema.h:878
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:611
Represents a function declaration or definition.
Definition: Decl.h:1738
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition: Sema.h:573
bool hasErrorOccurred() const
Definition: Diagnostic.h:747
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
Definition: TargetInfo.h:759
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
CanQualType OCLQueueTy
Definition: ASTContext.h:1054
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:3864
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
TypedefDecl * getCFConstantStringDecl() const
A (possibly-)qualified type.
Definition: Type.h:638
ASTConsumer & Consumer
Definition: Sema.h:325
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:653
void Initialize()
Perform initialization that occurs after the parser has been initialized but before it parses anythin...
Definition: Sema.cpp:186
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:34
DeclContext * getFunctionLevelDeclContext()
Definition: Sema.cpp:1183
RecordDecl * MSVCGuidDecl
The MSVC "_GUID" struct, which is defined in MSVC header files.
Definition: Sema.h:857
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3055
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:676
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:11736
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:556
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:3355
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:650
static void notePlausibleOverloads(Sema &S, SourceLocation Loc, const UnresolvedSetImpl &Overloads, bool(*IsPlausibleResult)(QualType))
Definition: Sema.cpp:1774
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:625
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:86
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1308
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
Module * getCurrentModule()
Retrieves the module that we&#39;re currently building, if any.
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
bool isExtVectorType() const
Definition: Type.h:6385
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2132
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed...
Definition: Sema.h:7649
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with the preprocessor.
Definition: Sema.cpp:50
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:828
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:368
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7286
virtual void updateOutOfDateSelector(Selector Sel)
Load the contents of the global method pool for a given selector if necessary.
Definition: Sema.cpp:1613
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:1612
CanQualType LongTy
Definition: ASTContext.h:1025
Any normal BCPL comments.
Declaration of a variable template.
static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E)
Definition: Sema.cpp:1803
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
A container of type source information.
Definition: Decl.h:87
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3589
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:626
IdentifierInfo * getSuperIdentifier() const
Definition: Sema.cpp:1859
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:7327
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1262
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3169
IdentifierInfo * getFloat128Identifier() const
Definition: Sema.cpp:1865
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:7620
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:97
std::string getOpenCLExtensionsFromTypeExtMap(FunctionType *FT)
Check if a function type FT associates with any extensions present in OpenCLTypeExtMap and if so retu...
Definition: Sema.cpp:1930
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10853
Compiling a C++ modules TS module interface unit.
Definition: LangOptions.h:85
Represents a variable declaration or definition.
Definition: Decl.h:813
QualType getReturnType() const
Definition: Decl.h:2302
DiagnosticsEngine & Diags
Definition: Sema.h:326
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:6748
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2178
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:432
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:10764
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1135
Expr * IgnoreImplicit() LLVM_READONLY
IgnoreImplicit - Skip past any implicit AST nodes which might surround this expression.
Definition: Expr.h:747
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:655
bool isInvalidDecl() const
Definition: DeclBase.h:542
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
ObjCMethodDecl * ValueWithBytesObjCTypeMethod
The declaration of the valueWithBytes:objCType: method.
Definition: Sema.h:887
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:36
OpenCLOptions & getOpenCLOptions()
Definition: Sema.h:1232
Defines the clang::Expr interface and subclasses for C++ expressions.
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
Definition: Sema.h:896
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:1888
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:5408
void threadSafetyCleanup(BeforeSet *Cache)
CanQualType OCLSamplerTy
Definition: ASTContext.h:1053
void CheckDelayedMemberExceptionSpecs()
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
Represents a struct/union/class.
Definition: Decl.h:3593
void FreeVisContext()
FreeVisContext - Deallocate and null out VisContext.
Definition: SemaAttr.cpp:767
An iterator over the friend declarations of a class.
Definition: DeclFriend.h:188
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:298
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:860
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7616
virtual void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls)
Read the set of potentially unused typedefs known to the source.
void enableSupportedCore(unsigned CLVer)
bool doesNotEscape() const
Definition: Decl.h:4009
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:633
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.cpp:1538
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
Definition: ModuleMap.cpp:1275
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1574
unsigned getCurrentDiagID() const
Definition: Diagnostic.h:989
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7520
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:515
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1523
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:288
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:1911
Represents a member of a struct/union/class.
Definition: Decl.h:2579
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:4109
void setEscapingByref()
Definition: Decl.h:1420
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:7635
ObjCInterfaceDecl * NSValueDecl
The declaration of the Objective-C NSValue class.
Definition: Sema.h:866
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:1053
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:406
llvm::SmallPtrSet< const BlockDecl *, 1 > Blocks
The set of blocks that are introduced in this function.
Definition: ScopeInfo.h:207
void setFunctionHasBranchIntoScope()
Definition: Sema.cpp:1508
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3538
void setVisible(Module *M, SourceLocation Loc, VisibleCallback Vis=[](Module *) {}, ConflictCallback Cb=[](ArrayRef< Module *>, Module *, StringRef) {})
Make a specific module visible.
Definition: Module.cpp:598
void setPrintingPolicy(const clang::PrintingPolicy &Policy)
Definition: ASTContext.h:658
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:1951
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1054
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:815
Describes a module or submodule.
Definition: Module.h:65
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1112
IdentifierTable & Idents
Definition: ASTContext.h:566
static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc)
Give notes for a set of overloads.
Definition: Sema.cpp:1745
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors...
Definition: Sema.h:6111
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:110
static InitializedEntity InitializeBlock(SourceLocation BlockVarLoc, QualType Type, bool NRVO)
Values of this type can be null.
iterator end()
end - Returns an iterator that has &#39;finished&#39;.
DiagnosticErrorTrap ErrorTrap
Used to determine if errors occurred in this function or block.
Definition: ScopeInfo.h:177
An abstract interface that should be implemented by clients that read ASTs and then require further s...
Definition: SemaConsumer.h:26
unsigned TyposCorrected
The number of typos corrected by CorrectTypo.
Definition: Sema.h:7623
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
Definition: Decl.cpp:2115
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:1332
Module * createGlobalModuleForInterfaceUnit(SourceLocation Loc)
Create a &#39;global module&#39; for a C++ Modules TS module interface unit.
Definition: ModuleMap.cpp:810
PtrTy get() const
Definition: Ownership.h:174
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:422
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:821
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1327
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:1981
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:405
std::pair< SourceLocation, bool > DeleteExprLoc
Delete-expressions to be analyzed at the end of translation unit.
Definition: Sema.h:580
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:654
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:61
void IssueWarnings(Policy P, FunctionScopeInfo *fscope, const Decl *D, const BlockExpr *blkExpr)
void CheckDelegatingCtorCycles()
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:9391
friend_iterator friend_end() const
Definition: DeclFriend.h:244
~ExternalSemaSource() override
Definition: Sema.cpp:1610
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:41
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6072
static const unsigned NumNSNumberLiteralMethods
Definition: NSAPI.h:195
submodule_iterator submodule_end()
Definition: Module.h:558
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:991
virtual ASTMutationListener * GetASTMutationListener()
If the consumer is interested in entities getting modified after their initial creation, it should return a pointer to an ASTMutationListener here.
Definition: ASTConsumer.h:124
Preprocessor & PP
Definition: Sema.h:323
ObjCInterfaceDecl * NSNumberDecl
The declaration of the Objective-C NSNumber class.
Definition: Sema.h:863
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:1615
const LangOptions & getLangOpts() const
Definition: Sema.h:1231
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:167
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
Definition: Sema.h:7634
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4044
NamespaceDecl * StdExperimentalNamespaceCache
The C++ "std::experimental" namespace, where the experimental parts of the standard library resides...
Definition: Sema.h:843
ObjCMethodDecl * StringWithUTF8StringMethod
The declaration of the stringWithUTF8String: method.
Definition: Sema.h:884
void DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc)
Definition: SemaAttr.cpp:216
const LangOptions & LangOpts
Definition: Sema.h:322
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:2005
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:67
bool EmitCurrentDiagnostic(bool Force=false)
Emit the current diagnostic and clear the diagnostic state.
Definition: Diagnostic.cpp:499
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1235
static bool IsCallableWithAppend(Expr *E)
Determine whether the given expression can be called by just putting parentheses after it...
Definition: Sema.cpp:1795
bool hasAttr() const
Definition: DeclBase.h:531
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:103
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1613
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3687
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:603
Retains information about a captured region.
Definition: ScopeInfo.h:737
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:1491
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:689
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:1844
void PopCompoundScope()
Definition: Sema.cpp:1495
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:1622
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:1513
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:39
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:10729
unsigned Offset
Definition: Format.cpp:1631
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:236
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
Definition: Sema.h:7653
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:711
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...
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3858
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
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:106
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:1902
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:771
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:107
bool isAlmostTrailingComment() const LLVM_READONLY
Returns true if it is a probable typo:
int Id
Definition: ASTDiff.cpp:191
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:593
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2695
TypedefDecl * buildImplicitTypedef(QualType T, StringRef Name) const
Create a new implicit TU-level typedef declaration.
void addImplicitTypedef(StringRef Name, QualType T)
Definition: Sema.cpp:180
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6811
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5177
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2706
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
Definition: Sema.h:7318
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
Definition: Type.h:6569
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:804
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Not compiling a module interface at all.
Definition: LangOptions.h:76
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy inialization expression of a block var decl.
DeclContext * getDeclContext()
Definition: DeclBase.h:427
void PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, const BlockExpr *blkExpr=nullptr)
Definition: Sema.cpp:1464
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
Definition: ModuleMap.cpp:1249
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:1967
decls_iterator decls_begin() const
Definition: ExprCXX.h:2727
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7603
int Depth
Definition: ASTDiff.cpp:191
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:981
QualType getType() const
Definition: Expr.h:128
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:881
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:552
PartialDiagnostic::StorageAllocator & getDiagAllocator()
Definition: ASTContext.h:686
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:1752
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:86
bool isInvalid() const
Definition: Ownership.h:170
SourceLocation getEnd() const
Preprocessor & getPreprocessor() const
Definition: Sema.h:1237
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:893
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1342
bool isUsable() const
Definition: Ownership.h:171
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1396
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:250
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:703
const SourceManager & SM
Definition: Format.cpp:1490
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:660
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1115
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:6131
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:1391
CanQualType OverloadTy
Definition: ASTContext.h:1045
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:854
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2635
QualType getCanonicalType() const
Definition: Type.h:6111
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
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:3613
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:1917
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:784
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:1371
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:1923
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:847
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2041
void DiagnoseUseOfUnimplementedSelectors()
CanQualType FloatTy
Definition: ASTContext.h:1028
CanQualType VoidTy
Definition: ASTContext.h:1016
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:89
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie)
Definition: Diagnostic.h:792
virtual void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined)
Load the set of used but not defined functions or variables with internal linkage, or used but not defined internal functions.
Definition: Sema.cpp:1619
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:1147
void addSupport(const OpenCLOptions &Opts)
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3115
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:240
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:397
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition: Sema.h:564
static bool isFunctionOrVarDeclExternC(NamedDecl *ND)
Definition: Sema.cpp:607
sema::CapturedRegionScopeInfo * getCurCapturedRegion()
Retrieve the current captured region, if any.
Definition: Sema.cpp:1880
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:1239
void setLastDiagnosticIgnored(bool Ignored=true)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:668
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:1892
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1954
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2916
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:654
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:7351
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
ObjCMethodDecl * NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]
The Objective-C NSNumber methods used to create NSNumber literals.
Definition: Sema.h:875
static void checkEscapingByref(VarDecl *VD, Sema &S)
Definition: Sema.cpp:1413
ArrayRef< Capture > captures() const
Definition: Decl.h:3985
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:1402
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
Definition: SemaDecl.cpp:1555
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include&#39;d file otherwise it returns an invalid location...
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:78
ClassTemplateDecl * StdCoroutineTraitsCache
The C++ "std::coroutine_traits" template, which is defined in <coroutine_traits>
Definition: Sema.h:851
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:909
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:1818
A set of unresolved declarations.
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created...
Definition: Diagnostic.h:1016
IdentifierResolver IdResolver
Definition: Sema.h:823
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:2374
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i...
Definition: LangOptions.h:251
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
Definition: Sema.cpp:529
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1083
Abstract interface for a module loader.
Definition: ModuleLoader.h:74
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:1938
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
Definition: Sema.cpp:1504
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2693
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:582
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:710
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
DeclarationName VAListTagName
VAListTagName - The declaration name corresponding to __va_list_tag.
Definition: Sema.h:344
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:1026
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:1438
void * OpaqueParser
Definition: Sema.h:655
ExtVectorType - Extended vector type.
Definition: Type.h:3287
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:7242
CanQualType BoundMemberTy
Definition: ASTContext.h:1045
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1041
void addComment(const RawComment &RC)
Definition: ASTContext.h:803
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
Definition: Sema.h:890
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:3696
The "class" keyword.
Definition: Type.h:5042
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:511
std::unique_ptr< sema::FunctionScopeInfo > PreallocatedFunctionScope
Definition: Sema.h:548
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2070
This is a scope that can contain a declaration.
Definition: Scope.h:60
SourceManager & getSourceManager()
Definition: ASTContext.h:662
The type-property cache.
Definition: Type.cpp:3448
void ActOnTranslationUnitScope(Scope *S)
Definition: Sema.cpp:69
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:1360
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2253
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:3076
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1009
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:633
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:496
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:691
static SFINAEResponse getDiagnosticSFINAEResponse(unsigned DiagID)
Determines whether the given built-in diagnostic ID is for an error that is suppressed if it occurs d...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
CommentKind getKind() const LLVM_READONLY
void setFunctionHasIndirectGoto()
Definition: Sema.cpp:1518
Represents a C array with an unspecified size.
Definition: Type.h:2926
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1358
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:336
bool isRValue() const
Definition: Expr.h:250
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:362
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
void addAttr(Attr *A)
Definition: DeclBase.cpp:840
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C &#39;Class&#39; type...
SourceManager & getSourceManager() const
Definition: Sema.h:1236
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:276
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
Definition: Sema.cpp:1636
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1316
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:1110
Defines the clang::TargetInfo interface.
bool isIncrementalProcessingEnabled() const
Returns true if incremental processing is enabled.
ExprResult ExprError()
Definition: Ownership.h:283
The diagnostic should be reported.
CanQualType IntTy
Definition: ASTContext.h:1025
void ActOnComment(SourceRange Comment)
Definition: Sema.cpp:1583
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:226
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:1041
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:819
bool isUnion() const
Definition: Decl.h:3252
NamedDecl * getMostRecentDecl()
Definition: Decl.h:446
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2136
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1158
SourceManager & SourceMgr
Definition: Sema.h:327
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:17
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound stamement scopes in the function.
Definition: ScopeInfo.h:204
QualType getType() const
Definition: Decl.h:648
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:114
virtual void CompleteTentativeDefinition(VarDecl *D)
CompleteTentativeDefinition - Callback invoked at the end of a translation unit to notify the consume...
Definition: ASTConsumer.h:104
A trivial tuple used to represent a source range.
llvm::TinyPtrVector< VarDecl * > ByrefBlockVars
The set of __block variables that are introduced in this function.
Definition: ScopeInfo.h:210
ASTContext & Context
Definition: Sema.h:324
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:249
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K)
Definition: Sema.cpp:1871
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1550
CanQualType DoubleTy
Definition: ASTContext.h:1028
IdentifierInfo * getBoolName() const
Retrieve the identifier &#39;bool&#39;.
Definition: ASTContext.h:1710
void setType(QualType newType)
Definition: Decl.h:649
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:707
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:2730
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:643
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:908
This class handles loading and caching of source files into memory.
void PrintContextStack()
Definition: Sema.h:7524
OpenCLOptions & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1290
bool getSuppressAllDiagnostics() const
Definition: Diagnostic.h:636
Declaration of a template function.
Definition: DeclTemplate.h:969
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1379
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:569
SourceLocation getLocation() const
Definition: DeclBase.h:418
bool isExternallyVisible() const
Definition: Decl.h:380
CanQualType OCLClkEventTy
Definition: ASTContext.h:1053
ObjCMethodDecl * DictionaryWithObjectsMethod
The declaration of the dictionaryWithObjects:forKeys:count: method.
Definition: Sema.h:899
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1261
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2560
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125
This is a C++ Modules TS module interface unit.
Definition: Module.h:79
CanQualType UnsignedIntTy
Definition: ASTContext.h:1026
decl_iterator decls_end() const
Definition: DeclBase.h:1999
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:376
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:54
The translation unit is a module.
Definition: LangOptions.h:371