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