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