clang  8.0.0
Sema.cpp
Go to the documentation of this file.
1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the actions class which performs semantic analysis and
11 // builds an AST out of a parse stream.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclFriend.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/StmtCXX.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Lex/HeaderSearch.h"
28 #include "clang/Lex/Preprocessor.h"
35 #include "clang/Sema/Scope.h"
36 #include "clang/Sema/ScopeInfo.h"
41 #include "llvm/ADT/DenseMap.h"
42 #include "llvm/ADT/SmallSet.h"
43 using namespace clang;
44 using namespace sema;
45 
47  return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
48 }
49 
50 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
51 
53  const Preprocessor &PP) {
54  PrintingPolicy Policy = Context.getPrintingPolicy();
55  // In diagnostics, we print _Bool as bool if the latter is defined as the
56  // former.
57  Policy.Bool = Context.getLangOpts().Bool;
58  if (!Policy.Bool) {
59  if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
60  Policy.Bool = BoolMacro->isObjectLike() &&
61  BoolMacro->getNumTokens() == 1 &&
62  BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
63  }
64  }
65 
66  return Policy;
67 }
68 
70  TUScope = S;
71  PushDeclContext(S, Context.getTranslationUnitDecl());
72 }
73 
74 namespace clang {
75 namespace sema {
76 
77 class SemaPPCallbacks : public PPCallbacks {
78  Sema *S = nullptr;
80 
81 public:
82  void set(Sema &S) { this->S = &S; }
83 
84  void reset() { S = nullptr; }
85 
86  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
88  FileID PrevFID) override {
89  if (!S)
90  return;
91  switch (Reason) {
92  case EnterFile: {
94  SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
95  if (IncludeLoc.isValid()) {
96  IncludeStack.push_back(IncludeLoc);
99  }
100  break;
101  }
102  case ExitFile:
103  if (!IncludeStack.empty())
106  IncludeStack.pop_back_val());
107  break;
108  default:
109  break;
110  }
111  }
112 };
113 
114 } // end namespace sema
115 } // end namespace clang
116 
117 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
118  TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
119  : ExternalSource(nullptr), isMultiplexExternalSource(false),
120  FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
121  Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
122  SourceMgr(PP.getSourceManager()), CollectStats(false),
123  CodeCompleter(CodeCompleter), CurContext(nullptr),
124  OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
125  MSPointerToMemberRepresentationMethod(
126  LangOpts.getMSPointerToMemberRepresentationMethod()),
127  VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),
128  DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
129  CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
130  PragmaAttributeCurrentTargetDecl(nullptr),
131  IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
132  LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
134  StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
135  MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
136  NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
137  ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
138  ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
141  FullyCheckedComparisonCategories(
142  static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
146  TyposCorrected(0), AnalysisWarnings(*this),
147  ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
148  CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
149  TUScope = nullptr;
150 
151  LoadedExternalKnownNamespaces = false;
152  for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
153  NSNumberLiteralMethods[I] = nullptr;
154 
155  if (getLangOpts().ObjC)
156  NSAPIObj.reset(new NSAPI(Context));
157 
158  if (getLangOpts().CPlusPlus)
159  FieldCollector.reset(new CXXFieldCollector());
160 
161  // Tell diagnostics how to render things from the AST library.
163 
164  ExprEvalContexts.emplace_back(
167 
169 
170  // Initialization of data sharing attributes stack for OpenMP
171  InitDataSharingAttributesStack();
172 
173  std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
174  llvm::make_unique<sema::SemaPPCallbacks>();
175  SemaPPCallbackHandler = Callbacks.get();
176  PP.addPPCallbacks(std::move(Callbacks));
177  SemaPPCallbackHandler->set(*this);
178 }
179 
180 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
181  DeclarationName DN = &Context.Idents.get(Name);
182  if (IdResolver.begin(DN) == IdResolver.end())
184 }
185 
187  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
188  SC->InitializeSema(*this);
189 
190  // Tell the external Sema source about this Sema object.
191  if (ExternalSemaSource *ExternalSema
192  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
193  ExternalSema->InitializeSema(*this);
194 
195  // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
196  // will not be able to merge any duplicate __va_list_tag decls correctly.
197  VAListTagName = PP.getIdentifierInfo("__va_list_tag");
198 
199  if (!TUScope)
200  return;
201 
202  // Initialize predefined 128-bit integer types, if needed.
204  // If either of the 128-bit integer types are unavailable to name lookup,
205  // define them now.
206  DeclarationName Int128 = &Context.Idents.get("__int128_t");
207  if (IdResolver.begin(Int128) == IdResolver.end())
209 
210  DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
211  if (IdResolver.begin(UInt128) == IdResolver.end())
213  }
214 
215 
216  // Initialize predefined Objective-C types:
217  if (getLangOpts().ObjC) {
218  // If 'SEL' does not yet refer to any declarations, make it refer to the
219  // predefined 'SEL'.
220  DeclarationName SEL = &Context.Idents.get("SEL");
221  if (IdResolver.begin(SEL) == IdResolver.end())
223 
224  // If 'id' does not yet refer to any declarations, make it refer to the
225  // predefined 'id'.
227  if (IdResolver.begin(Id) == IdResolver.end())
229 
230  // Create the built-in typedef for 'Class'.
231  DeclarationName Class = &Context.Idents.get("Class");
232  if (IdResolver.begin(Class) == IdResolver.end())
234 
235  // Create the built-in forward declaratino for 'Protocol'.
236  DeclarationName Protocol = &Context.Idents.get("Protocol");
237  if (IdResolver.begin(Protocol) == IdResolver.end())
239  }
240 
241  // Create the internal type for the *StringMakeConstantString builtins.
242  DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
243  if (IdResolver.begin(ConstantString) == IdResolver.end())
245 
246  // Initialize Microsoft "predefined C++ types".
247  if (getLangOpts().MSVCCompat) {
248  if (getLangOpts().CPlusPlus &&
249  IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
251  TUScope);
252 
254  }
255 
256  // Initialize predefined OpenCL types and supported extensions and (optional)
257  // core features.
258  if (getLangOpts().OpenCL) {
264  if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
265  addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
267  addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
269  addImplicitTypedef("atomic_uint",
271  auto AtomicLongT = Context.getAtomicType(Context.LongTy);
272  addImplicitTypedef("atomic_long", AtomicLongT);
273  auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
274  addImplicitTypedef("atomic_ulong", AtomicULongT);
275  addImplicitTypedef("atomic_float",
277  auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
278  addImplicitTypedef("atomic_double", AtomicDoubleT);
279  // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
280  // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
282  auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
283  addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
284  auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
285  addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
286  auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
287  addImplicitTypedef("atomic_size_t", AtomicSizeT);
288  auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
289  addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
290 
291  // OpenCL v2.0 s6.13.11.6:
292  // - The atomic_long and atomic_ulong types are supported if the
293  // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
294  // extensions are supported.
295  // - The atomic_double type is only supported if double precision
296  // is supported and the cl_khr_int64_base_atomics and
297  // cl_khr_int64_extended_atomics extensions are supported.
298  // - If the device address space is 64-bits, the data types
299  // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
300  // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
301  // cl_khr_int64_extended_atomics extensions are supported.
302  std::vector<QualType> Atomic64BitTypes;
303  Atomic64BitTypes.push_back(AtomicLongT);
304  Atomic64BitTypes.push_back(AtomicULongT);
305  Atomic64BitTypes.push_back(AtomicDoubleT);
306  if (Context.getTypeSize(AtomicSizeT) == 64) {
307  Atomic64BitTypes.push_back(AtomicSizeT);
308  Atomic64BitTypes.push_back(AtomicIntPtrT);
309  Atomic64BitTypes.push_back(AtomicUIntPtrT);
310  Atomic64BitTypes.push_back(AtomicPtrDiffT);
311  }
312  for (auto &I : Atomic64BitTypes)
314  "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
315 
316  setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
317  }
318 
320 
321 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
322  setOpenCLExtensionForType(Context.Id, Ext);
323 #include "clang/Basic/OpenCLImageTypes.def"
324 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
325  addImplicitTypedef(#ExtType, Context.Id##Ty); \
326  setOpenCLExtensionForType(Context.Id##Ty, #Ext);
327 #include "clang/Basic/OpenCLExtensionTypes.def"
328  };
329 
331  DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
332  if (IdResolver.begin(MSVaList) == IdResolver.end())
334  }
335 
336  DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
337  if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
339 }
340 
342  if (VisContext) FreeVisContext();
343 
344  // Kill all the active scopes.
346  if (FSI != PreallocatedFunctionScope.get())
347  delete FSI;
348 
349  // Tell the SemaConsumer to forget about us; we're going out of scope.
350  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
351  SC->ForgetSema();
352 
353  // Detach from the external Sema source.
354  if (ExternalSemaSource *ExternalSema
355  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
356  ExternalSema->ForgetSema();
357 
358  // If Sema's ExternalSource is the multiplexer - we own it.
359  if (isMultiplexExternalSource)
360  delete ExternalSource;
361 
363 
364  // Destroys data sharing attributes stack for OpenMP
365  DestroyDataSharingAttributesStack();
366 
367  // Detach from the PP callback handler which outlives Sema since it's owned
368  // by the preprocessor.
369  SemaPPCallbackHandler->reset();
370 
371  assert(DelayedTypos.empty() && "Uncorrected typos!");
372 }
373 
374 /// makeUnavailableInSystemHeader - There is an error in the current
375 /// context. If we're still in a system header, and we can plausibly
376 /// make the relevant declaration unavailable instead of erroring, do
377 /// so and return true.
379  UnavailableAttr::ImplicitReason reason) {
380  // If we're not in a function, it's an error.
381  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
382  if (!fn) return false;
383 
384  // If we're in template instantiation, it's an error.
386  return false;
387 
388  // If that function's not in a system header, it's an error.
390  return false;
391 
392  // If the function is already unavailable, it's not an error.
393  if (fn->hasAttr<UnavailableAttr>()) return true;
394 
395  fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
396  return true;
397 }
398 
401 }
402 
403 ///Registers an external source. If an external source already exists,
404 /// creates a multiplex external source and appends to it.
405 ///
406 ///\param[in] E - A non-null external sema source.
407 ///
409  assert(E && "Cannot use with NULL ptr");
410 
411  if (!ExternalSource) {
412  ExternalSource = E;
413  return;
414  }
415 
416  if (isMultiplexExternalSource)
417  static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
418  else {
419  ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
420  isMultiplexExternalSource = true;
421  }
422 }
423 
424 /// Print out statistics about the semantic analysis.
425 void Sema::PrintStats() const {
426  llvm::errs() << "\n*** Semantic Analysis Stats:\n";
427  llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
428 
429  BumpAlloc.PrintStats();
431 }
432 
434  QualType SrcType,
435  SourceLocation Loc) {
436  Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
437  if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
438  return;
439 
440  Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
441  if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
442  return;
443 
444  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
445 }
446 
448  if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
449  E->getBeginLoc()))
450  return;
451  // nullptr only exists from C++11 on, so don't warn on its absence earlier.
452  if (!getLangOpts().CPlusPlus11)
453  return;
454 
455  if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
456  return;
458  return;
459 
460  // If it is a macro from system header, and if the macro name is not "NULL",
461  // do not warn.
462  SourceLocation MaybeMacroLoc = E->getBeginLoc();
464  SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
465  !findMacroSpelling(MaybeMacroLoc, "NULL"))
466  return;
467 
468  Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
469  << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
470 }
471 
472 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
473 /// If there is already an implicit cast, merge into the existing one.
474 /// The result is of the given category.
477  const CXXCastPath *BasePath,
478  CheckedConversionKind CCK) {
479 #ifndef NDEBUG
480  if (VK == VK_RValue && !E->isRValue()) {
481  switch (Kind) {
482  default:
483  llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
484  "kind");
485  case CK_LValueToRValue:
486  case CK_ArrayToPointerDecay:
487  case CK_FunctionToPointerDecay:
488  case CK_ToVoid:
489  case CK_NonAtomicToAtomic:
490  break;
491  }
492  }
493  assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
494 #endif
495 
498 
499  QualType ExprTy = Context.getCanonicalType(E->getType());
501 
502  if (ExprTy == TypeTy)
503  return E;
504 
505  // C++1z [conv.array]: The temporary materialization conversion is applied.
506  // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
507  if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
508  E->getValueKind() == VK_RValue) {
509  // The temporary is an lvalue in C++98 and an xvalue otherwise.
511  E->getType(), E, !getLangOpts().CPlusPlus11);
512  if (Materialized.isInvalid())
513  return ExprError();
514  E = Materialized.get();
515  }
516 
517  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
518  if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
519  ImpCast->setType(Ty);
520  ImpCast->setValueKind(VK);
521  return E;
522  }
523  }
524 
525  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
526 }
527 
528 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
529 /// to the conversion from scalar type ScalarTy to the Boolean type.
531  switch (ScalarTy->getScalarTypeKind()) {
532  case Type::STK_Bool: return CK_NoOp;
533  case Type::STK_CPointer: return CK_PointerToBoolean;
534  case Type::STK_BlockPointer: return CK_PointerToBoolean;
535  case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
536  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
537  case Type::STK_Integral: return CK_IntegralToBoolean;
538  case Type::STK_Floating: return CK_FloatingToBoolean;
539  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
540  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
541  case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
542  }
543  llvm_unreachable("unknown scalar type kind");
544 }
545 
546 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
547 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
548  if (D->getMostRecentDecl()->isUsed())
549  return true;
550 
551  if (D->isExternallyVisible())
552  return true;
553 
554  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
555  // If this is a function template and none of its specializations is used,
556  // we should warn.
557  if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
558  for (const auto *Spec : Template->specializations())
559  if (ShouldRemoveFromUnused(SemaRef, Spec))
560  return true;
561 
562  // UnusedFileScopedDecls stores the first declaration.
563  // The declaration may have become definition so check again.
564  const FunctionDecl *DeclToCheck;
565  if (FD->hasBody(DeclToCheck))
566  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
567 
568  // Later redecls may add new information resulting in not having to warn,
569  // so check again.
570  DeclToCheck = FD->getMostRecentDecl();
571  if (DeclToCheck != FD)
572  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
573  }
574 
575  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
576  // If a variable usable in constant expressions is referenced,
577  // don't warn if it isn't used: if the value of a variable is required
578  // for the computation of a constant expression, it doesn't make sense to
579  // warn even if the variable isn't odr-used. (isReferenced doesn't
580  // precisely reflect that, but it's a decent approximation.)
581  if (VD->isReferenced() &&
582  VD->isUsableInConstantExpressions(SemaRef->Context))
583  return true;
584 
585  if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
586  // If this is a variable template and none of its specializations is used,
587  // we should warn.
588  for (const auto *Spec : Template->specializations())
589  if (ShouldRemoveFromUnused(SemaRef, Spec))
590  return true;
591 
592  // UnusedFileScopedDecls stores the first declaration.
593  // The declaration may have become definition so check again.
594  const VarDecl *DeclToCheck = VD->getDefinition();
595  if (DeclToCheck)
596  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
597 
598  // Later redecls may add new information resulting in not having to warn,
599  // so check again.
600  DeclToCheck = VD->getMostRecentDecl();
601  if (DeclToCheck != VD)
602  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
603  }
604 
605  return false;
606 }
607 
609  if (auto *FD = dyn_cast<FunctionDecl>(ND))
610  return FD->isExternC();
611  return cast<VarDecl>(ND)->isExternC();
612 }
613 
614 /// Determine whether ND is an external-linkage function or variable whose
615 /// type has no linkage.
617  // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
618  // because we also want to catch the case where its type has VisibleNoLinkage,
619  // which does not affect the linkage of VD.
620  return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
623 }
624 
625 /// Obtains a sorted list of functions and variables that are undefined but
626 /// ODR-used.
628  SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
629  for (const auto &UndefinedUse : UndefinedButUsed) {
630  NamedDecl *ND = UndefinedUse.first;
631 
632  // Ignore attributes that have become invalid.
633  if (ND->isInvalidDecl()) continue;
634 
635  // __attribute__((weakref)) is basically a definition.
636  if (ND->hasAttr<WeakRefAttr>()) continue;
637 
638  if (isa<CXXDeductionGuideDecl>(ND))
639  continue;
640 
641  if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
642  // An exported function will always be emitted when defined, so even if
643  // the function is inline, it doesn't have to be emitted in this TU. An
644  // imported function implies that it has been exported somewhere else.
645  continue;
646  }
647 
648  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
649  if (FD->isDefined())
650  continue;
651  if (FD->isExternallyVisible() &&
653  !FD->getMostRecentDecl()->isInlined() &&
654  !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
655  continue;
656  if (FD->getBuiltinID())
657  continue;
658  } else {
659  auto *VD = cast<VarDecl>(ND);
660  if (VD->hasDefinition() != VarDecl::DeclarationOnly)
661  continue;
662  if (VD->isExternallyVisible() &&
664  !VD->getMostRecentDecl()->isInline() &&
665  !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
666  continue;
667 
668  // Skip VarDecls that lack formal definitions but which we know are in
669  // fact defined somewhere.
670  if (VD->isKnownToBeDefined())
671  continue;
672  }
673 
674  Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
675  }
676 }
677 
678 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
679 /// or that are inline.
680 static void checkUndefinedButUsed(Sema &S) {
681  if (S.UndefinedButUsed.empty()) return;
682 
683  // Collect all the still-undefined entities with internal linkage.
685  S.getUndefinedButUsed(Undefined);
686  if (Undefined.empty()) return;
687 
688  for (auto Undef : Undefined) {
689  ValueDecl *VD = cast<ValueDecl>(Undef.first);
690  SourceLocation UseLoc = Undef.second;
691 
692  if (S.isExternalWithNoLinkageType(VD)) {
693  // C++ [basic.link]p8:
694  // A type without linkage shall not be used as the type of a variable
695  // or function with external linkage unless
696  // -- the entity has C language linkage
697  // -- the entity is not odr-used or is defined in the same TU
698  //
699  // As an extension, accept this in cases where the type is externally
700  // visible, since the function or variable actually can be defined in
701  // another translation unit in that case.
703  ? diag::ext_undefined_internal_type
704  : diag::err_undefined_internal_type)
705  << isa<VarDecl>(VD) << VD;
706  } else if (!VD->isExternallyVisible()) {
707  // FIXME: We can promote this to an error. The function or variable can't
708  // be defined anywhere else, so the program must necessarily violate the
709  // one definition rule.
710  S.Diag(VD->getLocation(), diag::warn_undefined_internal)
711  << isa<VarDecl>(VD) << VD;
712  } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
713  (void)FD;
714  assert(FD->getMostRecentDecl()->isInlined() &&
715  "used object requires definition but isn't inline or internal?");
716  // FIXME: This is ill-formed; we should reject.
717  S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
718  } else {
719  assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
720  "used var requires definition but isn't inline or internal?");
721  S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
722  }
723  if (UseLoc.isValid())
724  S.Diag(UseLoc, diag::note_used_here);
725  }
726 
727  S.UndefinedButUsed.clear();
728 }
729 
731  if (!ExternalSource)
732  return;
733 
735  ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
736  for (auto &WeakID : WeakIDs)
737  WeakUndeclaredIdentifiers.insert(WeakID);
738 }
739 
740 
741 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
742 
743 /// Returns true, if all methods and nested classes of the given
744 /// CXXRecordDecl are defined in this translation unit.
745 ///
746 /// Should only be called from ActOnEndOfTranslationUnit so that all
747 /// definitions are actually read.
749  RecordCompleteMap &MNCComplete) {
750  RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
751  if (Cache != MNCComplete.end())
752  return Cache->second;
753  if (!RD->isCompleteDefinition())
754  return false;
755  bool Complete = true;
757  E = RD->decls_end();
758  I != E && Complete; ++I) {
759  if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
760  Complete = M->isDefined() || M->isDefaulted() ||
761  (M->isPure() && !isa<CXXDestructorDecl>(M));
762  else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
763  // If the template function is marked as late template parsed at this
764  // point, it has not been instantiated and therefore we have not
765  // performed semantic analysis on it yet, so we cannot know if the type
766  // can be considered complete.
767  Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
768  F->getTemplatedDecl()->isDefined();
769  else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
770  if (R->isInjectedClassName())
771  continue;
772  if (R->hasDefinition())
773  Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
774  MNCComplete);
775  else
776  Complete = false;
777  }
778  }
779  MNCComplete[RD] = Complete;
780  return Complete;
781 }
782 
783 /// Returns true, if the given CXXRecordDecl is fully defined in this
784 /// translation unit, i.e. all methods are defined or pure virtual and all
785 /// friends, friend functions and nested classes are fully defined in this
786 /// translation unit.
787 ///
788 /// Should only be called from ActOnEndOfTranslationUnit so that all
789 /// definitions are actually read.
790 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
791  RecordCompleteMap &RecordsComplete,
792  RecordCompleteMap &MNCComplete) {
793  RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
794  if (Cache != RecordsComplete.end())
795  return Cache->second;
796  bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
798  E = RD->friend_end();
799  I != E && Complete; ++I) {
800  // Check if friend classes and methods are complete.
801  if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
802  // Friend classes are available as the TypeSourceInfo of the FriendDecl.
803  if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
804  Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
805  else
806  Complete = false;
807  } else {
808  // Friend functions are available through the NamedDecl of FriendDecl.
809  if (const FunctionDecl *FD =
810  dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
811  Complete = FD->isDefined();
812  else
813  // This is a template friend, give up.
814  Complete = false;
815  }
816  }
817  RecordsComplete[RD] = Complete;
818  return Complete;
819 }
820 
822  if (ExternalSource)
823  ExternalSource->ReadUnusedLocalTypedefNameCandidates(
826  if (TD->isReferenced())
827  continue;
828  Diag(TD->getLocation(), diag::warn_unused_local_typedef)
829  << isa<TypeAliasDecl>(TD) << TD->getDeclName();
830  }
831  UnusedLocalTypedefNameCandidates.clear();
832 }
833 
834 /// This is called before the very first declaration in the translation unit
835 /// is parsed. Note that the ASTContext may have already injected some
836 /// declarations.
838  if (getLangOpts().ModulesTS &&
839  (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
840  getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
841  SourceLocation StartOfTU =
843 
844  // We start in the global module; all those declarations are implicitly
845  // module-private (though they do not have module linkage).
846  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
847  auto *GlobalModule = Map.createGlobalModuleForInterfaceUnit(StartOfTU);
848  assert(GlobalModule && "module creation should not fail");
849 
850  // Enter the scope of the global module.
851  ModuleScopes.push_back({});
852  ModuleScopes.back().Module = GlobalModule;
853  VisibleModules.setVisible(GlobalModule, StartOfTU);
854 
855  // All declarations created from now on are owned by the global module.
856  auto *TU = Context.getTranslationUnitDecl();
858  TU->setLocalOwningModule(GlobalModule);
859  }
860 }
861 
862 /// ActOnEndOfTranslationUnit - This is called at the very end of the
863 /// translation unit when EOF is reached and all but the top-level scope is
864 /// popped.
866  assert(DelayedDiagnostics.getCurrentPool() == nullptr
867  && "reached end of translation unit with a pool attached?");
868 
869  // If code completion is enabled, don't perform any end-of-translation-unit
870  // work.
872  return;
873 
874  // Transfer late parsed template instantiations over to the pending template
875  // instantiation list. During normal compliation, the late template parser
876  // will be installed and instantiating these templates will succeed.
877  //
878  // If we are building a TU prefix for serialization, it is also safe to
879  // transfer these over, even though they are not parsed. The end of the TU
880  // should be outside of any eager template instantiation scope, so when this
881  // AST is deserialized, these templates will not be parsed until the end of
882  // the combined TU.
884  LateParsedInstantiations.begin(),
886  LateParsedInstantiations.clear();
887 
888  // Complete translation units and modules define vtables and perform implicit
889  // instantiations. PCH files do not.
890  if (TUKind != TU_Prefix) {
892 
893  // If DefinedUsedVTables ends up marking any virtual member functions it
894  // might lead to more pending template instantiations, which we then need
895  // to instantiate.
897 
898  // C++: Perform implicit template instantiations.
899  //
900  // FIXME: When we perform these implicit instantiations, we do not
901  // carefully keep track of the point of instantiation (C++ [temp.point]).
902  // This means that name lookup that occurs within the template
903  // instantiation will always happen at the end of the translation unit,
904  // so it will find some names that are not required to be found. This is
905  // valid, but we could do better by diagnosing if an instantiation uses a
906  // name that was not visible at its first point of instantiation.
907  if (ExternalSource) {
908  // Load pending instantiations from the external source.
910  ExternalSource->ReadPendingInstantiations(Pending);
911  for (auto PII : Pending)
912  if (auto Func = dyn_cast<FunctionDecl>(PII.first))
913  Func->setInstantiationIsPending(true);
915  Pending.begin(), Pending.end());
916  }
917 
919 
920  assert(LateParsedInstantiations.empty() &&
921  "end of TU template instantiation should not create more "
922  "late-parsed templates");
923 
926 
928  }
929 
932 
933  // All delayed member exception specs should be checked or we end up accepting
934  // incompatible declarations.
935  assert(DelayedOverridingExceptionSpecChecks.empty());
936  assert(DelayedEquivalentExceptionSpecChecks.empty());
937  assert(DelayedDefaultedMemberExceptionSpecs.empty());
938 
939  // All dllexport classes should have been processed already.
940  assert(DelayedDllExportClasses.empty());
941 
942  // Remove file scoped decls that turned out to be used.
944  std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
946  [this](const DeclaratorDecl *DD) {
947  return ShouldRemoveFromUnused(this, DD);
948  }),
950 
951  if (TUKind == TU_Prefix) {
952  // Translation unit prefixes don't need any of the checking below.
954  TUScope = nullptr;
955  return;
956  }
957 
958  // Check for #pragma weak identifiers that were never declared
960  for (auto WeakID : WeakUndeclaredIdentifiers) {
961  if (WeakID.second.getUsed())
962  continue;
963 
964  Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
966  if (PrevDecl != nullptr &&
967  !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
968  Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
969  << "'weak'" << ExpectedVariableOrFunction;
970  else
971  Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
972  << WeakID.first;
973  }
974 
975  if (LangOpts.CPlusPlus11 &&
976  !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
978 
979  if (!Diags.hasErrorOccurred()) {
980  if (ExternalSource)
981  ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
982  checkUndefinedButUsed(*this);
983  }
984 
985  if (TUKind == TU_Module) {
986  // If we are building a module interface unit, we need to have seen the
987  // module declaration by now.
988  if (getLangOpts().getCompilingModule() ==
990  (ModuleScopes.empty() ||
991  ModuleScopes.back().Module->Kind != Module::ModuleInterfaceUnit)) {
992  // FIXME: Make a better guess as to where to put the module declaration.
993  Diag(getSourceManager().getLocForStartOfFile(
994  getSourceManager().getMainFileID()),
995  diag::err_module_declaration_missing);
996  }
997 
998  // If we are building a module, resolve all of the exported declarations
999  // now.
1000  if (Module *CurrentModule = PP.getCurrentModule()) {
1002 
1004  Stack.push_back(CurrentModule);
1005  while (!Stack.empty()) {
1006  Module *Mod = Stack.pop_back_val();
1007 
1008  // Resolve the exported declarations and conflicts.
1009  // FIXME: Actually complain, once we figure out how to teach the
1010  // diagnostic client to deal with complaints in the module map at this
1011  // point.
1012  ModMap.resolveExports(Mod, /*Complain=*/false);
1013  ModMap.resolveUses(Mod, /*Complain=*/false);
1014  ModMap.resolveConflicts(Mod, /*Complain=*/false);
1015 
1016  // Queue the submodules, so their exports will also be resolved.
1017  Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1018  }
1019  }
1020 
1021  // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1022  // modules when they are built, not every time they are used.
1024  }
1025 
1026  // C99 6.9.2p2:
1027  // A declaration of an identifier for an object that has file
1028  // scope without an initializer, and without a storage-class
1029  // specifier or with the storage-class specifier static,
1030  // constitutes a tentative definition. If a translation unit
1031  // contains one or more tentative definitions for an identifier,
1032  // and the translation unit contains no external definition for
1033  // that identifier, then the behavior is exactly as if the
1034  // translation unit contains a file scope declaration of that
1035  // identifier, with the composite type as of the end of the
1036  // translation unit, with an initializer equal to 0.
1037  llvm::SmallSet<VarDecl *, 32> Seen;
1038  for (TentativeDefinitionsType::iterator
1039  T = TentativeDefinitions.begin(ExternalSource),
1040  TEnd = TentativeDefinitions.end();
1041  T != TEnd; ++T) {
1042  VarDecl *VD = (*T)->getActingDefinition();
1043 
1044  // If the tentative definition was completed, getActingDefinition() returns
1045  // null. If we've already seen this variable before, insert()'s second
1046  // return value is false.
1047  if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1048  continue;
1049 
1050  if (const IncompleteArrayType *ArrayT
1052  // Set the length of the array to 1 (C99 6.9.2p5).
1053  Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1054  llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
1055  QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1056  One, ArrayType::Normal, 0);
1057  VD->setType(T);
1058  } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1059  diag::err_tentative_def_incomplete_type))
1060  VD->setInvalidDecl();
1061 
1062  // No initialization is performed for a tentative definition.
1064 
1065  // Notify the consumer that we've completed a tentative definition.
1066  if (!VD->isInvalidDecl())
1068  }
1069 
1070  // If there were errors, disable 'unused' warnings since they will mostly be
1071  // noise. Don't warn for a use from a module: either we should warn on all
1072  // file-scope declarations in modules or not at all, but whether the
1073  // declaration is used is immaterial.
1074  if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1075  // Output warning for unused file scoped decls.
1076  for (UnusedFileScopedDeclsType::iterator
1077  I = UnusedFileScopedDecls.begin(ExternalSource),
1078  E = UnusedFileScopedDecls.end(); I != E; ++I) {
1079  if (ShouldRemoveFromUnused(this, *I))
1080  continue;
1081 
1082  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1083  const FunctionDecl *DiagD;
1084  if (!FD->hasBody(DiagD))
1085  DiagD = FD;
1086  if (DiagD->isDeleted())
1087  continue; // Deleted functions are supposed to be unused.
1088  if (DiagD->isReferenced()) {
1089  if (isa<CXXMethodDecl>(DiagD))
1090  Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1091  << DiagD->getDeclName();
1092  else {
1093  if (FD->getStorageClass() == SC_Static &&
1094  !FD->isInlineSpecified() &&
1096  SourceMgr.getExpansionLoc(FD->getLocation())))
1097  Diag(DiagD->getLocation(),
1098  diag::warn_unneeded_static_internal_decl)
1099  << DiagD->getDeclName();
1100  else
1101  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1102  << /*function*/0 << DiagD->getDeclName();
1103  }
1104  } else {
1105  if (FD->getDescribedFunctionTemplate())
1106  Diag(DiagD->getLocation(), diag::warn_unused_template)
1107  << /*function*/0 << DiagD->getDeclName();
1108  else
1109  Diag(DiagD->getLocation(),
1110  isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1111  : diag::warn_unused_function)
1112  << DiagD->getDeclName();
1113  }
1114  } else {
1115  const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1116  if (!DiagD)
1117  DiagD = cast<VarDecl>(*I);
1118  if (DiagD->isReferenced()) {
1119  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1120  << /*variable*/1 << DiagD->getDeclName();
1121  } else if (DiagD->getType().isConstQualified()) {
1122  const SourceManager &SM = SourceMgr;
1123  if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1125  Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1126  << DiagD->getDeclName();
1127  } else {
1128  if (DiagD->getDescribedVarTemplate())
1129  Diag(DiagD->getLocation(), diag::warn_unused_template)
1130  << /*variable*/1 << DiagD->getDeclName();
1131  else
1132  Diag(DiagD->getLocation(), diag::warn_unused_variable)
1133  << DiagD->getDeclName();
1134  }
1135  }
1136  }
1137 
1139  }
1140 
1141  if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1142  // FIXME: Load additional unused private field candidates from the external
1143  // source.
1144  RecordCompleteMap RecordsComplete;
1145  RecordCompleteMap MNCComplete;
1146  for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1147  E = UnusedPrivateFields.end(); I != E; ++I) {
1148  const NamedDecl *D = *I;
1149  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1150  if (RD && !RD->isUnion() &&
1151  IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1152  Diag(D->getLocation(), diag::warn_unused_private_field)
1153  << D->getDeclName();
1154  }
1155  }
1156  }
1157 
1158  if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1159  if (ExternalSource)
1161  for (const auto &DeletedFieldInfo : DeleteExprs) {
1162  for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1163  AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1164  DeleteExprLoc.second);
1165  }
1166  }
1167  }
1168 
1169  // Check we've noticed that we're no longer parsing the initializer for every
1170  // variable. If we miss cases, then at best we have a performance issue and
1171  // at worst a rejects-valid bug.
1172  assert(ParsingInitForAutoVars.empty() &&
1173  "Didn't unmark var as having its initializer parsed");
1174 
1176  TUScope = nullptr;
1177 }
1178 
1179 
1180 //===----------------------------------------------------------------------===//
1181 // Helper functions.
1182 //===----------------------------------------------------------------------===//
1183 
1185  DeclContext *DC = CurContext;
1186 
1187  while (true) {
1188  if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1189  DC = DC->getParent();
1190  } else if (isa<CXXMethodDecl>(DC) &&
1191  cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1192  cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1193  DC = DC->getParent()->getParent();
1194  }
1195  else break;
1196  }
1197 
1198  return DC;
1199 }
1200 
1201 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1202 /// to the function decl for the function being parsed. If we're currently
1203 /// in a 'block', this returns the containing context.
1206  return dyn_cast<FunctionDecl>(DC);
1207 }
1208 
1211  while (isa<RecordDecl>(DC))
1212  DC = DC->getParent();
1213  return dyn_cast<ObjCMethodDecl>(DC);
1214 }
1215 
1218  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1219  return cast<NamedDecl>(DC);
1220  return nullptr;
1221 }
1222 
1223 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1224  // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1225  // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1226  // been made more painfully obvious by the refactor that introduced this
1227  // function, but it is possible that the incoming argument can be
1228  // eliminated. If it truly cannot be (for example, there is some reentrancy
1229  // issue I am not seeing yet), then there should at least be a clarifying
1230  // comment somewhere.
1233  Diags.getCurrentDiagID())) {
1235  // We'll report the diagnostic below.
1236  break;
1237 
1239  // Count this failure so that we know that template argument deduction
1240  // has failed.
1241  ++NumSFINAEErrors;
1242 
1243  // Make a copy of this suppressed diagnostic and store it with the
1244  // template-deduction information.
1245  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1246  Diagnostic DiagInfo(&Diags);
1247  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1249  }
1250 
1252  Diags.Clear();
1253  return;
1254 
1256  // Per C++ Core Issue 1170, access control is part of SFINAE.
1257  // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1258  // make access control a part of SFINAE for the purposes of checking
1259  // type traits.
1261  break;
1262 
1264 
1265  // Suppress this diagnostic.
1266  ++NumSFINAEErrors;
1267 
1268  // Make a copy of this suppressed diagnostic and store it with the
1269  // template-deduction information.
1270  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1271  Diagnostic DiagInfo(&Diags);
1272  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1274  }
1275 
1277  Diags.Clear();
1278 
1279  // Now the diagnostic state is clear, produce a C++98 compatibility
1280  // warning.
1281  Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1282 
1283  // The last diagnostic which Sema produced was ignored. Suppress any
1284  // notes attached to it.
1286  return;
1287  }
1288 
1290  // Make a copy of this suppressed diagnostic and store it with the
1291  // template-deduction information;
1292  if (*Info) {
1293  Diagnostic DiagInfo(&Diags);
1294  (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1296  }
1297 
1298  // Suppress this diagnostic.
1300  Diags.Clear();
1301  return;
1302  }
1303  }
1304 
1305  // Copy the diagnostic printing policy over the ASTContext printing policy.
1306  // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1308 
1309  // Emit the diagnostic.
1311  return;
1312 
1313  // If this is not a note, and we're in a template instantiation
1314  // that is different from the last template instantiation where
1315  // we emitted an error, print a template instantiation
1316  // backtrace.
1317  if (!DiagnosticIDs::isBuiltinNote(DiagID))
1319 }
1320 
1323  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1324  PD.Emit(Builder);
1325 
1326  return Builder;
1327 }
1328 
1329 /// Looks through the macro-expansion chain for the given
1330 /// location, looking for a macro expansion with the given name.
1331 /// If one is found, returns true and sets the location to that
1332 /// expansion loc.
1333 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1334  SourceLocation loc = locref;
1335  if (!loc.isMacroID()) return false;
1336 
1337  // There's no good way right now to look at the intermediate
1338  // expansions, so just jump to the expansion location.
1339  loc = getSourceManager().getExpansionLoc(loc);
1340 
1341  // If that's written with the name, stop here.
1342  SmallVector<char, 16> buffer;
1343  if (getPreprocessor().getSpelling(loc, buffer) == name) {
1344  locref = loc;
1345  return true;
1346  }
1347  return false;
1348 }
1349 
1350 /// Determines the active Scope associated with the given declaration
1351 /// context.
1352 ///
1353 /// This routine maps a declaration context to the active Scope object that
1354 /// represents that declaration context in the parser. It is typically used
1355 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1356 /// declarations) that injects a name for name-lookup purposes and, therefore,
1357 /// must update the Scope.
1358 ///
1359 /// \returns The scope corresponding to the given declaraion context, or NULL
1360 /// if no such scope is open.
1362 
1363  if (!Ctx)
1364  return nullptr;
1365 
1366  Ctx = Ctx->getPrimaryContext();
1367  for (Scope *S = getCurScope(); S; S = S->getParent()) {
1368  // Ignore scopes that cannot have declarations. This is important for
1369  // out-of-line definitions of static class members.
1370  if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1371  if (DeclContext *Entity = S->getEntity())
1372  if (Ctx == Entity->getPrimaryContext())
1373  return S;
1374  }
1375 
1376  return nullptr;
1377 }
1378 
1379 /// Enter a new function scope
1381  if (FunctionScopes.empty()) {
1382  // Use PreallocatedFunctionScope to avoid allocating memory when possible.
1383  PreallocatedFunctionScope->Clear();
1384  FunctionScopes.push_back(PreallocatedFunctionScope.get());
1385  } else {
1387  }
1388  if (LangOpts.OpenMP)
1389  pushOpenMPFunctionRegion();
1390 }
1391 
1392 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1394  BlockScope, Block));
1395 }
1396 
1398  LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1399  FunctionScopes.push_back(LSI);
1400  return LSI;
1401 }
1402 
1404  if (LambdaScopeInfo *const LSI = getCurLambda()) {
1405  LSI->AutoTemplateParameterDepth = Depth;
1406  return;
1407  }
1408  llvm_unreachable(
1409  "Remove assertion if intentionally called in a non-lambda context.");
1410 }
1411 
1412 // Check that the type of the VarDecl has an accessible copy constructor and
1413 // resolve its destructor's exception spefication.
1414 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1415  QualType T = VD->getType();
1418  SourceLocation Loc = VD->getLocation();
1419  Expr *VarRef =
1420  new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1422  InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1423  VarRef, /*AllowNRVO=*/true);
1424  if (!Result.isInvalid()) {
1425  Result = S.MaybeCreateExprWithCleanups(Result);
1426  Expr *Init = Result.getAs<Expr>();
1427  S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1428  }
1429 
1430  // The destructor's exception spefication is needed when IRGen generates
1431  // block copy/destroy functions. Resolve it here.
1432  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1433  if (CXXDestructorDecl *DD = RD->getDestructor()) {
1434  auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1435  S.ResolveExceptionSpec(Loc, FPT);
1436  }
1437 }
1438 
1439 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1440  // Set the EscapingByref flag of __block variables captured by
1441  // escaping blocks.
1442  for (const BlockDecl *BD : FSI.Blocks) {
1443  if (BD->doesNotEscape())
1444  continue;
1445  for (const BlockDecl::Capture &BC : BD->captures()) {
1446  VarDecl *VD = BC.getVariable();
1447  if (VD->hasAttr<BlocksAttr>())
1448  VD->setEscapingByref();
1449  }
1450  }
1451 
1452  for (VarDecl *VD : FSI.ByrefBlockVars) {
1453  // __block variables might require us to capture a copy-initializer.
1454  if (!VD->isEscapingByref())
1455  continue;
1456  // It's currently invalid to ever have a __block variable with an
1457  // array type; should we diagnose that here?
1458  // Regardless, we don't want to ignore array nesting when
1459  // constructing this copy.
1460  if (VD->getType()->isStructureOrClassType())
1461  checkEscapingByref(VD, S);
1462  }
1463 }
1464 
1466  const Decl *D, const BlockExpr *blkExpr) {
1467  assert(!FunctionScopes.empty() && "mismatched push/pop!");
1468 
1469  // This function shouldn't be called after popping the current function scope.
1470  // markEscapingByrefs calls PerformMoveOrCopyInitialization, which can call
1471  // PushFunctionScope, which can cause clearing out PreallocatedFunctionScope
1472  // when FunctionScopes is empty.
1473  markEscapingByrefs(*FunctionScopes.back(), *this);
1474 
1475  FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
1476 
1477  if (LangOpts.OpenMP)
1478  popOpenMPFunctionRegion(Scope);
1479 
1480  // Issue any analysis-based warnings.
1481  if (WP && D)
1482  AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
1483  else
1484  for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1485  Diag(PUD.Loc, PUD.PD);
1486 
1487  // Delete the scope unless its our preallocated scope.
1488  if (Scope != PreallocatedFunctionScope.get())
1489  delete Scope;
1490 }
1491 
1492 void Sema::PushCompoundScope(bool IsStmtExpr) {
1493  getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1494 }
1495 
1497  FunctionScopeInfo *CurFunction = getCurFunction();
1498  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1499 
1500  CurFunction->CompoundScopes.pop_back();
1501 }
1502 
1503 /// Determine whether any errors occurred within this function/method/
1504 /// block.
1507 }
1508 
1510  if (!FunctionScopes.empty())
1511  FunctionScopes.back()->setHasBranchIntoScope();
1512 }
1513 
1515  if (!FunctionScopes.empty())
1516  FunctionScopes.back()->setHasBranchProtectedScope();
1517 }
1518 
1520  if (!FunctionScopes.empty())
1521  FunctionScopes.back()->setHasIndirectGoto();
1522 }
1523 
1525  if (FunctionScopes.empty())
1526  return nullptr;
1527 
1528  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1529  if (CurBSI && CurBSI->TheDecl &&
1530  !CurBSI->TheDecl->Encloses(CurContext)) {
1531  // We have switched contexts due to template instantiation.
1532  assert(!CodeSynthesisContexts.empty());
1533  return nullptr;
1534  }
1535 
1536  return CurBSI;
1537 }
1538 
1540  if (FunctionScopes.empty())
1541  return nullptr;
1542 
1543  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1544  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1545  continue;
1546  return FunctionScopes[e];
1547  }
1548  return nullptr;
1549 }
1550 
1551 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1552  if (FunctionScopes.empty())
1553  return nullptr;
1554 
1555  auto I = FunctionScopes.rbegin();
1556  if (IgnoreNonLambdaCapturingScope) {
1557  auto E = FunctionScopes.rend();
1558  while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1559  ++I;
1560  if (I == E)
1561  return nullptr;
1562  }
1563  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1564  if (CurLSI && CurLSI->Lambda &&
1565  !CurLSI->Lambda->Encloses(CurContext)) {
1566  // We have switched contexts due to template instantiation.
1567  assert(!CodeSynthesisContexts.empty());
1568  return nullptr;
1569  }
1570 
1571  return CurLSI;
1572 }
1573 // We have a generic lambda if we parsed auto parameters, or we have
1574 // an associated template parameter list.
1576  if (LambdaScopeInfo *LSI = getCurLambda()) {
1577  return (LSI->AutoTemplateParams.size() ||
1578  LSI->GLTemplateParameterList) ? LSI : nullptr;
1579  }
1580  return nullptr;
1581 }
1582 
1583 
1585  if (!LangOpts.RetainCommentsFromSystemHeaders &&
1586  SourceMgr.isInSystemHeader(Comment.getBegin()))
1587  return;
1588  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1589  if (RC.isAlmostTrailingComment()) {
1590  SourceRange MagicMarkerRange(Comment.getBegin(),
1591  Comment.getBegin().getLocWithOffset(3));
1592  StringRef MagicMarkerText;
1593  switch (RC.getKind()) {
1595  MagicMarkerText = "///<";
1596  break;
1598  MagicMarkerText = "/**<";
1599  break;
1600  default:
1601  llvm_unreachable("if this is an almost Doxygen comment, "
1602  "it should be ordinary");
1603  }
1604  Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1605  FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1606  }
1607  Context.addComment(RC);
1608 }
1609 
1610 // Pin this vtable to this file.
1612 
1615 
1617  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1618 }
1619 
1621  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1622 
1624  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1625 
1626 /// Figure out if an expression could be turned into a call.
1627 ///
1628 /// Use this when trying to recover from an error where the programmer may have
1629 /// written just the name of a function instead of actually calling it.
1630 ///
1631 /// \param E - The expression to examine.
1632 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1633 /// with no arguments, this parameter is set to the type returned by such a
1634 /// call; otherwise, it is set to an empty QualType.
1635 /// \param OverloadSet - If the expression is an overloaded function
1636 /// name, this parameter is populated with the decls of the various overloads.
1637 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1638  UnresolvedSetImpl &OverloadSet) {
1639  ZeroArgCallReturnTy = QualType();
1640  OverloadSet.clear();
1641 
1642  const OverloadExpr *Overloads = nullptr;
1643  bool IsMemExpr = false;
1644  if (E.getType() == Context.OverloadTy) {
1645  OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1646 
1647  // Ignore overloads that are pointer-to-member constants.
1648  if (FR.HasFormOfMemberPointer)
1649  return false;
1650 
1651  Overloads = FR.Expression;
1652  } else if (E.getType() == Context.BoundMemberTy) {
1653  Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1654  IsMemExpr = true;
1655  }
1656 
1657  bool Ambiguous = false;
1658  bool IsMV = false;
1659 
1660  if (Overloads) {
1661  for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1662  DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1663  OverloadSet.addDecl(*it);
1664 
1665  // Check whether the function is a non-template, non-member which takes no
1666  // arguments.
1667  if (IsMemExpr)
1668  continue;
1669  if (const FunctionDecl *OverloadDecl
1670  = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1671  if (OverloadDecl->getMinRequiredArguments() == 0) {
1672  if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1673  (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1674  OverloadDecl->isCPUSpecificMultiVersion()))) {
1675  ZeroArgCallReturnTy = QualType();
1676  Ambiguous = true;
1677  } else {
1678  ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1679  IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1680  OverloadDecl->isCPUSpecificMultiVersion();
1681  }
1682  }
1683  }
1684  }
1685 
1686  // If it's not a member, use better machinery to try to resolve the call
1687  if (!IsMemExpr)
1688  return !ZeroArgCallReturnTy.isNull();
1689  }
1690 
1691  // Attempt to call the member with no arguments - this will correctly handle
1692  // member templates with defaults/deduction of template arguments, overloads
1693  // with default arguments, etc.
1694  if (IsMemExpr && !E.isTypeDependent()) {
1695  bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1698  None, SourceLocation());
1700  if (R.isUsable()) {
1701  ZeroArgCallReturnTy = R.get()->getType();
1702  return true;
1703  }
1704  return false;
1705  }
1706 
1707  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1708  if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1709  if (Fun->getMinRequiredArguments() == 0)
1710  ZeroArgCallReturnTy = Fun->getReturnType();
1711  return true;
1712  }
1713  }
1714 
1715  // We don't have an expression that's convenient to get a FunctionDecl from,
1716  // but we can at least check if the type is "function of 0 arguments".
1717  QualType ExprTy = E.getType();
1718  const FunctionType *FunTy = nullptr;
1719  QualType PointeeTy = ExprTy->getPointeeType();
1720  if (!PointeeTy.isNull())
1721  FunTy = PointeeTy->getAs<FunctionType>();
1722  if (!FunTy)
1723  FunTy = ExprTy->getAs<FunctionType>();
1724 
1725  if (const FunctionProtoType *FPT =
1726  dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1727  if (FPT->getNumParams() == 0)
1728  ZeroArgCallReturnTy = FunTy->getReturnType();
1729  return true;
1730  }
1731  return false;
1732 }
1733 
1734 /// Give notes for a set of overloads.
1735 ///
1736 /// A companion to tryExprAsCall. In cases when the name that the programmer
1737 /// wrote was an overloaded function, we may be able to make some guesses about
1738 /// plausible overloads based on their return types; such guesses can be handed
1739 /// off to this method to be emitted as notes.
1740 ///
1741 /// \param Overloads - The overloads to note.
1742 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1743 /// -fshow-overloads=best, this is the location to attach to the note about too
1744 /// many candidates. Typically this will be the location of the original
1745 /// ill-formed expression.
1746 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1747  const SourceLocation FinalNoteLoc) {
1748  int ShownOverloads = 0;
1749  int SuppressedOverloads = 0;
1750  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1751  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1752  // FIXME: Magic number for max shown overloads stolen from
1753  // OverloadCandidateSet::NoteCandidates.
1754  if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1755  ++SuppressedOverloads;
1756  continue;
1757  }
1758 
1759  NamedDecl *Fn = (*It)->getUnderlyingDecl();
1760  // Don't print overloads for non-default multiversioned functions.
1761  if (const auto *FD = Fn->getAsFunction()) {
1762  if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1763  !FD->getAttr<TargetAttr>()->isDefaultVersion())
1764  continue;
1765  }
1766  S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1767  ++ShownOverloads;
1768  }
1769 
1770  if (SuppressedOverloads)
1771  S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1772  << SuppressedOverloads;
1773 }
1774 
1776  const UnresolvedSetImpl &Overloads,
1777  bool (*IsPlausibleResult)(QualType)) {
1778  if (!IsPlausibleResult)
1779  return noteOverloads(S, Overloads, Loc);
1780 
1781  UnresolvedSet<2> PlausibleOverloads;
1782  for (OverloadExpr::decls_iterator It = Overloads.begin(),
1783  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1784  const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1785  QualType OverloadResultTy = OverloadDecl->getReturnType();
1786  if (IsPlausibleResult(OverloadResultTy))
1787  PlausibleOverloads.addDecl(It.getDecl());
1788  }
1789  noteOverloads(S, PlausibleOverloads, Loc);
1790 }
1791 
1792 /// Determine whether the given expression can be called by just
1793 /// putting parentheses after it. Notably, expressions with unary
1794 /// operators can't be because the unary operator will start parsing
1795 /// outside the call.
1796 static bool IsCallableWithAppend(Expr *E) {
1797  E = E->IgnoreImplicit();
1798  return (!isa<CStyleCastExpr>(E) &&
1799  !isa<UnaryOperator>(E) &&
1800  !isa<BinaryOperator>(E) &&
1801  !isa<CXXOperatorCallExpr>(E));
1802 }
1803 
1805  if (const auto *UO = dyn_cast<UnaryOperator>(E))
1806  E = UO->getSubExpr();
1807 
1808  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
1809  if (ULE->getNumDecls() == 0)
1810  return false;
1811 
1812  const NamedDecl *ND = *ULE->decls_begin();
1813  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
1814  return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
1815  }
1816  return false;
1817 }
1818 
1820  bool ForceComplain,
1821  bool (*IsPlausibleResult)(QualType)) {
1822  SourceLocation Loc = E.get()->getExprLoc();
1823  SourceRange Range = E.get()->getSourceRange();
1824 
1825  QualType ZeroArgCallTy;
1826  UnresolvedSet<4> Overloads;
1827  if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
1828  !ZeroArgCallTy.isNull() &&
1829  (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1830  // At this point, we know E is potentially callable with 0
1831  // arguments and that it returns something of a reasonable type,
1832  // so we can emit a fixit and carry on pretending that E was
1833  // actually a CallExpr.
1834  SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
1835  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1836  Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
1837  << (IsCallableWithAppend(E.get())
1838  ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1839  : FixItHint());
1840  if (!IsMV)
1841  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1842 
1843  // FIXME: Try this before emitting the fixit, and suppress diagnostics
1844  // while doing so.
1845  E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None,
1846  Range.getEnd().getLocWithOffset(1));
1847  return true;
1848  }
1849 
1850  if (!ForceComplain) return false;
1851 
1852  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1853  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
1854  if (!IsMV)
1855  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1856  E = ExprError();
1857  return true;
1858 }
1859 
1861  if (!Ident_super)
1862  Ident_super = &Context.Idents.get("super");
1863  return Ident_super;
1864 }
1865 
1867  if (!Ident___float128)
1868  Ident___float128 = &Context.Idents.get("__float128");
1869  return Ident___float128;
1870 }
1871 
1873  CapturedRegionKind K) {
1875  getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
1876  (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
1877  CSI->ReturnType = Context.VoidTy;
1878  FunctionScopes.push_back(CSI);
1879 }
1880 
1882  if (FunctionScopes.empty())
1883  return nullptr;
1884 
1885  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1886 }
1887 
1888 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
1890  return DeleteExprs;
1891 }
1892 
1893 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
1894  if (ExtStr.empty())
1895  return;
1897  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1898  auto CanT = T.getCanonicalType().getTypePtr();
1899  for (auto &I : Exts)
1900  OpenCLTypeExtMap[CanT].insert(I.str());
1901 }
1902 
1903 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
1905  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1906  if (Exts.empty())
1907  return;
1908  for (auto &I : Exts)
1909  OpenCLDeclExtMap[FD].insert(I.str());
1910 }
1911 
1913  if (CurrOpenCLExtension.empty())
1914  return;
1915  setOpenCLExtensionForType(T, CurrOpenCLExtension);
1916 }
1917 
1919  if (CurrOpenCLExtension.empty())
1920  return;
1921  setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
1922 }
1923 
1925  if (!OpenCLDeclExtMap.empty())
1926  return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
1927 
1928  return "";
1929 }
1930 
1932  if (!OpenCLTypeExtMap.empty())
1933  return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
1934 
1935  return "";
1936 }
1937 
1938 template <typename T, typename MapT>
1939 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
1940  std::string ExtensionNames = "";
1941  auto Loc = Map.find(FDT);
1942 
1943  for (auto const& I : Loc->second) {
1944  ExtensionNames += I;
1945  ExtensionNames += " ";
1946  }
1947  ExtensionNames.pop_back();
1948 
1949  return ExtensionNames;
1950 }
1951 
1953  auto Loc = OpenCLDeclExtMap.find(FD);
1954  if (Loc == OpenCLDeclExtMap.end())
1955  return false;
1956  for (auto &I : Loc->second) {
1957  if (!getOpenCLOptions().isEnabled(I))
1958  return true;
1959  }
1960  return false;
1961 }
1962 
1963 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
1964 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
1965  DiagInfoT DiagInfo, MapT &Map,
1966  unsigned Selector,
1967  SourceRange SrcRange) {
1968  auto Loc = Map.find(D);
1969  if (Loc == Map.end())
1970  return false;
1971  bool Disabled = false;
1972  for (auto &I : Loc->second) {
1973  if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
1974  Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
1975  << I << SrcRange;
1976  Disabled = true;
1977  }
1978  }
1979  return Disabled;
1980 }
1981 
1983  // Check extensions for declared types.
1984  Decl *Decl = nullptr;
1985  if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
1986  Decl = TypedefT->getDecl();
1987  if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
1988  Decl = TagT->getDecl();
1989  auto Loc = DS.getTypeSpecTypeLoc();
1990 
1991  // Check extensions for vector types.
1992  // e.g. double4 is not allowed when cl_khr_fp64 is absent.
1993  if (QT->isExtVectorType()) {
1994  auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
1995  return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
1996  }
1997 
1998  if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
1999  return true;
2000 
2001  // Check extensions for builtin types.
2002  return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2003  QT, OpenCLTypeExtMap);
2004 }
2005 
2007  IdentifierInfo *FnName = D.getIdentifier();
2008  return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2009  OpenCLDeclExtMap, 1, D.getSourceRange());
2010 }
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=TTK_Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2454
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2419
Defines the clang::ASTContext interface.
ObjCInterfaceDecl * NSStringDecl
The declaration of the Objective-C NSString class.
Definition: Sema.h:878
CanThrowResult canThrow(const Expr *E)
UnusedFileScopedDeclsType UnusedFileScopedDecls
The set of file scoped decls seen so far that have not been used and must warn if not used...
Definition: Sema.h:611
Represents a function declaration or definition.
Definition: Decl.h:1738
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition: Sema.h:573
bool hasErrorOccurred() const
Definition: Diagnostic.h:747
bool hasBuiltinMSVaList() const
Returns whether or not type __builtin_ms_va_list type is available on this target.
Definition: TargetInfo.h:759
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
CanQualType OCLQueueTy
Definition: ASTContext.h:1054
Smart pointer class that efficiently represents Objective-C method names.
A class which contains all the information about a particular captured value.
Definition: Decl.h:3864
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
TypedefDecl * getCFConstantStringDecl() const
A (possibly-)qualified type.
Definition: Type.h:638
ASTConsumer & Consumer
Definition: Sema.h:325
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:653
void Initialize()
Perform initialization that occurs after the parser has been initialized but before it parses anythin...
Definition: Sema.cpp:186
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
DeclContext * getFunctionLevelDeclContext()
Definition: Sema.cpp:1184
RecordDecl * MSVCGuidDecl
The MSVC "_GUID" struct, which is defined in MSVC header files.
Definition: Sema.h:857
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3054
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:676
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:11736
void getUndefinedButUsed(SmallVectorImpl< std::pair< NamedDecl *, SourceLocation > > &Undefined)
Obtain a sorted list of functions that are undefined but ODR-used.
Definition: Sema.cpp:627
submodule_iterator submodule_begin()
Definition: Module.h:556
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3355
CXXFieldCollector - Used to keep track of CXXFieldDecls during parsing of C++ classes.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:650
static void notePlausibleOverloads(Sema &S, SourceLocation Loc, const UnresolvedSetImpl &Overloads, bool(*IsPlausibleResult)(QualType))
Definition: Sema.cpp:1775
SmallVector< std::pair< const CXXMethodDecl *, const CXXMethodDecl * >, 2 > DelayedOverridingExceptionSpecChecks
All the overriding functions seen during a class definition that had their exception spec checks dela...
Definition: Sema.h:625
virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID) override
Callback invoked whenever a source file is entered or exited.
Definition: Sema.cpp:86
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1308
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
Module * getCurrentModule()
Retrieves the module that we&#39;re currently building, if any.
ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc)
BuildCallToMemberFunction - Build a call to a member function.
bool isExtVectorType() const
Definition: Type.h:6385
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2132
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed...
Definition: Sema.h:7648
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with the preprocessor.
Definition: Sema.cpp:50
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:828
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:368
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7285
virtual void updateOutOfDateSelector(Selector Sel)
Load the contents of the global method pool for a given selector if necessary.
Definition: Sema.cpp:1614
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:1613
CanQualType LongTy
Definition: ASTContext.h:1025
Any normal BCPL comments.
Declaration of a variable template.
static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E)
Definition: Sema.cpp:1804
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:46
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
A container of type source information.
Definition: Decl.h:87
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3589
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:626
IdentifierInfo * getSuperIdentifier() const
Definition: Sema.cpp:1860
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:730
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:7326
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1262
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3169
IdentifierInfo * getFloat128Identifier() const
Definition: Sema.cpp:1866
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:7619
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:1931
RAII object that enters a new expression evaluation context.
Definition: Sema.h:10852
Compiling a C++ modules TS module interface unit.
Definition: LangOptions.h:85
Represents a variable declaration or definition.
Definition: Decl.h:813
QualType getReturnType() const
Definition: Decl.h:2302
DiagnosticsEngine & Diags
Definition: Sema.h:326
virtual void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WI)
Read the set of weak, undeclared identifiers known to the external Sema source.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6748
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2177
void enableSupportedCore(LangOptions LO)
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:432
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:10763
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1135
Expr * IgnoreImplicit() LLVM_READONLY
IgnoreImplicit - Skip past any implicit AST nodes which might surround this expression.
Definition: Expr.h:747
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:655
bool isInvalidDecl() const
Definition: DeclBase.h:542
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
ObjCMethodDecl * ValueWithBytesObjCTypeMethod
The declaration of the valueWithBytes:objCType: method.
Definition: Sema.h:887
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:36
OpenCLOptions & getOpenCLOptions()
Definition: Sema.h:1232
Defines the clang::Expr interface and subclasses for C++ expressions.
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
Definition: Sema.h:896
const llvm::MapVector< FieldDecl *, DeleteLocs > & getMismatchingDeleteExpressions() const
Retrieves list of suspicious delete-expressions that will be checked at the end of translation unit...
Definition: Sema.cpp:1889
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:5407
void threadSafetyCleanup(BeforeSet *Cache)
CanQualType OCLSamplerTy
Definition: ASTContext.h:1053
void CheckDelayedMemberExceptionSpecs()
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
Represents a struct/union/class.
Definition: Decl.h:3593
void FreeVisContext()
FreeVisContext - Deallocate and null out VisContext.
Definition: SemaAttr.cpp:767
An iterator over the friend declarations of a class.
Definition: DeclFriend.h:188
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:298
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
One of these records is kept for each identifier that is lexed.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:860
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7615
virtual void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls)
Read the set of potentially unused typedefs known to the source.
bool doesNotEscape() const
Definition: Decl.h:4009
SmallVector< std::pair< FunctionDecl *, FunctionDecl * >, 2 > DelayedEquivalentExceptionSpecChecks
All the function redeclarations seen during a class definition that had their exception spec checks d...
Definition: Sema.h:633
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.cpp:1539
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
Definition: ModuleMap.cpp:1275
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1575
unsigned getCurrentDiagID() const
Definition: Diagnostic.h:989
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7519
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:515
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1524
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:288
void setCurrentOpenCLExtensionForType(QualType T)
Set current OpenCL extensions for a type which can only be used when these OpenCL extensions are enab...
Definition: Sema.cpp:1912
Represents a member of a struct/union/class.
Definition: Decl.h:2579
void erase(iterator From, iterator To)
The current expression is potentially evaluated at run time, which means that code may be generated t...
ImplicitParamDecl * getContextParam() const
Retrieve the parameter containing captured variables.
Definition: Decl.h:4109
void setEscapingByref()
Definition: Decl.h:1420
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:7634
ObjCInterfaceDecl * NSValueDecl
The declaration of the Objective-C NSValue class.
Definition: Sema.h:866
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
Definition: Sema.cpp:865
CanQualType OCLEventTy
Definition: ASTContext.h:1053
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:406
llvm::SmallPtrSet< const BlockDecl *, 1 > Blocks
The set of blocks that are introduced in this function.
Definition: ScopeInfo.h:207
void setFunctionHasBranchIntoScope()
Definition: Sema.cpp:1509
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3538
void setVisible(Module *M, SourceLocation Loc, VisibleCallback Vis=[](Module *) {}, ConflictCallback Cb=[](ArrayRef< Module *>, Module *, StringRef) {})
Make a specific module visible.
Definition: Module.cpp:598
void setPrintingPolicy(const clang::PrintingPolicy &Policy)
Definition: ASTContext.h:658
bool DefineUsedVTables()
Define all of the vtables that have been used in this translation unit and reference any virtual memb...
bool isOpenCLDisabledDecl(Decl *FD)
Definition: Sema.cpp:1952
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1054
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:815
Describes a module or submodule.
Definition: Module.h:65
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1112
IdentifierTable & Idents
Definition: ASTContext.h:566
static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc)
Give notes for a set of overloads.
Definition: Sema.cpp:1746
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors...
Definition: Sema.h:6110
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:7622
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:748
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:1333
Module * createGlobalModuleForInterfaceUnit(SourceLocation Loc)
Create a &#39;global module&#39; for a C++ Modules TS module interface unit.
Definition: ModuleMap.cpp:810
PtrTy get() const
Definition: Ownership.h:174
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1209
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:422
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:821
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1327
bool checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType T)
Check if type T corresponding to declaration specifier DS is disabled due to required OpenCL extensio...
Definition: Sema.cpp:1982
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined &#39;SEL&#39; type in Objective-C.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:405
std::pair< SourceLocation, bool > DeleteExprLoc
Delete-expressions to be analyzed at the end of translation unit.
Definition: Sema.h:580
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:654
void PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
void IssueWarnings(Policy P, FunctionScopeInfo *fscope, const Decl *D, const BlockExpr *blkExpr)
void CheckDelegatingCtorCycles()
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:9390
friend_iterator friend_end() const
Definition: DeclFriend.h:244
~ExternalSemaSource() override
Definition: Sema.cpp:1611
Values of this type can never be null.
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:408
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6072
static const unsigned NumNSNumberLiteralMethods
Definition: NSAPI.h:195
submodule_iterator submodule_end()
Definition: Module.h:558
void PrintStats() const
Print out statistics about the semantic analysis.
Definition: Sema.cpp:425
void emitAndClearUnusedLocalTypedefWarnings()
Definition: Sema.cpp:821
SourceLocation getCurrentDiagLoc() const
Definition: Diagnostic.h:991
virtual ASTMutationListener * GetASTMutationListener()
If the consumer is interested in entities getting modified after their initial creation, it should return a pointer to an ASTMutationListener here.
Definition: ASTConsumer.h:124
Preprocessor & PP
Definition: Sema.h:323
ObjCInterfaceDecl * NSNumberDecl
The declaration of the Objective-C NSNumber class.
Definition: Sema.h:863
virtual void ReadKnownNamespaces(SmallVectorImpl< NamespaceDecl *> &Namespaces)
Load the set of namespaces that are known to the external source, which will be used during typo corr...
Definition: Sema.cpp:1616
const LangOptions & getLangOpts() const
Definition: Sema.h:1231
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:167
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
Definition: Sema.h:7633
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4044
NamespaceDecl * StdExperimentalNamespaceCache
The C++ "std::experimental" namespace, where the experimental parts of the standard library resides...
Definition: Sema.h:843
ObjCMethodDecl * StringWithUTF8StringMethod
The declaration of the stringWithUTF8String: method.
Definition: Sema.h:884
void DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc)
Definition: SemaAttr.cpp:216
const LangOptions & LangOpts
Definition: Sema.h:322
bool checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E)
Check if declaration D used by expression E is disabled due to required OpenCL extensions being disab...
Definition: Sema.cpp:2006
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:67
bool EmitCurrentDiagnostic(bool Force=false)
Emit the current diagnostic and clear the diagnostic state.
Definition: Diagnostic.cpp:499
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1235
static bool IsCallableWithAppend(Expr *E)
Determine whether the given expression can be called by just putting parentheses after it...
Definition: Sema.cpp:1796
bool hasAttr() const
Definition: DeclBase.h:531
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:103
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1613
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3687
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:603
Retains information about a captured region.
Definition: ScopeInfo.h:737
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:1492
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:689
CastKind
CastKind - The kind of operation required for a conversion.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1844
void PopCompoundScope()
Definition: Sema.cpp:1496
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:1623
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:1514
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:40
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:10728
unsigned Offset
Definition: Format.cpp:1631
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:236
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
Definition: Sema.h:7652
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:711
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
Any normal C comment.
An abstract interface that should be implemented by external AST sources that also provide informatio...
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3858
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D)
Used to prune the decls of Sema&#39;s UnusedFileScopedDecls vector.
Definition: Sema.cpp:547
This represents one expression.
Definition: Expr.h:106
void setOpenCLExtensionForDecl(Decl *FD, llvm::StringRef Exts)
Set OpenCL extensions for a declaration which can only be used when these OpenCL extensions are enabl...
Definition: Sema.cpp:1903
Show just the "best" overload candidates.
static SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset, const SourceManager &SM, const LangOptions &LangOpts)
Computes the source location just past the end of the token at this source location.
Definition: Lexer.cpp:771
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:107
bool isAlmostTrailingComment() const LLVM_READONLY
Returns true if it is a probable typo:
int Id
Definition: ASTDiff.cpp:191
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition: Sema.h:593
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2695
TypedefDecl * buildImplicitTypedef(QualType T, StringRef Name) const
Create a new implicit TU-level typedef declaration.
void addImplicitTypedef(StringRef Name, QualType T)
Definition: Sema.cpp:180
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6811
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5182
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2706
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
bool InNonInstantiationSFINAEContext
Whether we are in a SFINAE context that is not associated with template instantiation.
Definition: Sema.h:7317
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
Definition: Type.h:6569
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:804
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Not compiling a module interface at all.
Definition: LangOptions.h:76
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy inialization expression of a block var decl.
DeclContext * getDeclContext()
Definition: DeclBase.h:427
void PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, const BlockExpr *blkExpr=nullptr)
Definition: Sema.cpp:1465
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
Definition: ModuleMap.cpp:1249
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
ScalarTypeKind getScalarTypeKind() const
Given that this is a scalar type, classify it.
Definition: Type.cpp:1967
decls_iterator decls_begin() const
Definition: ExprCXX.h:2727
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7603
int Depth
Definition: ASTDiff.cpp:191
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:981
QualType getType() const
Definition: Expr.h:128
void Clear()
Clear out the current diagnostic.
Definition: Diagnostic.h:881
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:552
PartialDiagnostic::StorageAllocator & getDiagAllocator()
Definition: ASTContext.h:686
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1752
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:86
bool isInvalid() const
Definition: Ownership.h:170
SourceLocation getEnd() const
Preprocessor & getPreprocessor() const
Definition: Sema.h:1237
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type...
ObjCMethodDecl * ArrayWithObjectsMethod
The declaration of the arrayWithObjects:count: method.
Definition: Sema.h:893
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1342
bool isUsable() const
Definition: Ownership.h:171
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1397
The result type of a method or function.
NamedDecl * LookupSingleName(Scope *S, DeclarationName Name, SourceLocation Loc, LookupNameKind NameKind, RedeclarationKind Redecl=NotForRedeclaration)
Look up a name, looking for a single declaration.
void DiagnoseUnterminatedPragmaPack()
Definition: SemaAttr.cpp:250
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:703
const SourceManager & SM
Definition: Format.cpp:1490
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:660
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1115
llvm::DenseMap< const CXXRecordDecl *, bool > RecordCompleteMap
Definition: Sema.cpp:741
An abstract interface that should be implemented by external AST sources that also provide informatio...
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6131
unsigned Bool
Whether we can use &#39;bool&#39; rather than &#39;_Bool&#39; (even if the language doesn&#39;t actually have &#39;bool&#39;...
bool isStructureOrClassType() const
Definition: Type.cpp:461
void PushBlockScope(Scope *BlockScope, BlockDecl *Block)
Definition: Sema.cpp:1392
CanQualType OverloadTy
Definition: ASTContext.h:1045
This declaration has an owning module, but is globally visible (typically because its owning module i...
void Emit(const DiagnosticBuilder &DB) const
#define false
Definition: stdbool.h:33
RecordDecl * CXXTypeInfoDecl
The C++ "type_info" declaration, which is defined in <typeinfo>.
Definition: Sema.h:854
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2635
QualType getCanonicalType() const
Definition: Type.h:6111
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
Encodes a location in the source.
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
QualType getReturnType() const
Definition: Type.h:3613
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
void setCurrentOpenCLExtensionForDecl(Decl *FD)
Set current OpenCL extensions for a declaration which can only be used when these OpenCL extensions a...
Definition: Sema.cpp:1918
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:784
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1371
bool makeUnavailableInSystemHeader(SourceLocation loc, UnavailableAttr::ImplicitReason reason)
makeUnavailableInSystemHeader - There is an error in the current context.
Definition: Sema.cpp:378
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:1924
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:616
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>. ...
Definition: Sema.h:847
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2041
void DiagnoseUseOfUnimplementedSelectors()
CanQualType FloatTy
Definition: ASTContext.h:1028
CanQualType VoidTy
Definition: ASTContext.h:1016
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:89
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie)
Definition: Diagnostic.h:792
virtual void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined)
Load the set of used but not defined functions or variables with internal linkage, or used but not defined internal functions.
Definition: Sema.cpp:1620
void EmitCurrentDiagnostic(unsigned DiagID)
Cause the active diagnostic on the DiagosticsEngine to be emitted.
Definition: Sema.cpp:1223
This declaration is only a declaration.
Definition: Decl.h:1147
void addSupport(const OpenCLOptions &Opts)
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3120
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:790
friend_iterator friend_begin() const
Definition: DeclFriend.h:240
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:397
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition: Sema.h:564
static bool isFunctionOrVarDeclExternC(NamedDecl *ND)
Definition: Sema.cpp:608
sema::CapturedRegionScopeInfo * getCurCapturedRegion()
Retrieve the current captured region, if any.
Definition: Sema.cpp:1881
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:837
ASTConsumer & getASTConsumer() const
Definition: Sema.h:1239
void setLastDiagnosticIgnored(bool Ignored=true)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:668
void setOpenCLExtensionForType(QualType T, llvm::StringRef Exts)
Set OpenCL extensions for a type which can only be used when these OpenCL extensions are enabled...
Definition: Sema.cpp:1893
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1954
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2916
Abstract interface for a consumer of code-completion information.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Dataflow Directional Tag Classes.
LateTemplateParserCleanupCB * LateTemplateParserCleanup
Definition: Sema.h:654
bool isValid() const
Return true if this is a valid SourceLocation object.
int ArgumentPackSubstitutionIndex
The current index into pack expansion arguments that will be used for substitution of parameter packs...
Definition: Sema.h:7350
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
ObjCMethodDecl * NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]
The Objective-C NSNumber methods used to create NSNumber literals.
Definition: Sema.h:875
static void checkEscapingByref(VarDecl *VD, Sema &S)
Definition: Sema.cpp:1414
ArrayRef< Capture > captures() const
Definition: Decl.h:3985
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:399
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:475
void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E)
Warn when implicitly casting 0 to nullptr.
Definition: Sema.cpp:447
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing.
Definition: Sema.cpp:1403
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
Definition: SemaDecl.cpp:1555
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include&#39;d file otherwise it returns an invalid location...
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:78
ClassTemplateDecl * StdCoroutineTraitsCache
The C++ "std::coroutine_traits" template, which is defined in <coroutine_traits>
Definition: Sema.h:851
FileID getMainFileID() const
Returns the FileID of the main source file.
bool GlobalNewDeleteDeclared
A flag to remember whether the implicit forms of operator new and delete have been declared...
Definition: Sema.h:909
The name of a declaration.
bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain=false, bool(*IsPlausibleResult)(QualType)=nullptr)
Try to recover by turning the given expression into a call.
Definition: Sema.cpp:1819
A set of unresolved declarations.
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created...
Definition: Diagnostic.h:1016
IdentifierResolver IdResolver
Definition: Sema.h:823
Optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool isEscapingByref() const
Indicates the capture is a __block variable that is captured by a block that can potentially escape (...
Definition: Decl.cpp:2374
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i...
Definition: LangOptions.h:251
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
Definition: Sema.cpp:530
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1083
Abstract interface for a module loader.
Definition: ModuleLoader.h:74
NamedDecl * getCurFunctionOrMethodDecl()
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we&#39;re in...
Definition: Sema.cpp:1216
std::string getOpenCLExtensionsFromExtMap(T *FT, MapT &Map)
Find an extension in an appropriate extension map and return its name.
Definition: Sema.cpp:1939
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
Definition: Sema.cpp:1505
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2693
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:582
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:710
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
DeclarationName VAListTagName
VAListTagName - The declaration name corresponding to __va_list_tag.
Definition: Sema.h:344
void FormatASTNodeDiagnosticArgument(DiagnosticsEngine::ArgumentKind Kind, intptr_t Val, StringRef Modifier, StringRef Argument, ArrayRef< DiagnosticsEngine::ArgumentValue > PrevArgs, SmallVectorImpl< char > &Output, void *Cookie, ArrayRef< intptr_t > QualTypeVals)
DiagnosticsEngine argument formatting function for diagnostics that involve AST nodes.
CanQualType UnsignedLongTy
Definition: ASTContext.h:1026
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1204
static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S)
Definition: Sema.cpp:1439
void * OpaqueParser
Definition: Sema.h:655
ExtVectorType - Extended vector type.
Definition: Type.h:3287
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:7242
CanQualType BoundMemberTy
Definition: ASTContext.h:1045
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1041
void addComment(const RawComment &RC)
Definition: ASTContext.h:803
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
ObjCInterfaceDecl * NSArrayDecl
The declaration of the Objective-C NSArray class.
Definition: Sema.h:890
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3696
The "class" keyword.
Definition: Type.h:5042
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:511
std::unique_ptr< sema::FunctionScopeInfo > PreallocatedFunctionScope
Definition: Sema.h:548
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2070
This is a scope that can contain a declaration.
Definition: Scope.h:60
SourceManager & getSourceManager()
Definition: ASTContext.h:662
The type-property cache.
Definition: Type.cpp:3448
void ActOnTranslationUnitScope(Scope *S)
Definition: Sema.cpp:69
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:1361
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2253
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Expr * MaybeCreateExprWithCleanups(Expr *SubExpr)
MaybeCreateExprWithCleanups - If the current full-expression requires any cleanups, surround it with a ExprWithCleanups node.
ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const VarDecl *NRVOCandidate, QualType ResultType, Expr *Value, bool AllowNRVO=true)
Perform the initialization of a potentially-movable value, which is the result of return value...
Definition: SemaStmt.cpp:3094
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1009
void setSuppressAllDiagnostics(bool Val=true)
Suppress all diagnostics, to silence the front end when we know that we don&#39;t want any more diagnosti...
Definition: Diagnostic.h:633
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:496
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:691
static SFINAEResponse getDiagnosticSFINAEResponse(unsigned DiagID)
Determines whether the given built-in diagnostic ID is for an error that is suppressed if it occurs d...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
CommentKind getKind() const LLVM_READONLY
void setFunctionHasIndirectGoto()
Definition: Sema.cpp:1519
Represents a C array with an unspecified size.
Definition: Type.h:2926
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1358
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:336
bool isRValue() const
Definition: Expr.h:250
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:362
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
void addAttr(Attr *A)
Definition: DeclBase.cpp:840
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C &#39;Class&#39; type...
SourceManager & getSourceManager() const
Definition: Sema.h:1236
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:276
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
Definition: Sema.cpp:1637
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1316
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:1110
Defines the clang::TargetInfo interface.
bool isIncrementalProcessingEnabled() const
Returns true if incremental processing is enabled.
ExprResult ExprError()
Definition: Ownership.h:283
The diagnostic should be reported.
CanQualType IntTy
Definition: ASTContext.h:1025
void ActOnComment(SourceRange Comment)
Definition: Sema.cpp:1584
virtual void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending)
Read the set of pending instantiations known to the external Sema source.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:226
The diagnostic is an access-control diagnostic, which will be substitution failures in some contexts ...
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1041
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:819
bool isUnion() const
Definition: Decl.h:3252
NamedDecl * getMostRecentDecl()
Definition: Decl.h:446
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2136
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1158
SourceManager & SourceMgr
Definition: Sema.h:327
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:17
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound stamement scopes in the function.
Definition: ScopeInfo.h:204
QualType getType() const
Definition: Decl.h:648
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:114
virtual void CompleteTentativeDefinition(VarDecl *D)
CompleteTentativeDefinition - Callback invoked at the end of a translation unit to notify the consume...
Definition: ASTConsumer.h:104
A trivial tuple used to represent a source range.
llvm::TinyPtrVector< VarDecl * > ByrefBlockVars
The set of __block variables that are introduced in this function.
Definition: ScopeInfo.h:210
ASTContext & Context
Definition: Sema.h:324
void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType, SourceLocation Loc)
Warn if we&#39;re implicitly casting from a _Nullable pointer type to a _Nonnull one. ...
Definition: Sema.cpp:433
This represents a decl that may have a name.
Definition: Decl.h:249
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K)
Definition: Sema.cpp:1872
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1551
CanQualType DoubleTy
Definition: ASTContext.h:1028
IdentifierInfo * getBoolName() const
Retrieve the identifier &#39;bool&#39;.
Definition: ASTContext.h:1710
void setType(QualType newType)
Definition: Decl.h:649
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:707
static void checkUndefinedButUsed(Sema &S)
checkUndefinedButUsed - Check for undefined objects with internal linkage or that are inline...
Definition: Sema.cpp:680
decls_iterator decls_end() const
Definition: ExprCXX.h:2730
SmallVector< std::pair< CXXMethodDecl *, const FunctionProtoType * >, 2 > DelayedDefaultedMemberExceptionSpecs
All the members seen during a class definition which were both explicitly defaulted and had explicitl...
Definition: Sema.h:643
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:908
This class handles loading and caching of source files into memory.
void PrintContextStack()
Definition: Sema.h:7523
OpenCLOptions & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1290
bool getSuppressAllDiagnostics() const
Definition: Diagnostic.h:636
Declaration of a template function.
Definition: DeclTemplate.h:969
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1380
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:569
SourceLocation getLocation() const
Definition: DeclBase.h:418
bool isExternallyVisible() const
Definition: Decl.h:380
CanQualType OCLClkEventTy
Definition: ASTContext.h:1053
ObjCMethodDecl * DictionaryWithObjectsMethod
The declaration of the dictionaryWithObjects:forKeys:count: method.
Definition: Sema.h:899
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1261
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2560
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125
This is a C++ Modules TS module interface unit.
Definition: Module.h:79
CanQualType UnsignedIntTy
Definition: ASTContext.h:1026
decl_iterator decls_end() const
Definition: DeclBase.h:1999
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:376
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static bool isExternC(const NamedDecl *ND)
Definition: Mangle.cpp:54
The translation unit is a module.
Definition: LangOptions.h:371