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