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().ObjC1)
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().ObjC1) {
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  };
324 
326  DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
327  if (IdResolver.begin(MSVaList) == IdResolver.end())
329  }
330 
331  DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
332  if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
334 }
335 
337  if (VisContext) FreeVisContext();
338 
339  // Kill all the active scopes.
341  if (FSI != PreallocatedFunctionScope.get())
342  delete FSI;
343 
344  // Tell the SemaConsumer to forget about us; we're going out of scope.
345  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
346  SC->ForgetSema();
347 
348  // Detach from the external Sema source.
349  if (ExternalSemaSource *ExternalSema
350  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
351  ExternalSema->ForgetSema();
352 
353  // If Sema's ExternalSource is the multiplexer - we own it.
354  if (isMultiplexExternalSource)
355  delete ExternalSource;
356 
358 
359  // Destroys data sharing attributes stack for OpenMP
360  DestroyDataSharingAttributesStack();
361 
362  // Detach from the PP callback handler which outlives Sema since it's owned
363  // by the preprocessor.
364  SemaPPCallbackHandler->reset();
365 
366  assert(DelayedTypos.empty() && "Uncorrected typos!");
367 }
368 
369 /// makeUnavailableInSystemHeader - There is an error in the current
370 /// context. If we're still in a system header, and we can plausibly
371 /// make the relevant declaration unavailable instead of erroring, do
372 /// so and return true.
374  UnavailableAttr::ImplicitReason reason) {
375  // If we're not in a function, it's an error.
376  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
377  if (!fn) return false;
378 
379  // If we're in template instantiation, it's an error.
381  return false;
382 
383  // If that function's not in a system header, it's an error.
385  return false;
386 
387  // If the function is already unavailable, it's not an error.
388  if (fn->hasAttr<UnavailableAttr>()) return true;
389 
390  fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
391  return true;
392 }
393 
396 }
397 
398 ///Registers an external source. If an external source already exists,
399 /// creates a multiplex external source and appends to it.
400 ///
401 ///\param[in] E - A non-null external sema source.
402 ///
404  assert(E && "Cannot use with NULL ptr");
405 
406  if (!ExternalSource) {
407  ExternalSource = E;
408  return;
409  }
410 
411  if (isMultiplexExternalSource)
412  static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
413  else {
414  ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
415  isMultiplexExternalSource = true;
416  }
417 }
418 
419 /// Print out statistics about the semantic analysis.
420 void Sema::PrintStats() const {
421  llvm::errs() << "\n*** Semantic Analysis Stats:\n";
422  llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
423 
424  BumpAlloc.PrintStats();
426 }
427 
429  QualType SrcType,
430  SourceLocation Loc) {
431  Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
432  if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
433  return;
434 
435  Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
436  if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
437  return;
438 
439  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
440 }
441 
443  if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
444  E->getBeginLoc()))
445  return;
446  // nullptr only exists from C++11 on, so don't warn on its absence earlier.
447  if (!getLangOpts().CPlusPlus11)
448  return;
449 
450  if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
451  return;
453  return;
454 
455  // If it is a macro from system header, and if the macro name is not "NULL",
456  // do not warn.
457  SourceLocation MaybeMacroLoc = E->getBeginLoc();
459  SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
460  !findMacroSpelling(MaybeMacroLoc, "NULL"))
461  return;
462 
463  Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
464  << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
465 }
466 
467 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
468 /// If there is already an implicit cast, merge into the existing one.
469 /// The result is of the given category.
472  const CXXCastPath *BasePath,
473  CheckedConversionKind CCK) {
474 #ifndef NDEBUG
475  if (VK == VK_RValue && !E->isRValue()) {
476  switch (Kind) {
477  default:
478  llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
479  "kind");
480  case CK_LValueToRValue:
481  case CK_ArrayToPointerDecay:
482  case CK_FunctionToPointerDecay:
483  case CK_ToVoid:
484  case CK_NonAtomicToAtomic:
485  break;
486  }
487  }
488  assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
489 #endif
490 
493 
494  QualType ExprTy = Context.getCanonicalType(E->getType());
496 
497  if (ExprTy == TypeTy)
498  return E;
499 
500  // C++1z [conv.array]: The temporary materialization conversion is applied.
501  // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
502  if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
503  E->getValueKind() == VK_RValue) {
504  // The temporary is an lvalue in C++98 and an xvalue otherwise.
506  E->getType(), E, !getLangOpts().CPlusPlus11);
507  if (Materialized.isInvalid())
508  return ExprError();
509  E = Materialized.get();
510  }
511 
512  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
513  if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
514  ImpCast->setType(Ty);
515  ImpCast->setValueKind(VK);
516  return E;
517  }
518  }
519 
520  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
521 }
522 
523 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
524 /// to the conversion from scalar type ScalarTy to the Boolean type.
526  switch (ScalarTy->getScalarTypeKind()) {
527  case Type::STK_Bool: return CK_NoOp;
528  case Type::STK_CPointer: return CK_PointerToBoolean;
529  case Type::STK_BlockPointer: return CK_PointerToBoolean;
530  case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
531  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
532  case Type::STK_Integral: return CK_IntegralToBoolean;
533  case Type::STK_Floating: return CK_FloatingToBoolean;
534  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
535  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
537  llvm_unreachable("Unknown cast from FixedPoint to boolean");
538  }
539  llvm_unreachable("unknown scalar type kind");
540 }
541 
542 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
543 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
544  if (D->getMostRecentDecl()->isUsed())
545  return true;
546 
547  if (D->isExternallyVisible())
548  return true;
549 
550  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
551  // If this is a function template and none of its specializations is used,
552  // we should warn.
553  if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
554  for (const auto *Spec : Template->specializations())
555  if (ShouldRemoveFromUnused(SemaRef, Spec))
556  return true;
557 
558  // UnusedFileScopedDecls stores the first declaration.
559  // The declaration may have become definition so check again.
560  const FunctionDecl *DeclToCheck;
561  if (FD->hasBody(DeclToCheck))
562  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
563 
564  // Later redecls may add new information resulting in not having to warn,
565  // so check again.
566  DeclToCheck = FD->getMostRecentDecl();
567  if (DeclToCheck != FD)
568  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
569  }
570 
571  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
572  // If a variable usable in constant expressions is referenced,
573  // don't warn if it isn't used: if the value of a variable is required
574  // for the computation of a constant expression, it doesn't make sense to
575  // warn even if the variable isn't odr-used. (isReferenced doesn't
576  // precisely reflect that, but it's a decent approximation.)
577  if (VD->isReferenced() &&
578  VD->isUsableInConstantExpressions(SemaRef->Context))
579  return true;
580 
581  if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
582  // If this is a variable template and none of its specializations is used,
583  // we should warn.
584  for (const auto *Spec : Template->specializations())
585  if (ShouldRemoveFromUnused(SemaRef, Spec))
586  return true;
587 
588  // UnusedFileScopedDecls stores the first declaration.
589  // The declaration may have become definition so check again.
590  const VarDecl *DeclToCheck = VD->getDefinition();
591  if (DeclToCheck)
592  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
593 
594  // Later redecls may add new information resulting in not having to warn,
595  // so check again.
596  DeclToCheck = VD->getMostRecentDecl();
597  if (DeclToCheck != VD)
598  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
599  }
600 
601  return false;
602 }
603 
605  if (auto *FD = dyn_cast<FunctionDecl>(ND))
606  return FD->isExternC();
607  return cast<VarDecl>(ND)->isExternC();
608 }
609 
610 /// Determine whether ND is an external-linkage function or variable whose
611 /// type has no linkage.
613  // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
614  // because we also want to catch the case where its type has VisibleNoLinkage,
615  // which does not affect the linkage of VD.
616  return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
619 }
620 
621 /// Obtains a sorted list of functions and variables that are undefined but
622 /// ODR-used.
624  SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
625  for (const auto &UndefinedUse : UndefinedButUsed) {
626  NamedDecl *ND = UndefinedUse.first;
627 
628  // Ignore attributes that have become invalid.
629  if (ND->isInvalidDecl()) continue;
630 
631  // __attribute__((weakref)) is basically a definition.
632  if (ND->hasAttr<WeakRefAttr>()) continue;
633 
634  if (isa<CXXDeductionGuideDecl>(ND))
635  continue;
636 
637  if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
638  // An exported function will always be emitted when defined, so even if
639  // the function is inline, it doesn't have to be emitted in this TU. An
640  // imported function implies that it has been exported somewhere else.
641  continue;
642  }
643 
644  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
645  if (FD->isDefined())
646  continue;
647  if (FD->isExternallyVisible() &&
649  !FD->getMostRecentDecl()->isInlined() &&
650  !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
651  continue;
652  if (FD->getBuiltinID())
653  continue;
654  } else {
655  auto *VD = cast<VarDecl>(ND);
656  if (VD->hasDefinition() != VarDecl::DeclarationOnly)
657  continue;
658  if (VD->isExternallyVisible() &&
660  !VD->getMostRecentDecl()->isInline() &&
661  !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
662  continue;
663 
664  // Skip VarDecls that lack formal definitions but which we know are in
665  // fact defined somewhere.
666  if (VD->isKnownToBeDefined())
667  continue;
668  }
669 
670  Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
671  }
672 }
673 
674 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
675 /// or that are inline.
676 static void checkUndefinedButUsed(Sema &S) {
677  if (S.UndefinedButUsed.empty()) return;
678 
679  // Collect all the still-undefined entities with internal linkage.
681  S.getUndefinedButUsed(Undefined);
682  if (Undefined.empty()) return;
683 
684  for (auto Undef : Undefined) {
685  ValueDecl *VD = cast<ValueDecl>(Undef.first);
686  SourceLocation UseLoc = Undef.second;
687 
688  if (S.isExternalWithNoLinkageType(VD)) {
689  // C++ [basic.link]p8:
690  // A type without linkage shall not be used as the type of a variable
691  // or function with external linkage unless
692  // -- the entity has C language linkage
693  // -- the entity is not odr-used or is defined in the same TU
694  //
695  // As an extension, accept this in cases where the type is externally
696  // visible, since the function or variable actually can be defined in
697  // another translation unit in that case.
699  ? diag::ext_undefined_internal_type
700  : diag::err_undefined_internal_type)
701  << isa<VarDecl>(VD) << VD;
702  } else if (!VD->isExternallyVisible()) {
703  // FIXME: We can promote this to an error. The function or variable can't
704  // be defined anywhere else, so the program must necessarily violate the
705  // one definition rule.
706  S.Diag(VD->getLocation(), diag::warn_undefined_internal)
707  << isa<VarDecl>(VD) << VD;
708  } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
709  (void)FD;
710  assert(FD->getMostRecentDecl()->isInlined() &&
711  "used object requires definition but isn't inline or internal?");
712  // FIXME: This is ill-formed; we should reject.
713  S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
714  } else {
715  assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
716  "used var requires definition but isn't inline or internal?");
717  S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
718  }
719  if (UseLoc.isValid())
720  S.Diag(UseLoc, diag::note_used_here);
721  }
722 
723  S.UndefinedButUsed.clear();
724 }
725 
727  if (!ExternalSource)
728  return;
729 
731  ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
732  for (auto &WeakID : WeakIDs)
733  WeakUndeclaredIdentifiers.insert(WeakID);
734 }
735 
736 
737 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
738 
739 /// Returns true, if all methods and nested classes of the given
740 /// CXXRecordDecl are defined in this translation unit.
741 ///
742 /// Should only be called from ActOnEndOfTranslationUnit so that all
743 /// definitions are actually read.
745  RecordCompleteMap &MNCComplete) {
746  RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
747  if (Cache != MNCComplete.end())
748  return Cache->second;
749  if (!RD->isCompleteDefinition())
750  return false;
751  bool Complete = true;
753  E = RD->decls_end();
754  I != E && Complete; ++I) {
755  if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
756  Complete = M->isDefined() || M->isDefaulted() ||
757  (M->isPure() && !isa<CXXDestructorDecl>(M));
758  else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
759  // If the template function is marked as late template parsed at this
760  // point, it has not been instantiated and therefore we have not
761  // performed semantic analysis on it yet, so we cannot know if the type
762  // can be considered complete.
763  Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
764  F->getTemplatedDecl()->isDefined();
765  else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
766  if (R->isInjectedClassName())
767  continue;
768  if (R->hasDefinition())
769  Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
770  MNCComplete);
771  else
772  Complete = false;
773  }
774  }
775  MNCComplete[RD] = Complete;
776  return Complete;
777 }
778 
779 /// Returns true, if the given CXXRecordDecl is fully defined in this
780 /// translation unit, i.e. all methods are defined or pure virtual and all
781 /// friends, friend functions and nested classes are fully defined in this
782 /// translation unit.
783 ///
784 /// Should only be called from ActOnEndOfTranslationUnit so that all
785 /// definitions are actually read.
786 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
787  RecordCompleteMap &RecordsComplete,
788  RecordCompleteMap &MNCComplete) {
789  RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
790  if (Cache != RecordsComplete.end())
791  return Cache->second;
792  bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
794  E = RD->friend_end();
795  I != E && Complete; ++I) {
796  // Check if friend classes and methods are complete.
797  if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
798  // Friend classes are available as the TypeSourceInfo of the FriendDecl.
799  if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
800  Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
801  else
802  Complete = false;
803  } else {
804  // Friend functions are available through the NamedDecl of FriendDecl.
805  if (const FunctionDecl *FD =
806  dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
807  Complete = FD->isDefined();
808  else
809  // This is a template friend, give up.
810  Complete = false;
811  }
812  }
813  RecordsComplete[RD] = Complete;
814  return Complete;
815 }
816 
818  if (ExternalSource)
819  ExternalSource->ReadUnusedLocalTypedefNameCandidates(
822  if (TD->isReferenced())
823  continue;
824  Diag(TD->getLocation(), diag::warn_unused_local_typedef)
825  << isa<TypeAliasDecl>(TD) << TD->getDeclName();
826  }
827  UnusedLocalTypedefNameCandidates.clear();
828 }
829 
830 /// This is called before the very first declaration in the translation unit
831 /// is parsed. Note that the ASTContext may have already injected some
832 /// declarations.
834  if (getLangOpts().ModulesTS &&
835  (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
836  getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
837  SourceLocation StartOfTU =
839 
840  // We start in the global module; all those declarations are implicitly
841  // module-private (though they do not have module linkage).
842  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
843  auto *GlobalModule = Map.createGlobalModuleForInterfaceUnit(StartOfTU);
844  assert(GlobalModule && "module creation should not fail");
845 
846  // Enter the scope of the global module.
847  ModuleScopes.push_back({});
848  ModuleScopes.back().Module = GlobalModule;
849  VisibleModules.setVisible(GlobalModule, StartOfTU);
850 
851  // All declarations created from now on are owned by the global module.
852  auto *TU = Context.getTranslationUnitDecl();
854  TU->setLocalOwningModule(GlobalModule);
855  }
856 }
857 
858 /// ActOnEndOfTranslationUnit - This is called at the very end of the
859 /// translation unit when EOF is reached and all but the top-level scope is
860 /// popped.
862  assert(DelayedDiagnostics.getCurrentPool() == nullptr
863  && "reached end of translation unit with a pool attached?");
864 
865  // If code completion is enabled, don't perform any end-of-translation-unit
866  // work.
868  return;
869 
870  // Transfer late parsed template instantiations over to the pending template
871  // instantiation list. During normal compliation, the late template parser
872  // will be installed and instantiating these templates will succeed.
873  //
874  // If we are building a TU prefix for serialization, it is also safe to
875  // transfer these over, even though they are not parsed. The end of the TU
876  // should be outside of any eager template instantiation scope, so when this
877  // AST is deserialized, these templates will not be parsed until the end of
878  // the combined TU.
880  LateParsedInstantiations.begin(),
882  LateParsedInstantiations.clear();
883 
884  // Complete translation units and modules define vtables and perform implicit
885  // instantiations. PCH files do not.
886  if (TUKind != TU_Prefix) {
888 
889  // If DefinedUsedVTables ends up marking any virtual member functions it
890  // might lead to more pending template instantiations, which we then need
891  // to instantiate.
893 
894  // C++: Perform implicit template instantiations.
895  //
896  // FIXME: When we perform these implicit instantiations, we do not
897  // carefully keep track of the point of instantiation (C++ [temp.point]).
898  // This means that name lookup that occurs within the template
899  // instantiation will always happen at the end of the translation unit,
900  // so it will find some names that are not required to be found. This is
901  // valid, but we could do better by diagnosing if an instantiation uses a
902  // name that was not visible at its first point of instantiation.
903  if (ExternalSource) {
904  // Load pending instantiations from the external source.
906  ExternalSource->ReadPendingInstantiations(Pending);
907  for (auto PII : Pending)
908  if (auto Func = dyn_cast<FunctionDecl>(PII.first))
909  Func->setInstantiationIsPending(true);
911  Pending.begin(), Pending.end());
912  }
913 
915 
916  assert(LateParsedInstantiations.empty() &&
917  "end of TU template instantiation should not create more "
918  "late-parsed templates");
919 
922 
924  }
925 
928 
929  // All delayed member exception specs should be checked or we end up accepting
930  // incompatible declarations.
931  assert(DelayedOverridingExceptionSpecChecks.empty());
932  assert(DelayedEquivalentExceptionSpecChecks.empty());
933  assert(DelayedDefaultedMemberExceptionSpecs.empty());
934 
935  // All dllexport classes should have been processed already.
936  assert(DelayedDllExportClasses.empty());
937 
938  // Remove file scoped decls that turned out to be used.
940  std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
942  [this](const DeclaratorDecl *DD) {
943  return ShouldRemoveFromUnused(this, DD);
944  }),
946 
947  if (TUKind == TU_Prefix) {
948  // Translation unit prefixes don't need any of the checking below.
950  TUScope = nullptr;
951  return;
952  }
953 
954  // Check for #pragma weak identifiers that were never declared
956  for (auto WeakID : WeakUndeclaredIdentifiers) {
957  if (WeakID.second.getUsed())
958  continue;
959 
960  Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
962  if (PrevDecl != nullptr &&
963  !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
964  Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
965  << "'weak'" << ExpectedVariableOrFunction;
966  else
967  Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
968  << WeakID.first;
969  }
970 
971  if (LangOpts.CPlusPlus11 &&
972  !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
974 
975  if (!Diags.hasErrorOccurred()) {
976  if (ExternalSource)
977  ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
978  checkUndefinedButUsed(*this);
979  }
980 
981  if (TUKind == TU_Module) {
982  // If we are building a module interface unit, we need to have seen the
983  // module declaration by now.
984  if (getLangOpts().getCompilingModule() ==
986  (ModuleScopes.empty() ||
987  ModuleScopes.back().Module->Kind != Module::ModuleInterfaceUnit)) {
988  // FIXME: Make a better guess as to where to put the module declaration.
989  Diag(getSourceManager().getLocForStartOfFile(
990  getSourceManager().getMainFileID()),
991  diag::err_module_declaration_missing);
992  }
993 
994  // If we are building a module, resolve all of the exported declarations
995  // now.
996  if (Module *CurrentModule = PP.getCurrentModule()) {
998 
1000  Stack.push_back(CurrentModule);
1001  while (!Stack.empty()) {
1002  Module *Mod = Stack.pop_back_val();
1003 
1004  // Resolve the exported declarations and conflicts.
1005  // FIXME: Actually complain, once we figure out how to teach the
1006  // diagnostic client to deal with complaints in the module map at this
1007  // point.
1008  ModMap.resolveExports(Mod, /*Complain=*/false);
1009  ModMap.resolveUses(Mod, /*Complain=*/false);
1010  ModMap.resolveConflicts(Mod, /*Complain=*/false);
1011 
1012  // Queue the submodules, so their exports will also be resolved.
1013  Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1014  }
1015  }
1016 
1017  // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1018  // modules when they are built, not every time they are used.
1020  }
1021 
1022  // C99 6.9.2p2:
1023  // A declaration of an identifier for an object that has file
1024  // scope without an initializer, and without a storage-class
1025  // specifier or with the storage-class specifier static,
1026  // constitutes a tentative definition. If a translation unit
1027  // contains one or more tentative definitions for an identifier,
1028  // and the translation unit contains no external definition for
1029  // that identifier, then the behavior is exactly as if the
1030  // translation unit contains a file scope declaration of that
1031  // identifier, with the composite type as of the end of the
1032  // translation unit, with an initializer equal to 0.
1033  llvm::SmallSet<VarDecl *, 32> Seen;
1034  for (TentativeDefinitionsType::iterator
1035  T = TentativeDefinitions.begin(ExternalSource),
1036  TEnd = TentativeDefinitions.end();
1037  T != TEnd; ++T) {
1038  VarDecl *VD = (*T)->getActingDefinition();
1039 
1040  // If the tentative definition was completed, getActingDefinition() returns
1041  // null. If we've already seen this variable before, insert()'s second
1042  // return value is false.
1043  if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1044  continue;
1045 
1046  if (const IncompleteArrayType *ArrayT
1048  // Set the length of the array to 1 (C99 6.9.2p5).
1049  Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1050  llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
1051  QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1052  One, ArrayType::Normal, 0);
1053  VD->setType(T);
1054  } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1055  diag::err_tentative_def_incomplete_type))
1056  VD->setInvalidDecl();
1057 
1058  // No initialization is performed for a tentative definition.
1060 
1061  // Notify the consumer that we've completed a tentative definition.
1062  if (!VD->isInvalidDecl())
1064  }
1065 
1066  // If there were errors, disable 'unused' warnings since they will mostly be
1067  // noise. Don't warn for a use from a module: either we should warn on all
1068  // file-scope declarations in modules or not at all, but whether the
1069  // declaration is used is immaterial.
1070  if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1071  // Output warning for unused file scoped decls.
1072  for (UnusedFileScopedDeclsType::iterator
1073  I = UnusedFileScopedDecls.begin(ExternalSource),
1074  E = UnusedFileScopedDecls.end(); I != E; ++I) {
1075  if (ShouldRemoveFromUnused(this, *I))
1076  continue;
1077 
1078  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1079  const FunctionDecl *DiagD;
1080  if (!FD->hasBody(DiagD))
1081  DiagD = FD;
1082  if (DiagD->isDeleted())
1083  continue; // Deleted functions are supposed to be unused.
1084  if (DiagD->isReferenced()) {
1085  if (isa<CXXMethodDecl>(DiagD))
1086  Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1087  << DiagD->getDeclName();
1088  else {
1089  if (FD->getStorageClass() == SC_Static &&
1090  !FD->isInlineSpecified() &&
1092  SourceMgr.getExpansionLoc(FD->getLocation())))
1093  Diag(DiagD->getLocation(),
1094  diag::warn_unneeded_static_internal_decl)
1095  << DiagD->getDeclName();
1096  else
1097  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1098  << /*function*/0 << DiagD->getDeclName();
1099  }
1100  } else {
1101  if (FD->getDescribedFunctionTemplate())
1102  Diag(DiagD->getLocation(), diag::warn_unused_template)
1103  << /*function*/0 << DiagD->getDeclName();
1104  else
1105  Diag(DiagD->getLocation(),
1106  isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1107  : diag::warn_unused_function)
1108  << DiagD->getDeclName();
1109  }
1110  } else {
1111  const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1112  if (!DiagD)
1113  DiagD = cast<VarDecl>(*I);
1114  if (DiagD->isReferenced()) {
1115  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1116  << /*variable*/1 << DiagD->getDeclName();
1117  } else if (DiagD->getType().isConstQualified()) {
1118  const SourceManager &SM = SourceMgr;
1119  if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1121  Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1122  << DiagD->getDeclName();
1123  } else {
1124  if (DiagD->getDescribedVarTemplate())
1125  Diag(DiagD->getLocation(), diag::warn_unused_template)
1126  << /*variable*/1 << DiagD->getDeclName();
1127  else
1128  Diag(DiagD->getLocation(), diag::warn_unused_variable)
1129  << DiagD->getDeclName();
1130  }
1131  }
1132  }
1133 
1135  }
1136 
1137  if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1138  // FIXME: Load additional unused private field candidates from the external
1139  // source.
1140  RecordCompleteMap RecordsComplete;
1141  RecordCompleteMap MNCComplete;
1142  for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1143  E = UnusedPrivateFields.end(); I != E; ++I) {
1144  const NamedDecl *D = *I;
1145  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1146  if (RD && !RD->isUnion() &&
1147  IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1148  Diag(D->getLocation(), diag::warn_unused_private_field)
1149  << D->getDeclName();
1150  }
1151  }
1152  }
1153 
1154  if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1155  if (ExternalSource)
1157  for (const auto &DeletedFieldInfo : DeleteExprs) {
1158  for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1159  AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1160  DeleteExprLoc.second);
1161  }
1162  }
1163  }
1164 
1165  // Check we've noticed that we're no longer parsing the initializer for every
1166  // variable. If we miss cases, then at best we have a performance issue and
1167  // at worst a rejects-valid bug.
1168  assert(ParsingInitForAutoVars.empty() &&
1169  "Didn't unmark var as having its initializer parsed");
1170 
1172  TUScope = nullptr;
1173 }
1174 
1175 
1176 //===----------------------------------------------------------------------===//
1177 // Helper functions.
1178 //===----------------------------------------------------------------------===//
1179 
1181  DeclContext *DC = CurContext;
1182 
1183  while (true) {
1184  if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1185  DC = DC->getParent();
1186  } else if (isa<CXXMethodDecl>(DC) &&
1187  cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1188  cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1189  DC = DC->getParent()->getParent();
1190  }
1191  else break;
1192  }
1193 
1194  return DC;
1195 }
1196 
1197 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1198 /// to the function decl for the function being parsed. If we're currently
1199 /// in a 'block', this returns the containing context.
1202  return dyn_cast<FunctionDecl>(DC);
1203 }
1204 
1207  while (isa<RecordDecl>(DC))
1208  DC = DC->getParent();
1209  return dyn_cast<ObjCMethodDecl>(DC);
1210 }
1211 
1214  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1215  return cast<NamedDecl>(DC);
1216  return nullptr;
1217 }
1218 
1219 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1220  // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1221  // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1222  // been made more painfully obvious by the refactor that introduced this
1223  // function, but it is possible that the incoming argument can be
1224  // eliminated. If it truly cannot be (for example, there is some reentrancy
1225  // issue I am not seeing yet), then there should at least be a clarifying
1226  // comment somewhere.
1229  Diags.getCurrentDiagID())) {
1231  // We'll report the diagnostic below.
1232  break;
1233 
1235  // Count this failure so that we know that template argument deduction
1236  // has failed.
1237  ++NumSFINAEErrors;
1238 
1239  // Make a copy of this suppressed diagnostic and store it with the
1240  // template-deduction information.
1241  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1242  Diagnostic DiagInfo(&Diags);
1243  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1245  }
1246 
1248  Diags.Clear();
1249  return;
1250 
1252  // Per C++ Core Issue 1170, access control is part of SFINAE.
1253  // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1254  // make access control a part of SFINAE for the purposes of checking
1255  // type traits.
1257  break;
1258 
1260 
1261  // Suppress this diagnostic.
1262  ++NumSFINAEErrors;
1263 
1264  // Make a copy of this suppressed diagnostic and store it with the
1265  // template-deduction information.
1266  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1267  Diagnostic DiagInfo(&Diags);
1268  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1270  }
1271 
1273  Diags.Clear();
1274 
1275  // Now the diagnostic state is clear, produce a C++98 compatibility
1276  // warning.
1277  Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1278 
1279  // The last diagnostic which Sema produced was ignored. Suppress any
1280  // notes attached to it.
1282  return;
1283  }
1284 
1286  // Make a copy of this suppressed diagnostic and store it with the
1287  // template-deduction information;
1288  if (*Info) {
1289  Diagnostic DiagInfo(&Diags);
1290  (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1292  }
1293 
1294  // Suppress this diagnostic.
1296  Diags.Clear();
1297  return;
1298  }
1299  }
1300 
1301  // Copy the diagnostic printing policy over the ASTContext printing policy.
1302  // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1304 
1305  // Emit the diagnostic.
1307  return;
1308 
1309  // If this is not a note, and we're in a template instantiation
1310  // that is different from the last template instantiation where
1311  // we emitted an error, print a template instantiation
1312  // backtrace.
1313  if (!DiagnosticIDs::isBuiltinNote(DiagID))
1315 }
1316 
1319  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1320  PD.Emit(Builder);
1321 
1322  return Builder;
1323 }
1324 
1325 /// Looks through the macro-expansion chain for the given
1326 /// location, looking for a macro expansion with the given name.
1327 /// If one is found, returns true and sets the location to that
1328 /// expansion loc.
1329 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1330  SourceLocation loc = locref;
1331  if (!loc.isMacroID()) return false;
1332 
1333  // There's no good way right now to look at the intermediate
1334  // expansions, so just jump to the expansion location.
1335  loc = getSourceManager().getExpansionLoc(loc);
1336 
1337  // If that's written with the name, stop here.
1338  SmallVector<char, 16> buffer;
1339  if (getPreprocessor().getSpelling(loc, buffer) == name) {
1340  locref = loc;
1341  return true;
1342  }
1343  return false;
1344 }
1345 
1346 /// Determines the active Scope associated with the given declaration
1347 /// context.
1348 ///
1349 /// This routine maps a declaration context to the active Scope object that
1350 /// represents that declaration context in the parser. It is typically used
1351 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1352 /// declarations) that injects a name for name-lookup purposes and, therefore,
1353 /// must update the Scope.
1354 ///
1355 /// \returns The scope corresponding to the given declaraion context, or NULL
1356 /// if no such scope is open.
1358 
1359  if (!Ctx)
1360  return nullptr;
1361 
1362  Ctx = Ctx->getPrimaryContext();
1363  for (Scope *S = getCurScope(); S; S = S->getParent()) {
1364  // Ignore scopes that cannot have declarations. This is important for
1365  // out-of-line definitions of static class members.
1366  if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1367  if (DeclContext *Entity = S->getEntity())
1368  if (Ctx == Entity->getPrimaryContext())
1369  return S;
1370  }
1371 
1372  return nullptr;
1373 }
1374 
1375 /// Enter a new function scope
1377  if (FunctionScopes.empty()) {
1378  // Use PreallocatedFunctionScope to avoid allocating memory when possible.
1379  PreallocatedFunctionScope->Clear();
1380  FunctionScopes.push_back(PreallocatedFunctionScope.get());
1381  } else {
1383  }
1384  if (LangOpts.OpenMP)
1385  pushOpenMPFunctionRegion();
1386 }
1387 
1388 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1390  BlockScope, Block));
1391 }
1392 
1394  LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1395  FunctionScopes.push_back(LSI);
1396  return LSI;
1397 }
1398 
1400  if (LambdaScopeInfo *const LSI = getCurLambda()) {
1401  LSI->AutoTemplateParameterDepth = Depth;
1402  return;
1403  }
1404  llvm_unreachable(
1405  "Remove assertion if intentionally called in a non-lambda context.");
1406 }
1407 
1408 // Check that the type of the VarDecl has an accessible copy constructor and
1409 // resolve its destructor's exception spefication.
1410 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1411  QualType T = VD->getType();
1414  SourceLocation Loc = VD->getLocation();
1415  Expr *VarRef = new (S.Context) DeclRefExpr(VD, false, T, VK_LValue, Loc);
1417  InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1418  VarRef, /*AllowNRVO=*/true);
1419  if (!Result.isInvalid()) {
1420  Result = S.MaybeCreateExprWithCleanups(Result);
1421  Expr *Init = Result.getAs<Expr>();
1422  S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1423  }
1424 
1425  // The destructor's exception spefication is needed when IRGen generates
1426  // block copy/destroy functions. Resolve it here.
1427  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1428  if (CXXDestructorDecl *DD = RD->getDestructor()) {
1429  auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1430  S.ResolveExceptionSpec(Loc, FPT);
1431  }
1432 }
1433 
1434 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1435  // Set the EscapingByref flag of __block variables captured by
1436  // escaping blocks.
1437  for (const BlockDecl *BD : FSI.Blocks) {
1438  if (BD->doesNotEscape())
1439  continue;
1440  for (const BlockDecl::Capture &BC : BD->captures()) {
1441  VarDecl *VD = BC.getVariable();
1442  if (VD->hasAttr<BlocksAttr>())
1443  VD->setEscapingByref();
1444  }
1445  }
1446 
1447  for (VarDecl *VD : FSI.ByrefBlockVars) {
1448  // __block variables might require us to capture a copy-initializer.
1449  if (!VD->isEscapingByref())
1450  continue;
1451  // It's currently invalid to ever have a __block variable with an
1452  // array type; should we diagnose that here?
1453  // Regardless, we don't want to ignore array nesting when
1454  // constructing this copy.
1455  if (VD->getType()->isStructureOrClassType())
1456  checkEscapingByref(VD, S);
1457  }
1458 }
1459 
1461  const Decl *D, const BlockExpr *blkExpr) {
1462  assert(!FunctionScopes.empty() && "mismatched push/pop!");
1463 
1464  // This function shouldn't be called after popping the current function scope.
1465  // markEscapingByrefs calls PerformMoveOrCopyInitialization, which can call
1466  // PushFunctionScope, which can cause clearing out PreallocatedFunctionScope
1467  // when FunctionScopes is empty.
1468  markEscapingByrefs(*FunctionScopes.back(), *this);
1469 
1470  FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
1471 
1472  if (LangOpts.OpenMP)
1473  popOpenMPFunctionRegion(Scope);
1474 
1475  // Issue any analysis-based warnings.
1476  if (WP && D)
1477  AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
1478  else
1479  for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1480  Diag(PUD.Loc, PUD.PD);
1481 
1482  // Delete the scope unless its our preallocated scope.
1483  if (Scope != PreallocatedFunctionScope.get())
1484  delete Scope;
1485 }
1486 
1487 void Sema::PushCompoundScope(bool IsStmtExpr) {
1488  getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1489 }
1490 
1492  FunctionScopeInfo *CurFunction = getCurFunction();
1493  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1494 
1495  CurFunction->CompoundScopes.pop_back();
1496 }
1497 
1498 /// Determine whether any errors occurred within this function/method/
1499 /// block.
1502 }
1503 
1505  if (!FunctionScopes.empty())
1506  FunctionScopes.back()->setHasBranchIntoScope();
1507 }
1508 
1510  if (!FunctionScopes.empty())
1511  FunctionScopes.back()->setHasBranchProtectedScope();
1512 }
1513 
1515  if (!FunctionScopes.empty())
1516  FunctionScopes.back()->setHasIndirectGoto();
1517 }
1518 
1520  if (FunctionScopes.empty())
1521  return nullptr;
1522 
1523  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1524  if (CurBSI && CurBSI->TheDecl &&
1525  !CurBSI->TheDecl->Encloses(CurContext)) {
1526  // We have switched contexts due to template instantiation.
1527  assert(!CodeSynthesisContexts.empty());
1528  return nullptr;
1529  }
1530 
1531  return CurBSI;
1532 }
1533 
1535  if (FunctionScopes.empty())
1536  return nullptr;
1537 
1538  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1539  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1540  continue;
1541  return FunctionScopes[e];
1542  }
1543  return nullptr;
1544 }
1545 
1546 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1547  if (FunctionScopes.empty())
1548  return nullptr;
1549 
1550  auto I = FunctionScopes.rbegin();
1551  if (IgnoreNonLambdaCapturingScope) {
1552  auto E = FunctionScopes.rend();
1553  while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1554  ++I;
1555  if (I == E)
1556  return nullptr;
1557  }
1558  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1559  if (CurLSI && CurLSI->Lambda &&
1560  !CurLSI->Lambda->Encloses(CurContext)) {
1561  // We have switched contexts due to template instantiation.
1562  assert(!CodeSynthesisContexts.empty());
1563  return nullptr;
1564  }
1565 
1566  return CurLSI;
1567 }
1568 // We have a generic lambda if we parsed auto parameters, or we have
1569 // an associated template parameter list.
1571  if (LambdaScopeInfo *LSI = getCurLambda()) {
1572  return (LSI->AutoTemplateParams.size() ||
1573  LSI->GLTemplateParameterList) ? LSI : nullptr;
1574  }
1575  return nullptr;
1576 }
1577 
1578 
1580  if (!LangOpts.RetainCommentsFromSystemHeaders &&
1581  SourceMgr.isInSystemHeader(Comment.getBegin()))
1582  return;
1583  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1584  if (RC.isAlmostTrailingComment()) {
1585  SourceRange MagicMarkerRange(Comment.getBegin(),
1586  Comment.getBegin().getLocWithOffset(3));
1587  StringRef MagicMarkerText;
1588  switch (RC.getKind()) {
1590  MagicMarkerText = "///<";
1591  break;
1593  MagicMarkerText = "/**<";
1594  break;
1595  default:
1596  llvm_unreachable("if this is an almost Doxygen comment, "
1597  "it should be ordinary");
1598  }
1599  Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1600  FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1601  }
1602  Context.addComment(RC);
1603 }
1604 
1605 // Pin this vtable to this file.
1607 
1610 
1612  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1613 }
1614 
1616  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1617 
1619  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1620 
1621 /// Figure out if an expression could be turned into a call.
1622 ///
1623 /// Use this when trying to recover from an error where the programmer may have
1624 /// written just the name of a function instead of actually calling it.
1625 ///
1626 /// \param E - The expression to examine.
1627 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1628 /// with no arguments, this parameter is set to the type returned by such a
1629 /// call; otherwise, it is set to an empty QualType.
1630 /// \param OverloadSet - If the expression is an overloaded function
1631 /// name, this parameter is populated with the decls of the various overloads.
1632 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1633  UnresolvedSetImpl &OverloadSet) {
1634  ZeroArgCallReturnTy = QualType();
1635  OverloadSet.clear();
1636 
1637  const OverloadExpr *Overloads = nullptr;
1638  bool IsMemExpr = false;
1639  if (E.getType() == Context.OverloadTy) {
1640  OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1641 
1642  // Ignore overloads that are pointer-to-member constants.
1643  if (FR.HasFormOfMemberPointer)
1644  return false;
1645 
1646  Overloads = FR.Expression;
1647  } else if (E.getType() == Context.BoundMemberTy) {
1648  Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1649  IsMemExpr = true;
1650  }
1651 
1652  bool Ambiguous = false;
1653  bool IsMV = false;
1654 
1655  if (Overloads) {
1656  for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1657  DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1658  OverloadSet.addDecl(*it);
1659 
1660  // Check whether the function is a non-template, non-member which takes no
1661  // arguments.
1662  if (IsMemExpr)
1663  continue;
1664  if (const FunctionDecl *OverloadDecl
1665  = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1666  if (OverloadDecl->getMinRequiredArguments() == 0) {
1667  if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1668  (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1669  OverloadDecl->isCPUSpecificMultiVersion()))) {
1670  ZeroArgCallReturnTy = QualType();
1671  Ambiguous = true;
1672  } else {
1673  ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1674  IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1675  OverloadDecl->isCPUSpecificMultiVersion();
1676  }
1677  }
1678  }
1679  }
1680 
1681  // If it's not a member, use better machinery to try to resolve the call
1682  if (!IsMemExpr)
1683  return !ZeroArgCallReturnTy.isNull();
1684  }
1685 
1686  // Attempt to call the member with no arguments - this will correctly handle
1687  // member templates with defaults/deduction of template arguments, overloads
1688  // with default arguments, etc.
1689  if (IsMemExpr && !E.isTypeDependent()) {
1690  bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1693  None, SourceLocation());
1695  if (R.isUsable()) {
1696  ZeroArgCallReturnTy = R.get()->getType();
1697  return true;
1698  }
1699  return false;
1700  }
1701 
1702  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1703  if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1704  if (Fun->getMinRequiredArguments() == 0)
1705  ZeroArgCallReturnTy = Fun->getReturnType();
1706  return true;
1707  }
1708  }
1709 
1710  // We don't have an expression that's convenient to get a FunctionDecl from,
1711  // but we can at least check if the type is "function of 0 arguments".
1712  QualType ExprTy = E.getType();
1713  const FunctionType *FunTy = nullptr;
1714  QualType PointeeTy = ExprTy->getPointeeType();
1715  if (!PointeeTy.isNull())
1716  FunTy = PointeeTy->getAs<FunctionType>();
1717  if (!FunTy)
1718  FunTy = ExprTy->getAs<FunctionType>();
1719 
1720  if (const FunctionProtoType *FPT =
1721  dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1722  if (FPT->getNumParams() == 0)
1723  ZeroArgCallReturnTy = FunTy->getReturnType();
1724  return true;
1725  }
1726  return false;
1727 }
1728 
1729 /// Give notes for a set of overloads.
1730 ///
1731 /// A companion to tryExprAsCall. In cases when the name that the programmer
1732 /// wrote was an overloaded function, we may be able to make some guesses about
1733 /// plausible overloads based on their return types; such guesses can be handed
1734 /// off to this method to be emitted as notes.
1735 ///
1736 /// \param Overloads - The overloads to note.
1737 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1738 /// -fshow-overloads=best, this is the location to attach to the note about too
1739 /// many candidates. Typically this will be the location of the original
1740 /// ill-formed expression.
1741 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1742  const SourceLocation FinalNoteLoc) {
1743  int ShownOverloads = 0;
1744  int SuppressedOverloads = 0;
1745  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1746  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1747  // FIXME: Magic number for max shown overloads stolen from
1748  // OverloadCandidateSet::NoteCandidates.
1749  if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1750  ++SuppressedOverloads;
1751  continue;
1752  }
1753 
1754  NamedDecl *Fn = (*It)->getUnderlyingDecl();
1755  // Don't print overloads for non-default multiversioned functions.
1756  if (const auto *FD = Fn->getAsFunction()) {
1757  if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1758  !FD->getAttr<TargetAttr>()->isDefaultVersion())
1759  continue;
1760  }
1761  S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1762  ++ShownOverloads;
1763  }
1764 
1765  if (SuppressedOverloads)
1766  S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1767  << SuppressedOverloads;
1768 }
1769 
1771  const UnresolvedSetImpl &Overloads,
1772  bool (*IsPlausibleResult)(QualType)) {
1773  if (!IsPlausibleResult)
1774  return noteOverloads(S, Overloads, Loc);
1775 
1776  UnresolvedSet<2> PlausibleOverloads;
1777  for (OverloadExpr::decls_iterator It = Overloads.begin(),
1778  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1779  const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1780  QualType OverloadResultTy = OverloadDecl->getReturnType();
1781  if (IsPlausibleResult(OverloadResultTy))
1782  PlausibleOverloads.addDecl(It.getDecl());
1783  }
1784  noteOverloads(S, PlausibleOverloads, Loc);
1785 }
1786 
1787 /// Determine whether the given expression can be called by just
1788 /// putting parentheses after it. Notably, expressions with unary
1789 /// operators can't be because the unary operator will start parsing
1790 /// outside the call.
1791 static bool IsCallableWithAppend(Expr *E) {
1792  E = E->IgnoreImplicit();
1793  return (!isa<CStyleCastExpr>(E) &&
1794  !isa<UnaryOperator>(E) &&
1795  !isa<BinaryOperator>(E) &&
1796  !isa<CXXOperatorCallExpr>(E));
1797 }
1798 
1800  if (const auto *UO = dyn_cast<UnaryOperator>(E))
1801  E = UO->getSubExpr();
1802 
1803  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
1804  if (ULE->getNumDecls() == 0)
1805  return false;
1806 
1807  const NamedDecl *ND = *ULE->decls_begin();
1808  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
1809  return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
1810  }
1811  return false;
1812 }
1813 
1815  bool ForceComplain,
1816  bool (*IsPlausibleResult)(QualType)) {
1817  SourceLocation Loc = E.get()->getExprLoc();
1818  SourceRange Range = E.get()->getSourceRange();
1819 
1820  QualType ZeroArgCallTy;
1821  UnresolvedSet<4> Overloads;
1822  if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
1823  !ZeroArgCallTy.isNull() &&
1824  (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1825  // At this point, we know E is potentially callable with 0
1826  // arguments and that it returns something of a reasonable type,
1827  // so we can emit a fixit and carry on pretending that E was
1828  // actually a CallExpr.
1829  SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
1830  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1831  Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
1832  << (IsCallableWithAppend(E.get())
1833  ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1834  : FixItHint());
1835  if (!IsMV)
1836  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1837 
1838  // FIXME: Try this before emitting the fixit, and suppress diagnostics
1839  // while doing so.
1840  E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None,
1841  Range.getEnd().getLocWithOffset(1));
1842  return true;
1843  }
1844 
1845  if (!ForceComplain) return false;
1846 
1847  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1848  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
1849  if (!IsMV)
1850  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1851  E = ExprError();
1852  return true;
1853 }
1854 
1856  if (!Ident_super)
1857  Ident_super = &Context.Idents.get("super");
1858  return Ident_super;
1859 }
1860 
1862  if (!Ident___float128)
1863  Ident___float128 = &Context.Idents.get("__float128");
1864  return Ident___float128;
1865 }
1866 
1868  CapturedRegionKind K) {
1870  getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
1871  (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
1872  CSI->ReturnType = Context.VoidTy;
1873  FunctionScopes.push_back(CSI);
1874 }
1875 
1877  if (FunctionScopes.empty())
1878  return nullptr;
1879 
1880  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1881 }
1882 
1883 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
1885  return DeleteExprs;
1886 }
1887 
1888 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
1889  if (ExtStr.empty())
1890  return;
1892  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1893  auto CanT = T.getCanonicalType().getTypePtr();
1894  for (auto &I : Exts)
1895  OpenCLTypeExtMap[CanT].insert(I.str());
1896 }
1897 
1898 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
1900  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1901  if (Exts.empty())
1902  return;
1903  for (auto &I : Exts)
1904  OpenCLDeclExtMap[FD].insert(I.str());
1905 }
1906 
1908  if (CurrOpenCLExtension.empty())
1909  return;
1910  setOpenCLExtensionForType(T, CurrOpenCLExtension);
1911 }
1912 
1914  if (CurrOpenCLExtension.empty())
1915  return;
1916  setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
1917 }
1918 
1920  if (!OpenCLDeclExtMap.empty())
1921  return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
1922 
1923  return "";
1924 }
1925 
1927  if (!OpenCLTypeExtMap.empty())
1928  return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
1929 
1930  return "";
1931 }
1932 
1933 template <typename T, typename MapT>
1934 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
1935  std::string ExtensionNames = "";
1936  auto Loc = Map.find(FDT);
1937 
1938  for (auto const& I : Loc->second) {
1939  ExtensionNames += I;
1940  ExtensionNames += " ";
1941  }
1942  ExtensionNames.pop_back();
1943 
1944  return ExtensionNames;
1945 }
1946 
1948  auto Loc = OpenCLDeclExtMap.find(FD);
1949  if (Loc == OpenCLDeclExtMap.end())
1950  return false;
1951  for (auto &I : Loc->second) {
1952  if (!getOpenCLOptions().isEnabled(I))
1953  return true;
1954  }
1955  return false;
1956 }
1957 
1958 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
1959 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
1960  DiagInfoT DiagInfo, MapT &Map,
1961  unsigned Selector,
1962  SourceRange SrcRange) {
1963  auto Loc = Map.find(D);
1964  if (Loc == Map.end())
1965  return false;
1966  bool Disabled = false;
1967  for (auto &I : Loc->second) {
1968  if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
1969  Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
1970  << I << SrcRange;
1971  Disabled = true;
1972  }
1973  }
1974  return Disabled;
1975 }
1976 
1978  // Check extensions for declared types.
1979  Decl *Decl = nullptr;
1980  if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
1981  Decl = TypedefT->getDecl();
1982  if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
1983  Decl = TagT->getDecl();
1984  auto Loc = DS.getTypeSpecTypeLoc();
1985 
1986  // Check extensions for vector types.
1987  // e.g. double4 is not allowed when cl_khr_fp64 is absent.
1988  if (QT->isExtVectorType()) {
1989  auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
1990  return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
1991  }
1992 
1993  if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
1994  return true;
1995 
1996  // Check extensions for builtin types.
1997  return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
1998  QT, OpenCLTypeExtMap);
1999 }
2000 
2002  IdentifierInfo *FnName = D.getIdentifier();
2003  return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2004  OpenCLDeclExtMap, 1, D.getSourceRange());
2005 }
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:2425
Defines the clang::ASTContext interface.
ObjCInterfaceDecl * NSStringDecl
The declaration of the Objective-C NSString class.
Definition: Sema.h:865
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:598
Represents a function declaration or definition.
Definition: Decl.h:1732
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition: Sema.h:560
bool hasErrorOccurred() const
Definition: Diagnostic.h:746
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
Definition: TargetInfo.h:755
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
CanQualType OCLQueueTy
Definition: ASTContext.h:1063
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:3856
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:640
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:1180
RecordDecl * MSVCGuidDecl
The MSVC "_GUID" struct, which is defined in MSVC header files.
Definition: Sema.h:844
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3027
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:663
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:11699
void getUndefinedButUsed(SmallVectorImpl< std::pair< NamedDecl *, SourceLocation > > &Undefined)
Obtain a sorted list of functions that are undefined but ODR-used.
Definition: Sema.cpp:623
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:3351
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:497
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:1770
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:612
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:1290
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:6359
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:7611
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:815
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:335
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7248
virtual void updateOutOfDateSelector(Selector Sel)
Load the contents of the global method pool for a given selector if necessary.
Definition: Sema.cpp:1609
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:1608
CanQualType LongTy
Definition: ASTContext.h:1034
Any normal BCPL comments.
Declaration of a variable template.
static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E)
Definition: Sema.cpp:1799
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:699
A container of type source information.
Definition: Decl.h:86
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3560
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:625
IdentifierInfo * getSuperIdentifier() const
Definition: Sema.cpp:1855
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:726
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:7289
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:3161
IdentifierInfo * getFloat128Identifier() const
Definition: Sema.cpp:1861
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:7582
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:1926
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10796
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:2286
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:6683
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2147
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:10707
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1117
Expr * IgnoreImplicit() LLVM_READONLY
IgnoreImplicit - Skip past any implicit AST nodes which might surround this expression.
Definition: Expr.h:745
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:874
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:1214
Defines the clang::Expr interface and subclasses for C++ expressions.
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
Definition: Sema.h:883
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:1884
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:5312
void threadSafetyCleanup(BeforeSet *Cache)
CanQualType OCLSamplerTy
Definition: ASTContext.h:1062
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:3585
void FreeVisContext()
FreeVisContext - Deallocate and null out VisContext.
Definition: SemaAttr.cpp:733
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:847
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7578
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:4001
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:620
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.cpp:1534
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:1570
unsigned getCurrentDiagID() const
Definition: Diagnostic.h:988
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7482
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:515
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1519
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:280
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:1907
Represents a member of a struct/union/class.
Definition: Decl.h:2571
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:4101
void setEscapingByref()
Definition: Decl.h:1421
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:7597
ObjCInterfaceDecl * NSValueDecl
The declaration of the Objective-C NSValue class.
Definition: Sema.h:853
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
Definition: Sema.cpp:861
CanQualType OCLEventTy
Definition: ASTContext.h:1062
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:1504
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3480
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:667
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:1947
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1063
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:827
Describes a module or submodule.
Definition: Module.h:65
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1094
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:1741
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors...
Definition: Sema.h:6073
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:7585
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:744
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:1329
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:1205
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:422
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:833
uint32_t Offset
Definition: CacheTokens.cpp:43
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1326
bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T)
Check if type T corresponding to declaration specifier DS is disabled due to required OpenCL extensio...
Definition: Sema.cpp:1977
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:404
std::pair< SourceLocation, bool > DeleteExprLoc
Delete-expressions to be analyzed at the end of translation unit.
Definition: Sema.h:567
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:663
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:9338
friend_iterator friend_end() const
Definition: DeclFriend.h:244
~ExternalSemaSource() override
Definition: Sema.cpp:1606
Values of this type can never be null.
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:403
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:6046
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:420
void emitAndClearUnusedLocalTypedefWarnings()
Definition: Sema.cpp:817
SourceLocation getCurrentDiagLoc() const
Definition: Diagnostic.h:990
virtual ASTMutationListener * GetASTMutationListener()
If the consumer is interested in entities getting modified after their initial creation, it should return a pointer to an ASTMutationListener here.
Definition: ASTConsumer.h:124
Preprocessor & PP
Definition: Sema.h:319
ObjCInterfaceDecl * NSNumberDecl
The declaration of the Objective-C NSNumber class.
Definition: Sema.h:850
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:1611
const LangOptions & getLangOpts() const
Definition: Sema.h:1213
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:166
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
Definition: Sema.h:7596
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4036
NamespaceDecl * StdExperimentalNamespaceCache
The C++ "std::experimental" namespace, where the experimental parts of the standard library resides...
Definition: Sema.h:830
ObjCMethodDecl * StringWithUTF8StringMethod
The declaration of the stringWithUTF8String: method.
Definition: Sema.h:871
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:2001
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:491
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1217
static bool IsCallableWithAppend(Expr *E)
Determine whether the given expression can be called by just putting parentheses after it...
Definition: Sema.cpp:1791
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:1605
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3676
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:590
Retains information about a captured region.
Definition: ScopeInfo.h:737
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:1487
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:1786
void PopCompoundScope()
Definition: Sema.cpp:1491
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:1618
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:1509
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:39
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:10672
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:203
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
Definition: Sema.h:7615
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:3850
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:543
This represents one expression.
Definition: Expr.h:105
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:1898
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:580
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2645
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:6746
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:4979
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2700
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:7280
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
Definition: Type.h:6522
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:791
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:1460
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:1959
decls_iterator decls_begin() const
Definition: ExprCXX.h:2673
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7535
int Depth
Definition: ASTDiff.cpp:191
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:997
QualType getType() const
Definition: Expr.h:127
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:880
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:539
PartialDiagnostic::StorageAllocator & getDiagAllocator()
Definition: ASTContext.h:695
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:1751
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:86
bool isInvalid() const
Definition: Ownership.h:170
SourceLocation getEnd() const
Preprocessor & getPreprocessor() const
Definition: Sema.h:1219
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:880
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:1393
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:659
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1097
llvm::DenseMap< const CXXRecordDecl *, bool > RecordCompleteMap
Definition: Sema.cpp:737
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:6105
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:453
void PushBlockScope(Scope *BlockScope, BlockDecl *Block)
Definition: Sema.cpp:1388
CanQualType OverloadTy
Definition: ASTContext.h:1054
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:841
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2581
QualType getCanonicalType() const
Definition: Type.h:6085
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:3607
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:1913
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:1374
bool makeUnavailableInSystemHeader(SourceLocation loc, UnavailableAttr::ImplicitReason reason)
makeUnavailableInSystemHeader - There is an error in the current context.
Definition: Sema.cpp:373
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:1919
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:612
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>. ...
Definition: Sema.h:834
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2041
void DiagnoseUseOfUnimplementedSelectors()
CanQualType FloatTy
Definition: ASTContext.h:1037
CanQualType VoidTy
Definition: ASTContext.h:1025
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:791
virtual void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined)
Load the set of used but not defined functions or variables with internal linkage, or used but not defined internal functions.
Definition: Sema.cpp:1615
void EmitCurrentDiagnostic(unsigned DiagID)
Cause the active diagnostic on the DiagosticsEngine to be emitted.
Definition: Sema.cpp:1219
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:2929
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:786
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:551
static bool isFunctionOrVarDeclExternC(NamedDecl *ND)
Definition: Sema.cpp:604
sema::CapturedRegionScopeInfo * getCurCapturedRegion()
Retrieve the current captured region, if any.
Definition: Sema.cpp:1876
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:833
ASTConsumer & getASTConsumer() const
Definition: Sema.h:1221
void setLastDiagnosticIgnored(bool Ignored=true)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:667
void setOpenCLExtensionForType(QualType T, llvm::StringRef Exts)
Set OpenCL extensions for a type which can only be used when these OpenCL extensions are enabled...
Definition: Sema.cpp:1888
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1953
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2908
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:641
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:7313
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1261
ObjCMethodDecl * NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]
The Objective-C NSNumber methods used to create NSNumber literals.
Definition: Sema.h:862
static void checkEscapingByref(VarDecl *VD, Sema &S)
Definition: Sema.cpp:1410
ArrayRef< Capture > captures() const
Definition: Decl.h:3977
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:394
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:470
void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E)
Warn when implicitly casting 0 to nullptr.
Definition: Sema.cpp:442
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing.
Definition: Sema.cpp:1399
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:838
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:896
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:1814
A set of unresolved declarations.
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created...
Definition: Diagnostic.h:1015
IdentifierResolver IdResolver
Definition: Sema.h:810
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:218
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
Definition: Sema.cpp:525
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1089
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:1212
std::string getOpenCLExtensionsFromExtMap(T *FT, MapT &Map)
Find an extension in an appropriate extension map and return its name.
Definition: Sema.cpp:1934
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
Definition: Sema.cpp:1500
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2632
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:569
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:676
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:1035
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1200
static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S)
Definition: Sema.cpp:1434
void * OpaqueParser
Definition: Sema.h:642
ExtVectorType - Extended vector type.
Definition: Type.h:3283
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:7208
CanQualType BoundMemberTy
Definition: ASTContext.h:1054
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1026
void addComment(const RawComment &RC)
Definition: ASTContext.h:812
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:877
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:3667
The "class" keyword.
Definition: Type.h:5016
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:535
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2076
This is a scope that can contain a declaration.
Definition: Scope.h:59
SourceManager & getSourceManager()
Definition: ASTContext.h:671
The type-property cache.
Definition: Type.cpp:3419
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:1357
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2259
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:3086
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1018
void setSuppressAllDiagnostics(bool Val=true)
Suppress all diagnostics, to silence the front end when we know that we don&#39;t want any more diagnosti...
Definition: Diagnostic.h:632
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:492
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:678
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:1514
Represents a C array with an unspecified size.
Definition: Type.h:2922
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1340
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:332
bool isRValue() const
Definition: Expr.h:249
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:329
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:1218
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:268
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
Definition: Sema.cpp:1632
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1315
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:1092
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:1034
void ActOnComment(SourceRange Comment)
Definition: Sema.cpp:1579
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:976
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:818
bool isUnion() const
Definition: Decl.h:3244
NamedDecl * getMostRecentDecl()
Definition: Decl.h:445
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2130
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1161
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:428
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:1867
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1546
CanQualType DoubleTy
Definition: ASTContext.h:1037
IdentifierInfo * getBoolName() const
Retrieve the identifier &#39;bool&#39;.
Definition: ASTContext.h:1716
void setType(QualType newType)
Definition: Decl.h:648
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:716
static void checkUndefinedButUsed(Sema &S)
checkUndefinedButUsed - Check for undefined objects with internal linkage or that are inline...
Definition: Sema.cpp:676
decls_iterator decls_end() const
Definition: ExprCXX.h:2674
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:630
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:924
This class handles loading and caching of source files into memory.
void PrintContextStack()
Definition: Sema.h:7486
OpenCLOptions & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1280
bool getSuppressAllDiagnostics() const
Definition: Diagnostic.h:635
Declaration of a template function.
Definition: DeclTemplate.h:968
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1376
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:556
SourceLocation getLocation() const
Definition: DeclBase.h:418
bool isExternallyVisible() const
Definition: Decl.h:379
CanQualType OCLClkEventTy
Definition: ASTContext.h:1062
ObjCMethodDecl * DictionaryWithObjectsMethod
The declaration of the dictionaryWithObjects:forKeys:count: method.
Definition: Sema.h:886
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1243
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2514
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
This is a C++ Modules TS module interface unit.
Definition: Module.h:79
CanQualType UnsignedIntTy
Definition: ASTContext.h:1035
decl_iterator decls_end() const
Definition: DeclBase.h:1998
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:60
The translation unit is a module.
Definition: LangOptions.h:338