14 #ifndef LLVM_CLANG_SEMA_SEMA_H
15 #define LLVM_CLANG_SEMA_SEMA_H
60 #include "llvm/ADT/ArrayRef.h"
61 #include "llvm/ADT/SetVector.h"
62 #include "llvm/ADT/SmallBitVector.h"
63 #include "llvm/ADT/SmallPtrSet.h"
64 #include "llvm/ADT/SmallSet.h"
65 #include "llvm/ADT/SmallVector.h"
66 #include "llvm/ADT/TinyPtrVector.h"
67 #include "llvm/Frontend/OpenMP/OMPConstants.h"
77 template <
typename ValueT,
typename ValueInfoT>
class DenseSet;
79 struct InlineAsmIdentifierInfo;
86 class ASTMutationListener;
96 class CXXBindTemporaryExpr;
98 class CXXConstructorDecl;
99 class CXXConversionDecl;
101 class CXXDestructorDecl;
102 class CXXFieldCollector;
103 class CXXMemberCallExpr;
109 class ClassTemplateDecl;
110 class ClassTemplatePartialSpecializationDecl;
111 class ClassTemplateSpecializationDecl;
112 class VarTemplatePartialSpecializationDecl;
113 class CodeCompleteConsumer;
114 class CodeCompletionAllocator;
115 class CodeCompletionTUInfo;
116 class CodeCompletionResult;
117 class CoroutineBodyStmt;
119 class DeclAccessPair;
122 class DeclaratorDecl;
123 class DeducedTemplateArgument;
124 class DependentDiagnostic;
125 class DesignatedInitExpr;
128 class EnumConstantDecl;
134 class FunctionProtoType;
135 class FunctionTemplateDecl;
136 class ImplicitConversionSequence;
139 class InitializationKind;
140 class InitializationSequence;
141 class InitializedEntity;
142 class IntegerLiteral;
146 class LocalInstantiationScope;
151 class MultiLevelTemplateArgumentList;
153 class ObjCCategoryDecl;
154 class ObjCCategoryImplDecl;
155 class ObjCCompatibleAliasDecl;
156 class ObjCContainerDecl;
158 class ObjCImplementationDecl;
159 class ObjCInterfaceDecl;
161 template <
class T>
class ObjCList;
162 class ObjCMessageExpr;
163 class ObjCMethodDecl;
164 class ObjCPropertyDecl;
165 class ObjCProtocolDecl;
166 class OMPThreadPrivateDecl;
167 class OMPRequiresDecl;
168 class OMPDeclareReductionDecl;
169 class OMPDeclareSimdDecl;
171 struct OMPVarListLocTy;
172 struct OverloadCandidate;
175 class OverloadCandidateSet;
180 class PseudoDestructorTypeStorage;
181 class PseudoObjectExpr;
183 class StandardConversionSequence;
187 class TemplateArgument;
188 class TemplateArgumentList;
189 class TemplateArgumentLoc;
191 class TemplateInstantiationCallback;
192 class TemplateParameterList;
193 class TemplatePartialOrderingContext;
194 class TemplateTemplateParmDecl;
198 class TypedefNameDecl;
200 class TypoCorrectionConsumer;
202 class UnresolvedLookupExpr;
203 class UnresolvedMemberExpr;
204 class UnresolvedSetImpl;
205 class UnresolvedSetIterator;
207 class UsingShadowDecl;
210 class VarTemplateSpecializationDecl;
211 class VisibilityAttr;
212 class VisibleDeclConsumer;
213 class IndirectFieldDecl;
214 struct DeductionFailureInfo;
215 class TemplateSpecCandidateSet;
218 class AccessedEntity;
219 class BlockScopeInfo;
221 class CapturedRegionScopeInfo;
222 class CapturingScopeInfo;
223 class CompoundScopeInfo;
224 class DelayedDiagnostic;
225 class DelayedDiagnosticPool;
226 class FunctionScopeInfo;
227 class LambdaScopeInfo;
228 class PossiblyUnreachableDiag;
229 class RISCVIntrinsicManager;
230 class SemaPPCallbacks;
231 class TemplateDeductionInfo;
234 namespace threadSafety {
243 const TemplateTypeParmType *,
const SubstTemplateTypeParmPackType *,
244 const SubstNonTypeTemplateParmPackExpr *,
const NamedDecl *>,
269 llvm::DenseMap<FileID, FileNullability> Map;
280 if (file ==
Cache.File)
281 return Cache.Nullability;
284 if (!
Cache.File.isInvalid()) {
290 Cache.Nullability = Map[file];
291 return Cache.Nullability;
319 llvm::function_ref<
QualType()> ComputeType);
337 if (!Enabled || Tok != ExpectedLoc)
342 return ComputeType();
354 llvm::function_ref<
QualType()> ComputeType;
360 void operator=(
const Sema &) =
delete;
365 static bool mightHaveNonExternalLinkage(
const DeclaratorDecl *FD);
370 bool shouldLinkPossiblyHiddenDecl(
const NamedDecl *Old,
378 "should not have found a non-externally-declarable previous decl");
385 void setupImplicitSpecialMemberType(
CXXMethodDecl *SpecialMem,
495 : PackAttr(
true), AlignMode(M), PackNumber(Num), XLStack(IsXL) {
496 assert(Num == PackNumber &&
"The pack number has been truncated.");
501 : PackAttr(
false), AlignMode(M),
502 PackNumber(M ==
Packed ? 1 : UninitPackVal), XLStack(IsXL) {}
527 bool IsXL =
static_cast<bool>(
Encoding & IsXLMask);
530 int PackNumber = (
Encoding & PackNumMask) >> 4;
549 return PackNumber != UninitPackVal && PackNumber != 0;
555 return std::tie(AlignMode, PackNumber, PackAttr, XLStack) ==
556 std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr,
561 return !(*
this == Info);
573 unsigned char PackNumber;
579 static constexpr
unsigned char UninitPackVal = -1;
582 static constexpr uint32_t IsXLMask{0x0000
'0001};
583 static constexpr uint32_t AlignModeMask{0x0000'0006};
584 static constexpr uint32_t PackAttrMask{0x00000
'0008};
585 static constexpr uint32_t PackNumMask{0x0000'01F0};
588 template<
typename ValueType>
603 llvm::StringRef StackSlotLabel, ValueType
Value) {
613 if (!StackSlotLabel.empty()) {
615 auto I = llvm::find_if(llvm::reverse(
Stack), [&](
const Slot &
x) {
616 return x.StackSlotLabel == StackSlotLabel;
619 if (I !=
Stack.rend()) {
622 Stack.erase(std::prev(I.base()),
Stack.end());
624 }
else if (!
Stack.empty()) {
653 "Can only push / pop #pragma stack sentinels!");
912 std::unique_ptr<LateParsedTemplate>>
965 state.SavedPool = CurPool;
974 CurPool =
state.SavedPool;
981 state.SavedPool = CurPool;
988 assert(CurPool ==
nullptr);
989 CurPool =
state.SavedPool;
1000 unsigned SavedFunctionScopesStart;
1001 unsigned SavedInventedParameterInfosStart;
1011 assert(ContextToPush &&
"pushing null context");
1012 S.CurContext = ContextToPush;
1014 S.CXXThisTypeOverride =
QualType();
1016 S.FunctionScopesStart = S.FunctionScopes.size();
1017 S.InventedParameterInfosStart = S.InventedParameterInfos.size();
1021 if (!SavedContext)
return;
1022 S.CurContext = SavedContext;
1023 S.DelayedDiagnostics.popUndelayed(SavedContextState);
1024 S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
1025 S.FunctionScopesStart = SavedFunctionScopesStart;
1026 S.InventedParameterInfosStart = SavedInventedParameterInfosStart;
1027 SavedContext =
nullptr;
1054 bool PushedCodeSynthesisContext =
false;
1058 : S(S), SavedContext(S, DC) {
1059 S.PushFunctionScope();
1060 S.PushExpressionEvaluationContext(
1062 if (
auto *FD = dyn_cast<FunctionDecl>(DC))
1063 FD->setWillHaveBody(
true);
1065 assert(isa<ObjCMethodDecl>(DC));
1069 assert(!PushedCodeSynthesisContext);
1074 Ctx.
Entity = cast<Decl>(S.CurContext);
1075 S.pushCodeSynthesisContext(Ctx);
1077 PushedCodeSynthesisContext =
true;
1081 if (PushedCodeSynthesisContext)
1082 S.popCodeSynthesisContext();
1083 if (
auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
1084 FD->setWillHaveBody(
false);
1085 S.PopExpressionEvaluationContext();
1086 S.PopFunctionScopeInfo();
1102 llvm::SmallDenseSet<WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly>>>
1343 assert(
Decl &&
Context &&
"invalid initialization context");
1407 std::tuple<MangleNumberingContext *, Decl *>
1425 llvm::PointerIntPair<CXXMethodDecl *, 2> Pair;
1440 :
public llvm::FastFoldingSetNode,
1444 : FastFoldingSetNode(
ID)
1470 typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1501 const llvm::MapVector<FieldDecl *, DeleteLocs> &
1506 using Lists = std::pair<ObjCMethodList, ObjCMethodList>;
1507 using iterator = llvm::DenseMap<Selector, Lists>::iterator;
1511 std::pair<iterator, bool>
insert(std::pair<Selector, Lists> &&Val) {
1512 return Methods.insert(Val);
1515 bool empty()
const {
return Methods.empty(); }
1518 llvm::DenseMap<Selector, Lists> Methods;
1549 typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1626 std::unique_ptr<sema::RISCVIntrinsicManager> RVIntrinsicManager;
1628 std::optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;
1630 bool WarnedDarwinSDKInfoMissing =
false;
1662 StringRef Platform);
1682 llvm::function_ref<
void()> Fn);
1730 template <
typename T>
1741 template <
typename T,
1742 typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>
1745 BaseDiag << std::move(
V);
1801 template <
typename T>
1804 if (
Diag.ImmediateDiag)
1806 else if (
Diag.PartialDiagId)
1815 template <
typename T,
1816 typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>
1819 *ImmediateDiag << std::move(
V);
1820 else if (PartialDiagId)
1827 if (
Diag.ImmediateDiag)
1829 else if (
Diag.PartialDiagId)
1836 ImmediateDiag->AddFixItHint(Hint);
1837 else if (PartialDiagId)
1862 std::optional<ImmediateDiagBuilder> ImmediateDiag;
1863 std::optional<unsigned> PartialDiagId;
1872 bool DeferHint =
false);
1876 bool DeferHint =
false);
1887 bool SavedDeferDiags =
false;
1961 unsigned OpenMPCaptureLevel = 0);
1974 std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>;
1978 const Decl *D =
nullptr,
2012 getCurLambda(
bool IgnoreNonLambdaCapturingScope =
false);
2030 unsigned TemplateParameterDepth);
2051 Expr *ArraySize,
unsigned Quals,
2196 std::index_sequence<Is...>)
const {
2198 bool Dummy[] = {
false, (DB << getPrintable(std::get<Is>(
Args)))...};
2205 assert(
DiagID != 0 &&
"no diagnostic for type diagnoser");
2210 emit(DB, std::index_sequence_for<Ts...>());
2229 template <
typename... Ts>
2237 this->
emit(DB, std::index_sequence_for<Ts...>());
2267 void CheckAddressOfNoDeref(
const Expr *E);
2268 void CheckMemberAccessOfNoDeref(
const MemberExpr *E);
2273 struct ModuleScope {
2276 bool ModuleInterface =
false;
2277 bool IsPartition =
false;
2278 bool ImplicitGlobalModuleFragment =
false;
2299 bool isCurrentModulePurview()
const {
2304 Module *PushGlobalModuleFragment(SourceLocation BeginLoc,
bool IsImplicit);
2306 void PopGlobalModuleFragment();
2308 VisibleModuleSet VisibleModules;
2313 bool isUsableModule(
const Module *M);
2320 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
2325 return ModuleScopes.empty() ?
false : ModuleScopes.back().ModuleInterface;
2330 return ModuleScopes.empty() ?
false
2331 : ModuleScopes.back().Module->isHeaderUnit();
2340 return DirectModuleImports.contains(M);
2355 VisibleModules.setVisible(Mod, ImportLoc);
2404 bool OnlyNeedComplete =
false);
2413 bool OnlyNeedComplete =
false);
2421 bool OnlyNeedComplete =
false);
2476 return !RequireCompleteTypeImpl(Loc, T,
Kind,
nullptr);
2491 template <
typename... Ts>
2493 const Ts &...Args) {
2498 template <
typename... Ts>
2500 const Ts &... Args) {
2517 TypeDiagnoser &Diagnoser);
2520 template <
typename... Ts>
2526 template <
typename... Ts>
2528 const Ts &... Args) {
2534 TypeDiagnoser &Diagnoser);
2537 template <
typename... Ts>
2539 const Ts &...Args) {
2546 TagDecl *OwnedTagDecl =
nullptr);
2596 bool isClassName =
false,
bool HasTrailingDot =
false,
2598 bool IsCtorOrDtorName =
false,
2599 bool WantNontrivialTypeSourceInfo =
false,
2600 bool IsClassTemplateDeductionContext =
true,
2611 bool IsTemplateName =
false);
2619 bool IsTemplateTypeArg);
2694 Result.NonTypeDecl = D;
2708 Result.Template = Name;
2714 Result.Template = Name;
2720 Result.Template = Name;
2726 Result.Template = Name;
2732 Result.Template = Name;
2773 llvm_unreachable(
"unsupported name classification.");
2800 const Token &NextToken,
2812 bool IsAddressOfOperand);
2818 const Token &NextToken);
2841 if (
auto *DRE = dyn_cast<DeclRefExpr>(E.
get()))
2842 return !DRE->hasExplicitTemplateArgs();
2843 if (
auto *ME = dyn_cast<MemberExpr>(E.
get()))
2844 return !ME->hasExplicitTemplateArgs();
2846 if (
auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.
get()))
2847 return !DSDRE->hasExplicitTemplateArgs();
2848 if (
auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.
get()))
2849 return !DSME->hasExplicitTemplateArgs();
2866 unsigned FailedFoldDiagID);
2901 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
2956 bool IsMemberSpecialization,
bool DeclIsDefn);
3025 unsigned NonTrivialKind);
3066 SkipBodyInfo *SkipBody =
nullptr);
3069 SkipBodyInfo *SkipBody =
nullptr,
3072 SkipBodyInfo *SkipBody =
nullptr,
3080 return D && isa<ObjCMethodDecl>(D);
3163 void HandleStartOfHeaderUnit();
3196 bool IsPartition =
false);
3269 bool IsExplicitInstantiation,
3326 bool &OwnedDecl,
bool &IsDependent,
3328 bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType,
3329 bool IsTypeSpecifier,
bool IsTemplateParamOrArg,
3359 Expr *BitfieldWidth,
3367 bool Mutable,
Expr *BitfieldWidth,
3386 bool Diagnose =
false);
3417 "invalid should have highest index");
3419 "none should be equal to zero");
3420 return SpecialMember + (
unsigned)Comparison;
3457 template <
typename T,
3458 typename = std::enable_if_t<std::is_base_of<NamedDecl, T>::value>>
3460 if (Duplicate->getODRHash() !=
Previous->getODRHash())
3480 bool IsFinalSpelledSealed,
3511 QualType EnumUnderlyingTy,
bool IsFixed,
3575 bool AllowInlineNamespace =
false);
3634 VersionTuple Introduced, VersionTuple Deprecated,
3635 VersionTuple Obsoleted,
bool IsUnavailable,
3636 StringRef Message,
bool IsStrict, StringRef Replacement,
3638 TypeVisibilityAttr *
3640 TypeVisibilityAttr::VisibilityType Vis);
3642 VisibilityAttr::VisibilityType Vis);
3644 StringRef UuidAsWritten,
MSGuidDecl *GuidDecl);
3652 StringRef NewUserDiagnostic);
3670 const InternalLinkageAttr &AL);
3672 Decl *D,
const WebAssemblyImportNameAttr &AL);
3674 Decl *D,
const WebAssemblyImportModuleAttr &AL);
3677 const EnforceTCBLeafAttr &AL);
3681 int X,
int Y,
int Z);
3683 HLSLShaderAttr::ShaderType ShaderType);
3690 bool MergeTypeWithOld,
bool NewDeclIsDefn);
3692 Scope *S,
bool MergeTypeWithOld);
3732 bool UseMemberUsingDeclRules);
3734 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs =
true,
3735 bool ConsiderRequiresClauses =
true);
3746 unsigned TemplateDepth,
3747 const Expr *Constraint);
3760 const Expr *OldConstr,
3762 const Expr *NewConstr);
3775 bool SuppressUserConversions,
3777 bool InOverloadResolution,
3779 bool AllowObjCWritebackConversion);
3785 bool InOverloadResolution,
3786 QualType& ConvertedType,
bool &IncompatibleObjC);
3788 QualType& ConvertedType,
bool &IncompatibleObjC);
3795 unsigned *ArgPos =
nullptr,
3796 bool Reversed =
false);
3805 bool IgnoreBaseAccess,
3806 bool Diagnose =
true);
3808 bool InOverloadResolution,
3813 bool IgnoreBaseAccess);
3815 bool CStyle,
bool &ObjCLifetimeConversion);
3831 bool TopLevelOfInitList =
false,
3832 bool AllowExplicit =
false);
3912 bool AllowScopedEnumerations;
3918 AllowScopedEnumerations(AllowScopedEnumerations) {}
3974 bool PartialOverloading =
false,
bool AllowExplicit =
true,
3975 bool AllowExplicitConversion =
false,
3983 bool SuppressUserConversions =
false,
3984 bool PartialOverloading =
false,
3985 bool FirstArgumentIsBase =
false);
3991 bool SuppressUserConversion =
false,
3995 CXXRecordDecl *ActingContext, QualType ObjectType,
3996 Expr::Classification ObjectClassification,
3997 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
3998 bool SuppressUserConversions =
false,
3999 bool PartialOverloading =
false,
4003 DeclAccessPair FoundDecl,
4004 CXXRecordDecl *ActingContext,
4005 TemplateArgumentListInfo *ExplicitTemplateArgs,
4006 QualType ObjectType,
4007 Expr::Classification ObjectClassification,
4008 ArrayRef<Expr *> Args,
4009 OverloadCandidateSet& CandidateSet,
4010 bool SuppressUserConversions =
false,
4011 bool PartialOverloading =
false,
4014 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
4015 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
4016 OverloadCandidateSet &CandidateSet,
bool SuppressUserConversions =
false,
4017 bool PartialOverloading =
false,
bool AllowExplicit =
true,
4021 FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
4022 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
4024 CXXRecordDecl *ActingContext =
nullptr, QualType ObjectType = QualType(),
4025 Expr::Classification ObjectClassification = {},
4028 CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
4029 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
4030 OverloadCandidateSet &CandidateSet,
bool AllowObjCConversionOnExplicit,
4031 bool AllowExplicit,
bool AllowResultConversion =
true);
4033 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
4034 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
4035 OverloadCandidateSet &CandidateSet,
bool AllowObjCConversionOnExplicit,
4036 bool AllowExplicit,
bool AllowResultConversion =
true);
4038 DeclAccessPair FoundDecl,
4039 CXXRecordDecl *ActingContext,
4040 const FunctionProtoType *Proto,
4041 Expr *Object, ArrayRef<Expr *> Args,
4042 OverloadCandidateSet& CandidateSet);
4044 const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,
4045 OverloadCandidateSet &CandidateSet,
4046 TemplateArgumentListInfo *ExplicitTemplateArgs =
nullptr);
4048 SourceLocation OpLoc, ArrayRef<Expr *> Args,
4049 OverloadCandidateSet &CandidateSet,
4052 OverloadCandidateSet& CandidateSet,
4053 bool IsAssignmentOperator =
false,
4054 unsigned NumContextualBoolArguments = 0);
4056 SourceLocation OpLoc, ArrayRef<Expr *> Args,
4057 OverloadCandidateSet& CandidateSet);
4060 ArrayRef<Expr *> Args,
4061 TemplateArgumentListInfo *ExplicitTemplateArgs,
4062 OverloadCandidateSet& CandidateSet,
4063 bool PartialOverloading =
false);
4067 NamedDecl *Found, FunctionDecl *Fn,
4069 QualType DestType = QualType(),
bool TakingAddress =
false);
4074 bool TakingAddress =
false);
4078 EnableIfAttr *
CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc,
4079 ArrayRef<Expr *> Args,
4080 bool MissingImplicitThis =
false);
4094 const Expr *ThisArg,
4095 ArrayRef<const Expr *> Args,
4096 SourceLocation Loc);
4106 SourceLocation Loc);
4113 bool Complain =
false,
4114 SourceLocation Loc = SourceLocation());
4126 QualType TargetType,
4128 DeclAccessPair &Found,
4129 bool *pHadMultipleCandidates =
nullptr);
4135 ExprResult &SrcExpr,
bool DoFunctionPointerConversion =
false);
4139 bool Complain =
false,
4140 DeclAccessPair *Found =
nullptr);
4143 ExprResult &SrcExpr,
bool DoFunctionPointerConversion =
false,
4144 bool Complain =
false, SourceRange OpRangeForComplaining = SourceRange(),
4145 QualType DestTypeForComplaining = QualType(),
4146 unsigned DiagIDForComplaining = 0);
4149 DeclAccessPair FoundDecl,
4152 DeclAccessPair FoundDecl,
4156 ArrayRef<Expr *> Args,
4157 OverloadCandidateSet &CandidateSet,
4158 bool PartialOverloading =
false);
4160 LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
4161 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet);
4184 bool AllowTypoCorrection=
true,
4185 bool CalleesAddressIsTaken=
false);
4196 bool PerformADL =
true);
4201 Expr *input,
bool RequiresADL =
true);
4211 bool RequiresADL =
true,
4212 bool AllowRewrittenCandidates =
true,
4227 Expr *ExecConfig =
nullptr,
4228 bool IsExecConfig =
false,
4229 bool AllowRecovery =
false);
4237 bool *NoArrowOperatorFound =
nullptr);
4247 bool CheckParameterNames);
4353 ->getOwningModuleForLinkage(
true))
4395 struct TypoExprState {
4396 std::unique_ptr<TypoCorrectionConsumer>
Consumer;
4400 TypoExprState(TypoExprState &&other) noexcept;
4401 TypoExprState &operator=(TypoExprState &&other) noexcept;
4405 llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;
4408 TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
4416 llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces;
4420 bool LoadedExternalKnownNamespaces;
4425 std::unique_ptr<TypoCorrectionConsumer>
4432 bool ErrorRecovery);
4453 bool ForceNoCPlusPlus =
false);
4455 bool InUnqualifiedLookup =
false);
4459 bool AllowBuiltinCreation =
false,
4460 bool EnteringContext =
false);
4477 bool RValueThis,
unsigned ThisQuals);
4481 bool RValueThis,
unsigned ThisQuals);
4488 bool AllowRaw,
bool AllowTemplate,
4489 bool AllowStringTemplate,
bool DiagnoseMissing,
4502 bool Final =
false);
4512 bool IncludeGlobalScope =
true,
4513 bool LoadExternal =
true);
4516 bool IncludeGlobalScope =
true,
4517 bool IncludeDependentBases =
false,
4518 bool LoadExternal =
true);
4531 bool EnteringContext =
false,
4533 bool RecordFailure =
true);
4542 bool EnteringContext =
false,
4564 bool RecoverUncorrectedTypos =
false,
4570 bool RecoverUncorrectedTypos =
false,
4576 RecoverUncorrectedTypos,
Filter);
4580 const PartialDiagnostic &TypoDiag,
4581 bool ErrorRecovery =
true);
4584 const PartialDiagnostic &TypoDiag,
4585 const PartialDiagnostic &PrevNote,
4586 bool ErrorRecovery =
true);
4591 ArrayRef<Expr *> Args,
4596 bool ConsiderLinkage,
bool AllowInlineNamespace);
4602 const NamedDecl *Old)
const;
4609 ArrayRef<Expr *> SubExprs,
4610 QualType T = QualType());
4613 SourceLocation IdLoc,
4614 bool TypoCorrection =
false);
4615 FunctionDecl *
CreateBuiltin(IdentifierInfo *II, QualType Type,
unsigned ID,
4616 SourceLocation Loc);