clang  10.0.0svn
Sema.cpp
Go to the documentation of this file.
1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the actions class which performs semantic analysis and
10 // builds an AST out of a parse stream.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclFriend.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/StmtCXX.h"
25 #include "clang/Basic/Stack.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 #include "llvm/Support/TimeProfiler.h"
44 
45 using namespace clang;
46 using namespace sema;
47 
49  return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
50 }
51 
52 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
53 
55  const Preprocessor &PP) {
56  PrintingPolicy Policy = Context.getPrintingPolicy();
57  // In diagnostics, we print _Bool as bool if the latter is defined as the
58  // former.
59  Policy.Bool = Context.getLangOpts().Bool;
60  if (!Policy.Bool) {
61  if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
62  Policy.Bool = BoolMacro->isObjectLike() &&
63  BoolMacro->getNumTokens() == 1 &&
64  BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
65  }
66  }
67 
68  return Policy;
69 }
70 
72  TUScope = S;
73  PushDeclContext(S, Context.getTranslationUnitDecl());
74 }
75 
76 namespace clang {
77 namespace sema {
78 
79 class SemaPPCallbacks : public PPCallbacks {
80  Sema *S = nullptr;
82 
83 public:
84  void set(Sema &S) { this->S = &S; }
85 
86  void reset() { S = nullptr; }
87 
88  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
90  FileID PrevFID) override {
91  if (!S)
92  return;
93  switch (Reason) {
94  case EnterFile: {
96  SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
97  if (IncludeLoc.isValid()) {
98  if (llvm::timeTraceProfilerEnabled()) {
99  const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
100  llvm::timeTraceProfilerBegin(
101  "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));
102  }
103 
104  IncludeStack.push_back(IncludeLoc);
107  }
108  break;
109  }
110  case ExitFile:
111  if (!IncludeStack.empty()) {
112  if (llvm::timeTraceProfilerEnabled())
113  llvm::timeTraceProfilerEnd();
114 
117  IncludeStack.pop_back_val());
118  }
119  break;
120  default:
121  break;
122  }
123  }
124 };
125 
126 } // end namespace sema
127 } // end namespace clang
128 
129 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
130  TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
131  : ExternalSource(nullptr), isMultiplexExternalSource(false),
132  FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
133  Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
134  SourceMgr(PP.getSourceManager()), CollectStats(false),
135  CodeCompleter(CodeCompleter), CurContext(nullptr),
136  OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
137  MSPointerToMemberRepresentationMethod(
138  LangOpts.getMSPointerToMemberRepresentationMethod()),
139  VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),
140  DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
141  CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
142  PragmaAttributeCurrentTargetDecl(nullptr),
143  IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
144  LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
146  StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
147  MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
148  NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
149  ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
150  ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
153  FullyCheckedComparisonCategories(
154  static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
158  TyposCorrected(0), AnalysisWarnings(*this),
159  ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
160  CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
161  TUScope = nullptr;
163 
164  LoadedExternalKnownNamespaces = false;
165  for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
166  NSNumberLiteralMethods[I] = nullptr;
167 
168  if (getLangOpts().ObjC)
169  NSAPIObj.reset(new NSAPI(Context));
170 
171  if (getLangOpts().CPlusPlus)
172  FieldCollector.reset(new CXXFieldCollector());
173 
174  // Tell diagnostics how to render things from the AST library.
176 
177  ExprEvalContexts.emplace_back(
180 
181  // Initialization of data sharing attributes stack for OpenMP
182  InitDataSharingAttributesStack();
183 
184  std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
185  std::make_unique<sema::SemaPPCallbacks>();
186  SemaPPCallbackHandler = Callbacks.get();
187  PP.addPPCallbacks(std::move(Callbacks));
188  SemaPPCallbackHandler->set(*this);
189 }
190 
191 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
192  DeclarationName DN = &Context.Idents.get(Name);
193  if (IdResolver.begin(DN) == IdResolver.end())
195 }
196 
198  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
199  SC->InitializeSema(*this);
200 
201  // Tell the external Sema source about this Sema object.
202  if (ExternalSemaSource *ExternalSema
203  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
204  ExternalSema->InitializeSema(*this);
205 
206  // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
207  // will not be able to merge any duplicate __va_list_tag decls correctly.
208  VAListTagName = PP.getIdentifierInfo("__va_list_tag");
209 
210  if (!TUScope)
211  return;
212 
213  // Initialize predefined 128-bit integer types, if needed.
215  // If either of the 128-bit integer types are unavailable to name lookup,
216  // define them now.
217  DeclarationName Int128 = &Context.Idents.get("__int128_t");
218  if (IdResolver.begin(Int128) == IdResolver.end())
220 
221  DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
222  if (IdResolver.begin(UInt128) == IdResolver.end())
224  }
225 
226 
227  // Initialize predefined Objective-C types:
228  if (getLangOpts().ObjC) {
229  // If 'SEL' does not yet refer to any declarations, make it refer to the
230  // predefined 'SEL'.
231  DeclarationName SEL = &Context.Idents.get("SEL");
232  if (IdResolver.begin(SEL) == IdResolver.end())
234 
235  // If 'id' does not yet refer to any declarations, make it refer to the
236  // predefined 'id'.
238  if (IdResolver.begin(Id) == IdResolver.end())
240 
241  // Create the built-in typedef for 'Class'.
242  DeclarationName Class = &Context.Idents.get("Class");
243  if (IdResolver.begin(Class) == IdResolver.end())
245 
246  // Create the built-in forward declaratino for 'Protocol'.
247  DeclarationName Protocol = &Context.Idents.get("Protocol");
248  if (IdResolver.begin(Protocol) == IdResolver.end())
250  }
251 
252  // Create the internal type for the *StringMakeConstantString builtins.
253  DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
254  if (IdResolver.begin(ConstantString) == IdResolver.end())
256 
257  // Initialize Microsoft "predefined C++ types".
258  if (getLangOpts().MSVCCompat) {
259  if (getLangOpts().CPlusPlus &&
260  IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
262  TUScope);
263 
265  }
266 
267  // Initialize predefined OpenCL types and supported extensions and (optional)
268  // core features.
269  if (getLangOpts().OpenCL) {
275  if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
276  addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
278  addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
280  addImplicitTypedef("atomic_uint",
282  auto AtomicLongT = Context.getAtomicType(Context.LongTy);
283  addImplicitTypedef("atomic_long", AtomicLongT);
284  auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
285  addImplicitTypedef("atomic_ulong", AtomicULongT);
286  addImplicitTypedef("atomic_float",
288  auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
289  addImplicitTypedef("atomic_double", AtomicDoubleT);
290  // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
291  // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
293  auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
294  addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
295  auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
296  addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
297  auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
298  addImplicitTypedef("atomic_size_t", AtomicSizeT);
299  auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
300  addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
301 
302  // OpenCL v2.0 s6.13.11.6:
303  // - The atomic_long and atomic_ulong types are supported if the
304  // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
305  // extensions are supported.
306  // - The atomic_double type is only supported if double precision
307  // is supported and the cl_khr_int64_base_atomics and
308  // cl_khr_int64_extended_atomics extensions are supported.
309  // - If the device address space is 64-bits, the data types
310  // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
311  // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
312  // cl_khr_int64_extended_atomics extensions are supported.
313  std::vector<QualType> Atomic64BitTypes;
314  Atomic64BitTypes.push_back(AtomicLongT);
315  Atomic64BitTypes.push_back(AtomicULongT);
316  Atomic64BitTypes.push_back(AtomicDoubleT);
317  if (Context.getTypeSize(AtomicSizeT) == 64) {
318  Atomic64BitTypes.push_back(AtomicSizeT);
319  Atomic64BitTypes.push_back(AtomicIntPtrT);
320  Atomic64BitTypes.push_back(AtomicUIntPtrT);
321  Atomic64BitTypes.push_back(AtomicPtrDiffT);
322  }
323  for (auto &I : Atomic64BitTypes)
325  "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
326 
327  setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
328  }
329 
331 
332 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
333  setOpenCLExtensionForType(Context.Id, Ext);
334 #include "clang/Basic/OpenCLImageTypes.def"
335 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
336  addImplicitTypedef(#ExtType, Context.Id##Ty); \
337  setOpenCLExtensionForType(Context.Id##Ty, #Ext);
338 #include "clang/Basic/OpenCLExtensionTypes.def"
339  }
340 
342 #define SVE_TYPE(Name, Id, SingletonId) \
343  addImplicitTypedef(Name, Context.SingletonId);
344 #include "clang/Basic/AArch64SVEACLETypes.def"
345  }
346 
348  DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
349  if (IdResolver.begin(MSVaList) == IdResolver.end())
351  }
352 
353  DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
354  if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
356 }
357 
359  if (VisContext) FreeVisContext();
360 
361  // Kill all the active scopes.
363  delete FSI;
364 
365  // Tell the SemaConsumer to forget about us; we're going out of scope.
366  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
367  SC->ForgetSema();
368 
369  // Detach from the external Sema source.
370  if (ExternalSemaSource *ExternalSema
371  = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
372  ExternalSema->ForgetSema();
373 
374  // If Sema's ExternalSource is the multiplexer - we own it.
375  if (isMultiplexExternalSource)
376  delete ExternalSource;
377 
379 
380  // Destroys data sharing attributes stack for OpenMP
381  DestroyDataSharingAttributesStack();
382 
383  // Detach from the PP callback handler which outlives Sema since it's owned
384  // by the preprocessor.
385  SemaPPCallbackHandler->reset();
386 
387  assert(DelayedTypos.empty() && "Uncorrected typos!");
388 }
389 
391  // Only warn about this once.
392  if (!WarnedStackExhausted) {
393  Diag(Loc, diag::warn_stack_exhausted);
394  WarnedStackExhausted = true;
395  }
396 }
397 
399  llvm::function_ref<void()> Fn) {
401 }
402 
403 /// makeUnavailableInSystemHeader - There is an error in the current
404 /// context. If we're still in a system header, and we can plausibly
405 /// make the relevant declaration unavailable instead of erroring, do
406 /// so and return true.
408  UnavailableAttr::ImplicitReason reason) {
409  // If we're not in a function, it's an error.
410  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
411  if (!fn) return false;
412 
413  // If we're in template instantiation, it's an error.
415  return false;
416 
417  // If that function's not in a system header, it's an error.
419  return false;
420 
421  // If the function is already unavailable, it's not an error.
422  if (fn->hasAttr<UnavailableAttr>()) return true;
423 
424  fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
425  return true;
426 }
427 
430 }
431 
432 ///Registers an external source. If an external source already exists,
433 /// creates a multiplex external source and appends to it.
434 ///
435 ///\param[in] E - A non-null external sema source.
436 ///
438  assert(E && "Cannot use with NULL ptr");
439 
440  if (!ExternalSource) {
441  ExternalSource = E;
442  return;
443  }
444 
445  if (isMultiplexExternalSource)
446  static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
447  else {
448  ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
449  isMultiplexExternalSource = true;
450  }
451 }
452 
453 /// Print out statistics about the semantic analysis.
454 void Sema::PrintStats() const {
455  llvm::errs() << "\n*** Semantic Analysis Stats:\n";
456  llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
457 
458  BumpAlloc.PrintStats();
460 }
461 
463  QualType SrcType,
464  SourceLocation Loc) {
465  Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
466  if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
467  return;
468 
469  Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
470  if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
471  return;
472 
473  Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
474 }
475 
477  if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
478  E->getBeginLoc()))
479  return;
480  // nullptr only exists from C++11 on, so don't warn on its absence earlier.
481  if (!getLangOpts().CPlusPlus11)
482  return;
483 
484  if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
485  return;
487  return;
488 
489  // If it is a macro from system header, and if the macro name is not "NULL",
490  // do not warn.
491  SourceLocation MaybeMacroLoc = E->getBeginLoc();
493  SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
494  !findMacroSpelling(MaybeMacroLoc, "NULL"))
495  return;
496 
497  Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
498  << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
499 }
500 
501 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
502 /// If there is already an implicit cast, merge into the existing one.
503 /// The result is of the given category.
506  const CXXCastPath *BasePath,
507  CheckedConversionKind CCK) {
508 #ifndef NDEBUG
509  if (VK == VK_RValue && !E->isRValue()) {
510  switch (Kind) {
511  default:
512  llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
513  "kind");
514  case CK_Dependent:
515  case CK_LValueToRValue:
516  case CK_ArrayToPointerDecay:
517  case CK_FunctionToPointerDecay:
518  case CK_ToVoid:
519  case CK_NonAtomicToAtomic:
520  break;
521  }
522  }
523  assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) &&
524  "can't cast rvalue to lvalue");
525 #endif
526 
529 
530  QualType ExprTy = Context.getCanonicalType(E->getType());
532 
533  if (ExprTy == TypeTy)
534  return E;
535 
536  // C++1z [conv.array]: The temporary materialization conversion is applied.
537  // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
538  if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
539  E->getValueKind() == VK_RValue) {
540  // The temporary is an lvalue in C++98 and an xvalue otherwise.
542  E->getType(), E, !getLangOpts().CPlusPlus11);
543  if (Materialized.isInvalid())
544  return ExprError();
545  E = Materialized.get();
546  }
547 
548  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
549  if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
550  ImpCast->setType(Ty);
551  ImpCast->setValueKind(VK);
552  return E;
553  }
554  }
555 
556  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
557 }
558 
559 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
560 /// to the conversion from scalar type ScalarTy to the Boolean type.
562  switch (ScalarTy->getScalarTypeKind()) {
563  case Type::STK_Bool: return CK_NoOp;
564  case Type::STK_CPointer: return CK_PointerToBoolean;
565  case Type::STK_BlockPointer: return CK_PointerToBoolean;
566  case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
567  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
568  case Type::STK_Integral: return CK_IntegralToBoolean;
569  case Type::STK_Floating: return CK_FloatingToBoolean;
570  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
571  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
572  case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
573  }
574  llvm_unreachable("unknown scalar type kind");
575 }
576 
577 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
578 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
579  if (D->getMostRecentDecl()->isUsed())
580  return true;
581 
582  if (D->isExternallyVisible())
583  return true;
584 
585  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
586  // If this is a function template and none of its specializations is used,
587  // we should warn.
588  if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
589  for (const auto *Spec : Template->specializations())
590  if (ShouldRemoveFromUnused(SemaRef, Spec))
591  return true;
592 
593  // UnusedFileScopedDecls stores the first declaration.
594  // The declaration may have become definition so check again.
595  const FunctionDecl *DeclToCheck;
596  if (FD->hasBody(DeclToCheck))
597  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
598 
599  // Later redecls may add new information resulting in not having to warn,
600  // so check again.
601  DeclToCheck = FD->getMostRecentDecl();
602  if (DeclToCheck != FD)
603  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
604  }
605 
606  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
607  // If a variable usable in constant expressions is referenced,
608  // don't warn if it isn't used: if the value of a variable is required
609  // for the computation of a constant expression, it doesn't make sense to
610  // warn even if the variable isn't odr-used. (isReferenced doesn't
611  // precisely reflect that, but it's a decent approximation.)
612  if (VD->isReferenced() &&
613  VD->mightBeUsableInConstantExpressions(SemaRef->Context))
614  return true;
615 
616  if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
617  // If this is a variable template and none of its specializations is used,
618  // we should warn.
619  for (const auto *Spec : Template->specializations())
620  if (ShouldRemoveFromUnused(SemaRef, Spec))
621  return true;
622 
623  // UnusedFileScopedDecls stores the first declaration.
624  // The declaration may have become definition so check again.
625  const VarDecl *DeclToCheck = VD->getDefinition();
626  if (DeclToCheck)
627  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
628 
629  // Later redecls may add new information resulting in not having to warn,
630  // so check again.
631  DeclToCheck = VD->getMostRecentDecl();
632  if (DeclToCheck != VD)
633  return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
634  }
635 
636  return false;
637 }
638 
640  if (auto *FD = dyn_cast<FunctionDecl>(ND))
641  return FD->isExternC();
642  return cast<VarDecl>(ND)->isExternC();
643 }
644 
645 /// Determine whether ND is an external-linkage function or variable whose
646 /// type has no linkage.
648  // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
649  // because we also want to catch the case where its type has VisibleNoLinkage,
650  // which does not affect the linkage of VD.
651  return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
654 }
655 
656 /// Obtains a sorted list of functions and variables that are undefined but
657 /// ODR-used.
659  SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
660  for (const auto &UndefinedUse : UndefinedButUsed) {
661  NamedDecl *ND = UndefinedUse.first;
662 
663  // Ignore attributes that have become invalid.
664  if (ND->isInvalidDecl()) continue;
665 
666  // __attribute__((weakref)) is basically a definition.
667  if (ND->hasAttr<WeakRefAttr>()) continue;
668 
669  if (isa<CXXDeductionGuideDecl>(ND))
670  continue;
671 
672  if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
673  // An exported function will always be emitted when defined, so even if
674  // the function is inline, it doesn't have to be emitted in this TU. An
675  // imported function implies that it has been exported somewhere else.
676  continue;
677  }
678 
679  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
680  if (FD->isDefined())
681  continue;
682  if (FD->isExternallyVisible() &&
684  !FD->getMostRecentDecl()->isInlined() &&
685  !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
686  continue;
687  if (FD->getBuiltinID())
688  continue;
689  } else {
690  auto *VD = cast<VarDecl>(ND);
691  if (VD->hasDefinition() != VarDecl::DeclarationOnly)
692  continue;
693  if (VD->isExternallyVisible() &&
695  !VD->getMostRecentDecl()->isInline() &&
696  !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
697  continue;
698 
699  // Skip VarDecls that lack formal definitions but which we know are in
700  // fact defined somewhere.
701  if (VD->isKnownToBeDefined())
702  continue;
703  }
704 
705  Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
706  }
707 }
708 
709 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
710 /// or that are inline.
711 static void checkUndefinedButUsed(Sema &S) {
712  if (S.UndefinedButUsed.empty()) return;
713 
714  // Collect all the still-undefined entities with internal linkage.
716  S.getUndefinedButUsed(Undefined);
717  if (Undefined.empty()) return;
718 
719  for (auto Undef : Undefined) {
720  ValueDecl *VD = cast<ValueDecl>(Undef.first);
721  SourceLocation UseLoc = Undef.second;
722 
723  if (S.isExternalWithNoLinkageType(VD)) {
724  // C++ [basic.link]p8:
725  // A type without linkage shall not be used as the type of a variable
726  // or function with external linkage unless
727  // -- the entity has C language linkage
728  // -- the entity is not odr-used or is defined in the same TU
729  //
730  // As an extension, accept this in cases where the type is externally
731  // visible, since the function or variable actually can be defined in
732  // another translation unit in that case.
734  ? diag::ext_undefined_internal_type
735  : diag::err_undefined_internal_type)
736  << isa<VarDecl>(VD) << VD;
737  } else if (!VD->isExternallyVisible()) {
738  // FIXME: We can promote this to an error. The function or variable can't
739  // be defined anywhere else, so the program must necessarily violate the
740  // one definition rule.
741  S.Diag(VD->getLocation(), diag::warn_undefined_internal)
742  << isa<VarDecl>(VD) << VD;
743  } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
744  (void)FD;
745  assert(FD->getMostRecentDecl()->isInlined() &&
746  "used object requires definition but isn't inline or internal?");
747  // FIXME: This is ill-formed; we should reject.
748  S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
749  } else {
750  assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
751  "used var requires definition but isn't inline or internal?");
752  S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
753  }
754  if (UseLoc.isValid())
755  S.Diag(UseLoc, diag::note_used_here);
756  }
757 
758  S.UndefinedButUsed.clear();
759 }
760 
762  if (!ExternalSource)
763  return;
764 
766  ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
767  for (auto &WeakID : WeakIDs)
768  WeakUndeclaredIdentifiers.insert(WeakID);
769 }
770 
771 
772 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
773 
774 /// Returns true, if all methods and nested classes of the given
775 /// CXXRecordDecl are defined in this translation unit.
776 ///
777 /// Should only be called from ActOnEndOfTranslationUnit so that all
778 /// definitions are actually read.
780  RecordCompleteMap &MNCComplete) {
781  RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
782  if (Cache != MNCComplete.end())
783  return Cache->second;
784  if (!RD->isCompleteDefinition())
785  return false;
786  bool Complete = true;
788  E = RD->decls_end();
789  I != E && Complete; ++I) {
790  if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
791  Complete = M->isDefined() || M->isDefaulted() ||
792  (M->isPure() && !isa<CXXDestructorDecl>(M));
793  else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
794  // If the template function is marked as late template parsed at this
795  // point, it has not been instantiated and therefore we have not
796  // performed semantic analysis on it yet, so we cannot know if the type
797  // can be considered complete.
798  Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
799  F->getTemplatedDecl()->isDefined();
800  else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
801  if (R->isInjectedClassName())
802  continue;
803  if (R->hasDefinition())
804  Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
805  MNCComplete);
806  else
807  Complete = false;
808  }
809  }
810  MNCComplete[RD] = Complete;
811  return Complete;
812 }
813 
814 /// Returns true, if the given CXXRecordDecl is fully defined in this
815 /// translation unit, i.e. all methods are defined or pure virtual and all
816 /// friends, friend functions and nested classes are fully defined in this
817 /// translation unit.
818 ///
819 /// Should only be called from ActOnEndOfTranslationUnit so that all
820 /// definitions are actually read.
821 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
822  RecordCompleteMap &RecordsComplete,
823  RecordCompleteMap &MNCComplete) {
824  RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
825  if (Cache != RecordsComplete.end())
826  return Cache->second;
827  bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
829  E = RD->friend_end();
830  I != E && Complete; ++I) {
831  // Check if friend classes and methods are complete.
832  if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
833  // Friend classes are available as the TypeSourceInfo of the FriendDecl.
834  if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
835  Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
836  else
837  Complete = false;
838  } else {
839  // Friend functions are available through the NamedDecl of FriendDecl.
840  if (const FunctionDecl *FD =
841  dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
842  Complete = FD->isDefined();
843  else
844  // This is a template friend, give up.
845  Complete = false;
846  }
847  }
848  RecordsComplete[RD] = Complete;
849  return Complete;
850 }
851 
853  if (ExternalSource)
854  ExternalSource->ReadUnusedLocalTypedefNameCandidates(
857  if (TD->isReferenced())
858  continue;
859  Diag(TD->getLocation(), diag::warn_unused_local_typedef)
860  << isa<TypeAliasDecl>(TD) << TD->getDeclName();
861  }
862  UnusedLocalTypedefNameCandidates.clear();
863 }
864 
865 /// This is called before the very first declaration in the translation unit
866 /// is parsed. Note that the ASTContext may have already injected some
867 /// declarations.
869  if (getLangOpts().ModulesTS &&
870  (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
871  getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
872  // We start in an implied global module fragment.
873  SourceLocation StartOfTU =
876  ModuleScopes.back().ImplicitGlobalModuleFragment = true;
877  }
878 }
879 
881  // No explicit actions are required at the end of the global module fragment.
882  if (Kind == TUFragmentKind::Global)
883  return;
884 
885  // Transfer late parsed template instantiations over to the pending template
886  // instantiation list. During normal compilation, the late template parser
887  // will be installed and instantiating these templates will succeed.
888  //
889  // If we are building a TU prefix for serialization, it is also safe to
890  // transfer these over, even though they are not parsed. The end of the TU
891  // should be outside of any eager template instantiation scope, so when this
892  // AST is deserialized, these templates will not be parsed until the end of
893  // the combined TU.
895  LateParsedInstantiations.begin(),
897  LateParsedInstantiations.clear();
898 
899  // If DefinedUsedVTables ends up marking any virtual member functions it
900  // might lead to more pending template instantiations, which we then need
901  // to instantiate.
903 
904  // C++: Perform implicit template instantiations.
905  //
906  // FIXME: When we perform these implicit instantiations, we do not
907  // carefully keep track of the point of instantiation (C++ [temp.point]).
908  // This means that name lookup that occurs within the template
909  // instantiation will always happen at the end of the translation unit,
910  // so it will find some names that are not required to be found. This is
911  // valid, but we could do better by diagnosing if an instantiation uses a
912  // name that was not visible at its first point of instantiation.
913  if (ExternalSource) {
914  // Load pending instantiations from the external source.
916  ExternalSource->ReadPendingInstantiations(Pending);
917  for (auto PII : Pending)
918  if (auto Func = dyn_cast<FunctionDecl>(PII.first))
919  Func->setInstantiationIsPending(true);
921  Pending.begin(), Pending.end());
922  }
923 
924  {
925  llvm::TimeTraceScope TimeScope("PerformPendingInstantiations",
926  StringRef(""));
928  }
929 
930  // Finalize analysis of OpenMP-specific constructs.
931  if (LangOpts.OpenMP)
932  finalizeOpenMPDelayedAnalysis();
933 
934  assert(LateParsedInstantiations.empty() &&
935  "end of TU template instantiation should not create more "
936  "late-parsed templates");
937 }
938 
939 /// ActOnEndOfTranslationUnit - This is called at the very end of the
940 /// translation unit when EOF is reached and all but the top-level scope is
941 /// popped.
943  assert(DelayedDiagnostics.getCurrentPool() == nullptr
944  && "reached end of translation unit with a pool attached?");
945 
946  // If code completion is enabled, don't perform any end-of-translation-unit
947  // work.
949  return;
950 
951  // Complete translation units and modules define vtables and perform implicit
952  // instantiations. PCH files do not.
953  if (TUKind != TU_Prefix) {
955 
957  !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
959  ? TUFragmentKind::Private
960  : TUFragmentKind::Normal);
961 
964 
966  } else {
967  // If we are building a TU prefix for serialization, it is safe to transfer
968  // these over, even though they are not parsed. The end of the TU should be
969  // outside of any eager template instantiation scope, so when this AST is
970  // deserialized, these templates will not be parsed until the end of the
971  // combined TU.
973  LateParsedInstantiations.begin(),
975  LateParsedInstantiations.clear();
976  }
977 
980 
981  // All delayed member exception specs should be checked or we end up accepting
982  // incompatible declarations.
983  assert(DelayedOverridingExceptionSpecChecks.empty());
984  assert(DelayedEquivalentExceptionSpecChecks.empty());
985 
986  // All dllexport classes should have been processed already.
987  assert(DelayedDllExportClasses.empty());
988  assert(DelayedDllExportMemberFunctions.empty());
989 
990  // Remove file scoped decls that turned out to be used.
992  std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
994  [this](const DeclaratorDecl *DD) {
995  return ShouldRemoveFromUnused(this, DD);
996  }),
998 
999  if (TUKind == TU_Prefix) {
1000  // Translation unit prefixes don't need any of the checking below.
1002  TUScope = nullptr;
1003  return;
1004  }
1005 
1006  // Check for #pragma weak identifiers that were never declared
1008  for (auto WeakID : WeakUndeclaredIdentifiers) {
1009  if (WeakID.second.getUsed())
1010  continue;
1011 
1012  Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
1014  if (PrevDecl != nullptr &&
1015  !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
1016  Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
1017  << "'weak'" << ExpectedVariableOrFunction;
1018  else
1019  Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
1020  << WeakID.first;
1021  }
1022 
1023  if (LangOpts.CPlusPlus11 &&
1024  !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
1026 
1027  if (!Diags.hasErrorOccurred()) {
1028  if (ExternalSource)
1029  ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1030  checkUndefinedButUsed(*this);
1031  }
1032 
1033  // A global-module-fragment is only permitted within a module unit.
1034  bool DiagnosedMissingModuleDeclaration = false;
1035  if (!ModuleScopes.empty() &&
1036  ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1037  !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1038  Diag(ModuleScopes.back().BeginLoc,
1039  diag::err_module_declaration_missing_after_global_module_introducer);
1040  DiagnosedMissingModuleDeclaration = true;
1041  }
1042 
1043  if (TUKind == TU_Module) {
1044  // If we are building a module interface unit, we need to have seen the
1045  // module declaration by now.
1046  if (getLangOpts().getCompilingModule() ==
1048  (ModuleScopes.empty() ||
1049  !ModuleScopes.back().Module->isModulePurview()) &&
1050  !DiagnosedMissingModuleDeclaration) {
1051  // FIXME: Make a better guess as to where to put the module declaration.
1052  Diag(getSourceManager().getLocForStartOfFile(
1053  getSourceManager().getMainFileID()),
1054  diag::err_module_declaration_missing);
1055  }
1056 
1057  // If we are building a module, resolve all of the exported declarations
1058  // now.
1059  if (Module *CurrentModule = PP.getCurrentModule()) {
1061 
1063  Stack.push_back(CurrentModule);
1064  while (!Stack.empty()) {
1065  Module *Mod = Stack.pop_back_val();
1066 
1067  // Resolve the exported declarations and conflicts.
1068  // FIXME: Actually complain, once we figure out how to teach the
1069  // diagnostic client to deal with complaints in the module map at this
1070  // point.
1071  ModMap.resolveExports(Mod, /*Complain=*/false);
1072  ModMap.resolveUses(Mod, /*Complain=*/false);
1073  ModMap.resolveConflicts(Mod, /*Complain=*/false);
1074 
1075  // Queue the submodules, so their exports will also be resolved.
1076  Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1077  }
1078  }
1079 
1080  // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1081  // modules when they are built, not every time they are used.
1083  }
1084 
1085  // C99 6.9.2p2:
1086  // A declaration of an identifier for an object that has file
1087  // scope without an initializer, and without a storage-class
1088  // specifier or with the storage-class specifier static,
1089  // constitutes a tentative definition. If a translation unit
1090  // contains one or more tentative definitions for an identifier,
1091  // and the translation unit contains no external definition for
1092  // that identifier, then the behavior is exactly as if the
1093  // translation unit contains a file scope declaration of that
1094  // identifier, with the composite type as of the end of the
1095  // translation unit, with an initializer equal to 0.
1096  llvm::SmallSet<VarDecl *, 32> Seen;
1097  for (TentativeDefinitionsType::iterator
1098  T = TentativeDefinitions.begin(ExternalSource),
1099  TEnd = TentativeDefinitions.end();
1100  T != TEnd; ++T) {
1101  VarDecl *VD = (*T)->getActingDefinition();
1102 
1103  // If the tentative definition was completed, getActingDefinition() returns
1104  // null. If we've already seen this variable before, insert()'s second
1105  // return value is false.
1106  if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1107  continue;
1108 
1109  if (const IncompleteArrayType *ArrayT
1111  // Set the length of the array to 1 (C99 6.9.2p5).
1112  Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1114  QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1115  One, ArrayType::Normal, 0);
1116  VD->setType(T);
1117  } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1118  diag::err_tentative_def_incomplete_type))
1119  VD->setInvalidDecl();
1120 
1121  // No initialization is performed for a tentative definition.
1123 
1124  // Notify the consumer that we've completed a tentative definition.
1125  if (!VD->isInvalidDecl())
1127  }
1128 
1129  // If there were errors, disable 'unused' warnings since they will mostly be
1130  // noise. Don't warn for a use from a module: either we should warn on all
1131  // file-scope declarations in modules or not at all, but whether the
1132  // declaration is used is immaterial.
1133  if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1134  // Output warning for unused file scoped decls.
1135  for (UnusedFileScopedDeclsType::iterator
1136  I = UnusedFileScopedDecls.begin(ExternalSource),
1137  E = UnusedFileScopedDecls.end(); I != E; ++I) {
1138  if (ShouldRemoveFromUnused(this, *I))
1139  continue;
1140 
1141  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1142  const FunctionDecl *DiagD;
1143  if (!FD->hasBody(DiagD))
1144  DiagD = FD;
1145  if (DiagD->isDeleted())
1146  continue; // Deleted functions are supposed to be unused.
1147  if (DiagD->isReferenced()) {
1148  if (isa<CXXMethodDecl>(DiagD))
1149  Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1150  << DiagD->getDeclName();
1151  else {
1152  if (FD->getStorageClass() == SC_Static &&
1153  !FD->isInlineSpecified() &&
1155  SourceMgr.getExpansionLoc(FD->getLocation())))
1156  Diag(DiagD->getLocation(),
1157  diag::warn_unneeded_static_internal_decl)
1158  << DiagD->getDeclName();
1159  else
1160  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1161  << /*function*/0 << DiagD->getDeclName();
1162  }
1163  } else {
1164  if (FD->getDescribedFunctionTemplate())
1165  Diag(DiagD->getLocation(), diag::warn_unused_template)
1166  << /*function*/0 << DiagD->getDeclName();
1167  else
1168  Diag(DiagD->getLocation(),
1169  isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1170  : diag::warn_unused_function)
1171  << DiagD->getDeclName();
1172  }
1173  } else {
1174  const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1175  if (!DiagD)
1176  DiagD = cast<VarDecl>(*I);
1177  if (DiagD->isReferenced()) {
1178  Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1179  << /*variable*/1 << DiagD->getDeclName();
1180  } else if (DiagD->getType().isConstQualified()) {
1181  const SourceManager &SM = SourceMgr;
1182  if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1184  Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1185  << DiagD->getDeclName();
1186  } else {
1187  if (DiagD->getDescribedVarTemplate())
1188  Diag(DiagD->getLocation(), diag::warn_unused_template)
1189  << /*variable*/1 << DiagD->getDeclName();
1190  else
1191  Diag(DiagD->getLocation(), diag::warn_unused_variable)
1192  << DiagD->getDeclName();
1193  }
1194  }
1195  }
1196 
1198  }
1199 
1200  if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1201  // FIXME: Load additional unused private field candidates from the external
1202  // source.
1203  RecordCompleteMap RecordsComplete;
1204  RecordCompleteMap MNCComplete;
1205  for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1206  E = UnusedPrivateFields.end(); I != E; ++I) {
1207  const NamedDecl *D = *I;
1208  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1209  if (RD && !RD->isUnion() &&
1210  IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1211  Diag(D->getLocation(), diag::warn_unused_private_field)
1212  << D->getDeclName();
1213  }
1214  }
1215  }
1216 
1217  if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1218  if (ExternalSource)
1220  for (const auto &DeletedFieldInfo : DeleteExprs) {
1221  for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1222  AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1223  DeleteExprLoc.second);
1224  }
1225  }
1226  }
1227 
1228  // Check we've noticed that we're no longer parsing the initializer for every
1229  // variable. If we miss cases, then at best we have a performance issue and
1230  // at worst a rejects-valid bug.
1231  assert(ParsingInitForAutoVars.empty() &&
1232  "Didn't unmark var as having its initializer parsed");
1233 
1235  TUScope = nullptr;
1236 }
1237 
1238 
1239 //===----------------------------------------------------------------------===//
1240 // Helper functions.
1241 //===----------------------------------------------------------------------===//
1242 
1244  DeclContext *DC = CurContext;
1245 
1246  while (true) {
1247  if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1248  DC = DC->getParent();
1249  } else if (isa<CXXMethodDecl>(DC) &&
1250  cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1251  cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1252  DC = DC->getParent()->getParent();
1253  }
1254  else break;
1255  }
1256 
1257  return DC;
1258 }
1259 
1260 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1261 /// to the function decl for the function being parsed. If we're currently
1262 /// in a 'block', this returns the containing context.
1265  return dyn_cast<FunctionDecl>(DC);
1266 }
1267 
1270  while (isa<RecordDecl>(DC))
1271  DC = DC->getParent();
1272  return dyn_cast<ObjCMethodDecl>(DC);
1273 }
1274 
1277  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1278  return cast<NamedDecl>(DC);
1279  return nullptr;
1280 }
1281 
1282 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1283  // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1284  // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1285  // been made more painfully obvious by the refactor that introduced this
1286  // function, but it is possible that the incoming argument can be
1287  // eliminated. If it truly cannot be (for example, there is some reentrancy
1288  // issue I am not seeing yet), then there should at least be a clarifying
1289  // comment somewhere.
1292  Diags.getCurrentDiagID())) {
1294  // We'll report the diagnostic below.
1295  break;
1296 
1298  // Count this failure so that we know that template argument deduction
1299  // has failed.
1300  ++NumSFINAEErrors;
1301 
1302  // Make a copy of this suppressed diagnostic and store it with the
1303  // template-deduction information.
1304  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1305  Diagnostic DiagInfo(&Diags);
1306  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1308  }
1309 
1311  Diags.Clear();
1312  return;
1313 
1315  // Per C++ Core Issue 1170, access control is part of SFINAE.
1316  // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1317  // make access control a part of SFINAE for the purposes of checking
1318  // type traits.
1320  break;
1321 
1323 
1324  // Suppress this diagnostic.
1325  ++NumSFINAEErrors;
1326 
1327  // Make a copy of this suppressed diagnostic and store it with the
1328  // template-deduction information.
1329  if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1330  Diagnostic DiagInfo(&Diags);
1331  (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1333  }
1334 
1336  Diags.Clear();
1337 
1338  // Now the diagnostic state is clear, produce a C++98 compatibility
1339  // warning.
1340  Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1341 
1342  // The last diagnostic which Sema produced was ignored. Suppress any
1343  // notes attached to it.
1345  return;
1346  }
1347 
1349  // Make a copy of this suppressed diagnostic and store it with the
1350  // template-deduction information;
1351  if (*Info) {
1352  Diagnostic DiagInfo(&Diags);
1353  (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1355  }
1356 
1357  // Suppress this diagnostic.
1359  Diags.Clear();
1360  return;
1361  }
1362  }
1363 
1364  // Copy the diagnostic printing policy over the ASTContext printing policy.
1365  // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1367 
1368  // Emit the diagnostic.
1370  return;
1371 
1372  // If this is not a note, and we're in a template instantiation
1373  // that is different from the last template instantiation where
1374  // we emitted an error, print a template instantiation
1375  // backtrace.
1376  if (!DiagnosticIDs::isBuiltinNote(DiagID))
1378 }
1379 
1382  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1383  PD.Emit(Builder);
1384 
1385  return Builder;
1386 }
1387 
1388 // Print notes showing how we can reach FD starting from an a priori
1389 // known-callable function.
1390 static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1391  auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1392  while (FnIt != S.DeviceKnownEmittedFns.end()) {
1393  DiagnosticBuilder Builder(
1394  S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1395  Builder << FnIt->second.FD;
1396  Builder.setForceEmit();
1397 
1398  FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1399  }
1400 }
1401 
1402 // Emit any deferred diagnostics for FD and erase them from the map in which
1403 // they're stored.
1404 static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack) {
1405  auto It = S.DeviceDeferredDiags.find(FD);
1406  if (It == S.DeviceDeferredDiags.end())
1407  return;
1408  bool HasWarningOrError = false;
1409  for (PartialDiagnosticAt &PDAt : It->second) {
1410  const SourceLocation &Loc = PDAt.first;
1411  const PartialDiagnostic &PD = PDAt.second;
1412  HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1413  PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1414  DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1415  Builder.setForceEmit();
1416  PD.Emit(Builder);
1417  }
1418  S.DeviceDeferredDiags.erase(It);
1419 
1420  // FIXME: Should this be called after every warning/error emitted in the loop
1421  // above, instead of just once per function? That would be consistent with
1422  // how we handle immediate errors, but it also seems like a bit much.
1423  if (HasWarningOrError && ShowCallStack)
1424  emitCallStackNotes(S, FD);
1425 }
1426 
1427 // In CUDA, there are some constructs which may appear in semantically-valid
1428 // code, but trigger errors if we ever generate code for the function in which
1429 // they appear. Essentially every construct you're not allowed to use on the
1430 // device falls into this category, because you are allowed to use these
1431 // constructs in a __host__ __device__ function, but only if that function is
1432 // never codegen'ed on the device.
1433 //
1434 // To handle semantic checking for these constructs, we keep track of the set of
1435 // functions we know will be emitted, either because we could tell a priori that
1436 // they would be emitted, or because they were transitively called by a
1437 // known-emitted function.
1438 //
1439 // We also keep a partial call graph of which not-known-emitted functions call
1440 // which other not-known-emitted functions.
1441 //
1442 // When we see something which is illegal if the current function is emitted
1443 // (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1444 // CheckCUDACall), we first check if the current function is known-emitted. If
1445 // so, we immediately output the diagnostic.
1446 //
1447 // Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1448 // until we discover that the function is known-emitted, at which point we take
1449 // it out of this map and emit the diagnostic.
1450 
1452  unsigned DiagID, FunctionDecl *Fn,
1453  Sema &S)
1454  : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1455  ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1456  switch (K) {
1457  case K_Nop:
1458  break;
1459  case K_Immediate:
1461  ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1462  break;
1463  case K_Deferred:
1464  assert(Fn && "Must have a function to attach the deferred diag to.");
1465  auto &Diags = S.DeviceDeferredDiags[Fn];
1466  PartialDiagId.emplace(Diags.size());
1467  Diags.emplace_back(Loc, S.PDiag(DiagID));
1468  break;
1469  }
1470 }
1471 
1473  : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1474  ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1475  PartialDiagId(D.PartialDiagId) {
1476  // Clean the previous diagnostics.
1477  D.ShowCallStack = false;
1478  D.ImmediateDiag.reset();
1479  D.PartialDiagId.reset();
1480 }
1481 
1483  if (ImmediateDiag) {
1484  // Emit our diagnostic and, if it was a warning or error, output a callstack
1485  // if Fn isn't a priori known-emitted.
1486  bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1487  DiagID, Loc) >= DiagnosticsEngine::Warning;
1488  ImmediateDiag.reset(); // Emit the immediate diag.
1489  if (IsWarningOrError && ShowCallStack)
1490  emitCallStackNotes(S, Fn);
1491  } else {
1492  assert((!PartialDiagId || ShowCallStack) &&
1493  "Must always show call stack for deferred diags.");
1494  }
1495 }
1496 
1497 // Indicate that this function (and thus everything it transtively calls) will
1498 // be codegen'ed, and emit any deferred diagnostics on this function and its
1499 // (transitive) callees.
1501  Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1502  SourceLocation OrigLoc,
1503  const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1504  // Nothing to do if we already know that FD is emitted.
1505  if (IsKnownEmitted(S, OrigCallee)) {
1506  assert(!S.DeviceCallGraph.count(OrigCallee));
1507  return;
1508  }
1509 
1510  // We've just discovered that OrigCallee is known-emitted. Walk our call
1511  // graph to see what else we can now discover also must be emitted.
1512 
1513  struct CallInfo {
1514  FunctionDecl *Caller;
1515  FunctionDecl *Callee;
1516  SourceLocation Loc;
1517  };
1518  llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1519  llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1520  Seen.insert(OrigCallee);
1521  while (!Worklist.empty()) {
1522  CallInfo C = Worklist.pop_back_val();
1523  assert(!IsKnownEmitted(S, C.Callee) &&
1524  "Worklist should not contain known-emitted functions.");
1525  S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
1526  emitDeferredDiags(S, C.Callee, C.Caller);
1527 
1528  // If this is a template instantiation, explore its callgraph as well:
1529  // Non-dependent calls are part of the template's callgraph, while dependent
1530  // calls are part of to the instantiation's call graph.
1531  if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1532  FunctionDecl *TemplFD = Templ->getAsFunction();
1533  if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1534  Seen.insert(TemplFD);
1535  Worklist.push_back(
1536  {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1537  }
1538  }
1539 
1540  // Add all functions called by Callee to our worklist.
1541  auto CGIt = S.DeviceCallGraph.find(C.Callee);
1542  if (CGIt == S.DeviceCallGraph.end())
1543  continue;
1544 
1545  for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1546  CGIt->second) {
1547  FunctionDecl *NewCallee = FDLoc.first;
1548  SourceLocation CallLoc = FDLoc.second;
1549  if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1550  continue;
1551  Seen.insert(NewCallee);
1552  Worklist.push_back(
1553  {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1554  }
1555 
1556  // C.Callee is now known-emitted, so we no longer need to maintain its list
1557  // of callees in DeviceCallGraph.
1558  S.DeviceCallGraph.erase(CGIt);
1559  }
1560 }
1561 
1563  if (LangOpts.OpenMP)
1564  return LangOpts.OpenMPIsDevice ? diagIfOpenMPDeviceCode(Loc, DiagID)
1565  : diagIfOpenMPHostCode(Loc, DiagID);
1566  if (getLangOpts().CUDA)
1567  return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1568  : CUDADiagIfHostCode(Loc, DiagID);
1570  getCurFunctionDecl(), *this);
1571 }
1572 
1573 /// Looks through the macro-expansion chain for the given
1574 /// location, looking for a macro expansion with the given name.
1575 /// If one is found, returns true and sets the location to that
1576 /// expansion loc.
1577 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1578  SourceLocation loc = locref;
1579  if (!loc.isMacroID()) return false;
1580 
1581  // There's no good way right now to look at the intermediate
1582  // expansions, so just jump to the expansion location.
1583  loc = getSourceManager().getExpansionLoc(loc);
1584 
1585  // If that's written with the name, stop here.
1586  SmallVector<char, 16> buffer;
1587  if (getPreprocessor().getSpelling(loc, buffer) == name) {
1588  locref = loc;
1589  return true;
1590  }
1591  return false;
1592 }
1593 
1594 /// Determines the active Scope associated with the given declaration
1595 /// context.
1596 ///
1597 /// This routine maps a declaration context to the active Scope object that
1598 /// represents that declaration context in the parser. It is typically used
1599 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1600 /// declarations) that injects a name for name-lookup purposes and, therefore,
1601 /// must update the Scope.
1602 ///
1603 /// \returns The scope corresponding to the given declaraion context, or NULL
1604 /// if no such scope is open.
1606 
1607  if (!Ctx)
1608  return nullptr;
1609 
1610  Ctx = Ctx->getPrimaryContext();
1611  for (Scope *S = getCurScope(); S; S = S->getParent()) {
1612  // Ignore scopes that cannot have declarations. This is important for
1613  // out-of-line definitions of static class members.
1614  if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1615  if (DeclContext *Entity = S->getEntity())
1616  if (Ctx == Entity->getPrimaryContext())
1617  return S;
1618  }
1619 
1620  return nullptr;
1621 }
1622 
1623 /// Enter a new function scope
1625  if (FunctionScopes.empty() && CachedFunctionScope) {
1626  // Use CachedFunctionScope to avoid allocating memory when possible.
1627  CachedFunctionScope->Clear();
1628  FunctionScopes.push_back(CachedFunctionScope.release());
1629  } else {
1631  }
1632  if (LangOpts.OpenMP)
1633  pushOpenMPFunctionRegion();
1634 }
1635 
1636 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1638  BlockScope, Block));
1639 }
1640 
1642  LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1643  FunctionScopes.push_back(LSI);
1644  return LSI;
1645 }
1646 
1648  if (LambdaScopeInfo *const LSI = getCurLambda()) {
1649  LSI->AutoTemplateParameterDepth = Depth;
1650  return;
1651  }
1652  llvm_unreachable(
1653  "Remove assertion if intentionally called in a non-lambda context.");
1654 }
1655 
1656 // Check that the type of the VarDecl has an accessible copy constructor and
1657 // resolve its destructor's exception specification.
1658 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1659  QualType T = VD->getType();
1662  SourceLocation Loc = VD->getLocation();
1663  Expr *VarRef =
1664  new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1666  InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1667  VarRef, /*AllowNRVO=*/true);
1668  if (!Result.isInvalid()) {
1669  Result = S.MaybeCreateExprWithCleanups(Result);
1670  Expr *Init = Result.getAs<Expr>();
1671  S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1672  }
1673 
1674  // The destructor's exception specification is needed when IRGen generates
1675  // block copy/destroy functions. Resolve it here.
1676  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1677  if (CXXDestructorDecl *DD = RD->getDestructor()) {
1678  auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1679  S.ResolveExceptionSpec(Loc, FPT);
1680  }
1681 }
1682 
1683 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1684  // Set the EscapingByref flag of __block variables captured by
1685  // escaping blocks.
1686  for (const BlockDecl *BD : FSI.Blocks) {
1687  for (const BlockDecl::Capture &BC : BD->captures()) {
1688  VarDecl *VD = BC.getVariable();
1689  if (VD->hasAttr<BlocksAttr>()) {
1690  // Nothing to do if this is a __block variable captured by a
1691  // non-escaping block.
1692  if (BD->doesNotEscape())
1693  continue;
1694  VD->setEscapingByref();
1695  }
1696  // Check whether the captured variable is or contains an object of
1697  // non-trivial C union type.
1698  QualType CapType = BC.getVariable()->getType();
1701  S.checkNonTrivialCUnion(BC.getVariable()->getType(),
1702  BD->getCaretLocation(),
1705  }
1706  }
1707 
1708  for (VarDecl *VD : FSI.ByrefBlockVars) {
1709  // __block variables might require us to capture a copy-initializer.
1710  if (!VD->isEscapingByref())
1711  continue;
1712  // It's currently invalid to ever have a __block variable with an
1713  // array type; should we diagnose that here?
1714  // Regardless, we don't want to ignore array nesting when
1715  // constructing this copy.
1716  if (VD->getType()->isStructureOrClassType())
1717  checkEscapingByref(VD, S);
1718  }
1719 }
1720 
1721 /// Pop a function (or block or lambda or captured region) scope from the stack.
1722 ///
1723 /// \param WP The warning policy to use for CFG-based warnings, or null if such
1724 /// warnings should not be produced.
1725 /// \param D The declaration corresponding to this function scope, if producing
1726 /// CFG-based warnings.
1727 /// \param BlockType The type of the block expression, if D is a BlockDecl.
1730  const Decl *D, QualType BlockType) {
1731  assert(!FunctionScopes.empty() && "mismatched push/pop!");
1732 
1733  markEscapingByrefs(*FunctionScopes.back(), *this);
1734 
1737 
1738  if (LangOpts.OpenMP)
1739  popOpenMPFunctionRegion(Scope.get());
1740 
1741  // Issue any analysis-based warnings.
1742  if (WP && D)
1743  AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
1744  else
1745  for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1746  Diag(PUD.Loc, PUD.PD);
1747 
1748  return Scope;
1749 }
1750 
1753  // Stash the function scope for later reuse if it's for a normal function.
1754  if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1755  Self->CachedFunctionScope.reset(Scope);
1756  else
1757  delete Scope;
1758 }
1759 
1760 void Sema::PushCompoundScope(bool IsStmtExpr) {
1761  getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1762 }
1763 
1765  FunctionScopeInfo *CurFunction = getCurFunction();
1766  assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1767 
1768  CurFunction->CompoundScopes.pop_back();
1769 }
1770 
1771 /// Determine whether any errors occurred within this function/method/
1772 /// block.
1775 }
1776 
1778  if (!FunctionScopes.empty())
1779  FunctionScopes.back()->setHasBranchIntoScope();
1780 }
1781 
1783  if (!FunctionScopes.empty())
1784  FunctionScopes.back()->setHasBranchProtectedScope();
1785 }
1786 
1788  if (!FunctionScopes.empty())
1789  FunctionScopes.back()->setHasIndirectGoto();
1790 }
1791 
1793  if (FunctionScopes.empty())
1794  return nullptr;
1795 
1796  auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1797  if (CurBSI && CurBSI->TheDecl &&
1798  !CurBSI->TheDecl->Encloses(CurContext)) {
1799  // We have switched contexts due to template instantiation.
1800  assert(!CodeSynthesisContexts.empty());
1801  return nullptr;
1802  }
1803 
1804  return CurBSI;
1805 }
1806 
1808  if (FunctionScopes.empty())
1809  return nullptr;
1810 
1811  for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1812  if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1813  continue;
1814  return FunctionScopes[e];
1815  }
1816  return nullptr;
1817 }
1818 
1820  for (auto *Scope : llvm::reverse(FunctionScopes)) {
1821  if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Scope)) {
1822  if (LSI->Lambda && !LSI->Lambda->Encloses(CurContext)) {
1823  // We have switched contexts due to template instantiation.
1824  // FIXME: We should swap out the FunctionScopes during code synthesis
1825  // so that we don't need to check for this.
1826  assert(!CodeSynthesisContexts.empty());
1827  return nullptr;
1828  }
1829  return LSI;
1830  }
1831  }
1832  return nullptr;
1833 }
1834 
1835 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1836  if (FunctionScopes.empty())
1837  return nullptr;
1838 
1839  auto I = FunctionScopes.rbegin();
1840  if (IgnoreNonLambdaCapturingScope) {
1841  auto E = FunctionScopes.rend();
1842  while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1843  ++I;
1844  if (I == E)
1845  return nullptr;
1846  }
1847  auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1848  if (CurLSI && CurLSI->Lambda &&
1849  !CurLSI->Lambda->Encloses(CurContext)) {
1850  // We have switched contexts due to template instantiation.
1851  assert(!CodeSynthesisContexts.empty());
1852  return nullptr;
1853  }
1854 
1855  return CurLSI;
1856 }
1857 
1858 // We have a generic lambda if we parsed auto parameters, or we have
1859 // an associated template parameter list.
1861  if (LambdaScopeInfo *LSI = getCurLambda()) {
1862  return (LSI->TemplateParams.size() ||
1863  LSI->GLTemplateParameterList) ? LSI : nullptr;
1864  }
1865  return nullptr;
1866 }
1867 
1868 
1870  if (!LangOpts.RetainCommentsFromSystemHeaders &&
1871  SourceMgr.isInSystemHeader(Comment.getBegin()))
1872  return;
1873  RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1874  if (RC.isAlmostTrailingComment()) {
1875  SourceRange MagicMarkerRange(Comment.getBegin(),
1876  Comment.getBegin().getLocWithOffset(3));
1877  StringRef MagicMarkerText;
1878  switch (RC.getKind()) {
1880  MagicMarkerText = "///<";
1881  break;
1883  MagicMarkerText = "/**<";
1884  break;
1885  default:
1886  llvm_unreachable("if this is an almost Doxygen comment, "
1887  "it should be ordinary");
1888  }
1889  Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1890  FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1891  }
1892  Context.addComment(RC);
1893 }
1894 
1895 // Pin this vtable to this file.
1897 
1900 
1902  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1903 }
1904 
1906  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1907 
1909  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1910 
1911 /// Figure out if an expression could be turned into a call.
1912 ///
1913 /// Use this when trying to recover from an error where the programmer may have
1914 /// written just the name of a function instead of actually calling it.
1915 ///
1916 /// \param E - The expression to examine.
1917 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1918 /// with no arguments, this parameter is set to the type returned by such a
1919 /// call; otherwise, it is set to an empty QualType.
1920 /// \param OverloadSet - If the expression is an overloaded function
1921 /// name, this parameter is populated with the decls of the various overloads.
1922 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1923  UnresolvedSetImpl &OverloadSet) {
1924  ZeroArgCallReturnTy = QualType();
1925  OverloadSet.clear();
1926 
1927  const OverloadExpr *Overloads = nullptr;
1928  bool IsMemExpr = false;
1929  if (E.getType() == Context.OverloadTy) {
1930  OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1931 
1932  // Ignore overloads that are pointer-to-member constants.
1933  if (FR.HasFormOfMemberPointer)
1934  return false;
1935 
1936  Overloads = FR.Expression;
1937  } else if (E.getType() == Context.BoundMemberTy) {
1938  Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1939  IsMemExpr = true;
1940  }
1941 
1942  bool Ambiguous = false;
1943  bool IsMV = false;
1944 
1945  if (Overloads) {
1946  for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1947  DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1948  OverloadSet.addDecl(*it);
1949 
1950  // Check whether the function is a non-template, non-member which takes no
1951  // arguments.
1952  if (IsMemExpr)
1953  continue;
1954  if (const FunctionDecl *OverloadDecl
1955  = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1956  if (OverloadDecl->getMinRequiredArguments() == 0) {
1957  if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1958  (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1959  OverloadDecl->isCPUSpecificMultiVersion()))) {
1960  ZeroArgCallReturnTy = QualType();
1961  Ambiguous = true;
1962  } else {
1963  ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1964  IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1965  OverloadDecl->isCPUSpecificMultiVersion();
1966  }
1967  }
1968  }
1969  }
1970 
1971  // If it's not a member, use better machinery to try to resolve the call
1972  if (!IsMemExpr)
1973  return !ZeroArgCallReturnTy.isNull();
1974  }
1975 
1976  // Attempt to call the member with no arguments - this will correctly handle
1977  // member templates with defaults/deduction of template arguments, overloads
1978  // with default arguments, etc.
1979  if (IsMemExpr && !E.isTypeDependent()) {
1980  Sema::TentativeAnalysisScope Trap(*this);
1982  None, SourceLocation());
1983  if (R.isUsable()) {
1984  ZeroArgCallReturnTy = R.get()->getType();
1985  return true;
1986  }
1987  return false;
1988  }
1989 
1990  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1991  if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1992  if (Fun->getMinRequiredArguments() == 0)
1993  ZeroArgCallReturnTy = Fun->getReturnType();
1994  return true;
1995  }
1996  }
1997 
1998  // We don't have an expression that's convenient to get a FunctionDecl from,
1999  // but we can at least check if the type is "function of 0 arguments".
2000  QualType ExprTy = E.getType();
2001  const FunctionType *FunTy = nullptr;
2002  QualType PointeeTy = ExprTy->getPointeeType();
2003  if (!PointeeTy.isNull())
2004  FunTy = PointeeTy->getAs<FunctionType>();
2005  if (!FunTy)
2006  FunTy = ExprTy->getAs<FunctionType>();
2007 
2008  if (const FunctionProtoType *FPT =
2009  dyn_cast_or_null<FunctionProtoType>(FunTy)) {
2010  if (FPT->getNumParams() == 0)
2011  ZeroArgCallReturnTy = FunTy->getReturnType();
2012  return true;
2013  }
2014  return false;
2015 }
2016 
2017 /// Give notes for a set of overloads.
2018 ///
2019 /// A companion to tryExprAsCall. In cases when the name that the programmer
2020 /// wrote was an overloaded function, we may be able to make some guesses about
2021 /// plausible overloads based on their return types; such guesses can be handed
2022 /// off to this method to be emitted as notes.
2023 ///
2024 /// \param Overloads - The overloads to note.
2025 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
2026 /// -fshow-overloads=best, this is the location to attach to the note about too
2027 /// many candidates. Typically this will be the location of the original
2028 /// ill-formed expression.
2029 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
2030  const SourceLocation FinalNoteLoc) {
2031  int ShownOverloads = 0;
2032  int SuppressedOverloads = 0;
2033  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
2034  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2035  // FIXME: Magic number for max shown overloads stolen from
2036  // OverloadCandidateSet::NoteCandidates.
2037  if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
2038  ++SuppressedOverloads;
2039  continue;
2040  }
2041 
2042  NamedDecl *Fn = (*It)->getUnderlyingDecl();
2043  // Don't print overloads for non-default multiversioned functions.
2044  if (const auto *FD = Fn->getAsFunction()) {
2045  if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
2046  !FD->getAttr<TargetAttr>()->isDefaultVersion())
2047  continue;
2048  }
2049  S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
2050  ++ShownOverloads;
2051  }
2052 
2053  if (SuppressedOverloads)
2054  S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
2055  << SuppressedOverloads;
2056 }
2057 
2059  const UnresolvedSetImpl &Overloads,
2060  bool (*IsPlausibleResult)(QualType)) {
2061  if (!IsPlausibleResult)
2062  return noteOverloads(S, Overloads, Loc);
2063 
2064  UnresolvedSet<2> PlausibleOverloads;
2065  for (OverloadExpr::decls_iterator It = Overloads.begin(),
2066  DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2067  const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
2068  QualType OverloadResultTy = OverloadDecl->getReturnType();
2069  if (IsPlausibleResult(OverloadResultTy))
2070  PlausibleOverloads.addDecl(It.getDecl());
2071  }
2072  noteOverloads(S, PlausibleOverloads, Loc);
2073 }
2074 
2075 /// Determine whether the given expression can be called by just
2076 /// putting parentheses after it. Notably, expressions with unary
2077 /// operators can't be because the unary operator will start parsing
2078 /// outside the call.
2079 static bool IsCallableWithAppend(Expr *E) {
2080  E = E->IgnoreImplicit();
2081  return (!isa<CStyleCastExpr>(E) &&
2082  !isa<UnaryOperator>(E) &&
2083  !isa<BinaryOperator>(E) &&
2084  !isa<CXXOperatorCallExpr>(E));
2085 }
2086 
2088  if (const auto *UO = dyn_cast<UnaryOperator>(E))
2089  E = UO->getSubExpr();
2090 
2091  if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2092  if (ULE->getNumDecls() == 0)
2093  return false;
2094 
2095  const NamedDecl *ND = *ULE->decls_begin();
2096  if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2097  return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2098  }
2099  return false;
2100 }
2101 
2103  bool ForceComplain,
2104  bool (*IsPlausibleResult)(QualType)) {
2105  SourceLocation Loc = E.get()->getExprLoc();
2106  SourceRange Range = E.get()->getSourceRange();
2107 
2108  QualType ZeroArgCallTy;
2109  UnresolvedSet<4> Overloads;
2110  if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
2111  !ZeroArgCallTy.isNull() &&
2112  (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2113  // At this point, we know E is potentially callable with 0
2114  // arguments and that it returns something of a reasonable type,
2115  // so we can emit a fixit and carry on pretending that E was
2116  // actually a CallExpr.
2117  SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
2118  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2119  Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2120  << (IsCallableWithAppend(E.get())
2121  ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2122  : FixItHint());
2123  if (!IsMV)
2124  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2125 
2126  // FIXME: Try this before emitting the fixit, and suppress diagnostics
2127  // while doing so.
2128  E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
2129  Range.getEnd().getLocWithOffset(1));
2130  return true;
2131  }
2132 
2133  if (!ForceComplain) return false;
2134 
2135  bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2136  Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2137  if (!IsMV)
2138  notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2139  E = ExprError();
2140  return true;
2141 }
2142 
2144  if (!Ident_super)
2145  Ident_super = &Context.Idents.get("super");
2146  return Ident_super;
2147 }
2148 
2150  if (!Ident___float128)
2151  Ident___float128 = &Context.Idents.get("__float128");
2152  return Ident___float128;
2153 }
2154 
2157  unsigned OpenMPCaptureLevel) {
2158  auto *CSI = new CapturedRegionScopeInfo(
2159  getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2160  (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0,
2161  OpenMPCaptureLevel);
2162  CSI->ReturnType = Context.VoidTy;
2163  FunctionScopes.push_back(CSI);
2164 }
2165 
2167  if (FunctionScopes.empty())
2168  return nullptr;
2169 
2170  return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2171 }
2172 
2173 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2175  return DeleteExprs;
2176 }
2177 
2178 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2179  if (ExtStr.empty())
2180  return;
2182  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2183  auto CanT = T.getCanonicalType().getTypePtr();
2184  for (auto &I : Exts)
2185  OpenCLTypeExtMap[CanT].insert(I.str());
2186 }
2187 
2188 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2190  ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2191  if (Exts.empty())
2192  return;
2193  for (auto &I : Exts)
2194  OpenCLDeclExtMap[FD].insert(I.str());
2195 }
2196 
2198  if (CurrOpenCLExtension.empty())
2199  return;
2200  setOpenCLExtensionForType(T, CurrOpenCLExtension);
2201 }
2202 
2204  if (CurrOpenCLExtension.empty())
2205  return;
2206  setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2207 }
2208 
2210  if (!OpenCLDeclExtMap.empty())
2211  return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2212 
2213  return "";
2214 }
2215 
2217  if (!OpenCLTypeExtMap.empty())
2218  return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2219 
2220  return "";
2221 }
2222 
2223 template <typename T, typename MapT>
2224 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2225  std::string ExtensionNames = "";
2226  auto Loc = Map.find(FDT);
2227 
2228  for (auto const& I : Loc->second) {
2229  ExtensionNames += I;
2230  ExtensionNames += " ";
2231  }
2232  ExtensionNames.pop_back();
2233 
2234  return ExtensionNames;
2235 }
2236 
2238  auto Loc = OpenCLDeclExtMap.find(FD);
2239  if (Loc == OpenCLDeclExtMap.end())
2240  return false;
2241  for (auto &I : Loc->second) {
2242  if (!getOpenCLOptions().isEnabled(I))
2243  return true;
2244  }
2245  return false;
2246 }
2247 
2248 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2249 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2250  DiagInfoT DiagInfo, MapT &Map,
2251  unsigned Selector,
2252  SourceRange SrcRange) {
2253  auto Loc = Map.find(D);
2254  if (Loc == Map.end())
2255  return false;
2256  bool Disabled = false;
2257  for (auto &I : Loc->second) {
2258  if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2259  Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2260  << I << SrcRange;
2261  Disabled = true;
2262  }
2263  }
2264  return Disabled;
2265 }
2266 
2268  // Check extensions for declared types.
2269  Decl *Decl = nullptr;
2270  if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2271  Decl = TypedefT->getDecl();
2272  if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2273  Decl = TagT->getDecl();
2274  auto Loc = DS.getTypeSpecTypeLoc();
2275 
2276  // Check extensions for vector types.
2277  // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2278  if (QT->isExtVectorType()) {
2279  auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2280  return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2281  }
2282 
2283  if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2284  return true;
2285 
2286  // Check extensions for builtin types.
2287  return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2288  QT, OpenCLTypeExtMap);
2289 }
2290 
2292  IdentifierInfo *FnName = D.getIdentifier();
2293  return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2294  OpenCLDeclExtMap, 1, D.getSourceRange());
2295 }
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:2552
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:2453
Defines the clang::ASTContext interface.
ObjCInterfaceDecl * NSStringDecl
The declaration of the Objective-C NSString class.
Definition: Sema.h:933
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:667
Represents a function declaration or definition.
Definition: Decl.h:1756
llvm::SmallSetVector< const TypedefNameDecl *, 4 > UnusedLocalTypedefNameCandidates
Set containing all typedefs that are likely unused.
Definition: Sema.h:629
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:789
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
CanQualType OCLQueueTy
Definition: ASTContext.h:1050
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:3929
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
TypedefDecl * getCFConstantStringDecl() const
A (possibly-)qualified type.
Definition: Type.h:643
ASTConsumer & Consumer
Definition: Sema.h:375
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
Definition: Type.h:6285
LateTemplateParserCB * LateTemplateParser
Definition: Sema.h:699
void Initialize()
Perform initialization that occurs after the parser has been initialized but before it parses anythin...
Definition: Sema.cpp:197
DeviceDiagBuilder(Kind K, SourceLocation Loc, unsigned DiagID, FunctionDecl *Fn, Sema &S)
Definition: Sema.cpp:1451
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:33
DeclContext * getFunctionLevelDeclContext()
Definition: Sema.cpp:1243
RecordDecl * MSVCGuidDecl
The MSVC "_GUID" struct, which is defined in MSVC header files.
Definition: Sema.h:912
const FunctionProtoType * ResolveExceptionSpec(SourceLocation Loc, const FunctionProtoType *FPT)
Emit the diagnostic immediately, and, if it&#39;s a warning or error, also emit a call stack showing how ...
Definition: Sema.h:10537
Ordinary name lookup, which finds ordinary names (functions, variables, typedefs, etc...
Definition: Sema.h:3254
A class which encapsulates the logic for delaying diagnostics during parsing and other processing...
Definition: Sema.h:722
void CheckCompleteVariableDeclaration(VarDecl *VD)
Definition: SemaDecl.cpp:12293
void getUndefinedButUsed(SmallVectorImpl< std::pair< NamedDecl *, SourceLocation > > &Undefined)
Obtain a sorted list of functions that are undefined but ODR-used.
Definition: Sema.cpp:658
submodule_iterator submodule_begin()
Definition: Module.h:563
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:3393
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:518
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:658
static void notePlausibleOverloads(Sema &S, SourceLocation Loc, const UnresolvedSetImpl &Overloads, bool(*IsPlausibleResult)(QualType))
Definition: Sema.cpp:2058
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:681
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:88
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1380
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
Module * getCurrentModule()
Retrieves the module that we&#39;re currently building, if any.
static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack)
Definition: Sema.cpp:1404
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:6486
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition: Decl.cpp:2166
std::deque< PendingImplicitInstantiation > PendingInstantiations
The queue of implicit template instantiations that are required but have not yet been performed...
Definition: Sema.h:7993
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with the preprocessor.
Definition: Sema.cpp:52
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:883
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:384
SmallVector< CodeSynthesisContext, 16 > CodeSynthesisContexts
List of active code synthesis contexts.
Definition: Sema.h:7630
virtual void updateOutOfDateSelector(Selector Sel)
Load the contents of the global method pool for a given selector if necessary.
Definition: Sema.cpp:1899
virtual void ReadMethodPool(Selector Sel)
Load the contents of the global method pool for a given selector.
Definition: Sema.cpp:1898
CanQualType LongTy
Definition: ASTContext.h:1021
const DiagnosticBuilder & setForceEmit() const
Forces the diagnostic to be emitted.
Definition: Diagnostic.h:1129
Any normal BCPL comments.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1290
Declaration of a variable template.
static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E)
Definition: Sema.cpp:2087
SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset=0)
Calls Lexer::getLocForEndOfToken()
Definition: Sema.cpp:48
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:703
void checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind)
Emit diagnostics if a non-trivial C union type or a struct that contains a non-trivial C union is use...
Definition: SemaDecl.cpp:11478
A container of type source information.
Definition: Decl.h:86
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3665
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:628
IdentifierInfo * getSuperIdentifier() const
Definition: Sema.cpp:2143
The diagnostic should not be reported, but it should cause template argument deduction to fail...
void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind)
Definition: Sema.cpp:880
void LoadExternalWeakUndeclaredIdentifiers()
Load weak undeclared identifiers from the external source.
Definition: Sema.cpp:761
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:7671
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1280
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3210
IdentifierInfo * getFloat128Identifier() const
Definition: Sema.cpp:2149
bool DisableTypoCorrection
Tracks whether we are in a context where typo correction is disabled.
Definition: Sema.h:7964
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:2216
RAII object that enters a new expression evaluation context.
Definition: Sema.h:11360
Compiling a C++ modules TS module interface unit.
Definition: LangOptions.h:84
Represents a variable declaration or definition.
Definition: Decl.h:812
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
QualType getReturnType() const
Definition: Decl.h:2337
DiagnosticsEngine & Diags
Definition: Sema.h:376
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:6857
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2369
void enableSupportedCore(LangOptions LO)
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:431
SmallVector< CXXRecordDecl *, 4 > DelayedDllExportClasses
Definition: Sema.h:11268
llvm::MapVector< NamedDecl *, SourceLocation > UndefinedButUsed
UndefinedInternals - all the used, undefined objects which require a definition in this translation u...
Definition: Sema.h:1190
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:77
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:660
bool isInvalidDecl() const
Definition: DeclBase.h:553
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:37
ObjCMethodDecl * ValueWithBytesObjCTypeMethod
The declaration of the valueWithBytes:objCType: method.
Definition: Sema.h:942
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:35
OpenCLOptions & getOpenCLOptions()
Definition: Sema.h:1294
Defines the clang::Expr interface and subclasses for C++ expressions.
ObjCInterfaceDecl * NSDictionaryDecl
The declaration of the Objective-C NSDictionary class.
Definition: Sema.h:951
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:2174
iterator begin(Source *source, bool LocalOnly=false)
iterator begin(DeclarationName Name)
begin - Returns an iterator for decls with the name &#39;Name&#39;.
void threadSafetyCleanup(BeforeSet *Cache)
CanQualType OCLSamplerTy
Definition: ASTContext.h:1049
void CheckDelayedMemberExceptionSpecs()
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Represents a struct/union/class.
Definition: Decl.h:3634
void FreeVisContext()
FreeVisContext - Deallocate and null out VisContext.
Definition: SemaAttr.cpp:897
An iterator over the friend declarations of a class.
Definition: DeclFriend.h:187
This is the private module fragment within some C++ module.
Definition: Module.h:84
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
One of these records is kept for each identifier that is lexed.
std::unique_ptr< NSAPI > NSAPIObj
Caches identifiers/selectors for NSFoundation APIs.
Definition: Sema.h:915
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:7960
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:4074
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:689
sema::FunctionScopeInfo * getEnclosingFunction() const
Definition: Sema.cpp:1807
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
Definition: ModuleMap.cpp:1293
sema::LambdaScopeInfo * getCurGenericLambda()
Retrieve the current generic lambda info, if any.
Definition: Sema.cpp:1860
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:160
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:7864
SourceLocation getTypeSpecTypeLoc() const
Definition: DeclSpec.h:505
DeviceDiagBuilder diagIfOpenMPHostCode(SourceLocation Loc, unsigned DiagID)
Creates a DeviceDiagBuilder that emits the diagnostic if the current context is "used as host code"...
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1792
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:274
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:2197
Represents a member of a struct/union/class.
Definition: Decl.h:2615
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:4181
void setEscapingByref()
Definition: Decl.h:1436
std::unique_ptr< sema::FunctionScopeInfo > CachedFunctionScope
Definition: Sema.h:604
threadSafety::BeforeSet * ThreadSafetyDeclCache
Definition: Sema.h:7979
ObjCInterfaceDecl * NSValueDecl
The declaration of the Objective-C NSValue class.
Definition: Sema.h:921
void ActOnEndOfTranslationUnit()
ActOnEndOfTranslationUnit - This is called at the very end of the translation unit when EOF is reache...
Definition: Sema.cpp:942
CanQualType OCLEventTy
Definition: ASTContext.h:1049
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:31
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:417
bool hasAArch64SVETypes() const
Returns whether or not the AArch64 SVE built-in types are available on this target.
Definition: TargetInfo.h:796
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:1777
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3677
void setPrintingPolicy(const clang::PrintingPolicy &Policy)
Definition: ASTContext.h:671
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:2237
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1050
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:904
Describes a module or submodule.
Definition: Module.h:64
llvm::BumpPtrAllocator BumpAlloc
Definition: Sema.h:1167
IdentifierTable & Idents
Definition: ASTContext.h:576
static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, const SourceLocation FinalNoteLoc)
Give notes for a set of overloads.
Definition: Sema.cpp:2029
bool AccessCheckingSFINAE
When true, access checking violations are treated as SFINAE failures rather than hard errors...
Definition: Sema.h:6407
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:125
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:25
DeviceDiagBuilder CUDADiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a DeviceDiagBuilder that emits the diagnostic if the current context is "used as device code"...
Definition: SemaCUDA.cpp:623
unsigned TyposCorrected
The number of typos corrected by CorrectTypo.
Definition: Sema.h:7967
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
Definition: Decl.cpp:2149
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:779
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:1577
PtrTy get() const
Definition: Ownership.h:170
DeviceDiagBuilder targetDiag(SourceLocation Loc, unsigned DiagID)
Definition: Sema.cpp:1562
RAII class used to indicate that we are performing provisional semantic analysis to determine the val...
Definition: Sema.h:7942
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1268
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:423
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:909
const SourceLocation & getLocation() const
Definition: Diagnostic.h:1328
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:2267
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:414
std::pair< SourceLocation, bool > DeleteExprLoc
Delete-expressions to be analyzed at the end of translation unit.
Definition: Sema.h:636
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:667
void PerformPendingInstantiations(bool LocalOnly=false)
Performs template instantiation for all implicit template instantiations we have seen until this poin...
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Definition: Type.h:6279
A set of unresolved declarations.
Definition: UnresolvedSet.h:60
void CheckDelegatingCtorCycles()
CheckedConversionKind
The kind of conversion being performed.
Definition: Sema.h:9826
friend_iterator friend_end() const
Definition: DeclFriend.h:243
~ExternalSemaSource() override
Definition: Sema.cpp:1896
Values of this type can never be null.
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:437
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6148
static const unsigned NumNSNumberLiteralMethods
Definition: NSAPI.h:191
Emit no diagnostics.
Definition: Sema.h:10531
submodule_iterator submodule_end()
Definition: Module.h:565
void PrintStats() const
Print out statistics about the semantic analysis.
Definition: Sema.cpp:454
void emitAndClearUnusedLocalTypedefWarnings()
Definition: Sema.cpp:852
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:123
Preprocessor & PP
Definition: Sema.h:373
ObjCInterfaceDecl * NSNumberDecl
The declaration of the Objective-C NSNumber class.
Definition: Sema.h:918
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:1901
const LangOptions & getLangOpts() const
Definition: Sema.h:1293
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:176
sema::AnalysisBasedWarnings AnalysisWarnings
Worker object for performing CFG-based warnings.
Definition: Sema.h:7978
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4116
NamespaceDecl * StdExperimentalNamespaceCache
The C++ "std::experimental" namespace, where the experimental parts of the standard library resides...
Definition: Sema.h:898
ObjCMethodDecl * StringWithUTF8StringMethod
The declaration of the stringWithUTF8String: method.
Definition: Sema.h:939
void DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind, SourceLocation IncludeLoc)
Definition: SemaAttr.cpp:332
const LangOptions & LangOpts
Definition: Sema.h:372
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:2291
void warnStackExhausted(SourceLocation Loc)
Warn that the stack is nearly exhausted.
Definition: Sema.cpp:390
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:497
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1297
static bool IsCallableWithAppend(Expr *E)
Determine whether the given expression can be called by just putting parentheses after it...
Definition: Sema.cpp:2079
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K, unsigned OpenMPCaptureLevel=0)
Definition: Sema.cpp:2155
bool hasAttr() const
Definition: DeclBase.h:542
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:108
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1043
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1649
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3725
TentativeDefinitionsType TentativeDefinitions
All the tentative definitions encountered in the TU.
Definition: Sema.h:659
Retains information about a captured region.
Definition: ScopeInfo.h:741
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:1760
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:688
CastKind
CastKind - The kind of operation required for a conversion.
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1975
void PopCompoundScope()
Definition: Sema.cpp:1764
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:1908
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:1782
bool isEnabled(llvm::StringRef Ext) const
Definition: OpenCLOptions.h:39
Scope * getCurScope() const
Retrieve the parser&#39;s current scope.
Definition: Sema.h:11233
unsigned Offset
Definition: Format.cpp:1751
TUFragmentKind
Definition: Sema.h:1406
void runWithSufficientStackSpace(llvm::function_ref< void()> Diag, llvm::function_ref< void()> Fn)
Run a given function on a stack with "sufficient" space.
Definition: Stack.h:40
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:252
SmallVector< PendingImplicitInstantiation, 1 > LateParsedInstantiations
Queue of implicit template instantiations that cannot be performed eagerly.
Definition: Sema.h:7997
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:715
bool isCodeCompletionEnabled() const
Determine if we are performing code completion.
Any normal C comment.
An abstract interface that should be implemented by external AST sources that also provide informatio...
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3923
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D)
Used to prune the decls of Sema&#39;s UnusedFileScopedDecls vector.
Definition: Sema.cpp:578
This represents one expression.
Definition: Expr.h:108
void setOpenCLExtensionForDecl(Decl *FD, llvm::StringRef Exts)
Set OpenCL extensions for a declaration which can only be used when these OpenCL extensions are enabl...
Definition: Sema.cpp:2188
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:778
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:122
bool isAlmostTrailingComment() const LLVM_READONLY
Returns true if it is a probable typo:
int Id
Definition: ASTDiff.cpp:190
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
llvm::SmallPtrSet< const Decl *, 4 > ParsingInitForAutoVars
ParsingInitForAutoVars - a set of declarations with auto types for which we are currently parsing the...
Definition: Sema.h:649
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2810
TypedefDecl * buildImplicitTypedef(QualType T, StringRef Name) const
Create a new implicit TU-level typedef declaration.
void addImplicitTypedef(StringRef Name, QualType T)
Definition: Sema.cpp:191
ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
BuildCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5576
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6922
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2792
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:7662
Defines the clang::Preprocessor interface.
bool isNullPtrType() const
Definition: Type.h:6674
llvm::MapVector< IdentifierInfo *, WeakInfo > WeakUndeclaredIdentifiers
WeakUndeclaredIdentifiers - Identifiers contained in #pragma weak before declared.
Definition: Sema.h:859
Defines the classes clang::DelayedDiagnostic and clang::AccessedEntity.
Not compiling a module interface at all.
Definition: LangOptions.h:75
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy initialization expression of a block var decl.
DeclContext * getDeclContext()
Definition: DeclBase.h:438
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
Definition: ModuleMap.cpp:1267
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:2011
decls_iterator decls_begin() const
Definition: ExprCXX.h:2842
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7790
int Depth
Definition: ASTDiff.cpp:190
bool WarnedStackExhausted
Definition: Sema.h:1281
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
QualType getType() const
Definition: Expr.h:137
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:608
PartialDiagnostic::StorageAllocator & getDiagAllocator()
Definition: ASTContext.h:699
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:1779
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:91
bool isInvalid() const
Definition: Ownership.h:166
SourceLocation getEnd() const
Preprocessor & getPreprocessor() const
Definition: Sema.h:1299
SourceLocation getCaretLocation() const
Definition: Decl.h:3996
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:948
void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)
Add this decl to the scope shadowed decl chains.
Definition: SemaDecl.cpp:1370
bool isUsable() const
Definition: Ownership.h:167
sema::LambdaScopeInfo * PushLambdaScope()
Definition: Sema.cpp:1641
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:366
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:708
const SourceManager & SM
Definition: Format.cpp:1609
OverloadsShown getShowOverloads() const
Definition: Diagnostic.h:660
SmallVector< CXXMethodDecl *, 4 > DelayedDllExportMemberFunctions
Definition: Sema.h:11269
unsigned NumSFINAEErrors
The number of SFINAE diagnostics that have been trapped.
Definition: Sema.h:1170
llvm::DenseMap< const CXXRecordDecl *, bool > RecordCompleteMap
Definition: Sema.cpp:772
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:6207
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:474
void PushBlockScope(Scope *BlockScope, BlockDecl *Block)
Definition: Sema.cpp:1636
CanQualType OverloadTy
Definition: ASTContext.h:1041
void Emit(const DiagnosticBuilder &DB) const
#define false
Definition: stdbool.h:17
RecordDecl * CXXTypeInfoDecl
The C++ "type_info" declaration, which is defined in <typeinfo>.
Definition: Sema.h:909
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2750
QualType getCanonicalType() const
Definition: Type.h:6187
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
Definition: Sema.cpp:398
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:3651
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:2203
Diagnostic builder for CUDA/OpenMP devices errors which may or may not be deferred.
Definition: Sema.h:10527
StringRef getName() const
Definition: FileManager.h:102
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:1385
bool makeUnavailableInSystemHeader(SourceLocation loc, UnavailableAttr::ImplicitReason reason)
makeUnavailableInSystemHeader - There is an error in the current context.
Definition: Sema.cpp:407
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:78
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:2209
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:647
ClassTemplateDecl * StdInitializerList
The C++ "std::initializer_list" template, which is defined in <initializer_list>. ...
Definition: Sema.h:902
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2068
void DiagnoseUseOfUnimplementedSelectors()
CanQualType FloatTy
Definition: ASTContext.h:1024
DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc)
The parser has processed a global-module-fragment declaration that begins the definition of the globa...
Definition: SemaModule.cpp:58
This is a fragment of the global module within some C++ module.
Definition: Module.h:81
static void emitCallStackNotes(Sema &S, FunctionDecl *FD)
Definition: Sema.cpp:1390
CanQualType VoidTy
Definition: ASTContext.h:1012
void markKnownEmitted(Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee, SourceLocation OrigLoc, const llvm::function_ref< bool(Sema &, FunctionDecl *)> IsKnownEmitted)
Indicate that this function (and thus everything it transtively calls) will be codegen&#39;ed, and emit any deferred diagnostics on this function and its (transitive) callees.
Definition: Sema.cpp:1500
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:88
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie)
Definition: Diagnostic.h: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:1905
void EmitCurrentDiagnostic(unsigned DiagID)
Cause the active diagnostic on the DiagosticsEngine to be emitted.
Definition: Sema.cpp:1282
This declaration is only a declaration.
Definition: Decl.h:1146
void addSupport(const OpenCLOptions &Opts)
llvm::APInt APInt
Definition: Integral.h:27
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3244
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:821
friend_iterator friend_begin() const
Definition: DeclFriend.h:239
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:398
std::unique_ptr< CXXFieldCollector > FieldCollector
FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
Definition: Sema.h:620
Create a deferred diagnostic, which is emitted only if the function it&#39;s attached to is codegen&#39;ed...
Definition: Sema.h:10541
static bool isFunctionOrVarDeclExternC(NamedDecl *ND)
Definition: Sema.cpp:639
sema::CapturedRegionScopeInfo * getCurCapturedRegion()
Retrieve the current captured region, if any.
Definition: Sema.cpp:2166
void operator()(sema::FunctionScopeInfo *Scope) const
Definition: Sema.cpp:1752
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:868
void setLastDiagnosticIgnored(bool Ignored)
Pretend that the last diagnostic issued was ignored, so any subsequent notes will be suppressed...
Definition: Diagnostic.h:668
ASTConsumer & getASTConsumer() const
Definition: Sema.h:1301
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:2178
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1985
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2957
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:700
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:834
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:7695
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
ObjCMethodDecl * NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods]
The Objective-C NSNumber methods used to create NSNumber literals.
Definition: Sema.h:930
static void checkEscapingByref(VarDecl *VD, Sema &S)
Definition: Sema.cpp:1658
ArrayRef< Capture > captures() const
Definition: Decl.h:4050
ASTMutationListener * getASTMutationListener() const
Definition: Sema.cpp:428
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:504
void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E)
Warn when implicitly casting 0 to nullptr.
Definition: Sema.cpp:476
void RecordParsingTemplateParameterDepth(unsigned Depth)
This is used to inform Sema what the current TemplateParameterDepth is during Parsing.
Definition: Sema.cpp:1647
bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const
Definition: SemaDecl.cpp:1583
Custom deleter to allow FunctionScopeInfos to be kept alive for a short time after they&#39;ve been poppe...
Definition: Sema.h:1441
SourceLocation getIncludeLoc(FileID FID) const
Returns the include location if FID is a #include&#39;d file otherwise it returns an invalid location...
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:77
ClassTemplateDecl * StdCoroutineTraitsCache
The C++ "std::coroutine_traits" template, which is defined in <coroutine_traits>
Definition: Sema.h:906
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:964
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:2102
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
Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
Definition: Sema.h:10533
IdentifierResolver IdResolver
Definition: Sema.h:878
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:2448
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i...
Definition: LangOptions.h:267
static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy)
ScalarTypeToBooleanCastKind - Returns the cast kind corresponding to the conversion from scalar type ...
Definition: Sema.cpp:561
DeviceDiagBuilder diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a DeviceDiagBuilder that emits the diagnostic if the current context is "used as device code"...
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1082
Abstract interface for a module loader.
Definition: ModuleLoader.h:73
NamedDecl * getCurFunctionOrMethodDecl()
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we&#39;re in...
Definition: Sema.cpp:1275
std::string getOpenCLExtensionsFromExtMap(T *FT, MapT &Map)
Find an extension in an appropriate extension map and return its name.
Definition: Sema.cpp:2224
bool hasAnyUnrecoverableErrorsInThisFunction() const
Determine whether any errors occurred within this function/method/ block.
Definition: Sema.cpp:1773
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2960
bool isMacroID() const
llvm::MapVector< FieldDecl *, DeleteLocs > DeleteExprs
Definition: Sema.h:638
void DiagnoseUnterminatedPragmaAttribute()
Definition: SemaAttr.cpp:840
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2952
DeclarationName VAListTagName
VAListTagName - The declaration name corresponding to __va_list_tag.
Definition: Sema.h:394
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:1022
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1263
static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S)
Definition: Sema.cpp:1683
void * OpaqueParser
Definition: Sema.h:701
ExtVectorType - Extended vector type.
Definition: Type.h:3325
MaterializeTemporaryExpr * CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary, bool BoundToLvalueReference)
Definition: SemaInit.cpp:7686
CanQualType BoundMemberTy
Definition: ASTContext.h:1041
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1096
void addComment(const RawComment &RC)
Definition: ASTContext.h:794
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:945
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:3772
The "class" keyword.
Definition: Type.h:5118
virtual bool hasInt128Type() const
Determine whether the __int128 type is supported on this target.
Definition: TargetInfo.h:522
static bool IsKnownEmitted(Sema &S, FunctionDecl *FD)
Definition: SemaCUDA.cpp:590
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2085
This is a scope that can contain a declaration.
Definition: Scope.h:59
SourceManager & getSourceManager()
Definition: ASTContext.h:675
The type-property cache.
Definition: Type.cpp:3524
void ActOnTranslationUnitScope(Scope *S)
Definition: Sema.cpp:71
Scope * getScopeForContext(DeclContext *Ctx)
Determines the active Scope associated with the given declaration context.
Definition: Sema.cpp:1605
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2286
bool isConstantEvaluatedOverride
Used to change context to isConstantEvaluated without pushing a heavy ExpressionEvaluationContextReco...
Definition: Sema.h:808
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, std::vector< PartialDiagnosticAt > > DeviceDeferredDiags
Diagnostics that are emitted only if we discover that the given function must be codegen&#39;ed.
Definition: Sema.h:10477
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:3117
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1005
sema::LambdaScopeInfo * getEnclosingLambda() const
Get the innermost lambda enclosing the current location, if any.
Definition: Sema.cpp:1819
void * VisContext
VisContext - Manages the stack for #pragma GCC visibility.
Definition: Sema.h:552
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
sema::DelayedDiagnosticPool * getCurrentPool() const
Returns the current delayed-diagnostics pool.
Definition: Sema.h:737
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:254
CommentKind getKind() const LLVM_READONLY
void setFunctionHasIndirectGoto()
Definition: Sema.cpp:1787
Represents a C array with an unspecified size.
Definition: Type.h:2964
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1457
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Definition: Sema.cpp:1729
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
Definition: Sema.h:1450
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:386
bool isRValue() const
Definition: Expr.h:259
TranslationUnitKind
Describes the kind of translation unit being processed.
Definition: LangOptions.h:378
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:830
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C &#39;Class&#39; type...
SourceManager & getSourceManager() const
Definition: Sema.h:1298
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:262
bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, UnresolvedSetImpl &NonTemplateOverloads)
Figure out if an expression could be turned into a call.
Definition: Sema.cpp:1922
A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) ...
Definition: Diagnostic.h:1317
TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Sema.h:1165
Defines the clang::TargetInfo interface.
bool isIncrementalProcessingEnabled() const
Returns true if incremental processing is enabled.
ExprResult ExprError()
Definition: Ownership.h:279
The diagnostic should be reported.
CanQualType IntTy
Definition: ASTContext.h:1021
void ActOnComment(SourceRange Comment)
Definition: Sema.cpp:1869
virtual void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending)
Read the set of pending instantiations known to the external Sema source.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:225
The diagnostic is an access-control diagnostic, which will be substitution failures in some contexts ...
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1141
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:3293
Defines utilities for dealing with stack allocation and stack space.
NamedDecl * getMostRecentDecl()
Definition: Decl.h:445
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2171
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1169
SourceManager & SourceMgr
Definition: Sema.h:377
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, FunctionDeclAndLoc > DeviceKnownEmittedFns
An inverse call graph, mapping known-emitted functions to one of their known-emitted callers (plus th...
Definition: Sema.h:10498
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound stamement scopes in the function.
Definition: ScopeInfo.h:204
QualType getType() const
Definition: Decl.h:647
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:129
virtual void CompleteTentativeDefinition(VarDecl *D)
CompleteTentativeDefinition - Callback invoked at the end of a translation unit to notify the consume...
Definition: ASTConsumer.h:103
A wrapper class around a pointer that always points to its canonical declaration. ...
Definition: Redeclarable.h:347
A trivial tuple used to represent a source range.
llvm::TinyPtrVector< VarDecl * > ByrefBlockVars
The set of __block variables that are introduced in this function.
Definition: ScopeInfo.h:210
ASTContext & Context
Definition: Sema.h:374
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:462
This represents a decl that may have a name.
Definition: Decl.h:248
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:1835
CanQualType DoubleTy
Definition: ASTContext.h:1024
IdentifierInfo * getBoolName() const
Retrieve the identifier &#39;bool&#39;.
Definition: ASTContext.h:1716
void IssueWarnings(Policy P, FunctionScopeInfo *fscope, const Decl *D, QualType BlockType)
void setType(QualType newType)
Definition: Decl.h:648
SourceLocation getBegin() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:720
static void checkUndefinedButUsed(Sema &S)
checkUndefinedButUsed - Check for undefined objects with internal linkage or that are inline...
Definition: Sema.cpp:711
decls_iterator decls_end() const
Definition: ExprCXX.h:2845
void addPPCallbacks(std::unique_ptr< PPCallbacks > C)
Definition: Preprocessor.h:996
This class handles loading and caching of source files into memory.
void PrintContextStack()
Definition: Sema.h:7868
OpenCLOptions & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1323
Declaration of a template function.
void PushFunctionScope()
Enter a new function scope.
Definition: Sema.cpp:1624
NamedDeclSetType UnusedPrivateFields
Set containing all declared private fields that are not used.
Definition: Sema.h:625
SourceLocation getLocation() const
Definition: DeclBase.h:429
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, llvm::MapVector< CanonicalDeclPtr< FunctionDecl >, SourceLocation > > DeviceCallGraph
A partial call graph maintained during CUDA/OpenMP device code compilation to support deferred diagno...
Definition: Sema.h:10510
DeviceDiagBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID)
Creates a DeviceDiagBuilder that emits the diagnostic if the current context is "used as host code"...
Definition: SemaCUDA.cpp:650
bool isExternallyVisible() const
Definition: Decl.h:379
CanQualType OCLClkEventTy
Definition: ASTContext.h:1049
ObjCMethodDecl * DictionaryWithObjectsMethod
The declaration of the dictionaryWithObjects:forKeys:count: method.
Definition: Sema.h:954
Helper class that creates diagnostics with optional template instantiation stacks.
Definition: Sema.h:1333
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2956
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:125
CanQualType UnsignedIntTy
Definition: ASTContext.h:1022
decl_iterator decls_end() const
Definition: DeclBase.h:2030
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:375
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
static bool isExternC(const NamedDecl *ND)
Definition: Mangle.cpp:56
The translation unit is a module.
Definition: LangOptions.h:387