clang  8.0.0svn
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  // Initilization 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 = new (S.Context) DeclRefExpr(VD, false, T, VK_LValue, Loc);
1420  InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1421  VarRef, /*AllowNRVO=*/true);
1422  if (!Result.isInvalid()) {
1423  Result = S.MaybeCreateExprWithCleanups(Result);
1424  Expr *Init = Result.getAs<Expr>();
1425  S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1426  }
1427 
1428  // The destructor's exception spefication is needed when IRGen generates
1429  // block copy/destroy functions. Resolve it here.
1430  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1431  if (CXXDestructorDecl *DD = RD->getDestructor()) {
1432  auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1433  S.ResolveExceptionSpec(Loc, FPT);
1434  }
1435 }
1436 
1437 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1438  // Set the EscapingByref flag of __block variables captured by
1439  // escaping blocks.
1440  for (const BlockDecl *BD : FSI.Blocks) {
1441  if (BD->doesNotEscape())
1442  continue;
1443  for (const BlockDecl::Capture &BC : BD->captures()) {
1444  VarDecl *VD = BC.getVariable();
1445  if (VD->hasAttr<BlocksAttr>())
1446  VD->setEscapingByref();
1447  }
1448  }
1449 
1450  for (VarDecl *VD : FSI.ByrefBlockVars) {
1451  // __block variables might require us to capture a copy-initializer.
1452  if (!VD->isEscapingByref())
1453  continue;
1454  // It's currently invalid to ever have a __block variable with an
1455  // array type; should we diagnose that here?
1456  // Regardless, we don't want to ignore array nesting when
1457  // constructing this copy.
1458  if (VD->getType()->isStructureOrClassType())
1459  checkEscapingByref(VD, S);
1460  }
1461 }
1462 
1464  const Decl *D, const BlockExpr *blkExpr) {
1465  assert(!FunctionScopes.empty() && "mismatched push/pop!");
1466 
1467  // This function shouldn't be called after popping the current function scope.
1468  // markEscapingByrefs calls PerformMoveOrCopyInitialization, which can call
1469  // PushFunctionScope, which can cause clearing out PreallocatedFunctionScope
1470  // when FunctionScopes is empty.
1471  markEscapingByrefs(*FunctionScopes.back(), *this);
1472 
1473  FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
1474 
1475  if (LangOpts.OpenMP)
1476  popOpenMPFunctionRegion(Scope);
1477 
1478  // Issue any analysis-based warnings.
1479  if (WP && D)
1480  AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
1481  else
1482  for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1483  Diag(PUD.Loc, PUD.PD);
1484 
1485  // Delete the scope unless its our preallocated scope.
1486  if (Scope != PreallocatedFunctionScope.get())
1487  delete Scope;
1488 }
1489 
1490 void Sema::PushCompoundScope(bool IsStmtExpr) {
1491  getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1492 }
1493 
1495  FunctionScopeInfo *CurFunction = getCurFunction();
1496  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1497 
1498  CurFunction->CompoundScopes.pop_back();
1499 }
1500 
1501 /// Determine whether any errors occurred within this function/method/
1502 /// block.
1505 }
1506 
1508  if (!FunctionScopes.empty())
1509  FunctionScopes.back()->setHasBranchIntoScope();
1510 }
1511 
1513  if (!FunctionScopes.empty())
1514  FunctionScopes.back()->setHasBranchProtectedScope();
1515 }
1516 
1518  if (!FunctionScopes.empty())
1519  FunctionScopes.back()->setHasIndirectGoto();
1520 }
1521 
1523  if (FunctionScopes.empty())
1524  return nullptr;
1525 
1526  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1527  if (CurBSI && CurBSI->TheDecl &&
1528  !CurBSI->TheDecl->Encloses(CurContext)) {
1529  // We have switched contexts due to template instantiation.
1530  assert(!CodeSynthesisContexts.empty());
1531  return nullptr;
1532  }
1533 
1534  return CurBSI;
1535 }
1536 
1538  if (FunctionScopes.empty())
1539  return nullptr;
1540 
1541  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1542  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1543  continue;
1544  return FunctionScopes[e];
1545  }
1546  return nullptr;
1547 }
1548 
1549 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1550  if (FunctionScopes.empty())
1551  return nullptr;
1552 
1553  auto I = FunctionScopes.rbegin();
1554  if (IgnoreNonLambdaCapturingScope) {
1555  auto E = FunctionScopes.rend();
1556  while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1557  ++I;
1558  if (I == E)
1559  return nullptr;
1560  }
1561  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1562  if (CurLSI && CurLSI->Lambda &&
1563  !CurLSI->Lambda->Encloses(CurContext)) {
1564  // We have switched contexts due to template instantiation.
1565  assert(!CodeSynthesisContexts.empty());
1566  return nullptr;
1567  }
1568 
1569  return CurLSI;
1570 }
1571 // We have a generic lambda if we parsed auto parameters, or we have
1572 // an associated template parameter list.
1574  if (LambdaScopeInfo *LSI = getCurLambda()) {
1575  return (LSI->AutoTemplateParams.size() ||
1576  LSI->GLTemplateParameterList) ? LSI : nullptr;
1577  }
1578  return nullptr;
1579 }
1580 
1581 
1583  if (!LangOpts.RetainCommentsFromSystemHeaders &&
1584  SourceMgr.isInSystemHeader(Comment.getBegin()))
1585  return;
1586  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1587  if (RC.isAlmostTrailingComment()) {
1588  SourceRange MagicMarkerRange(Comment.getBegin(),
1589  Comment.getBegin().getLocWithOffset(3));
1590  StringRef MagicMarkerText;
1591  switch (RC.getKind()) {
1593  MagicMarkerText = "///<";
1594  break;
1596  MagicMarkerText = "/**<";
1597  break;
1598  default:
1599  llvm_unreachable("if this is an almost Doxygen comment, "
1600  "it should be ordinary");
1601  }
1602  Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1603  FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1604  }
1605  Context.addComment(RC);
1606 }
1607 
1608 // Pin this vtable to this file.
1610 
1613 
1615  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1616 }
1617 
1619  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1620 
1622  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1623 
1624 /// Figure out if an expression could be turned into a call.
1625 ///
1626 /// Use this when trying to recover from an error where the programmer may have
1627 /// written just the name of a function instead of actually calling it.
1628 ///
1629 /// \param E - The expression to examine.
1630 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1631 /// with no arguments, this parameter is set to the type returned by such a
1632 /// call; otherwise, it is set to an empty QualType.
1633 /// \param OverloadSet - If the expression is an overloaded function
1634 /// name, this parameter is populated with the decls of the various overloads.
1635 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1636  UnresolvedSetImpl &OverloadSet) {
1637  ZeroArgCallReturnTy = QualType();
1638  OverloadSet.clear();
1639 
1640  const OverloadExpr *Overloads = nullptr;
1641  bool IsMemExpr = false;
1642  if (E.getType() == Context.OverloadTy) {
1643  OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1644 
1645  // Ignore overloads that are pointer-to-member constants.
1646  if (FR.HasFormOfMemberPointer)
1647  return false;
1648 
1649  Overloads = FR.Expression;
1650  } else if (E.getType() == Context.BoundMemberTy) {
1651  Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1652  IsMemExpr = true;
1653  }
1654 
1655  bool Ambiguous = false;
1656  bool IsMV = false;
1657 
1658  if (Overloads) {
1659  for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1660  DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1661  OverloadSet.addDecl(*it);
1662 
1663  // Check whether the function is a non-template, non-member which takes no
1664  // arguments.
1665  if (IsMemExpr)
1666  continue;
1667  if (const FunctionDecl *OverloadDecl
1668  = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1669  if (OverloadDecl->getMinRequiredArguments() == 0) {
1670  if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1671  (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1672  OverloadDecl->isCPUSpecificMultiVersion()))) {
1673  ZeroArgCallReturnTy = QualType();
1674  Ambiguous = true;
1675  } else {
1676  ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1677  IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1678  OverloadDecl->isCPUSpecificMultiVersion();
1679  }
1680  }
1681  }
1682  }
1683 
1684  // If it's not a member, use better machinery to try to resolve the call
1685  if (!IsMemExpr)
1686  return !ZeroArgCallReturnTy.isNull();
1687  }
1688 
1689  // Attempt to call the member with no arguments - this will correctly handle
1690  // member templates with defaults/deduction of template arguments, overloads
1691  // with default arguments, etc.
1692  if (IsMemExpr && !E.isTypeDependent()) {
1693  bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1696  None, SourceLocation());
1698  if (R.isUsable()) {
1699  ZeroArgCallReturnTy = R.get()->getType();
1700  return true;
1701  }
1702  return false;
1703  }
1704 
1705  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1706  if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1707  if (Fun->getMinRequiredArguments() == 0)
1708  ZeroArgCallReturnTy = Fun->getReturnType();
1709  return true;
1710  }
1711  }
1712 
1713  // We don't have an expression that's convenient to get a FunctionDecl from,
1714  // but we can at least check if the type is "function of 0 arguments".
1715  QualType ExprTy = E.getType();
1716  const FunctionType *FunTy = nullptr;
1717  QualType PointeeTy = ExprTy->getPointeeType();
1718  if (!PointeeTy.isNull())
1719  FunTy = PointeeTy->getAs<FunctionType>();
1720  if (!FunTy)
1721  FunTy = ExprTy->getAs<FunctionType>();
1722 
1723  if (const FunctionProtoType *FPT =
1724  dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1725  if (FPT->getNumParams() == 0)
1726  ZeroArgCallReturnTy = FunTy->getReturnType();
1727  return true;
1728  }
1729  return false;
1730 }
1731 
1732 /// Give notes for a set of overloads.
1733 ///
1734 /// A companion to tryExprAsCall. In cases when the name that the programmer
1735 /// wrote was an overloaded function, we may be able to make some guesses about
1736 /// plausible overloads based on their return types; such guesses can be handed
1737 /// off to this method to be emitted as notes.
1738 ///
1739 /// \param Overloads - The overloads to note.
1740 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1741 /// -fshow-overloads=best, this is the location to attach to the note about too
1742 /// many candidates. Typically this will be the location of the original
1743 /// ill-formed expression.
1744 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1745  const SourceLocation FinalNoteLoc) {
1746  int ShownOverloads = 0;
1747  int SuppressedOverloads = 0;
1748  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1749  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1750  // FIXME: Magic number for max shown overloads stolen from
1751  // OverloadCandidateSet::NoteCandidates.
1752  if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1753  ++SuppressedOverloads;
1754  continue;
1755  }
1756 
1757  NamedDecl *Fn = (*It)->getUnderlyingDecl();
1758  // Don't print overloads for non-default multiversioned functions.
1759  if (const auto *FD = Fn->getAsFunction()) {
1760  if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1761  !FD->getAttr<TargetAttr>()->isDefaultVersion())
1762  continue;
1763  }
1764  S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1765  ++ShownOverloads;
1766  }
1767 
1768  if (SuppressedOverloads)
1769  S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1770  << SuppressedOverloads;
1771 }
1772 
1774  const UnresolvedSetImpl &Overloads,
1775  bool (*IsPlausibleResult)(QualType)) {
1776  if (!IsPlausibleResult)
1777  return noteOverloads(S, Overloads, Loc);
1778 
1779  UnresolvedSet<2> PlausibleOverloads;
1780  for (OverloadExpr::decls_iterator It = Overloads.begin(),
1781  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1782  const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1783  QualType OverloadResultTy = OverloadDecl->getReturnType();
1784  if (IsPlausibleResult(OverloadResultTy))
1785  PlausibleOverloads.addDecl(It.getDecl());
1786  }
1787  noteOverloads(S, PlausibleOverloads, Loc);
1788 }
1789 
1790 /// Determine whether the given expression can be called by just
1791 /// putting parentheses after it. Notably, expressions with unary
1792 /// operators can't be because the unary operator will start parsing
1793 /// outside the call.
1794 static bool IsCallableWithAppend(Expr *E) {
1795  E = E->IgnoreImplicit();
1796  return (!isa<CStyleCastExpr>(E) &&
1797  !isa<UnaryOperator>(E) &&
1798  !isa<BinaryOperator>(E) &&
1799  !isa<CXXOperatorCallExpr>(E));
1800 }
1801 
1803  if (const auto *UO = dyn_cast<UnaryOperator>(E))
1804  E = UO->getSubExpr();
1805 
1806  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
1807  if (ULE->getNumDecls() == 0)
1808  return false;
1809 
1810  const NamedDecl *ND = *ULE->decls_begin();
1811  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
1812  return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
1813  }
1814  return false;
1815 }
1816 
1818  bool ForceComplain,
1819  bool (*IsPlausibleResult)(QualType)) {
1820  SourceLocation Loc = E.get()->getExprLoc();
1821  SourceRange Range = E.get()->getSourceRange();
1822 
1823  QualType ZeroArgCallTy;
1824  UnresolvedSet<4> Overloads;
1825  if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
1826  !ZeroArgCallTy.isNull() &&
1827  (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1828  // At this point, we know E is potentially callable with 0
1829  // arguments and that it returns something of a reasonable type,
1830  // so we can emit a fixit and carry on pretending that E was
1831  // actually a CallExpr.
1832  SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
1833  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1834  Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
1835  << (IsCallableWithAppend(E.get())
1836  ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1837  : FixItHint());
1838  if (!IsMV)
1839  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1840 
1841  // FIXME: Try this before emitting the fixit, and suppress diagnostics
1842  // while doing so.
1843  E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None,
1844  Range.getEnd().getLocWithOffset(1));
1845  return true;
1846  }
1847 
1848  if (!ForceComplain) return false;
1849 
1850  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1851  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
1852  if (!IsMV)
1853  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1854  E = ExprError();
1855  return true;
1856 }
1857 
1859  if (!Ident_super)
1860  Ident_super = &Context.Idents.get("super");
1861  return Ident_super;
1862 }
1863 
1865  if (!Ident___float128)
1866  Ident___float128 = &Context.Idents.get("__float128");
1867  return Ident___float128;
1868 }
1869 
1871  CapturedRegionKind K) {
1873  getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
1874  (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
1875  CSI->ReturnType = Context.VoidTy;
1876  FunctionScopes.push_back(CSI);
1877 }
1878 
1880  if (FunctionScopes.empty())
1881  return nullptr;
1882 
1883  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1884 }
1885 
1886 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
1888  return DeleteExprs;
1889 }
1890 
1891 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
1892  if (ExtStr.empty())
1893  return;
1895  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1896  auto CanT = T.getCanonicalType().getTypePtr();
1897  for (auto &I : Exts)
1898  OpenCLTypeExtMap[CanT].insert(I.str());
1899 }
1900 
1901 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
1903  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1904  if (Exts.empty())
1905  return;
1906  for (auto &I : Exts)
1907  OpenCLDeclExtMap[FD].insert(I.str());
1908 }
1909 
1911  if (CurrOpenCLExtension.empty())
1912  return;
1913  setOpenCLExtensionForType(T, CurrOpenCLExtension);
1914 }
1915 
1917  if (CurrOpenCLExtension.empty())
1918  return;
1919  setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
1920 }
1921 
1923  if (!OpenCLDeclExtMap.empty())
1924  return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
1925 
1926  return "";
1927 }
1928 
1930  if (!OpenCLTypeExtMap.empty())
1931  return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
1932 
1933  return "";
1934 }
1935 
1936 template <typename T, typename MapT>
1937 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
1938  std::string ExtensionNames = "";
1939  auto Loc = Map.find(FDT);
1940 
1941  for (auto const& I : Loc->second) {
1942  ExtensionNames += I;
1943  ExtensionNames += " ";
1944  }
1945  ExtensionNames.pop_back();
1946 
1947  return ExtensionNames;
1948 }
1949 
1951  auto Loc = OpenCLDeclExtMap.find(FD);
1952  if (Loc == OpenCLDeclExtMap.end())
1953  return false;
1954  for (auto &I : Loc->second) {
1955  if (!getOpenCLOptions().isEnabled(I))
1956  return true;
1957  }
1958  return false;
1959 }
1960 
1961 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
1962 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
1963  DiagInfoT DiagInfo, MapT &Map,
1964  unsigned Selector,
1965  SourceRange SrcRange) {
1966  auto Loc = Map.find(D);
1967  if (Loc == Map.end())
1968  return false;
1969  bool Disabled = false;
1970  for (auto &I : Loc->second) {
1971  if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
1972  Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
1973  << I << SrcRange;
1974  Disabled = true;
1975  }
1976  }
1977  return Disabled;
1978 }
1979 
1981  // Check extensions for declared types.
1982  Decl *Decl = nullptr;
1983  if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
1984  Decl = TypedefT->getDecl();
1985  if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
1986  Decl = TagT->getDecl();
1987  auto Loc = DS.getTypeSpecTypeLoc();
1988 
1989  // Check extensions for vector types.
1990  // e.g. double4 is not allowed when cl_khr_fp64 is absent.
1991  if (QT->isExtVectorType()) {
1992  auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
1993  return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
1994  }
1995 
1996  if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
1997  return true;
1998 
1999  // Check extensions for builtin types.
2000  return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2001  QT, OpenCLTypeExtMap);
2002 }
2003 
2005  IdentifierInfo *FnName = D.getIdentifier();
2006  return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2007  OpenCLDeclExtMap, 1, D.getSourceRange());
2008 }
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:2418
Defines the clang::ASTContext interface.
ObjCInterfaceDecl * NSStringDecl
The declaration of the Objective-C NSString class.
Definition: Sema.h:872
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:605
Represents a function declaration or definition.
Definition: Decl.h:1739
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition: Sema.h:567
bool hasErrorOccurred() const
Definition: Diagnostic.h:744
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
Definition: TargetInfo.h:755
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
CanQualType OCLQueueTy
Definition: ASTContext.h:1053
Smart pointer class that efficiently represents Objective-C method names.
A class which contains all the information about a particular captured value.
Definition: Decl.h:3873
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
TypedefDecl * getCFConstantStringDecl() const
A (possibly-)qualified type.
Definition: Type.h:642
ASTConsumer & Consumer
Definition: Sema.h:321
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:647
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:851
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3047
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:670
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:11734
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:3361
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:1773
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:619
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:1302
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:6371
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:7633
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:822
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:360
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7270
virtual void updateOutOfDateSelector(Selector Sel)
Load the contents of the global method pool for a given selector if necessary.
Definition: Sema.cpp:1612
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:1611
CanQualType LongTy
Definition: ASTContext.h:1024
Any normal BCPL comments.
Declaration of a variable template.
static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E)
Definition: Sema.cpp:1802
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:689
A container of type source information.
Definition: Decl.h:86
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3574
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:623
IdentifierInfo * getSuperIdentifier() const
Definition: Sema.cpp:1858
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:7311
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1260
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3178
IdentifierInfo * getFloat128Identifier() const
Definition: Sema.cpp:1864
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:7604
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:1929
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10833
Compiling a C++ modules TS module interface unit.
Definition: LangOptions.h:80
Represents a variable declaration or definition.
Definition: Decl.h:812
QualType getReturnType() const
Definition: Decl.h:2303
DiagnosticsEngine & Diags
Definition: Sema.h:322
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:6716
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2171
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:431
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:10744
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1129
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:881
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:1226
Defines the clang::Expr interface and subclasses for C++ expressions.
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
Definition: Sema.h:890
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:1887
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:5412
void threadSafetyCleanup(BeforeSet *Cache)
CanQualType OCLSamplerTy
Definition: ASTContext.h:1052
void CheckDelayedMemberExceptionSpecs()
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Represents a struct/union/class.
Definition: Decl.h:3602
void FreeVisContext()
FreeVisContext - Deallocate and null out VisContext.
Definition: SemaAttr.cpp:749
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:297
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
One of these records is kept for each identifier that is lexed.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:854
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7600
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:4018
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:627
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.cpp:1537
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
Definition: ModuleMap.cpp:1273
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1573
unsigned getCurrentDiagID() const
Definition: Diagnostic.h:986
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7504
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:515
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1522
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:1910
Represents a member of a struct/union/class.
Definition: Decl.h:2588
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:4118
void setEscapingByref()
Definition: Decl.h:1421
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:7619
ObjCInterfaceDecl * NSValueDecl
The declaration of the Objective-C NSValue class.
Definition: Sema.h:860
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
Definition: Sema.cpp:864
CanQualType OCLEventTy
Definition: ASTContext.h:1052
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h: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:1507
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3450
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:657
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
bool isOpenCLDisabledDecl(Decl *FD)
Definition: Sema.cpp:1950
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1053
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:815
Describes a module or submodule.
Definition: Module.h:65
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1106
IdentifierTable & Idents
Definition: ASTContext.h:565
static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc)
Give notes for a set of overloads.
Definition: Sema.cpp:1744
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors...
Definition: Sema.h:6095
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:7607
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:808
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:1324
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:1980
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:574
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:653
void PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
A set of unresolved declarations.
Definition: UnresolvedSet.h: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:9370
friend_iterator friend_end() const
Definition: DeclFriend.h:244
~ExternalSemaSource() override
Definition: Sema.cpp:1609
Values of this type can never be null.
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:407
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6058
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:988
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:319
ObjCInterfaceDecl * NSNumberDecl
The declaration of the Objective-C NSNumber class.
Definition: Sema.h:857
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:1614
const LangOptions & getLangOpts() const
Definition: Sema.h:1225
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:7618
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4053
NamespaceDecl * StdExperimentalNamespaceCache
The C++ "std::experimental" namespace, where the experimental parts of the standard library resides...
Definition: Sema.h:837
ObjCMethodDecl * StringWithUTF8StringMethod
The declaration of the stringWithUTF8String: method.
Definition: Sema.h:878
void DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc)
Definition: SemaAttr.cpp:216
const LangOptions & LangOpts
Definition: Sema.h:318
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:2004
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:1229
static bool IsCallableWithAppend(Expr *E)
Determine whether the given expression can be called by just putting parentheses after it...
Definition: Sema.cpp:1794
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:3686
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:597
Retains information about a captured region.
Definition: ScopeInfo.h:737
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:1490
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:688
CastKind
CastKind - The kind of operation required for a conversion.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1795
void PopCompoundScope()
Definition: Sema.cpp:1494
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:1621
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:1512
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:39
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:10709
unsigned Offset
Definition: Format.cpp:1631
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:228
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
Definition: Sema.h:7637
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:3867
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D)
Used to prune the decls of Sema&#39;s UnusedFileScopedDecls vector.
Definition: Sema.cpp:546
This represents one expression.
Definition: Expr.h: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:1901
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:587
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2624
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:6779
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5123
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2703
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:7302
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
Definition: Type.h:6555
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:798
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Not compiling a module interface at all.
Definition: LangOptions.h:71
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:1463
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
Definition: ModuleMap.cpp:1247
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:2652
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7586
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:878
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:546
PartialDiagnostic::StorageAllocator & getDiagAllocator()
Definition: ASTContext.h:685
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h: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:1231
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:887
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:707
const SourceManager & SM
Definition: Format.cpp:1490
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:657
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1109
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:6117
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:1044
This declaration has an owning module, but is globally visible (typically because its owning module i...
void Emit(const DiagnosticBuilder &DB) const
#define false
Definition: stdbool.h:33
RecordDecl * CXXTypeInfoDecl
The C++ "type_info" declaration, which is defined in <typeinfo>.
Definition: Sema.h:848
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2560
QualType getCanonicalType() const
Definition: Type.h:6097
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:3617
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:1916
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:1922
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:841
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2041
void DiagnoseUseOfUnimplementedSelectors()
CanQualType FloatTy
Definition: ASTContext.h:1027
CanQualType VoidTy
Definition: ASTContext.h:1015
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:789
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:1618
void EmitCurrentDiagnostic(unsigned DiagID)
Cause the active diagnostic on the DiagosticsEngine to be emitted.
Definition: Sema.cpp:1222
This declaration is only a declaration.
Definition: Decl.h:1146
void addSupport(const OpenCLOptions &Opts)
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3051
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:558
static bool isFunctionOrVarDeclExternC(NamedDecl *ND)
Definition: Sema.cpp:607
sema::CapturedRegionScopeInfo * getCurCapturedRegion()
Retrieve the current captured region, if any.
Definition: Sema.cpp:1879
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:1233
void setLastDiagnosticIgnored(bool Ignored=true)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:665
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:1891
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:2925
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:648
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:7335
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:869
static void checkEscapingByref(VarDecl *VD, Sema &S)
Definition: Sema.cpp:1413
ArrayRef< Capture > captures() const
Definition: Decl.h:3994
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:77
ClassTemplateDecl * StdCoroutineTraitsCache
The C++ "std::coroutine_traits" template, which is defined in <coroutine_traits>
Definition: Sema.h:845
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:903
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:1817
A set of unresolved declarations.
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created...
Definition: Diagnostic.h:1013
IdentifierResolver IdResolver
Definition: Sema.h:817
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:243
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
Definition: Sema.cpp:529
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1082
Abstract interface for a module loader.
Definition: ModuleLoader.h: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:1937
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
Definition: Sema.cpp:1503
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2652
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:576
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:692
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:340
void FormatASTNodeDiagnosticArgument(DiagnosticsEngine::ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< DiagnosticsEngine::ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, void *Cookie, ArrayRef< intptr_t > QualTypeVals)
DiagnosticsEngine argument formatting function for diagnostics that involve AST nodes.
CanQualType UnsignedLongTy
Definition: ASTContext.h:1025
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1203
static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S)
Definition: Sema.cpp:1437
void * OpaqueParser
Definition: Sema.h:649
ExtVectorType - Extended vector type.
Definition: Type.h:3293
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:7231
CanQualType BoundMemberTy
Definition: ASTContext.h:1044
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1035
void addComment(const RawComment &RC)
Definition: ASTContext.h:802
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
Definition: Sema.h:884
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:3681
The "class" keyword.
Definition: Type.h:5028
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:510
std::unique_ptr< sema::FunctionScopeInfo > PreallocatedFunctionScope
Definition: Sema.h:542
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2069
This is a scope that can contain a declaration.
Definition: Scope.h:59
SourceManager & getSourceManager()
Definition: ASTContext.h:661
The type-property cache.
Definition: Type.cpp:3433
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:2252
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:3097
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1008
void setSuppressAllDiagnostics(bool Val=true)
Suppress all diagnostics, to silence the front end when we know that we don&#39;t want any more diagnosti...
Definition: Diagnostic.h:630
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:492
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:685
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:1517
Represents a C array with an unspecified size.
Definition: Type.h:2932
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1352
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:332
bool isRValue() const
Definition: Expr.h:250
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:354
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:1230
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:1635
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1313
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:1104
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:1024
void ActOnComment(SourceRange Comment)
Definition: Sema.cpp:1582
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:1042
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:816
bool isUnion() const
Definition: Decl.h:3261
NamedDecl * getMostRecentDecl()
Definition: Decl.h:445
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2137
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:323
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:647
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:320
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we&#39;re implicitly casting from a _Nullable pointer type to a _Nonnull one. ...
Definition: Sema.cpp:432
This represents a decl that may have a name.
Definition: Decl.h:248
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K)
Definition: Sema.cpp:1870
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1549
CanQualType DoubleTy
Definition: ASTContext.h:1027
IdentifierInfo * getBoolName() const
Retrieve the identifier &#39;bool&#39;.
Definition: ASTContext.h:1709
void setType(QualType newType)
Definition: Decl.h:648
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:706
static void checkUndefinedButUsed(Sema &S)
checkUndefinedButUsed - Check for undefined objects with internal linkage or that are inline...
Definition: Sema.cpp:679
decls_iterator decls_end() const
Definition: ExprCXX.h:2653
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:637
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:7508
OpenCLOptions & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1286
bool getSuppressAllDiagnostics() const
Definition: Diagnostic.h:633
Declaration of a template function.
Definition: DeclTemplate.h:968
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:563
SourceLocation getLocation() const
Definition: DeclBase.h:418
bool isExternallyVisible() const
Definition: Decl.h:379
CanQualType OCLClkEventTy
Definition: ASTContext.h:1052
ObjCMethodDecl * DictionaryWithObjectsMethod
The declaration of the dictionaryWithObjects:forKeys:count: method.
Definition: Sema.h:893
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1255
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2523
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:1025
decl_iterator decls_end() const
Definition: DeclBase.h:1999
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:375
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static bool isExternC(const NamedDecl *ND)
Definition: Mangle.cpp:54
The translation unit is a module.
Definition: LangOptions.h:363