14#ifndef LLVM_CLANG_SEMA_SEMA_H
15#define LLVM_CLANG_SEMA_SEMA_H
61#include "llvm/ADT/ArrayRef.h"
62#include "llvm/ADT/SetVector.h"
63#include "llvm/ADT/SmallBitVector.h"
64#include "llvm/ADT/SmallPtrSet.h"
65#include "llvm/ADT/SmallSet.h"
66#include "llvm/ADT/SmallVector.h"
67#include "llvm/ADT/TinyPtrVector.h"
68#include "llvm/Frontend/OpenMP/OMPConstants.h"
78 template <
typename ValueT,
typename ValueInfoT>
class DenseSet;
80 struct InlineAsmIdentifierInfo;
87 class ASTMutationListener;
97 class CXXBindTemporaryExpr;
99 class CXXConstructorDecl;
100 class CXXConversionDecl;
102 class CXXDestructorDecl;
103 class CXXFieldCollector;
104 class CXXMemberCallExpr;
110 class ClassTemplateDecl;
111 class ClassTemplatePartialSpecializationDecl;
112 class ClassTemplateSpecializationDecl;
113 class VarTemplatePartialSpecializationDecl;
114 class CodeCompleteConsumer;
115 class CodeCompletionAllocator;
116 class CodeCompletionTUInfo;
117 class CodeCompletionResult;
118 class CoroutineBodyStmt;
120 class DeclAccessPair;
123 class DeclaratorDecl;
124 class DeducedTemplateArgument;
125 class DependentDiagnostic;
126 class DesignatedInitExpr;
129 class EnumConstantDecl;
135 class FunctionProtoType;
136 class FunctionTemplateDecl;
137 class ImplicitConversionSequence;
140 class InitializationKind;
141 class InitializationSequence;
142 class InitializedEntity;
143 class IntegerLiteral;
147 class LocalInstantiationScope;
152 class MultiLevelTemplateArgumentList;
154 class ObjCCategoryDecl;
155 class ObjCCategoryImplDecl;
156 class ObjCCompatibleAliasDecl;
157 class ObjCContainerDecl;
159 class ObjCImplementationDecl;
160 class ObjCInterfaceDecl;
162 template <
class T>
class ObjCList;
163 class ObjCMessageExpr;
164 class ObjCMethodDecl;
165 class ObjCPropertyDecl;
166 class ObjCProtocolDecl;
167 class OMPThreadPrivateDecl;
168 class OMPRequiresDecl;
169 class OMPDeclareReductionDecl;
170 class OMPDeclareSimdDecl;
172 struct OMPVarListLocTy;
173 struct OverloadCandidate;
176 class OverloadCandidateSet;
181 class PseudoDestructorTypeStorage;
182 class PseudoObjectExpr;
184 class StandardConversionSequence;
188 class TemplateArgument;
189 class TemplateArgumentList;
190 class TemplateArgumentLoc;
192 class TemplateInstantiationCallback;
193 class TemplateParameterList;
194 class TemplatePartialOrderingContext;
195 class TemplateTemplateParmDecl;
199 class TypedefNameDecl;
201 class TypoCorrectionConsumer;
203 class UnresolvedLookupExpr;
204 class UnresolvedMemberExpr;
205 class UnresolvedSetImpl;
206 class UnresolvedSetIterator;
208 class UsingShadowDecl;
211 class VarTemplateSpecializationDecl;
212 class VisibilityAttr;
213 class VisibleDeclConsumer;
214 class IndirectFieldDecl;
215 struct DeductionFailureInfo;
216 class TemplateSpecCandidateSet;
219 class AccessedEntity;
220 class BlockScopeInfo;
222 class CapturedRegionScopeInfo;
223 class CapturingScopeInfo;
224 class CompoundScopeInfo;
225 class DelayedDiagnostic;
226 class DelayedDiagnosticPool;
227 class FunctionScopeInfo;
228 class LambdaScopeInfo;
229 class PossiblyUnreachableDiag;
230 class RISCVIntrinsicManager;
231 class SemaPPCallbacks;
232 class TemplateDeductionInfo;
235namespace threadSafety {
242typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType *, NamedDecl *>,
268 llvm::DenseMap<FileID, FileNullability> Map;
279 if (file ==
Cache.File)
280 return Cache.Nullability;
283 if (!
Cache.File.isInvalid()) {
289 Cache.Nullability = Map[file];
290 return Cache.Nullability;
318 llvm::function_ref<
QualType()> ComputeType);
336 if (!Enabled || Tok != ExpectedLoc)
341 return ComputeType();
353 llvm::function_ref<
QualType()> ComputeType;
359 void operator=(
const Sema &) =
delete;
364 static bool mightHaveNonExternalLinkage(
const DeclaratorDecl *FD);
369 bool shouldLinkPossiblyHiddenDecl(
const NamedDecl *Old,
377 "should not have found a non-externally-declarable previous decl");
384 void setupImplicitSpecialMemberType(
CXXMethodDecl *SpecialMem,
501 : PackAttr(
true), AlignMode(M), PackNumber(Num), XLStack(IsXL) {
502 assert(Num == PackNumber &&
"The pack number has been truncated.");
507 : PackAttr(
false), AlignMode(M),
508 PackNumber(M ==
Packed ? 1 : UninitPackVal), XLStack(IsXL) {}
518 std::uint32_t Encoding{};
520 Encoding |= IsXLMask;
522 Encoding |=
static_cast<uint32_t
>(Info.
getAlignMode()) << 1;
525 Encoding |= PackAttrMask;
527 Encoding |=
static_cast<uint32_t
>(Info.
getPackNumber()) << 4;
533 bool IsXL =
static_cast<bool>(Encoding & IsXLMask);
536 int PackNumber = (Encoding & PackNumMask) >> 4;
538 if (Encoding & PackAttrMask)
555 return PackNumber != UninitPackVal && PackNumber != 0;
561 return std::tie(AlignMode, PackNumber, PackAttr, XLStack) ==
562 std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr,
567 return !(*
this == Info);
579 unsigned char PackNumber;
585 static constexpr unsigned char UninitPackVal = -1;
588 static constexpr uint32_t IsXLMask{0x0000'0001};
589 static constexpr uint32_t AlignModeMask{0x0000'0006};
590 static constexpr uint32_t PackAttrMask{0x00000'0008};
591 static constexpr uint32_t PackNumMask{0x0000'01F0};
594 template<
typename ValueType>
609 llvm::StringRef StackSlotLabel, ValueType
Value) {
619 if (!StackSlotLabel.empty()) {
621 auto I = llvm::find_if(llvm::reverse(
Stack), [&](
const Slot &x) {
625 if (I !=
Stack.rend()) {
628 Stack.erase(std::prev(I.base()),
Stack.end());
630 }
else if (!
Stack.empty()) {
659 "Can only push / pop #pragma stack sentinels!");
720 S.FpPragmaStack.Stack.clear();
939 std::unique_ptr<LateParsedTemplate>>
958 class DelayedDiagnostics;
992 state.SavedPool = CurPool;
1001 CurPool = state.SavedPool;
1008 state.SavedPool = CurPool;
1015 assert(CurPool ==
nullptr);
1016 CurPool = state.SavedPool;
1018 } DelayedDiagnostics;
1035 unsigned SavedFunctionScopesStart;
1036 unsigned SavedInventedParameterInfosStart;
1046 assert(ContextToPush &&
"pushing null context");
1047 S.CurContext = ContextToPush;
1049 S.CXXThisTypeOverride =
QualType();
1051 S.FunctionScopesStart = S.FunctionScopes.size();
1052 S.InventedParameterInfosStart = S.InventedParameterInfos.size();
1056 if (!SavedContext)
return;
1057 S.CurContext = SavedContext;
1058 S.DelayedDiagnostics.popUndelayed(SavedContextState);
1059 S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
1060 S.FunctionScopesStart = SavedFunctionScopesStart;
1061 S.InventedParameterInfosStart = SavedInventedParameterInfosStart;
1062 SavedContext =
nullptr;
1075 bool PushedCodeSynthesisContext =
false;
1079 : S(S), SavedContext(S, DC) {
1080 auto *FD = dyn_cast<FunctionDecl>(DC);
1081 S.PushFunctionScope();
1082 S.PushExpressionEvaluationContext(
1083 (FD && FD->isConsteval())
1087 FD->setWillHaveBody(
true);
1088 S.ExprEvalContexts.back().InImmediateFunctionContext =
1089 FD->isImmediateFunction();
1090 S.ExprEvalContexts.back().InImmediateEscalatingFunctionContext =
1091 S.getLangOpts().CPlusPlus20 && FD->isImmediateEscalating();
1093 assert(isa<ObjCMethodDecl>(DC));
1097 assert(!PushedCodeSynthesisContext);
1102 Ctx.
Entity = cast<Decl>(S.CurContext);
1103 S.pushCodeSynthesisContext(Ctx);
1105 PushedCodeSynthesisContext =
true;
1109 if (PushedCodeSynthesisContext)
1110 S.popCodeSynthesisContext();
1111 if (
auto *FD = dyn_cast<FunctionDecl>(S.CurContext)) {
1112 FD->setWillHaveBody(
false);
1113 S.CheckImmediateEscalatingFunctionDefinition(FD, S.getCurFunction());
1115 S.PopExpressionEvaluationContext();
1116 S.PopFunctionScopeInfo();
1132 llvm::SmallDenseSet<WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly>>>
1368 assert(
Decl &&
Context &&
"invalid initialization context");
1436 std::tuple<MangleNumberingContext *, Decl *>
1454 llvm::PointerIntPair<CXXMethodDecl *, 2> Pair;
1469 :
public llvm::FastFoldingSetNode,
1473 : FastFoldingSetNode(
ID)
1499 typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1530 const llvm::MapVector<FieldDecl *, DeleteLocs> &
1535 using Lists = std::pair<ObjCMethodList, ObjCMethodList>;
1536 using iterator = llvm::DenseMap<Selector, Lists>::iterator;
1540 std::pair<iterator, bool>
insert(std::pair<Selector, Lists> &&Val) {
1541 return Methods.insert(Val);
1544 bool empty()
const {
return Methods.empty(); }
1547 llvm::DenseMap<Selector, Lists> Methods;
1578 typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1658 std::unique_ptr<sema::RISCVIntrinsicManager> RVIntrinsicManager;
1660 std::optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;
1662 bool WarnedDarwinSDKInfoMissing =
false;
1694 StringRef Platform);
1714 llvm::function_ref<
void()> Fn);
1762 template <
typename T>
1773 template <
typename T,
1774 typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>
1777 BaseDiag << std::move(
V);
1839 template <
typename T>
1842 if (
Diag.ImmediateDiag)
1844 else if (
Diag.PartialDiagId)
1853 template <
typename T,
1854 typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>
1857 *ImmediateDiag << std::move(
V);
1858 else if (PartialDiagId)
1865 if (
Diag.ImmediateDiag)
1867 else if (
Diag.PartialDiagId)
1874 ImmediateDiag->AddFixItHint(Hint);
1875 else if (PartialDiagId)
1900 std::optional<ImmediateDiagBuilder> ImmediateDiag;
1901 std::optional<unsigned> PartialDiagId;
1910 bool DeferHint =
false);
1914 bool DeferHint =
false);
1925 bool SavedDeferDiags =
false;
1999 unsigned OpenMPCaptureLevel = 0);
2012 std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>;
2016 const Decl *D =
nullptr,
2050 getCurLambda(
bool IgnoreNonLambdaCapturingScope =
false);
2068 unsigned TemplateParameterDepth);
2232 template <std::size_t... Is>
2234 std::index_sequence<Is...>)
const {
2236 bool Dummy[] = {
false, (DB << getPrintable(std::get<Is>(
Args)))...};
2243 assert(
DiagID != 0 &&
"no diagnostic for type diagnoser");
2248 emit(DB, std::index_sequence_for<Ts...>());
2267 template <
typename... Ts>
2275 this->
emit(DB, std::index_sequence_for<Ts...>());
2305 void CheckAddressOfNoDeref(
const Expr *E);
2306 void CheckMemberAccessOfNoDeref(
const MemberExpr *E);
2311 struct ModuleScope {
2342 bool isCurrentModulePurview()
const;
2345 Module *PushGlobalModuleFragment(SourceLocation BeginLoc);
2347 void PopGlobalModuleFragment();
2350 Module *PushImplicitGlobalModuleFragment(SourceLocation BeginLoc);
2352 void PopImplicitGlobalModuleFragment();
2354 VisibleModuleSet VisibleModules;
2359 bool isUsableModule(
const Module *M);
2366 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
2371 return ModuleScopes.empty()
2373 : ModuleScopes.back().Module->isModuleImplementation();
2378 return ModuleScopes.empty() ?
false
2379 : ModuleScopes.back().Module->isHeaderUnit();
2396 VisibleModules.setVisible(Mod, ImportLoc);
2445 bool OnlyNeedComplete =
false);
2454 bool OnlyNeedComplete =
false);
2462 bool OnlyNeedComplete =
false);
2517 return !RequireCompleteTypeImpl(Loc, T, Kind,
nullptr);
2532 template <
typename... Ts>
2534 const Ts &...Args) {
2539 template <
typename... Ts>
2541 const Ts &... Args) {
2558 TypeDiagnoser &Diagnoser);
2561 template <
typename... Ts>
2567 template <
typename... Ts>
2569 const Ts &... Args) {
2575 TypeDiagnoser &Diagnoser);
2578 template <
typename... Ts>
2580 const Ts &...Args) {
2587 TagDecl *OwnedTagDecl =
nullptr);
2635 bool isClassName =
false,
bool HasTrailingDot =
false,
2637 bool IsCtorOrDtorName =
false,
2638 bool WantNontrivialTypeSourceInfo =
false,
2639 bool IsClassTemplateDeductionContext =
true,
2650 bool IsTemplateName =
false);
2658 bool IsTemplateTypeArg);
2812 llvm_unreachable(
"unsupported name classification.");
2839 const Token &NextToken,
2851 bool IsAddressOfOperand);
2857 const Token &NextToken);
2880 if (
auto *DRE = dyn_cast<DeclRefExpr>(E.
get()))
2881 return !DRE->hasExplicitTemplateArgs();
2882 if (
auto *ME = dyn_cast<MemberExpr>(E.
get()))
2883 return !ME->hasExplicitTemplateArgs();
2885 if (
auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.
get()))
2886 return !DSDRE->hasExplicitTemplateArgs();
2887 if (
auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.
get()))
2888 return !DSME->hasExplicitTemplateArgs();
2905 unsigned FailedFoldDiagID);
2940 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
2999 bool IsMemberSpecialization,
bool DeclIsDefn);
3010 const Attr *A, HLSLShaderAttr::ShaderType Stage,
3011 std::initializer_list<HLSLShaderAttr::ShaderType> AllowedStages);
3020 ParmVarDecl *
CheckParameter(DeclContext *DC, SourceLocation StartLoc,
3021 SourceLocation NameLoc, IdentifierInfo *Name,
3022 QualType T, TypeSourceInfo *TSInfo,
3025 SourceLocation EqualLoc,
3028 SourceLocation ArgLoc);
3032 SourceLocation EqualLoc);
3034 SourceLocation EqualLoc);
3076 unsigned NonTrivialKind);
3117 SkipBodyInfo *SkipBody =
nullptr);
3120 SkipBodyInfo *SkipBody =
nullptr,
3123 SkipBodyInfo *SkipBody =
nullptr,
3131 return D && isa<ObjCMethodDecl>(D);
3214 void HandleStartOfHeaderUnit();
3247 bool IsPartition =
false);
3320 bool IsExplicitInstantiation,
3383 bool &OwnedDecl,
bool &IsDependent,
3385 bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType,
3386 bool IsTypeSpecifier,
bool IsTemplateParamOrArg,
3416 Expr *BitfieldWidth,
3424 bool Mutable,
Expr *BitfieldWidth,
3457 : SpecialMember(
CXXInvalid), Comparison(Comp) {}
3474 "invalid should have highest index");
3476 "none should be equal to zero");
3477 return SpecialMember + (
unsigned)Comparison;
3513 template <
typename T,
3514 typename = std::enable_if_t<std::is_base_of<NamedDecl, T>::value>>
3516 if (Duplicate->getODRHash() !=
Previous->getODRHash())
3536 bool IsFinalSpelledSealed,
3567 QualType EnumUnderlyingTy,
bool IsFixed,
3631 bool AllowInlineNamespace =
false)
const;
3690 VersionTuple Introduced, VersionTuple Deprecated,
3691 VersionTuple Obsoleted,
bool IsUnavailable,
3692 StringRef Message,
bool IsStrict, StringRef Replacement,
3694 TypeVisibilityAttr *
3696 TypeVisibilityAttr::VisibilityType Vis);
3698 VisibilityAttr::VisibilityType Vis);
3700 StringRef UuidAsWritten,
MSGuidDecl *GuidDecl);
3708 StringRef NewUserDiagnostic);
3726 const InternalLinkageAttr &AL);
3728 Decl *D,
const WebAssemblyImportNameAttr &AL);
3730 Decl *D,
const WebAssemblyImportModuleAttr &AL);
3733 const EnforceTCBLeafAttr &AL);
3737 int X,
int Y,
int Z);
3739 HLSLShaderAttr::ShaderType ShaderType);
3740 HLSLParamModifierAttr *
3742 HLSLParamModifierAttr::Spelling Spelling);
3749 bool MergeTypeWithOld,
bool NewDeclIsDefn);
3751 Scope *S,
bool MergeTypeWithOld);
3791 bool UseMemberUsingDeclRules);
3793 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs =
true);
3798 bool UseMemberUsingDeclRules,
bool ConsiderCudaAttrs =
true);
3809 unsigned TemplateDepth,
3810 const Expr *Constraint);
3827 bool SuppressUserConversions,
3829 bool InOverloadResolution,
3831 bool AllowObjCWritebackConversion);
3837 bool InOverloadResolution,
3838 QualType& ConvertedType,
bool &IncompatibleObjC);
3840 QualType& ConvertedType,
bool &IncompatibleObjC);
3848 unsigned *ArgPos =
nullptr,
3853 unsigned *ArgPos =
nullptr,
3858 unsigned *ArgPos =
nullptr,
3869 bool IgnoreBaseAccess,
3872 bool InOverloadResolution,
3877 bool IgnoreBaseAccess);
3879 bool CStyle,
bool &ObjCLifetimeConversion);
3895 bool TopLevelOfInitList =
false,
3896 bool AllowExplicit =
false);
3938 const APValue &PreNarrowingValue);
3991 bool AllowScopedEnumerations;
3997 AllowScopedEnumerations(AllowScopedEnumerations) {}
4053 bool PartialOverloading =
false,
bool AllowExplicit =
true,
4054 bool AllowExplicitConversion =
false,
4058 bool AggregateCandidateDeduction =
false);
4063 bool SuppressUserConversions =
false,
4064 bool PartialOverloading =
false,
4065 bool FirstArgumentIsBase =
false);
4071 bool SuppressUserConversion =
false,
4075 CXXRecordDecl *ActingContext, QualType ObjectType,
4076 Expr::Classification ObjectClassification,
4077 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
4078 bool SuppressUserConversions =
false,
4079 bool PartialOverloading =
false,
4083 DeclAccessPair FoundDecl,
4084 CXXRecordDecl *ActingContext,
4085 TemplateArgumentListInfo *ExplicitTemplateArgs,
4086 QualType ObjectType,
4087 Expr::Classification ObjectClassification,
4088 ArrayRef<Expr *> Args,
4089 OverloadCandidateSet& CandidateSet,
4090 bool SuppressUserConversions =
false,
4091 bool PartialOverloading =
false,
4095 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
4096 OverloadCandidateSet &CandidateSet,
bool SuppressUserConversions =
false,
4097 bool PartialOverloading =
false,
bool AllowExplicit =
true,
4100 bool AggregateCandidateDeduction =
false);
4103 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
4105 CXXRecordDecl *ActingContext =
nullptr, QualType ObjectType = QualType(),
4106 Expr::Classification ObjectClassification = {},
4109 CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
4110 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
4111 OverloadCandidateSet &CandidateSet,
bool AllowObjCConversionOnExplicit,
4112 bool AllowExplicit,
bool AllowResultConversion =
true);
4115 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
4116 OverloadCandidateSet &CandidateSet,
bool AllowObjCConversionOnExplicit,
4117 bool AllowExplicit,
bool AllowResultConversion =
true);
4119 DeclAccessPair FoundDecl,
4120 CXXRecordDecl *ActingContext,
4121 const FunctionProtoType *Proto,
4122 Expr *Object, ArrayRef<Expr *> Args,
4123 OverloadCandidateSet& CandidateSet);
4125 const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,
4126 OverloadCandidateSet &CandidateSet,
4127 TemplateArgumentListInfo *ExplicitTemplateArgs =
nullptr);
4129 SourceLocation OpLoc, ArrayRef<Expr *> Args,
4130 OverloadCandidateSet &CandidateSet,
4133 OverloadCandidateSet& CandidateSet,
4134 bool IsAssignmentOperator =
false,
4135 unsigned NumContextualBoolArguments = 0);
4137 SourceLocation OpLoc, ArrayRef<Expr *> Args,
4138 OverloadCandidateSet& CandidateSet);
4141 ArrayRef<Expr *> Args,
4142 TemplateArgumentListInfo *ExplicitTemplateArgs,
4143 OverloadCandidateSet& CandidateSet,
4144 bool PartialOverloading =
false);
4148 const NamedDecl *Found,
const FunctionDecl *Fn,
4150 QualType DestType = QualType(),
bool TakingAddress =
false);
4155 bool TakingAddress =
false);
4160 ArrayRef<Expr *> Args,
4161 bool MissingImplicitThis =
false);
4175 const Expr *ThisArg,
4176 ArrayRef<const Expr *> Args,
4177 SourceLocation Loc);
4187 SourceLocation Loc);
4194 bool Complain =
false,
4195 SourceLocation Loc = SourceLocation());
4207 QualType TargetType,
4209 DeclAccessPair &Found,
4210 bool *pHadMultipleCandidates =
nullptr);
4216 ExprResult &SrcExpr,
bool DoFunctionPointerConversion =
false);
4219 OverloadExpr *ovl,
bool Complain =
false, DeclAccessPair *Found =
nullptr,
4220 TemplateSpecCandidateSet *FailedTSC =
nullptr);
4223 ExprResult &SrcExpr,
bool DoFunctionPointerConversion =
false,
4224 bool Complain =
false, SourceRange OpRangeForComplaining = SourceRange(),
4225 QualType DestTypeForComplaining = QualType(),
4226 unsigned DiagIDForComplaining = 0);
4231 DeclAccessPair FoundDecl,
4235 ArrayRef<Expr *> Args,
4236 OverloadCandidateSet &CandidateSet,
4237 bool PartialOverloading =
false);
4239 LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
4240 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet);
4263 bool AllowTypoCorrection=
true,
4264 bool CalleesAddressIsTaken=
false);
4275 bool PerformADL =
true);
4280 Expr *input,
bool RequiresADL =
true);
4290 bool RequiresADL =
true,
4291 bool AllowRewrittenCandidates =
true,
4306 Expr *ExecConfig =
nullptr,
4307 bool IsExecConfig =
false,
4308 bool AllowRecovery =
false);
4316 bool *NoArrowOperatorFound =
nullptr);
4326 bool CheckParameterNames);