Bindings = None);\n NamedDecl *\n ActOnDecompositionDeclarator(Scope *S, Declarator &D,\n MultiTemplateParamsArg TemplateParamLists);\n // Returns true if the variable declaration is a redeclaration\n bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);\n void CheckVariableDeclarationType(VarDecl *NewVD);\n bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,\n Expr *Init);\n void CheckCompleteVariableDeclaration(VarDecl *VD);\n void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);\n void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);\n\n NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,\n TypeSourceInfo *TInfo,\n LookupResult &Previous,\n MultiTemplateParamsArg TemplateParamLists,\n bool &AddToScope);\n bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);\n\n enum class CheckConstexprKind {\n /// Diagnose issues that are non-constant or that are extensions.\n Diagnose,\n /// Identify whether this function satisfies the formal rules for constexpr\n /// functions in the current lanugage mode (with no extensions).\n CheckValid\n };\n\n bool CheckConstexprFunctionDefinition(const FunctionDecl *FD,\n CheckConstexprKind Kind);\n\n void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);\n void FindHiddenVirtualMethods(CXXMethodDecl *MD,\n SmallVectorImpl &OverloadedMethods);\n void NoteHiddenVirtualMethods(CXXMethodDecl *MD,\n SmallVectorImpl &OverloadedMethods);\n // Returns true if the function declaration is a redeclaration\n bool CheckFunctionDeclaration(Scope *S,\n FunctionDecl *NewFD, LookupResult &Previous,\n bool IsMemberSpecialization);\n bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);\n bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD,\n QualType NewT, QualType OldT);\n void CheckMain(FunctionDecl *FD, const DeclSpec &D);\n void CheckMSVCRTEntryPoint(FunctionDecl *FD);\n Attr *getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,\n bool IsDefinition);\n void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D);\n Decl *ActOnParamDeclarator(Scope *S, Declarator &D);\n ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,\n SourceLocation Loc,\n QualType T);\n ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,\n SourceLocation NameLoc, IdentifierInfo *Name,\n QualType T, TypeSourceInfo *TSInfo,\n StorageClass SC);\n void ActOnParamDefaultArgument(Decl *param,\n SourceLocation EqualLoc,\n Expr *defarg);\n void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc,\n SourceLocation ArgLoc);\n void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);\n ExprResult ConvertParamDefaultArgument(const ParmVarDecl *Param,\n Expr *DefaultArg,\n SourceLocation EqualLoc);\n void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,\n SourceLocation EqualLoc);\n\n // Contexts where using non-trivial C union types can be disallowed. This is\n // passed to err_non_trivial_c_union_in_invalid_context.\n enum NonTrivialCUnionContext {\n // Function parameter.\n NTCUC_FunctionParam,\n // Function return.\n NTCUC_FunctionReturn,\n // Default-initialized object.\n NTCUC_DefaultInitializedObject,\n // Variable with automatic storage duration.\n NTCUC_AutoVar,\n // Initializer expression that might copy from another object.\n NTCUC_CopyInit,\n // Assignment.\n NTCUC_Assignment,\n // Compound literal.\n NTCUC_CompoundLiteral,\n // Block capture.\n NTCUC_BlockCapture,\n // lvalue-to-rvalue conversion of volatile type.\n NTCUC_LValueToRValueVolatile,\n };\n\n /// Emit diagnostics if the initializer or any of its explicit or\n /// implicitly-generated subexpressions require copying or\n /// default-initializing a type that is or contains a C union type that is\n /// non-trivial to copy or default-initialize.\n void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);\n\n // These flags are passed to checkNonTrivialCUnion.\n enum NonTrivialCUnionKind {\n NTCUK_Init = 0x1,\n NTCUK_Destruct = 0x2,\n NTCUK_Copy = 0x4,\n };\n\n /// Emit diagnostics if a non-trivial C union type or a struct that contains\n /// a non-trivial C union is used in an invalid context.\n void checkNonTrivialCUnion(QualType QT, SourceLocation Loc,\n NonTrivialCUnionContext UseContext,\n unsigned NonTrivialKind);\n\n void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);\n void ActOnUninitializedDecl(Decl *dcl);\n void ActOnInitializerError(Decl *Dcl);\n\n void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);\n void ActOnCXXForRangeDecl(Decl *D);\n StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,\n IdentifierInfo *Ident,\n ParsedAttributes &Attrs,\n SourceLocation AttrEnd);\n void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);\n void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);\n void CheckStaticLocalForDllExport(VarDecl *VD);\n void FinalizeDeclaration(Decl *D);\n DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,\n ArrayRef Group);\n DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef Group);\n\n /// Should be called on all declarations that might have attached\n /// documentation comments.\n void ActOnDocumentableDecl(Decl *D);\n void ActOnDocumentableDecls(ArrayRef Group);\n\n void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,\n SourceLocation LocAfterDecls);\n void CheckForFunctionRedefinition(\n FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,\n SkipBodyInfo *SkipBody = nullptr);\n Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,\n MultiTemplateParamsArg TemplateParamLists,\n SkipBodyInfo *SkipBody = nullptr);\n Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,\n SkipBodyInfo *SkipBody = nullptr);\n void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D);\n ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr);\n ExprResult ActOnRequiresClause(ExprResult ConstraintExpr);\n void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);\n bool isObjCMethodDecl(Decl *D) {\n return D && isa(D);\n }\n\n /// Determine whether we can delay parsing the body of a function or\n /// function template until it is used, assuming we don't care about emitting\n /// code for that function.\n ///\n /// This will be \\c false if we may need the body of the function in the\n /// middle of parsing an expression (where it's impractical to switch to\n /// parsing a different function), for instance, if it's constexpr in C++11\n /// or has an 'auto' return type in C++14. These cases are essentially bugs.\n bool canDelayFunctionBody(const Declarator &D);\n\n /// Determine whether we can skip parsing the body of a function\n /// definition, assuming we don't care about analyzing its body or emitting\n /// code for that function.\n ///\n /// This will be \\c false only if we may need the body of the function in\n /// order to parse the rest of the program (for instance, if it is\n /// \\c constexpr in C++11 or has an 'auto' return type in C++14).\n bool canSkipFunctionBody(Decl *D);\n\n void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);\n Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);\n Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);\n Decl *ActOnSkippedFunctionBody(Decl *Decl);\n void ActOnFinishInlineFunctionDef(FunctionDecl *D);\n\n /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an\n /// attribute for which parsing is delayed.\n void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);\n\n /// Diagnose any unused parameters in the given sequence of\n /// ParmVarDecl pointers.\n void DiagnoseUnusedParameters(ArrayRef Parameters);\n\n /// Diagnose whether the size of parameters or return value of a\n /// function or obj-c method definition is pass-by-value and larger than a\n /// specified threshold.\n void\n DiagnoseSizeOfParametersAndReturnValue(ArrayRef Parameters,\n QualType ReturnTy, NamedDecl *D);\n\n void DiagnoseInvalidJumps(Stmt *Body);\n Decl *ActOnFileScopeAsmDecl(Expr *expr,\n SourceLocation AsmLoc,\n SourceLocation RParenLoc);\n\n /// Handle a C++11 empty-declaration and attribute-declaration.\n Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList,\n SourceLocation SemiLoc);\n\n enum class ModuleDeclKind {\n Interface, ///< 'export module X;'\n Implementation, ///< 'module X;'\n };\n\n /// The parser has processed a module-declaration that begins the definition\n /// of a module interface or implementation.\n DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,\n SourceLocation ModuleLoc, ModuleDeclKind MDK,\n ModuleIdPath Path, bool IsFirstDecl);\n\n /// The parser has processed a global-module-fragment declaration that begins\n /// the definition of the global module fragment of the current module unit.\n /// \\param ModuleLoc The location of the 'module' keyword.\n DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc);\n\n /// The parser has processed a private-module-fragment declaration that begins\n /// the definition of the private module fragment of the current module unit.\n /// \\param ModuleLoc The location of the 'module' keyword.\n /// \\param PrivateLoc The location of the 'private' keyword.\n DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,\n SourceLocation PrivateLoc);\n\n /// The parser has processed a module import declaration.\n ///\n /// \\param StartLoc The location of the first token in the declaration. This\n /// could be the location of an '@', 'export', or 'import'.\n /// \\param ExportLoc The location of the 'export' keyword, if any.\n /// \\param ImportLoc The location of the 'import' keyword.\n /// \\param Path The module access path.\n DeclResult ActOnModuleImport(SourceLocation StartLoc,\n SourceLocation ExportLoc,\n SourceLocation ImportLoc, ModuleIdPath Path);\n DeclResult ActOnModuleImport(SourceLocation StartLoc,\n SourceLocation ExportLoc,\n SourceLocation ImportLoc, Module *M,\n ModuleIdPath Path = {});\n\n /// The parser has processed a module import translated from a\n /// #include or similar preprocessing directive.\n void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);\n void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);\n\n /// The parsed has entered a submodule.\n void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);\n /// The parser has left a submodule.\n void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);\n\n /// Create an implicit import of the given module at the given\n /// source location, for error recovery, if possible.\n ///\n /// This routine is typically used when an entity found by name lookup\n /// is actually hidden within a module that we know about but the user\n /// has forgotten to import.\n void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,\n Module *Mod);\n\n /// Kinds of missing import. Note, the values of these enumerators correspond\n /// to %select values in diagnostics.\n enum class MissingImportKind {\n Declaration,\n Definition,\n DefaultArgument,\n ExplicitSpecialization,\n PartialSpecialization\n };\n\n /// Diagnose that the specified declaration needs to be visible but\n /// isn't, and suggest a module import that would resolve the problem.\n void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,\n MissingImportKind MIK, bool Recover = true);\n void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,\n SourceLocation DeclLoc, ArrayRef Modules,\n MissingImportKind MIK, bool Recover);\n\n Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,\n SourceLocation LBraceLoc);\n Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,\n SourceLocation RBraceLoc);\n\n /// We've found a use of a templated declaration that would trigger an\n /// implicit instantiation. Check that any relevant explicit specializations\n /// and partial specializations are visible, and diagnose if not.\n void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);\n\n /// Retrieve a suitable printing policy for diagnostics.\n PrintingPolicy getPrintingPolicy() const {\n return getPrintingPolicy(Context, PP);\n }\n\n /// Retrieve a suitable printing policy for diagnostics.\n static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,\n const Preprocessor &PP);\n\n /// Scope actions.\n void ActOnPopScope(SourceLocation Loc, Scope *S);\n void ActOnTranslationUnitScope(Scope *S);\n\n Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,\n RecordDecl *&AnonRecord);\n Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,\n MultiTemplateParamsArg TemplateParams,\n bool IsExplicitInstantiation,\n RecordDecl *&AnonRecord);\n\n Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,\n AccessSpecifier AS,\n RecordDecl *Record,\n const PrintingPolicy &Policy);\n\n Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,\n RecordDecl *Record);\n\n /// Common ways to introduce type names without a tag for use in diagnostics.\n /// Keep in sync with err_tag_reference_non_tag.\n enum NonTagKind {\n NTK_NonStruct,\n NTK_NonClass,\n NTK_NonUnion,\n NTK_NonEnum,\n NTK_Typedef,\n NTK_TypeAlias,\n NTK_Template,\n NTK_TypeAliasTemplate,\n NTK_TemplateTemplateArgument,\n };\n\n /// Given a non-tag type declaration, returns an enum useful for indicating\n /// what kind of non-tag type this is.\n NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);\n\n bool isAcceptableTagRedeclaration(const TagDecl *Previous,\n TagTypeKind NewTag, bool isDefinition,\n SourceLocation NewTagLoc,\n const IdentifierInfo *Name);\n\n enum TagUseKind {\n TUK_Reference, // Reference to a tag: 'struct foo *X;'\n TUK_Declaration, // Fwd decl of a tag: 'struct foo;'\n TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'\n TUK_Friend // Friend declaration: 'friend struct foo;'\n };\n\n Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,\n SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,\n SourceLocation NameLoc, const ParsedAttributesView &Attr,\n AccessSpecifier AS, SourceLocation ModulePrivateLoc,\n MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,\n bool &IsDependent, SourceLocation ScopedEnumKWLoc,\n bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,\n bool IsTypeSpecifier, bool IsTemplateParamOrArg,\n SkipBodyInfo *SkipBody = nullptr);\n\n Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,\n unsigned TagSpec, SourceLocation TagLoc,\n CXXScopeSpec &SS, IdentifierInfo *Name,\n SourceLocation NameLoc,\n const ParsedAttributesView &Attr,\n MultiTemplateParamsArg TempParamLists);\n\n TypeResult ActOnDependentTag(Scope *S,\n unsigned TagSpec,\n TagUseKind TUK,\n const CXXScopeSpec &SS,\n IdentifierInfo *Name,\n SourceLocation TagLoc,\n SourceLocation NameLoc);\n\n void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,\n IdentifierInfo *ClassName,\n SmallVectorImpl &Decls);\n Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,\n Declarator &D, Expr *BitfieldWidth);\n\n FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,\n Declarator &D, Expr *BitfieldWidth,\n InClassInitStyle InitStyle,\n AccessSpecifier AS);\n MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD,\n SourceLocation DeclStart, Declarator &D,\n Expr *BitfieldWidth,\n InClassInitStyle InitStyle,\n AccessSpecifier AS,\n const ParsedAttr &MSPropertyAttr);\n\n FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,\n TypeSourceInfo *TInfo,\n RecordDecl *Record, SourceLocation Loc,\n bool Mutable, Expr *BitfieldWidth,\n InClassInitStyle InitStyle,\n SourceLocation TSSL,\n AccessSpecifier AS, NamedDecl *PrevDecl,\n Declarator *D = nullptr);\n\n bool CheckNontrivialField(FieldDecl *FD);\n void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);\n\n enum TrivialABIHandling {\n /// The triviality of a method unaffected by \"trivial_abi\".\n TAH_IgnoreTrivialABI,\n\n /// The triviality of a method affected by \"trivial_abi\".\n TAH_ConsiderTrivialABI\n };\n\n bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,\n TrivialABIHandling TAH = TAH_IgnoreTrivialABI,\n bool Diagnose = false);\n\n /// For a defaulted function, the kind of defaulted function that it is.\n class DefaultedFunctionKind {\n CXXSpecialMember SpecialMember : 8;\n DefaultedComparisonKind Comparison : 8;\n\n public:\n DefaultedFunctionKind()\n : SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) {\n }\n DefaultedFunctionKind(CXXSpecialMember CSM)\n : SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {}\n DefaultedFunctionKind(DefaultedComparisonKind Comp)\n : SpecialMember(CXXInvalid), Comparison(Comp) {}\n\n bool isSpecialMember() const { return SpecialMember != CXXInvalid; }\n bool isComparison() const {\n return Comparison != DefaultedComparisonKind::None;\n }\n\n explicit operator bool() const {\n return isSpecialMember() || isComparison();\n }\n\n CXXSpecialMember asSpecialMember() const { return SpecialMember; }\n DefaultedComparisonKind asComparison() const { return Comparison; }\n\n /// Get the index of this function kind for use in diagnostics.\n unsigned getDiagnosticIndex() const {\n static_assert(CXXInvalid > CXXDestructor,\n \"invalid should have highest index\");\n static_assert((unsigned)DefaultedComparisonKind::None == 0,\n \"none should be equal to zero\");\n return SpecialMember + (unsigned)Comparison;\n }\n };\n\n DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD);\n\n CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) {\n return getDefaultedFunctionKind(MD).asSpecialMember();\n }\n DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) {\n return getDefaultedFunctionKind(FD).asComparison();\n }\n\n void ActOnLastBitfield(SourceLocation DeclStart,\n SmallVectorImpl &AllIvarDecls);\n Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,\n Declarator &D, Expr *BitfieldWidth,\n tok::ObjCKeywordKind visibility);\n\n // This is used for both record definitions and ObjC interface declarations.\n void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl,\n ArrayRef Fields, SourceLocation LBrac,\n SourceLocation RBrac, const ParsedAttributesView &AttrList);\n\n /// ActOnTagStartDefinition - Invoked when we have entered the\n /// scope of a tag's definition (e.g., for an enumeration, class,\n /// struct, or union).\n void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);\n\n /// Perform ODR-like check for C/ObjC when merging tag types from modules.\n /// Differently from C++, actually parse the body and reject / error out\n /// in case of a structural mismatch.\n bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,\n SkipBodyInfo &SkipBody);\n\n typedef void *SkippedDefinitionContext;\n\n /// Invoked when we enter a tag definition that we're skipping.\n SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD);\n\n Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);\n\n /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a\n /// C++ record definition's base-specifiers clause and are starting its\n /// member declarations.\n void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,\n SourceLocation FinalLoc,\n bool IsFinalSpelledSealed,\n SourceLocation LBraceLoc);\n\n /// ActOnTagFinishDefinition - Invoked once we have finished parsing\n /// the definition of a tag (enumeration, class, struct, or union).\n void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,\n SourceRange BraceRange);\n\n void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);\n\n void ActOnObjCContainerFinishDefinition();\n\n /// Invoked when we must temporarily exit the objective-c container\n /// scope for parsing/looking-up C constructs.\n ///\n /// Must be followed by a call to \\see ActOnObjCReenterContainerContext\n void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);\n void ActOnObjCReenterContainerContext(DeclContext *DC);\n\n /// ActOnTagDefinitionError - Invoked when there was an unrecoverable\n /// error parsing the definition of a tag.\n void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);\n\n EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,\n EnumConstantDecl *LastEnumConst,\n SourceLocation IdLoc,\n IdentifierInfo *Id,\n Expr *val);\n bool CheckEnumUnderlyingType(TypeSourceInfo *TI);\n bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,\n QualType EnumUnderlyingTy, bool IsFixed,\n const EnumDecl *Prev);\n\n /// Determine whether the body of an anonymous enumeration should be skipped.\n /// \\param II The name of the first enumerator.\n SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,\n SourceLocation IILoc);\n\n Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,\n SourceLocation IdLoc, IdentifierInfo *Id,\n const ParsedAttributesView &Attrs,\n SourceLocation EqualLoc, Expr *Val);\n void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,\n Decl *EnumDecl, ArrayRef Elements, Scope *S,\n const ParsedAttributesView &Attr);\n\n /// Set the current declaration context until it gets popped.\n void PushDeclContext(Scope *S, DeclContext *DC);\n void PopDeclContext();\n\n /// EnterDeclaratorContext - Used when we must lookup names in the context\n /// of a declarator's nested name specifier.\n void EnterDeclaratorContext(Scope *S, DeclContext *DC);\n void ExitDeclaratorContext(Scope *S);\n\n /// Enter a template parameter scope, after it's been associated with a particular\n /// DeclContext. Causes lookup within the scope to chain through enclosing contexts\n /// in the correct order.\n void EnterTemplatedContext(Scope *S, DeclContext *DC);\n\n /// Push the parameters of D, which must be a function, into scope.\n void ActOnReenterFunctionContext(Scope* S, Decl* D);\n void ActOnExitFunctionContext();\n\n DeclContext *getFunctionLevelDeclContext();\n\n /// getCurFunctionDecl - If inside of a function body, this returns a pointer\n /// to the function decl for the function being parsed. If we're currently\n /// in a 'block', this returns the containing context.\n FunctionDecl *getCurFunctionDecl();\n\n /// getCurMethodDecl - If inside of a method body, this returns a pointer to\n /// the method decl for the method being parsed. If we're currently\n /// in a 'block', this returns the containing context.\n ObjCMethodDecl *getCurMethodDecl();\n\n /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method\n /// or C function we're in, otherwise return null. If we're currently\n /// in a 'block', this returns the containing context.\n NamedDecl *getCurFunctionOrMethodDecl();\n\n /// Add this decl to the scope shadowed decl chains.\n void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);\n\n /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true\n /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns\n /// true if 'D' belongs to the given declaration context.\n ///\n /// \\param AllowInlineNamespace If \\c true, allow the declaration to be in the\n /// enclosing namespace set of the context, rather than contained\n /// directly within it.\n bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr,\n bool AllowInlineNamespace = false);\n\n /// Finds the scope corresponding to the given decl context, if it\n /// happens to be an enclosing scope. Otherwise return NULL.\n static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);\n\n /// Subroutines of ActOnDeclarator().\n TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,\n TypeSourceInfo *TInfo);\n bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);\n\n /// Describes the kind of merge to perform for availability\n /// attributes (including \"deprecated\", \"unavailable\", and \"availability\").\n enum AvailabilityMergeKind {\n /// Don't merge availability attributes at all.\n AMK_None,\n /// Merge availability attributes for a redeclaration, which requires\n /// an exact match.\n AMK_Redeclaration,\n /// Merge availability attributes for an override, which requires\n /// an exact match or a weakening of constraints.\n AMK_Override,\n /// Merge availability attributes for an implementation of\n /// a protocol requirement.\n AMK_ProtocolImplementation,\n };\n\n /// Describes the kind of priority given to an availability attribute.\n ///\n /// The sum of priorities deteremines the final priority of the attribute.\n /// The final priority determines how the attribute will be merged.\n /// An attribute with a lower priority will always remove higher priority\n /// attributes for the specified platform when it is being applied. An\n /// attribute with a higher priority will not be applied if the declaration\n /// already has an availability attribute with a lower priority for the\n /// specified platform. The final prirority values are not expected to match\n /// the values in this enumeration, but instead should be treated as a plain\n /// integer value. This enumeration just names the priority weights that are\n /// used to calculate that final vaue.\n enum AvailabilityPriority : int {\n /// The availability attribute was specified explicitly next to the\n /// declaration.\n AP_Explicit = 0,\n\n /// The availability attribute was applied using '#pragma clang attribute'.\n AP_PragmaClangAttribute = 1,\n\n /// The availability attribute for a specific platform was inferred from\n /// an availability attribute for another platform.\n AP_InferredFromOtherPlatform = 2\n };\n\n /// Attribute merging methods. Return true if a new attribute was added.\n AvailabilityAttr *\n mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI,\n IdentifierInfo *Platform, bool Implicit,\n VersionTuple Introduced, VersionTuple Deprecated,\n VersionTuple Obsoleted, bool IsUnavailable,\n StringRef Message, bool IsStrict, StringRef Replacement,\n AvailabilityMergeKind AMK, int Priority);\n TypeVisibilityAttr *\n mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,\n TypeVisibilityAttr::VisibilityType Vis);\n VisibilityAttr *mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,\n VisibilityAttr::VisibilityType Vis);\n UuidAttr *mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI,\n StringRef UuidAsWritten, MSGuidDecl *GuidDecl);\n DLLImportAttr *mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI);\n DLLExportAttr *mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI);\n MSInheritanceAttr *mergeMSInheritanceAttr(Decl *D,\n const AttributeCommonInfo &CI,\n bool BestCase,\n MSInheritanceModel Model);\n FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI,\n IdentifierInfo *Format, int FormatIdx,\n int FirstArg);\n SectionAttr *mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI,\n StringRef Name);\n CodeSegAttr *mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI,\n StringRef Name);\n AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D,\n const AttributeCommonInfo &CI,\n const IdentifierInfo *Ident);\n MinSizeAttr *mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI);\n NoSpeculativeLoadHardeningAttr *\n mergeNoSpeculativeLoadHardeningAttr(Decl *D,\n const NoSpeculativeLoadHardeningAttr &AL);\n SpeculativeLoadHardeningAttr *\n mergeSpeculativeLoadHardeningAttr(Decl *D,\n const SpeculativeLoadHardeningAttr &AL);\n SwiftNameAttr *mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA,\n StringRef Name);\n OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D,\n const AttributeCommonInfo &CI);\n InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL);\n InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D,\n const InternalLinkageAttr &AL);\n CommonAttr *mergeCommonAttr(Decl *D, const ParsedAttr &AL);\n CommonAttr *mergeCommonAttr(Decl *D, const CommonAttr &AL);\n WebAssemblyImportNameAttr *mergeImportNameAttr(\n Decl *D, const WebAssemblyImportNameAttr &AL);\n WebAssemblyImportModuleAttr *mergeImportModuleAttr(\n Decl *D, const WebAssemblyImportModuleAttr &AL);\n EnforceTCBAttr *mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL);\n EnforceTCBLeafAttr *mergeEnforceTCBLeafAttr(Decl *D,\n const EnforceTCBLeafAttr &AL);\n\n void mergeDeclAttributes(NamedDecl *New, Decl *Old,\n AvailabilityMergeKind AMK = AMK_Redeclaration);\n void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,\n LookupResult &OldDecls);\n bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S,\n bool MergeTypeWithOld);\n bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,\n Scope *S, bool MergeTypeWithOld);\n void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);\n void MergeVarDecl(VarDecl *New, LookupResult &Previous);\n void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld);\n void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);\n bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn);\n void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);\n bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);\n\n // AssignmentAction - This is used by all the assignment diagnostic functions\n // to represent what is actually causing the operation\n enum AssignmentAction {\n AA_Assigning,\n AA_Passing,\n AA_Returning,\n AA_Converting,\n AA_Initializing,\n AA_Sending,\n AA_Casting,\n AA_Passing_CFAudited\n };\n\n /// C++ Overloading.\n enum OverloadKind {\n /// This is a legitimate overload: the existing declarations are\n /// functions or function templates with different signatures.\n Ovl_Overload,\n\n /// This is not an overload because the signature exactly matches\n /// an existing declaration.\n Ovl_Match,\n\n /// This is not an overload because the lookup results contain a\n /// non-function.\n Ovl_NonFunction\n };\n OverloadKind CheckOverload(Scope *S,\n FunctionDecl *New,\n const LookupResult &OldDecls,\n NamedDecl *&OldDecl,\n bool IsForUsingDecl);\n bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,\n bool ConsiderCudaAttrs = true,\n bool ConsiderRequiresClauses = true);\n\n enum class AllowedExplicit {\n /// Allow no explicit functions to be used.\n None,\n /// Allow explicit conversion functions but not explicit constructors.\n Conversions,\n /// Allow both explicit conversion functions and explicit constructors.\n All\n };\n\n ImplicitConversionSequence\n TryImplicitConversion(Expr *From, QualType ToType,\n bool SuppressUserConversions,\n AllowedExplicit AllowExplicit,\n bool InOverloadResolution,\n bool CStyle,\n bool AllowObjCWritebackConversion);\n\n bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);\n bool IsFloatingPointPromotion(QualType FromType, QualType ToType);\n bool IsComplexPromotion(QualType FromType, QualType ToType);\n bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,\n bool InOverloadResolution,\n QualType& ConvertedType, bool &IncompatibleObjC);\n bool isObjCPointerConversion(QualType FromType, QualType ToType,\n QualType& ConvertedType, bool &IncompatibleObjC);\n bool isObjCWritebackConversion(QualType FromType, QualType ToType,\n QualType &ConvertedType);\n bool IsBlockPointerConversion(QualType FromType, QualType ToType,\n QualType& ConvertedType);\n bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,\n const FunctionProtoType *NewType,\n unsigned *ArgPos = nullptr);\n void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,\n QualType FromType, QualType ToType);\n\n void maybeExtendBlockObject(ExprResult &E);\n CastKind PrepareCastToObjCObjectPointer(ExprResult &E);\n bool CheckPointerConversion(Expr *From, QualType ToType,\n CastKind &Kind,\n CXXCastPath& BasePath,\n bool IgnoreBaseAccess,\n bool Diagnose = true);\n bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,\n bool InOverloadResolution,\n QualType &ConvertedType);\n bool CheckMemberPointerConversion(Expr *From, QualType ToType,\n CastKind &Kind,\n CXXCastPath &BasePath,\n bool IgnoreBaseAccess);\n bool IsQualificationConversion(QualType FromType, QualType ToType,\n bool CStyle, bool &ObjCLifetimeConversion);\n bool IsFunctionConversion(QualType FromType, QualType ToType,\n QualType &ResultTy);\n bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);\n bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);\n\n ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity,\n const VarDecl *NRVOCandidate,\n QualType ResultType,\n Expr *Value,\n bool AllowNRVO = true);\n\n bool CanPerformAggregateInitializationForOverloadResolution(\n const InitializedEntity &Entity, InitListExpr *From);\n\n bool IsStringInit(Expr *Init, const ArrayType *AT);\n\n bool CanPerformCopyInitialization(const InitializedEntity &Entity,\n ExprResult Init);\n ExprResult PerformCopyInitialization(const InitializedEntity &Entity,\n SourceLocation EqualLoc,\n ExprResult Init,\n bool TopLevelOfInitList = false,\n bool AllowExplicit = false);\n ExprResult PerformObjectArgumentInitialization(Expr *From,\n NestedNameSpecifier *Qualifier,\n NamedDecl *FoundDecl,\n CXXMethodDecl *Method);\n\n /// Check that the lifetime of the initializer (and its subobjects) is\n /// sufficient for initializing the entity, and perform lifetime extension\n /// (when permitted) if not.\n void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);\n\n ExprResult PerformContextuallyConvertToBool(Expr *From);\n ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);\n\n /// Contexts in which a converted constant expression is required.\n enum CCEKind {\n CCEK_CaseValue, ///< Expression in a case label.\n CCEK_Enumerator, ///< Enumerator value with fixed underlying type.\n CCEK_TemplateArg, ///< Value of a non-type template parameter.\n CCEK_ArrayBound, ///< Array bound in array declarator or new-expression.\n CCEK_ConstexprIf, ///< Condition in a constexpr if statement.\n CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.\n };\n ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,\n llvm::APSInt &Value, CCEKind CCE);\n ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,\n APValue &Value, CCEKind CCE,\n NamedDecl *Dest = nullptr);\n\n /// Abstract base class used to perform a contextual implicit\n /// conversion from an expression to any type passing a filter.\n class ContextualImplicitConverter {\n public:\n bool Suppress;\n bool SuppressConversion;\n\n ContextualImplicitConverter(bool Suppress = false,\n bool SuppressConversion = false)\n : Suppress(Suppress), SuppressConversion(SuppressConversion) {}\n\n /// Determine whether the specified type is a valid destination type\n /// for this conversion.\n virtual bool match(QualType T) = 0;\n\n /// Emits a diagnostic complaining that the expression does not have\n /// integral or enumeration type.\n virtual SemaDiagnosticBuilder\n diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0;\n\n /// Emits a diagnostic when the expression has incomplete class type.\n virtual SemaDiagnosticBuilder\n diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0;\n\n /// Emits a diagnostic when the only matching conversion function\n /// is explicit.\n virtual SemaDiagnosticBuilder diagnoseExplicitConv(\n Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;\n\n /// Emits a note for the explicit conversion function.\n virtual SemaDiagnosticBuilder\n noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;\n\n /// Emits a diagnostic when there are multiple possible conversion\n /// functions.\n virtual SemaDiagnosticBuilder\n diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0;\n\n /// Emits a note for one of the candidate conversions.\n virtual SemaDiagnosticBuilder\n noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;\n\n /// Emits a diagnostic when we picked a conversion function\n /// (for cases when we are not allowed to pick a conversion function).\n virtual SemaDiagnosticBuilder diagnoseConversion(\n Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;\n\n virtual ~ContextualImplicitConverter() {}\n };\n\n class ICEConvertDiagnoser : public ContextualImplicitConverter {\n bool AllowScopedEnumerations;\n\n public:\n ICEConvertDiagnoser(bool AllowScopedEnumerations,\n bool Suppress, bool SuppressConversion)\n : ContextualImplicitConverter(Suppress, SuppressConversion),\n AllowScopedEnumerations(AllowScopedEnumerations) {}\n\n /// Match an integral or (possibly scoped) enumeration type.\n bool match(QualType T) override;\n\n SemaDiagnosticBuilder\n diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override {\n return diagnoseNotInt(S, Loc, T);\n }\n\n /// Emits a diagnostic complaining that the expression does not have\n /// integral or enumeration type.\n virtual SemaDiagnosticBuilder\n diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0;\n };\n\n /// Perform a contextual implicit conversion.\n ExprResult PerformContextualImplicitConversion(\n SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);\n\n\n enum ObjCSubscriptKind {\n OS_Array,\n OS_Dictionary,\n OS_Error\n };\n ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);\n\n // Note that LK_String is intentionally after the other literals, as\n // this is used for diagnostics logic.\n enum ObjCLiteralKind {\n LK_Array,\n LK_Dictionary,\n LK_Numeric,\n LK_Boxed,\n LK_String,\n LK_Block,\n LK_None\n };\n ObjCLiteralKind CheckLiteralKind(Expr *FromE);\n\n ExprResult PerformObjectMemberConversion(Expr *From,\n NestedNameSpecifier *Qualifier,\n NamedDecl *FoundDecl,\n NamedDecl *Member);\n\n // Members have to be NamespaceDecl* or TranslationUnitDecl*.\n // TODO: make this is a typesafe union.\n typedef llvm::SmallSetVector AssociatedNamespaceSet;\n typedef llvm::SmallSetVector AssociatedClassSet;\n\n using ADLCallKind = CallExpr::ADLCallKind;\n\n void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,\n ArrayRef Args,\n OverloadCandidateSet &CandidateSet,\n bool SuppressUserConversions = false,\n bool PartialOverloading = false,\n bool AllowExplicit = true,\n bool AllowExplicitConversion = false,\n ADLCallKind IsADLCandidate = ADLCallKind::NotADL,\n ConversionSequenceList EarlyConversions = None,\n OverloadCandidateParamOrder PO = {});\n void AddFunctionCandidates(const UnresolvedSetImpl &Functions,\n ArrayRef Args,\n OverloadCandidateSet &CandidateSet,\n TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,\n bool SuppressUserConversions = false,\n bool PartialOverloading = false,\n bool FirstArgumentIsBase = false);\n void AddMethodCandidate(DeclAccessPair FoundDecl,\n QualType ObjectType,\n Expr::Classification ObjectClassification,\n ArrayRef Args,\n OverloadCandidateSet& CandidateSet,\n bool SuppressUserConversion = false,\n OverloadCandidateParamOrder PO = {});\n void AddMethodCandidate(CXXMethodDecl *Method,\n DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext, QualType ObjectType,\n Expr::Classification ObjectClassification,\n ArrayRef Args,\n OverloadCandidateSet& CandidateSet,\n bool SuppressUserConversions = false,\n bool PartialOverloading = false,\n ConversionSequenceList EarlyConversions = None,\n OverloadCandidateParamOrder PO = {});\n void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,\n DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext,\n TemplateArgumentListInfo *ExplicitTemplateArgs,\n QualType ObjectType,\n Expr::Classification ObjectClassification,\n ArrayRef Args,\n OverloadCandidateSet& CandidateSet,\n bool SuppressUserConversions = false,\n bool PartialOverloading = false,\n OverloadCandidateParamOrder PO = {});\n void AddTemplateOverloadCandidate(\n FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,\n TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef Args,\n OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,\n bool PartialOverloading = false, bool AllowExplicit = true,\n ADLCallKind IsADLCandidate = ADLCallKind::NotADL,\n OverloadCandidateParamOrder PO = {});\n bool CheckNonDependentConversions(\n FunctionTemplateDecl *FunctionTemplate, ArrayRef ParamTypes,\n ArrayRef Args, OverloadCandidateSet &CandidateSet,\n ConversionSequenceList &Conversions, bool SuppressUserConversions,\n CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(),\n Expr::Classification ObjectClassification = {},\n OverloadCandidateParamOrder PO = {});\n void AddConversionCandidate(\n CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext, Expr *From, QualType ToType,\n OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,\n bool AllowExplicit, bool AllowResultConversion = true);\n void AddTemplateConversionCandidate(\n FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext, Expr *From, QualType ToType,\n OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,\n bool AllowExplicit, bool AllowResultConversion = true);\n void AddSurrogateCandidate(CXXConversionDecl *Conversion,\n DeclAccessPair FoundDecl,\n CXXRecordDecl *ActingContext,\n const FunctionProtoType *Proto,\n Expr *Object, ArrayRef Args,\n OverloadCandidateSet& CandidateSet);\n void AddNonMemberOperatorCandidates(\n const UnresolvedSetImpl &Functions, ArrayRef Args,\n OverloadCandidateSet &CandidateSet,\n TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);\n void AddMemberOperatorCandidates(OverloadedOperatorKind Op,\n SourceLocation OpLoc, ArrayRef Args,\n OverloadCandidateSet &CandidateSet,\n OverloadCandidateParamOrder PO = {});\n void AddBuiltinCandidate(QualType *ParamTys, ArrayRef Args,\n OverloadCandidateSet& CandidateSet,\n bool IsAssignmentOperator = false,\n unsigned NumContextualBoolArguments = 0);\n void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,\n SourceLocation OpLoc, ArrayRef Args,\n OverloadCandidateSet& CandidateSet);\n void AddArgumentDependentLookupCandidates(DeclarationName Name,\n SourceLocation Loc,\n ArrayRef Args,\n TemplateArgumentListInfo *ExplicitTemplateArgs,\n OverloadCandidateSet& CandidateSet,\n bool PartialOverloading = false);\n\n // Emit as a 'note' the specific overload candidate\n void NoteOverloadCandidate(\n NamedDecl *Found, FunctionDecl *Fn,\n OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(),\n QualType DestType = QualType(), bool TakingAddress = false);\n\n // Emit as a series of 'note's all template and non-templates identified by\n // the expression Expr\n void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),\n bool TakingAddress = false);\n\n /// Check the enable_if expressions on the given function. Returns the first\n /// failing attribute, or NULL if they were all successful.\n EnableIfAttr *CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc,\n ArrayRef Args,\n bool MissingImplicitThis = false);\n\n /// Find the failed Boolean condition within a given Boolean\n /// constant expression, and describe it with a string.\n std::pair findFailedBooleanCondition(Expr *Cond);\n\n /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any\n /// non-ArgDependent DiagnoseIfAttrs.\n ///\n /// Argument-dependent diagnose_if attributes should be checked each time a\n /// function is used as a direct callee of a function call.\n ///\n /// Returns true if any errors were emitted.\n bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,\n const Expr *ThisArg,\n ArrayRef Args,\n SourceLocation Loc);\n\n /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any\n /// ArgDependent DiagnoseIfAttrs.\n ///\n /// Argument-independent diagnose_if attributes should be checked on every use\n /// of a function.\n ///\n /// Returns true if any errors were emitted.\n bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,\n SourceLocation Loc);\n\n /// Returns whether the given function's address can be taken or not,\n /// optionally emitting a diagnostic if the address can't be taken.\n ///\n /// Returns false if taking the address of the function is illegal.\n bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,\n bool Complain = false,\n SourceLocation Loc = SourceLocation());\n\n // [PossiblyAFunctionType] --> [Return]\n // NonFunctionType --> NonFunctionType\n // R (A) --> R(A)\n // R (*)(A) --> R (A)\n // R (&)(A) --> R (A)\n // R (S::*)(A) --> R (A)\n QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);\n\n FunctionDecl *\n ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,\n QualType TargetType,\n bool Complain,\n DeclAccessPair &Found,\n bool *pHadMultipleCandidates = nullptr);\n\n FunctionDecl *\n resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult);\n\n bool resolveAndFixAddressOfSingleOverloadCandidate(\n ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);\n\n FunctionDecl *\n ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,\n bool Complain = false,\n DeclAccessPair *Found = nullptr);\n\n bool ResolveAndFixSingleFunctionTemplateSpecialization(\n ExprResult &SrcExpr,\n bool DoFunctionPointerConverion = false,\n bool Complain = false,\n SourceRange OpRangeForComplaining = SourceRange(),\n QualType DestTypeForComplaining = QualType(),\n unsigned DiagIDForComplaining = 0);\n\n\n Expr *FixOverloadedFunctionReference(Expr *E,\n DeclAccessPair FoundDecl,\n FunctionDecl *Fn);\n ExprResult FixOverloadedFunctionReference(ExprResult,\n DeclAccessPair FoundDecl,\n FunctionDecl *Fn);\n\n void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,\n ArrayRef Args,\n OverloadCandidateSet &CandidateSet,\n bool PartialOverloading = false);\n void AddOverloadedCallCandidates(\n LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,\n ArrayRef Args, OverloadCandidateSet &CandidateSet);\n\n // An enum used to represent the different possible results of building a\n // range-based for loop.\n enum ForRangeStatus {\n FRS_Success,\n FRS_NoViableFunction,\n FRS_DiagnosticIssued\n };\n\n ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,\n SourceLocation RangeLoc,\n const DeclarationNameInfo &NameInfo,\n LookupResult &MemberLookup,\n OverloadCandidateSet *CandidateSet,\n Expr *Range, ExprResult *CallExpr);\n\n ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,\n UnresolvedLookupExpr *ULE,\n SourceLocation LParenLoc,\n MultiExprArg Args,\n SourceLocation RParenLoc,\n Expr *ExecConfig,\n bool AllowTypoCorrection=true,\n bool CalleesAddressIsTaken=false);\n\n bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,\n MultiExprArg Args, SourceLocation RParenLoc,\n OverloadCandidateSet *CandidateSet,\n ExprResult *Result);\n\n ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,\n NestedNameSpecifierLoc NNSLoc,\n DeclarationNameInfo DNI,\n const UnresolvedSetImpl &Fns,\n bool PerformADL = true);\n\n ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,\n UnaryOperatorKind Opc,\n const UnresolvedSetImpl &Fns,\n Expr *input, bool RequiresADL = true);\n\n void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,\n OverloadedOperatorKind Op,\n const UnresolvedSetImpl &Fns,\n ArrayRef Args, bool RequiresADL = true);\n ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,\n BinaryOperatorKind Opc,\n const UnresolvedSetImpl &Fns,\n Expr *LHS, Expr *RHS,\n bool RequiresADL = true,\n bool AllowRewrittenCandidates = true,\n FunctionDecl *DefaultedFn = nullptr);\n ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc,\n const UnresolvedSetImpl &Fns,\n Expr *LHS, Expr *RHS,\n FunctionDecl *DefaultedFn);\n\n ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,\n SourceLocation RLoc,\n Expr *Base,Expr *Idx);\n\n ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr,\n SourceLocation LParenLoc,\n MultiExprArg Args,\n SourceLocation RParenLoc,\n bool AllowRecovery = false);\n ExprResult\n BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,\n MultiExprArg Args,\n SourceLocation RParenLoc);\n\n ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,\n SourceLocation OpLoc,\n bool *NoArrowOperatorFound = nullptr);\n\n /// CheckCallReturnType - Checks that a call expression's return type is\n /// complete. Returns true on failure. The location passed in is the location\n /// that best represents the call.\n bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,\n CallExpr *CE, FunctionDecl *FD);\n\n /// Helpers for dealing with blocks and functions.\n bool CheckParmsForFunctionDef(ArrayRef Parameters,\n bool CheckParameterNames);\n void CheckCXXDefaultArguments(FunctionDecl *FD);\n void CheckExtraCXXDefaultArguments(Declarator &D);\n Scope *getNonFieldDeclScope(Scope *S);\n\n /// \\name Name lookup\n ///\n /// These routines provide name lookup that is used during semantic\n /// analysis to resolve the various kinds of names (identifiers,\n /// overloaded operator names, constructor names, etc.) into zero or\n /// more declarations within a particular scope. The major entry\n /// points are LookupName, which performs unqualified name lookup,\n /// and LookupQualifiedName, which performs qualified name lookup.\n ///\n /// All name lookup is performed based on some specific criteria,\n /// which specify what names will be visible to name lookup and how\n /// far name lookup should work. These criteria are important both\n /// for capturing language semantics (certain lookups will ignore\n /// certain names, for example) and for performance, since name\n /// lookup is often a bottleneck in the compilation of C++. Name\n /// lookup criteria is specified via the LookupCriteria enumeration.\n ///\n /// The results of name lookup can vary based on the kind of name\n /// lookup performed, the current language, and the translation\n /// unit. In C, for example, name lookup will either return nothing\n /// (no entity found) or a single declaration. In C++, name lookup\n /// can additionally refer to a set of overloaded functions or\n /// result in an ambiguity. All of the possible results of name\n /// lookup are captured by the LookupResult class, which provides\n /// the ability to distinguish among them.\n //@{\n\n /// Describes the kind of name lookup to perform.\n enum LookupNameKind {\n /// Ordinary name lookup, which finds ordinary names (functions,\n /// variables, typedefs, etc.) in C and most kinds of names\n /// (functions, variables, members, types, etc.) in C++.\n LookupOrdinaryName = 0,\n /// Tag name lookup, which finds the names of enums, classes,\n /// structs, and unions.\n LookupTagName,\n /// Label name lookup.\n LookupLabel,\n /// Member name lookup, which finds the names of\n /// class/struct/union members.\n LookupMemberName,\n /// Look up of an operator name (e.g., operator+) for use with\n /// operator overloading. This lookup is similar to ordinary name\n /// lookup, but will ignore any declarations that are class members.\n LookupOperatorName,\n /// Look up a name following ~ in a destructor name. This is an ordinary\n /// lookup, but prefers tags to typedefs.\n LookupDestructorName,\n /// Look up of a name that precedes the '::' scope resolution\n /// operator in C++. This lookup completely ignores operator, object,\n /// function, and enumerator names (C++ [basic.lookup.qual]p1).\n LookupNestedNameSpecifierName,\n /// Look up a namespace name within a C++ using directive or\n /// namespace alias definition, ignoring non-namespace names (C++\n /// [basic.lookup.udir]p1).\n LookupNamespaceName,\n /// Look up all declarations in a scope with the given name,\n /// including resolved using declarations. This is appropriate\n /// for checking redeclarations for a using declaration.\n LookupUsingDeclName,\n /// Look up an ordinary name that is going to be redeclared as a\n /// name with linkage. This lookup ignores any declarations that\n /// are outside of the current scope unless they have linkage. See\n /// C99 6.2.2p4-5 and C++ [basic.link]p6.\n LookupRedeclarationWithLinkage,\n /// Look up a friend of a local class. This lookup does not look\n /// outside the innermost non-class scope. See C++11 [class.friend]p11.\n LookupLocalFriendName,\n /// Look up the name of an Objective-C protocol.\n LookupObjCProtocolName,\n /// Look up implicit 'self' parameter of an objective-c method.\n LookupObjCImplicitSelfParam,\n /// Look up the name of an OpenMP user-defined reduction operation.\n LookupOMPReductionName,\n /// Look up the name of an OpenMP user-defined mapper.\n LookupOMPMapperName,\n /// Look up any declaration with any name.\n LookupAnyName\n };\n\n /// Specifies whether (or how) name lookup is being performed for a\n /// redeclaration (vs. a reference).\n enum RedeclarationKind {\n /// The lookup is a reference to this name that is not for the\n /// purpose of redeclaring the name.\n NotForRedeclaration = 0,\n /// The lookup results will be used for redeclaration of a name,\n /// if an entity by that name already exists and is visible.\n ForVisibleRedeclaration,\n /// The lookup results will be used for redeclaration of a name\n /// with external linkage; non-visible lookup results with external linkage\n /// may also be found.\n ForExternalRedeclaration\n };\n\n RedeclarationKind forRedeclarationInCurContext() {\n // A declaration with an owning module for linkage can never link against\n // anything that is not visible. We don't need to check linkage here; if\n // the context has internal linkage, redeclaration lookup won't find things\n // from other TUs, and we can't safely compute linkage yet in general.\n if (cast(CurContext)\n ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))\n return ForVisibleRedeclaration;\n return ForExternalRedeclaration;\n }\n\n /// The possible outcomes of name lookup for a literal operator.\n enum LiteralOperatorLookupResult {\n /// The lookup resulted in an error.\n LOLR_Error,\n /// The lookup found no match but no diagnostic was issued.\n LOLR_ErrorNoDiagnostic,\n /// The lookup found a single 'cooked' literal operator, which\n /// expects a normal literal to be built and passed to it.\n LOLR_Cooked,\n /// The lookup found a single 'raw' literal operator, which expects\n /// a string literal containing the spelling of the literal token.\n LOLR_Raw,\n /// The lookup found an overload set of literal operator templates,\n /// which expect the characters of the spelling of the literal token to be\n /// passed as a non-type template argument pack.\n LOLR_Template,\n /// The lookup found an overload set of literal operator templates,\n /// which expect the character type and characters of the spelling of the\n /// string literal token to be passed as template arguments.\n LOLR_StringTemplatePack,\n };\n\n SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,\n CXXSpecialMember SM,\n bool ConstArg,\n bool VolatileArg,\n bool RValueThis,\n bool ConstThis,\n bool VolatileThis);\n\n typedef std::function TypoDiagnosticGenerator;\n typedef std::function\n TypoRecoveryCallback;\n\nprivate:\n bool CppLookupName(LookupResult &R, Scope *S);\n\n struct TypoExprState {\n std::unique_ptr Consumer;\n TypoDiagnosticGenerator DiagHandler;\n TypoRecoveryCallback RecoveryHandler;\n TypoExprState();\n TypoExprState(TypoExprState &&other) noexcept;\n TypoExprState &operator=(TypoExprState &&other) noexcept;\n };\n\n /// The set of unhandled TypoExprs and their associated state.\n llvm::MapVector DelayedTypos;\n\n /// Creates a new TypoExpr AST node.\n TypoExpr *createDelayedTypo(std::unique_ptr TCC,\n TypoDiagnosticGenerator TDG,\n TypoRecoveryCallback TRC, SourceLocation TypoLoc);\n\n // The set of known/encountered (unique, canonicalized) NamespaceDecls.\n //\n // The boolean value will be true to indicate that the namespace was loaded\n // from an AST/PCH file, or false otherwise.\n llvm::MapVector KnownNamespaces;\n\n /// Whether we have already loaded known namespaces from an extenal\n /// source.\n bool LoadedExternalKnownNamespaces;\n\n /// Helper for CorrectTypo and CorrectTypoDelayed used to create and\n /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction\n /// should be skipped entirely.\n std::unique_ptr\n makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,\n Sema::LookupNameKind LookupKind, Scope *S,\n CXXScopeSpec *SS,\n CorrectionCandidateCallback &CCC,\n DeclContext *MemberContext, bool EnteringContext,\n const ObjCObjectPointerType *OPT,\n bool ErrorRecovery);\n\npublic:\n const TypoExprState &getTypoExprState(TypoExpr *TE) const;\n\n /// Clears the state of the given TypoExpr.\n void clearDelayedTypo(TypoExpr *TE);\n\n /// Look up a name, looking for a single declaration. Return\n /// null if the results were absent, ambiguous, or overloaded.\n ///\n /// It is preferable to use the elaborated form and explicitly handle\n /// ambiguity and overloaded.\n NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,\n SourceLocation Loc,\n LookupNameKind NameKind,\n RedeclarationKind Redecl\n = NotForRedeclaration);\n bool LookupBuiltin(LookupResult &R);\n void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID);\n bool LookupName(LookupResult &R, Scope *S,\n bool AllowBuiltinCreation = false);\n bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,\n bool InUnqualifiedLookup = false);\n bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,\n CXXScopeSpec &SS);\n bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,\n bool AllowBuiltinCreation = false,\n bool EnteringContext = false);\n ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,\n RedeclarationKind Redecl\n = NotForRedeclaration);\n bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);\n\n void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,\n UnresolvedSetImpl &Functions);\n\n LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,\n SourceLocation GnuLabelLoc = SourceLocation());\n\n DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);\n CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);\n CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,\n unsigned Quals);\n CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,\n bool RValueThis, unsigned ThisQuals);\n CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,\n unsigned Quals);\n CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,\n bool RValueThis, unsigned ThisQuals);\n CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);\n\n bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id);\n LiteralOperatorLookupResult\n LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef ArgTys,\n bool AllowRaw, bool AllowTemplate,\n bool AllowStringTemplate, bool DiagnoseMissing,\n StringLiteral *StringLit = nullptr);\n bool isKnownName(StringRef name);\n\n /// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.\n enum class FunctionEmissionStatus {\n Emitted,\n CUDADiscarded, // Discarded due to CUDA/HIP hostness\n OMPDiscarded, // Discarded due to OpenMP hostness\n TemplateDiscarded, // Discarded due to uninstantiated templates\n Unknown,\n };\n FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl,\n bool Final = false);\n\n // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check.\n bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee);\n\n void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,\n ArrayRef Args, ADLResult &Functions);\n\n void LookupVisibleDecls(Scope *S, LookupNameKind Kind,\n VisibleDeclConsumer &Consumer,\n bool IncludeGlobalScope = true,\n bool LoadExternal = true);\n void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,\n VisibleDeclConsumer &Consumer,\n bool IncludeGlobalScope = true,\n bool IncludeDependentBases = false,\n bool LoadExternal = true);\n\n enum CorrectTypoKind {\n CTK_NonError, // CorrectTypo used in a non error recovery situation.\n CTK_ErrorRecovery // CorrectTypo used in normal error recovery.\n };\n\n TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,\n Sema::LookupNameKind LookupKind,\n Scope *S, CXXScopeSpec *SS,\n CorrectionCandidateCallback &CCC,\n CorrectTypoKind Mode,\n DeclContext *MemberContext = nullptr,\n bool EnteringContext = false,\n const ObjCObjectPointerType *OPT = nullptr,\n bool RecordFailure = true);\n\n TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo,\n Sema::LookupNameKind LookupKind, Scope *S,\n CXXScopeSpec *SS,\n CorrectionCandidateCallback &CCC,\n TypoDiagnosticGenerator TDG,\n TypoRecoveryCallback TRC, CorrectTypoKind Mode,\n DeclContext *MemberContext = nullptr,\n bool EnteringContext = false,\n const ObjCObjectPointerType *OPT = nullptr);\n\n /// Process any TypoExprs in the given Expr and its children,\n /// generating diagnostics as appropriate and returning a new Expr if there\n /// were typos that were all successfully corrected and ExprError if one or\n /// more typos could not be corrected.\n ///\n /// \\param E The Expr to check for TypoExprs.\n ///\n /// \\param InitDecl A VarDecl to avoid because the Expr being corrected is its\n /// initializer.\n ///\n /// \\param RecoverUncorrectedTypos If true, when typo correction fails, it\n /// will rebuild the given Expr with all TypoExprs degraded to RecoveryExprs.\n ///\n /// \\param Filter A function applied to a newly rebuilt Expr to determine if\n /// it is an acceptable/usable result from a single combination of typo\n /// corrections. As long as the filter returns ExprError, different\n /// combinations of corrections will be tried until all are exhausted.\n ExprResult CorrectDelayedTyposInExpr(\n Expr *E, VarDecl *InitDecl = nullptr,\n bool RecoverUncorrectedTypos = false,\n llvm::function_ref Filter =\n [](Expr *E) -> ExprResult { return E; });\n\n ExprResult CorrectDelayedTyposInExpr(\n ExprResult ER, VarDecl *InitDecl = nullptr,\n bool RecoverUncorrectedTypos = false,\n llvm::function_ref Filter =\n [](Expr *E) -> ExprResult { return E; }) {\n return ER.isInvalid()\n ? ER\n : CorrectDelayedTyposInExpr(ER.get(), InitDecl,\n RecoverUncorrectedTypos, Filter);\n }\n\n void diagnoseTypo(const TypoCorrection &Correction,\n const PartialDiagnostic &TypoDiag,\n bool ErrorRecovery = true);\n\n void diagnoseTypo(const TypoCorrection &Correction,\n const PartialDiagnostic &TypoDiag,\n const PartialDiagnostic &PrevNote,\n bool ErrorRecovery = true);\n\n void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);\n\n void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,\n ArrayRef Args,\n AssociatedNamespaceSet &AssociatedNamespaces,\n AssociatedClassSet &AssociatedClasses);\n\n void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,\n bool ConsiderLinkage, bool AllowInlineNamespace);\n\n bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old);\n\n void DiagnoseAmbiguousLookup(LookupResult &Result);\n //@}\n\n /// Attempts to produce a RecoveryExpr after some AST node cannot be created.\n ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,\n ArrayRef SubExprs,\n QualType T = QualType());\n\n ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,\n SourceLocation IdLoc,\n bool TypoCorrection = false);\n FunctionDecl *CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID,\n SourceLocation Loc);\n NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,\n Scope *S, bool ForRedeclaration,\n SourceLocation Loc);\n NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,\n Scope *S);\n void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(\n FunctionDecl *FD);\n void AddKnownFunctionAttributes(FunctionDecl *FD);\n\n // More parsing and symbol table subroutines.\n\n void ProcessPragmaWeak(Scope *S, Decl *D);\n // Decl attributes - this routine is the top level dispatcher.\n void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);\n // Helper for delayed processing of attributes.\n void ProcessDeclAttributeDelayed(Decl *D,\n const ParsedAttributesView &AttrList);\n void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,\n bool IncludeCXX11Attributes = true);\n bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,\n const ParsedAttributesView &AttrList);\n\n void checkUnusedDeclAttributes(Declarator &D);\n\n /// Determine if type T is a valid subject for a nonnull and similar\n /// attributes. By default, we look through references (the behavior used by\n /// nonnull), but if the second parameter is true, then we treat a reference\n /// type as valid.\n bool isValidPointerAttrType(QualType T, bool RefOkay = false);\n\n bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value);\n bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC,\n const FunctionDecl *FD = nullptr);\n bool CheckAttrTarget(const ParsedAttr &CurrAttr);\n bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);\n bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum,\n StringRef &Str,\n SourceLocation *ArgLocation = nullptr);\n bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);\n bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);\n bool checkMSInheritanceAttrOnDefinition(\n CXXRecordDecl *RD, SourceRange Range, bool BestCase,\n MSInheritanceModel SemanticSpelling);\n\n void CheckAlignasUnderalignment(Decl *D);\n\n /// Adjust the calling convention of a method to be the ABI default if it\n /// wasn't specified explicitly. This handles method types formed from\n /// function type typedefs and typename template arguments.\n void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,\n SourceLocation Loc);\n\n // Check if there is an explicit attribute, but only look through parens.\n // The intent is to look for an attribute on the current declarator, but not\n // one that came from a typedef.\n bool hasExplicitCallingConv(QualType T);\n\n /// Get the outermost AttributedType node that sets a calling convention.\n /// Valid types should not have multiple attributes with different CCs.\n const AttributedType *getCallingConvAttributedType(QualType T) const;\n\n /// Stmt attributes - this routine is the top level dispatcher.\n StmtResult ProcessStmtAttributes(Stmt *Stmt,\n const ParsedAttributesView &Attrs,\n SourceRange Range);\n\n void WarnConflictingTypedMethods(ObjCMethodDecl *Method,\n ObjCMethodDecl *MethodDecl,\n bool IsProtocolMethodDecl);\n\n void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,\n ObjCMethodDecl *Overridden,\n bool IsProtocolMethodDecl);\n\n /// WarnExactTypedMethods - This routine issues a warning if method\n /// implementation declaration matches exactly that of its declaration.\n void WarnExactTypedMethods(ObjCMethodDecl *Method,\n ObjCMethodDecl *MethodDecl,\n bool IsProtocolMethodDecl);\n\n typedef llvm::SmallPtrSet SelectorSet;\n\n /// CheckImplementationIvars - This routine checks if the instance variables\n /// listed in the implelementation match those listed in the interface.\n void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,\n ObjCIvarDecl **Fields, unsigned nIvars,\n SourceLocation Loc);\n\n /// ImplMethodsVsClassMethods - This is main routine to warn if any method\n /// remains unimplemented in the class or category \\@implementation.\n void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,\n ObjCContainerDecl* IDecl,\n bool IncompleteImpl = false);\n\n /// DiagnoseUnimplementedProperties - This routine warns on those properties\n /// which must be implemented by this implementation.\n void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,\n ObjCContainerDecl *CDecl,\n bool SynthesizeProperties);\n\n /// Diagnose any null-resettable synthesized setters.\n void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl);\n\n /// DefaultSynthesizeProperties - This routine default synthesizes all\n /// properties which must be synthesized in the class's \\@implementation.\n void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl,\n ObjCInterfaceDecl *IDecl,\n SourceLocation AtEnd);\n void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd);\n\n /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is\n /// an ivar synthesized for 'Method' and 'Method' is a property accessor\n /// declared in class 'IFace'.\n bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,\n ObjCMethodDecl *Method, ObjCIvarDecl *IV);\n\n /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which\n /// backs the property is not used in the property's accessor.\n void DiagnoseUnusedBackingIvarInAccessor(Scope *S,\n const ObjCImplementationDecl *ImplD);\n\n /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and\n /// it property has a backing ivar, returns this ivar; otherwise, returns NULL.\n /// It also returns ivar's property on success.\n ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,\n const ObjCPropertyDecl *&PDecl) const;\n\n /// Called by ActOnProperty to handle \\@property declarations in\n /// class extensions.\n ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S,\n SourceLocation AtLoc,\n SourceLocation LParenLoc,\n FieldDeclarator &FD,\n Selector GetterSel,\n SourceLocation GetterNameLoc,\n Selector SetterSel,\n SourceLocation SetterNameLoc,\n const bool isReadWrite,\n unsigned &Attributes,\n const unsigned AttributesAsWritten,\n QualType T,\n TypeSourceInfo *TSI,\n tok::ObjCKeywordKind MethodImplKind);\n\n /// Called by ActOnProperty and HandlePropertyInClassExtension to\n /// handle creating the ObjcPropertyDecl for a category or \\@interface.\n ObjCPropertyDecl *CreatePropertyDecl(Scope *S,\n ObjCContainerDecl *CDecl,\n SourceLocation AtLoc,\n SourceLocation LParenLoc,\n FieldDeclarator &FD,\n Selector GetterSel,\n SourceLocation GetterNameLoc,\n Selector SetterSel,\n SourceLocation SetterNameLoc,\n const bool isReadWrite,\n const unsigned Attributes,\n const unsigned AttributesAsWritten,\n QualType T,\n TypeSourceInfo *TSI,\n tok::ObjCKeywordKind MethodImplKind,\n DeclContext *lexicalDC = nullptr);\n\n /// AtomicPropertySetterGetterRules - This routine enforces the rule (via\n /// warning) when atomic property has one but not the other user-declared\n /// setter or getter.\n void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,\n ObjCInterfaceDecl* IDecl);\n\n void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);\n\n void DiagnoseMissingDesignatedInitOverrides(\n const ObjCImplementationDecl *ImplD,\n const ObjCInterfaceDecl *IFD);\n\n void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID);\n\n enum MethodMatchStrategy {\n MMS_loose,\n MMS_strict\n };\n\n /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns\n /// true, or false, accordingly.\n bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,\n const ObjCMethodDecl *PrevMethod,\n MethodMatchStrategy strategy = MMS_strict);\n\n /// MatchAllMethodDeclarations - Check methods declaraed in interface or\n /// or protocol against those declared in their implementations.\n void MatchAllMethodDeclarations(const SelectorSet &InsMap,\n const SelectorSet &ClsMap,\n SelectorSet &InsMapSeen,\n SelectorSet &ClsMapSeen,\n ObjCImplDecl* IMPDecl,\n ObjCContainerDecl* IDecl,\n bool &IncompleteImpl,\n bool ImmediateClass,\n bool WarnCategoryMethodImpl=false);\n\n /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in\n /// category matches with those implemented in its primary class and\n /// warns each time an exact match is found.\n void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);\n\n /// Add the given method to the list of globally-known methods.\n void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method);\n\n /// Returns default addr space for method qualifiers.\n LangAS getDefaultCXXMethodAddrSpace() const;\n\nprivate:\n /// AddMethodToGlobalPool - Add an instance or factory method to the global\n /// pool. See descriptoin of AddInstanceMethodToGlobalPool.\n void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance);\n\n /// LookupMethodInGlobalPool - Returns the instance or factory method and\n /// optionally warns if there are multiple signatures.\n ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,\n bool receiverIdOrClass,\n bool instance);\n\npublic:\n /// - Returns instance or factory methods in global method pool for\n /// given selector. It checks the desired kind first, if none is found, and\n /// parameter checkTheOther is set, it then checks the other kind. If no such\n /// method or only one method is found, function returns false; otherwise, it\n /// returns true.\n bool\n CollectMultipleMethodsInGlobalPool(Selector Sel,\n SmallVectorImpl& Methods,\n bool InstanceFirst, bool CheckTheOther,\n const ObjCObjectType *TypeBound = nullptr);\n\n bool\n AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod,\n SourceRange R, bool receiverIdOrClass,\n SmallVectorImpl& Methods);\n\n void\n DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl &Methods,\n Selector Sel, SourceRange R,\n bool receiverIdOrClass);\n\nprivate:\n /// - Returns a selector which best matches given argument list or\n /// nullptr if none could be found\n ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args,\n bool IsInstance,\n SmallVectorImpl& Methods);\n\n\n /// Record the typo correction failure and return an empty correction.\n TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc,\n bool RecordFailure = true) {\n if (RecordFailure)\n TypoCorrectionFailures[Typo].insert(TypoLoc);\n return TypoCorrection();\n }\n\npublic:\n /// AddInstanceMethodToGlobalPool - All instance methods in a translation\n /// unit are added to a global pool. This allows us to efficiently associate\n /// a selector with a method declaraation for purposes of typechecking\n /// messages sent to \"id\" (where the class of the object is unknown).\n void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {\n AddMethodToGlobalPool(Method, impl, /*instance*/true);\n }\n\n /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.\n void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {\n AddMethodToGlobalPool(Method, impl, /*instance*/false);\n }\n\n /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global\n /// pool.\n void AddAnyMethodToGlobalPool(Decl *D);\n\n /// LookupInstanceMethodInGlobalPool - Returns the method and warns if\n /// there are multiple signatures.\n ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,\n bool receiverIdOrClass=false) {\n return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,\n /*instance*/true);\n }\n\n /// LookupFactoryMethodInGlobalPool - Returns the method and warns if\n /// there are multiple signatures.\n ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R,\n bool receiverIdOrClass=false) {\n return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,\n /*instance*/false);\n }\n\n const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel,\n QualType ObjectType=QualType());\n /// LookupImplementedMethodInGlobalPool - Returns the method which has an\n /// implementation.\n ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);\n\n /// CollectIvarsToConstructOrDestruct - Collect those ivars which require\n /// initialization.\n void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,\n SmallVectorImpl &Ivars);\n\n //===--------------------------------------------------------------------===//\n // Statement Parsing Callbacks: SemaStmt.cpp.\npublic:\n class FullExprArg {\n public:\n FullExprArg() : E(nullptr) { }\n FullExprArg(Sema &actions) : E(nullptr) { }\n\n ExprResult release() {\n return E;\n }\n\n Expr *get() const { return E; }\n\n Expr *operator->() {\n return E;\n }\n\n private:\n // FIXME: No need to make the entire Sema class a friend when it's just\n // Sema::MakeFullExpr that needs access to the constructor below.\n friend class Sema;\n\n explicit FullExprArg(Expr *expr) : E(expr) {}\n\n Expr *E;\n };\n\n FullExprArg MakeFullExpr(Expr *Arg) {\n return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation());\n }\n FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {\n return FullExprArg(\n ActOnFinishFullExpr(Arg, CC, /*DiscardedValue*/ false).get());\n }\n FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) {\n ExprResult FE =\n ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(),\n /*DiscardedValue*/ true);\n return FullExprArg(FE.get());\n }\n\n StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue = true);\n StmtResult ActOnExprStmtError();\n\n StmtResult ActOnNullStmt(SourceLocation SemiLoc,\n bool HasLeadingEmptyMacro = false);\n\n void ActOnStartOfCompoundStmt(bool IsStmtExpr);\n void ActOnAfterCompoundStatementLeadingPragmas();\n void ActOnFinishOfCompoundStmt();\n StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,\n ArrayRef Elts, bool isStmtExpr);\n\n /// A RAII object to enter scope of a compound statement.\n class CompoundScopeRAII {\n public:\n CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) {\n S.ActOnStartOfCompoundStmt(IsStmtExpr);\n }\n\n ~CompoundScopeRAII() {\n S.ActOnFinishOfCompoundStmt();\n }\n\n private:\n Sema &S;\n };\n\n /// An RAII helper that pops function a function scope on exit.\n struct FunctionScopeRAII {\n Sema &S;\n bool Active;\n FunctionScopeRAII(Sema &S) : S(S), Active(true) {}\n ~FunctionScopeRAII() {\n if (Active)\n S.PopFunctionScopeInfo();\n }\n void disable() { Active = false; }\n };\n\n StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,\n SourceLocation StartLoc,\n SourceLocation EndLoc);\n void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);\n StmtResult ActOnForEachLValueExpr(Expr *E);\n ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val);\n StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS,\n SourceLocation DotDotDotLoc, ExprResult RHS,\n SourceLocation ColonLoc);\n void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);\n\n StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,\n SourceLocation ColonLoc,\n Stmt *SubStmt, Scope *CurScope);\n StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,\n SourceLocation ColonLoc, Stmt *SubStmt);\n\n StmtResult ActOnAttributedStmt(SourceLocation AttrLoc,\n ArrayRef Attrs,\n Stmt *SubStmt);\n\n class ConditionResult;\n StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,\n SourceLocation LParenLoc, Stmt *InitStmt,\n ConditionResult Cond, SourceLocation RParenLoc,\n Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);\n StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,\n SourceLocation LParenLoc, Stmt *InitStmt,\n ConditionResult Cond, SourceLocation RParenLoc,\n Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);\n StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,\n SourceLocation LParenLoc, Stmt *InitStmt,\n ConditionResult Cond,\n SourceLocation RParenLoc);\n StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,\n Stmt *Switch, Stmt *Body);\n StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,\n ConditionResult Cond, SourceLocation RParenLoc,\n Stmt *Body);\n StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,\n SourceLocation WhileLoc, SourceLocation CondLParen,\n Expr *Cond, SourceLocation CondRParen);\n\n StmtResult ActOnForStmt(SourceLocation ForLoc,\n SourceLocation LParenLoc,\n Stmt *First,\n ConditionResult Second,\n FullExprArg Third,\n SourceLocation RParenLoc,\n Stmt *Body);\n ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,\n Expr *collection);\n StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,\n Stmt *First, Expr *collection,\n SourceLocation RParenLoc);\n StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);\n\n enum BuildForRangeKind {\n /// Initial building of a for-range statement.\n BFRK_Build,\n /// Instantiation or recovery rebuild of a for-range statement. Don't\n /// attempt any typo-correction.\n BFRK_Rebuild,\n /// Determining whether a for-range statement could be built. Avoid any\n /// unnecessary or irreversible actions.\n BFRK_Check\n };\n\n StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,\n SourceLocation CoawaitLoc,\n Stmt *InitStmt,\n Stmt *LoopVar,\n SourceLocation ColonLoc, Expr *Collection,\n SourceLocation RParenLoc,\n BuildForRangeKind Kind);\n StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,\n SourceLocation CoawaitLoc,\n Stmt *InitStmt,\n SourceLocation ColonLoc,\n Stmt *RangeDecl, Stmt *Begin, Stmt *End,\n Expr *Cond, Expr *Inc,\n Stmt *LoopVarDecl,\n SourceLocation RParenLoc,\n BuildForRangeKind Kind);\n StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);\n\n StmtResult ActOnGotoStmt(SourceLocation GotoLoc,\n SourceLocation LabelLoc,\n LabelDecl *TheDecl);\n StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,\n SourceLocation StarLoc,\n Expr *DestExp);\n StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);\n StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);\n\n void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,\n CapturedRegionKind Kind, unsigned NumParams);\n typedef std::pair CapturedParamNameType;\n void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,\n CapturedRegionKind Kind,\n ArrayRef Params,\n unsigned OpenMPCaptureLevel = 0);\n StmtResult ActOnCapturedRegionEnd(Stmt *S);\n void ActOnCapturedRegionError();\n RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,\n SourceLocation Loc,\n unsigned NumParams);\n\n enum CopyElisionSemanticsKind {\n CES_Strict = 0,\n CES_AllowParameters = 1,\n CES_AllowDifferentTypes = 2,\n CES_AllowExceptionVariables = 4,\n CES_AllowRValueReferenceType = 8,\n CES_ImplicitlyMovableCXX11CXX14CXX17 =\n (CES_AllowParameters | CES_AllowDifferentTypes),\n CES_ImplicitlyMovableCXX20 =\n (CES_AllowParameters | CES_AllowDifferentTypes |\n CES_AllowExceptionVariables | CES_AllowRValueReferenceType),\n };\n\n VarDecl *getCopyElisionCandidate(QualType ReturnType, Expr *E,\n CopyElisionSemanticsKind CESK);\n bool isCopyElisionCandidate(QualType ReturnType, const VarDecl *VD,\n CopyElisionSemanticsKind CESK);\n\n StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,\n Scope *CurScope);\n StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);\n StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);\n\n StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,\n bool IsVolatile, unsigned NumOutputs,\n unsigned NumInputs, IdentifierInfo **Names,\n MultiExprArg Constraints, MultiExprArg Exprs,\n Expr *AsmString, MultiExprArg Clobbers,\n unsigned NumLabels,\n SourceLocation RParenLoc);\n\n void FillInlineAsmIdentifierInfo(Expr *Res,\n llvm::InlineAsmIdentifierInfo &Info);\n ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n UnqualifiedId &Id,\n bool IsUnevaluatedContext);\n bool LookupInlineAsmField(StringRef Base, StringRef Member,\n unsigned &Offset, SourceLocation AsmLoc);\n ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,\n SourceLocation AsmLoc);\n StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,\n ArrayRef AsmToks,\n StringRef AsmString,\n unsigned NumOutputs, unsigned NumInputs,\n ArrayRef Constraints,\n ArrayRef Clobbers,\n ArrayRef Exprs,\n SourceLocation EndLoc);\n LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,\n SourceLocation Location,\n bool AlwaysCreate);\n\n VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,\n SourceLocation StartLoc,\n SourceLocation IdLoc, IdentifierInfo *Id,\n bool Invalid = false);\n\n Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);\n\n StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,\n Decl *Parm, Stmt *Body);\n\n StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);\n\n StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,\n MultiStmtArg Catch, Stmt *Finally);\n\n StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);\n StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,\n Scope *CurScope);\n ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,\n Expr *operand);\n StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,\n Expr *SynchExpr,\n Stmt *SynchBody);\n\n StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);\n\n VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,\n SourceLocation StartLoc,\n SourceLocation IdLoc,\n IdentifierInfo *Id);\n\n Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);\n\n StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,\n Decl *ExDecl, Stmt *HandlerBlock);\n StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,\n ArrayRef Handlers);\n\n StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?\n SourceLocation TryLoc, Stmt *TryBlock,\n Stmt *Handler);\n StmtResult ActOnSEHExceptBlock(SourceLocation Loc,\n Expr *FilterExpr,\n Stmt *Block);\n void ActOnStartSEHFinallyBlock();\n void ActOnAbortSEHFinallyBlock();\n StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);\n StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);\n\n void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);\n\n bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;\n\n /// If it's a file scoped decl that must warn if not used, keep track\n /// of it.\n void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);\n\n /// DiagnoseUnusedExprResult - If the statement passed in is an expression\n /// whose result is unused, warn.\n void DiagnoseUnusedExprResult(const Stmt *S);\n void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);\n void DiagnoseUnusedDecl(const NamedDecl *ND);\n\n /// Emit \\p DiagID if statement located on \\p StmtLoc has a suspicious null\n /// statement as a \\p Body, and it is located on the same line.\n ///\n /// This helps prevent bugs due to typos, such as:\n /// if (condition);\n /// do_stuff();\n void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,\n const Stmt *Body,\n unsigned DiagID);\n\n /// Warn if a for/while loop statement \\p S, which is followed by\n /// \\p PossibleBody, has a suspicious null statement as a body.\n void DiagnoseEmptyLoopBody(const Stmt *S,\n const Stmt *PossibleBody);\n\n /// Warn if a value is moved to itself.\n void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,\n SourceLocation OpLoc);\n\n /// Warn if we're implicitly casting from a _Nullable pointer type to a\n /// _Nonnull one.\n void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,\n SourceLocation Loc);\n\n /// Warn when implicitly casting 0 to nullptr.\n void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);\n\n ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {\n return DelayedDiagnostics.push(pool);\n }\n void PopParsingDeclaration(ParsingDeclState state, Decl *decl);\n\n typedef ProcessingContextState ParsingClassState;\n ParsingClassState PushParsingClass() {\n ParsingClassDepth++;\n return DelayedDiagnostics.pushUndelayed();\n }\n void PopParsingClass(ParsingClassState state) {\n ParsingClassDepth--;\n DelayedDiagnostics.popUndelayed(state);\n }\n\n void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);\n\n void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef Locs,\n const ObjCInterfaceDecl *UnknownObjCClass,\n bool ObjCPropertyAccess,\n bool AvoidPartialAvailabilityChecks = false,\n ObjCInterfaceDecl *ClassReceiver = nullptr);\n\n bool makeUnavailableInSystemHeader(SourceLocation loc,\n UnavailableAttr::ImplicitReason reason);\n\n /// Issue any -Wunguarded-availability warnings in \\c FD\n void DiagnoseUnguardedAvailabilityViolations(Decl *FD);\n\n void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);\n\n //===--------------------------------------------------------------------===//\n // Expression Parsing Callbacks: SemaExpr.cpp.\n\n bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);\n bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef Locs,\n const ObjCInterfaceDecl *UnknownObjCClass = nullptr,\n bool ObjCPropertyAccess = false,\n bool AvoidPartialAvailabilityChecks = false,\n ObjCInterfaceDecl *ClassReciever = nullptr);\n void NoteDeletedFunction(FunctionDecl *FD);\n void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);\n bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,\n ObjCMethodDecl *Getter,\n SourceLocation Loc);\n void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,\n ArrayRef Args);\n\n void PushExpressionEvaluationContext(\n ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl = nullptr,\n ExpressionEvaluationContextRecord::ExpressionKind Type =\n ExpressionEvaluationContextRecord::EK_Other);\n enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };\n void PushExpressionEvaluationContext(\n ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,\n ExpressionEvaluationContextRecord::ExpressionKind Type =\n ExpressionEvaluationContextRecord::EK_Other);\n void PopExpressionEvaluationContext();\n\n void DiscardCleanupsInEvaluationContext();\n\n ExprResult TransformToPotentiallyEvaluated(Expr *E);\n ExprResult HandleExprEvaluationContextForTypeof(Expr *E);\n\n ExprResult CheckUnevaluatedOperand(Expr *E);\n void CheckUnusedVolatileAssignment(Expr *E);\n\n ExprResult ActOnConstantExpression(ExprResult Res);\n\n // Functions for marking a declaration referenced. These functions also\n // contain the relevant logic for marking if a reference to a function or\n // variable is an odr-use (in the C++11 sense). There are separate variants\n // for expressions referring to a decl; these exist because odr-use marking\n // needs to be delayed for some constant variables when we build one of the\n // named expressions.\n //\n // MightBeOdrUse indicates whether the use could possibly be an odr-use, and\n // should usually be true. This only needs to be set to false if the lack of\n // odr-use cannot be determined from the current context (for instance,\n // because the name denotes a virtual function and was written without an\n // explicit nested-name-specifier).\n void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);\n void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,\n bool MightBeOdrUse = true);\n void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);\n void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);\n void MarkMemberReferenced(MemberExpr *E);\n void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E);\n void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc,\n unsigned CapturingScopeIndex);\n\n ExprResult CheckLValueToRValueConversionOperand(Expr *E);\n void CleanupVarDeclMarking();\n\n enum TryCaptureKind {\n TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef\n };\n\n /// Try to capture the given variable.\n ///\n /// \\param Var The variable to capture.\n ///\n /// \\param Loc The location at which the capture occurs.\n ///\n /// \\param Kind The kind of capture, which may be implicit (for either a\n /// block or a lambda), or explicit by-value or by-reference (for a lambda).\n ///\n /// \\param EllipsisLoc The location of the ellipsis, if one is provided in\n /// an explicit lambda capture.\n ///\n /// \\param BuildAndDiagnose Whether we are actually supposed to add the\n /// captures or diagnose errors. If false, this routine merely check whether\n /// the capture can occur without performing the capture itself or complaining\n /// if the variable cannot be captured.\n ///\n /// \\param CaptureType Will be set to the type of the field used to capture\n /// this variable in the innermost block or lambda. Only valid when the\n /// variable can be captured.\n ///\n /// \\param DeclRefType Will be set to the type of a reference to the capture\n /// from within the current scope. Only valid when the variable can be\n /// captured.\n ///\n /// \\param FunctionScopeIndexToStopAt If non-null, it points to the index\n /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.\n /// This is useful when enclosing lambdas must speculatively capture\n /// variables that may or may not be used in certain specializations of\n /// a nested generic lambda.\n ///\n /// \\returns true if an error occurred (i.e., the variable cannot be\n /// captured) and false if the capture succeeded.\n bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,\n SourceLocation EllipsisLoc, bool BuildAndDiagnose,\n QualType &CaptureType,\n QualType &DeclRefType,\n const unsigned *const FunctionScopeIndexToStopAt);\n\n /// Try to capture the given variable.\n bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,\n TryCaptureKind Kind = TryCapture_Implicit,\n SourceLocation EllipsisLoc = SourceLocation());\n\n /// Checks if the variable must be captured.\n bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);\n\n /// Given a variable, determine the type that a reference to that\n /// variable will have in the given scope.\n QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);\n\n /// Mark all of the declarations referenced within a particular AST node as\n /// referenced. Used when template instantiation instantiates a non-dependent\n /// type -- entities referenced by the type are now referenced.\n void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);\n void MarkDeclarationsReferencedInExpr(Expr *E,\n bool SkipLocalVariables = false);\n\n /// Try to recover by turning the given expression into a\n /// call. Returns true if recovery was attempted or an error was\n /// emitted; this may also leave the ExprResult invalid.\n bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,\n bool ForceComplain = false,\n bool (*IsPlausibleResult)(QualType) = nullptr);\n\n /// Figure out if an expression could be turned into a call.\n bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,\n UnresolvedSetImpl &NonTemplateOverloads);\n\n /// Try to convert an expression \\p E to type \\p Ty. Returns the result of the\n /// conversion.\n ExprResult tryConvertExprToType(Expr *E, QualType Ty);\n\n /// Conditionally issue a diagnostic based on the current\n /// evaluation context.\n ///\n /// \\param Statement If Statement is non-null, delay reporting the\n /// diagnostic until the function body is parsed, and then do a basic\n /// reachability analysis to determine if the statement is reachable.\n /// If it is unreachable, the diagnostic will not be emitted.\n bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,\n const PartialDiagnostic &PD);\n /// Similar, but diagnostic is only produced if all the specified statements\n /// are reachable.\n bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef Stmts,\n const PartialDiagnostic &PD);\n\n // Primary Expressions.\n SourceRange getExprRange(Expr *E) const;\n\n ExprResult ActOnIdExpression(\n Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,\n UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,\n CorrectionCandidateCallback *CCC = nullptr,\n bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr);\n\n void DecomposeUnqualifiedId(const UnqualifiedId &Id,\n TemplateArgumentListInfo &Buffer,\n DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *&TemplateArgs);\n\n bool DiagnoseDependentMemberLookup(LookupResult &R);\n\n bool\n DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,\n CorrectionCandidateCallback &CCC,\n TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,\n ArrayRef Args = None, TypoExpr **Out = nullptr);\n\n DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S,\n IdentifierInfo *II);\n ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV);\n\n ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,\n IdentifierInfo *II,\n bool AllowBuiltinCreation=false);\n\n ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n const DeclarationNameInfo &NameInfo,\n bool isAddressOfOperand,\n const TemplateArgumentListInfo *TemplateArgs);\n\n /// If \\p D cannot be odr-used in the current expression evaluation context,\n /// return a reason explaining why. Otherwise, return NOUR_None.\n NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D);\n\n DeclRefExpr *BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,\n SourceLocation Loc,\n const CXXScopeSpec *SS = nullptr);\n DeclRefExpr *\n BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,\n const DeclarationNameInfo &NameInfo,\n const CXXScopeSpec *SS = nullptr,\n NamedDecl *FoundD = nullptr,\n SourceLocation TemplateKWLoc = SourceLocation(),\n const TemplateArgumentListInfo *TemplateArgs = nullptr);\n DeclRefExpr *\n BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,\n const DeclarationNameInfo &NameInfo,\n NestedNameSpecifierLoc NNS,\n NamedDecl *FoundD = nullptr,\n SourceLocation TemplateKWLoc = SourceLocation(),\n const TemplateArgumentListInfo *TemplateArgs = nullptr);\n\n ExprResult\n BuildAnonymousStructUnionMemberReference(\n const CXXScopeSpec &SS,\n SourceLocation nameLoc,\n IndirectFieldDecl *indirectField,\n DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),\n Expr *baseObjectExpr = nullptr,\n SourceLocation opLoc = SourceLocation());\n\n ExprResult BuildPossibleImplicitMemberExpr(\n const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,\n const TemplateArgumentListInfo *TemplateArgs, const Scope *S,\n UnresolvedLookupExpr *AsULE = nullptr);\n ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n LookupResult &R,\n const TemplateArgumentListInfo *TemplateArgs,\n bool IsDefiniteInstance,\n const Scope *S);\n bool UseArgumentDependentLookup(const CXXScopeSpec &SS,\n const LookupResult &R,\n bool HasTrailingLParen);\n\n ExprResult\n BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,\n const DeclarationNameInfo &NameInfo,\n bool IsAddressOfOperand, const Scope *S,\n TypeSourceInfo **RecoveryTSI = nullptr);\n\n ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n const DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *TemplateArgs);\n\n ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,\n LookupResult &R,\n bool NeedsADL,\n bool AcceptInvalidDecl = false);\n ExprResult BuildDeclarationNameExpr(\n const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,\n NamedDecl *FoundD = nullptr,\n const TemplateArgumentListInfo *TemplateArgs = nullptr,\n bool AcceptInvalidDecl = false);\n\n ExprResult BuildLiteralOperatorCall(LookupResult &R,\n DeclarationNameInfo &SuffixInfo,\n ArrayRef Args,\n SourceLocation LitEndLoc,\n TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);\n\n ExprResult BuildPredefinedExpr(SourceLocation Loc,\n PredefinedExpr::IdentKind IK);\n ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);\n ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);\n\n bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);\n\n ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);\n ExprResult ActOnCharacterConstant(const Token &Tok,\n Scope *UDLScope = nullptr);\n ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);\n ExprResult ActOnParenListExpr(SourceLocation L,\n SourceLocation R,\n MultiExprArg Val);\n\n /// ActOnStringLiteral - The specified tokens were lexed as pasted string\n /// fragments (e.g. \"foo\" \"bar\" L\"baz\").\n ExprResult ActOnStringLiteral(ArrayRef StringToks,\n Scope *UDLScope = nullptr);\n\n ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,\n SourceLocation DefaultLoc,\n SourceLocation RParenLoc,\n Expr *ControllingExpr,\n ArrayRef ArgTypes,\n ArrayRef ArgExprs);\n ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,\n SourceLocation DefaultLoc,\n SourceLocation RParenLoc,\n Expr *ControllingExpr,\n ArrayRef Types,\n ArrayRef Exprs);\n\n // Binary/Unary Operators. 'Tok' is the token for the operator.\n ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,\n Expr *InputExpr);\n ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,\n UnaryOperatorKind Opc, Expr *Input);\n ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,\n tok::TokenKind Op, Expr *Input);\n\n bool isQualifiedMemberAccess(Expr *E);\n QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);\n\n ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,\n SourceLocation OpLoc,\n UnaryExprOrTypeTrait ExprKind,\n SourceRange R);\n ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,\n UnaryExprOrTypeTrait ExprKind);\n ExprResult\n ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,\n UnaryExprOrTypeTrait ExprKind,\n bool IsType, void *TyOrEx,\n SourceRange ArgRange);\n\n ExprResult CheckPlaceholderExpr(Expr *E);\n bool CheckVecStepExpr(Expr *E);\n\n bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);\n bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,\n SourceRange ExprRange,\n UnaryExprOrTypeTrait ExprKind);\n ExprResult ActOnSizeofParameterPackExpr(Scope *S,\n SourceLocation OpLoc,\n IdentifierInfo &Name,\n SourceLocation NameLoc,\n SourceLocation RParenLoc);\n ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,\n tok::TokenKind Kind, Expr *Input);\n\n ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,\n Expr *Idx, SourceLocation RLoc);\n ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,\n Expr *Idx, SourceLocation RLoc);\n\n ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,\n Expr *ColumnIdx,\n SourceLocation RBLoc);\n\n ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,\n Expr *LowerBound,\n SourceLocation ColonLocFirst,\n SourceLocation ColonLocSecond,\n Expr *Length, Expr *Stride,\n SourceLocation RBLoc);\n ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,\n SourceLocation RParenLoc,\n ArrayRef Dims,\n ArrayRef Brackets);\n\n /// Data structure for iterator expression.\n struct OMPIteratorData {\n IdentifierInfo *DeclIdent = nullptr;\n SourceLocation DeclIdentLoc;\n ParsedType Type;\n OMPIteratorExpr::IteratorRange Range;\n SourceLocation AssignLoc;\n SourceLocation ColonLoc;\n SourceLocation SecColonLoc;\n };\n\n ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc,\n SourceLocation LLoc, SourceLocation RLoc,\n ArrayRef Data);\n\n // This struct is for use by ActOnMemberAccess to allow\n // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after\n // changing the access operator from a '.' to a '->' (to see if that is the\n // change needed to fix an error about an unknown member, e.g. when the class\n // defines a custom operator->).\n struct ActOnMemberAccessExtraArgs {\n Scope *S;\n UnqualifiedId &Id;\n Decl *ObjCImpDecl;\n };\n\n ExprResult BuildMemberReferenceExpr(\n Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow,\n CXXScopeSpec &SS, SourceLocation TemplateKWLoc,\n NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *TemplateArgs,\n const Scope *S,\n ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);\n\n ExprResult\n BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,\n bool IsArrow, const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n NamedDecl *FirstQualifierInScope, LookupResult &R,\n const TemplateArgumentListInfo *TemplateArgs,\n const Scope *S,\n bool SuppressQualifierCheck = false,\n ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);\n\n ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,\n SourceLocation OpLoc,\n const CXXScopeSpec &SS, FieldDecl *Field,\n DeclAccessPair FoundDecl,\n const DeclarationNameInfo &MemberNameInfo);\n\n ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);\n\n bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,\n const CXXScopeSpec &SS,\n const LookupResult &R);\n\n ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,\n bool IsArrow, SourceLocation OpLoc,\n const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n NamedDecl *FirstQualifierInScope,\n const DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *TemplateArgs);\n\n ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n UnqualifiedId &Member,\n Decl *ObjCImpDecl);\n\n MemberExpr *\n BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,\n const CXXScopeSpec *SS, SourceLocation TemplateKWLoc,\n ValueDecl *Member, DeclAccessPair FoundDecl,\n bool HadMultipleCandidates,\n const DeclarationNameInfo &MemberNameInfo, QualType Ty,\n ExprValueKind VK, ExprObjectKind OK,\n const TemplateArgumentListInfo *TemplateArgs = nullptr);\n MemberExpr *\n BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,\n NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,\n ValueDecl *Member, DeclAccessPair FoundDecl,\n bool HadMultipleCandidates,\n const DeclarationNameInfo &MemberNameInfo, QualType Ty,\n ExprValueKind VK, ExprObjectKind OK,\n const TemplateArgumentListInfo *TemplateArgs = nullptr);\n\n void ActOnDefaultCtorInitializers(Decl *CDtorDecl);\n bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,\n FunctionDecl *FDecl,\n const FunctionProtoType *Proto,\n ArrayRef Args,\n SourceLocation RParenLoc,\n bool ExecConfig = false);\n void CheckStaticArrayArgument(SourceLocation CallLoc,\n ParmVarDecl *Param,\n const Expr *ArgExpr);\n\n /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.\n /// This provides the location of the left/right parens and a list of comma\n /// locations.\n ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,\n MultiExprArg ArgExprs, SourceLocation RParenLoc,\n Expr *ExecConfig = nullptr);\n ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,\n MultiExprArg ArgExprs, SourceLocation RParenLoc,\n Expr *ExecConfig = nullptr,\n bool IsExecConfig = false,\n bool AllowRecovery = false);\n enum class AtomicArgumentOrder { API, AST };\n ExprResult\n BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,\n SourceLocation RParenLoc, MultiExprArg Args,\n AtomicExpr::AtomicOp Op,\n AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API);\n ExprResult\n BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc,\n ArrayRef Arg, SourceLocation RParenLoc,\n Expr *Config = nullptr, bool IsExecConfig = false,\n ADLCallKind UsesADL = ADLCallKind::NotADL);\n\n ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,\n MultiExprArg ExecConfig,\n SourceLocation GGGLoc);\n\n ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,\n Declarator &D, ParsedType &Ty,\n SourceLocation RParenLoc, Expr *CastExpr);\n ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,\n TypeSourceInfo *Ty,\n SourceLocation RParenLoc,\n Expr *Op);\n CastKind PrepareScalarCast(ExprResult &src, QualType destType);\n\n /// Build an altivec or OpenCL literal.\n ExprResult BuildVectorLiteral(SourceLocation LParenLoc,\n SourceLocation RParenLoc, Expr *E,\n TypeSourceInfo *TInfo);\n\n ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);\n\n ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,\n ParsedType Ty,\n SourceLocation RParenLoc,\n Expr *InitExpr);\n\n ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,\n TypeSourceInfo *TInfo,\n SourceLocation RParenLoc,\n Expr *LiteralExpr);\n\n ExprResult ActOnInitList(SourceLocation LBraceLoc,\n MultiExprArg InitArgList,\n SourceLocation RBraceLoc);\n\n ExprResult BuildInitList(SourceLocation LBraceLoc,\n MultiExprArg InitArgList,\n SourceLocation RBraceLoc);\n\n ExprResult ActOnDesignatedInitializer(Designation &Desig,\n SourceLocation EqualOrColonLoc,\n bool GNUSyntax,\n ExprResult Init);\n\nprivate:\n static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);\n\npublic:\n ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,\n tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);\n ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,\n BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);\n ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,\n Expr *LHSExpr, Expr *RHSExpr);\n void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,\n UnresolvedSetImpl &Functions);\n\n void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);\n\n /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null\n /// in the case of a the GNU conditional expr extension.\n ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,\n SourceLocation ColonLoc,\n Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);\n\n /// ActOnAddrLabel - Parse the GNU address of label extension: \"&&foo\".\n ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,\n LabelDecl *TheDecl);\n\n void ActOnStartStmtExpr();\n ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,\n SourceLocation RPLoc);\n ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,\n SourceLocation RPLoc, unsigned TemplateDepth);\n // Handle the final expression in a statement expression.\n ExprResult ActOnStmtExprResult(ExprResult E);\n void ActOnStmtExprError();\n\n // __builtin_offsetof(type, identifier(.identifier|[expr])*)\n struct OffsetOfComponent {\n SourceLocation LocStart, LocEnd;\n bool isBrackets; // true if [expr], false if .ident\n union {\n IdentifierInfo *IdentInfo;\n Expr *E;\n } U;\n };\n\n /// __builtin_offsetof(type, a.b[123][456].c)\n ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,\n TypeSourceInfo *TInfo,\n ArrayRef Components,\n SourceLocation RParenLoc);\n ExprResult ActOnBuiltinOffsetOf(Scope *S,\n SourceLocation BuiltinLoc,\n SourceLocation TypeLoc,\n ParsedType ParsedArgTy,\n ArrayRef Components,\n SourceLocation RParenLoc);\n\n // __builtin_choose_expr(constExpr, expr1, expr2)\n ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,\n Expr *CondExpr, Expr *LHSExpr,\n Expr *RHSExpr, SourceLocation RPLoc);\n\n // __builtin_va_arg(expr, type)\n ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,\n SourceLocation RPLoc);\n ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,\n TypeSourceInfo *TInfo, SourceLocation RPLoc);\n\n // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(),\n // __builtin_COLUMN()\n ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,\n SourceLocation BuiltinLoc,\n SourceLocation RPLoc);\n\n // Build a potentially resolved SourceLocExpr.\n ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,\n SourceLocation BuiltinLoc, SourceLocation RPLoc,\n DeclContext *ParentContext);\n\n // __null\n ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);\n\n bool CheckCaseExpression(Expr *E);\n\n /// Describes the result of an \"if-exists\" condition check.\n enum IfExistsResult {\n /// The symbol exists.\n IER_Exists,\n\n /// The symbol does not exist.\n IER_DoesNotExist,\n\n /// The name is a dependent name, so the results will differ\n /// from one instantiation to the next.\n IER_Dependent,\n\n /// An error occurred.\n IER_Error\n };\n\n IfExistsResult\n CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,\n const DeclarationNameInfo &TargetNameInfo);\n\n IfExistsResult\n CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,\n bool IsIfExists, CXXScopeSpec &SS,\n UnqualifiedId &Name);\n\n StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,\n bool IsIfExists,\n NestedNameSpecifierLoc QualifierLoc,\n DeclarationNameInfo NameInfo,\n Stmt *Nested);\n StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,\n bool IsIfExists,\n CXXScopeSpec &SS, UnqualifiedId &Name,\n Stmt *Nested);\n\n //===------------------------- \"Block\" Extension ------------------------===//\n\n /// ActOnBlockStart - This callback is invoked when a block literal is\n /// started.\n void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);\n\n /// ActOnBlockArguments - This callback allows processing of block arguments.\n /// If there are no arguments, this is still invoked.\n void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,\n Scope *CurScope);\n\n /// ActOnBlockError - If there is an error parsing a block, this callback\n /// is invoked to pop the information about the block from the action impl.\n void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);\n\n /// ActOnBlockStmtExpr - This is called when the body of a block statement\n /// literal was successfully completed. ^(int x){...}\n ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,\n Scope *CurScope);\n\n //===---------------------------- Clang Extensions ----------------------===//\n\n /// __builtin_convertvector(...)\n ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,\n SourceLocation BuiltinLoc,\n SourceLocation RParenLoc);\n\n //===---------------------------- OpenCL Features -----------------------===//\n\n /// __builtin_astype(...)\n ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,\n SourceLocation BuiltinLoc,\n SourceLocation RParenLoc);\n\n //===---------------------------- C++ Features --------------------------===//\n\n // Act on C++ namespaces\n Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,\n SourceLocation NamespaceLoc,\n SourceLocation IdentLoc, IdentifierInfo *Ident,\n SourceLocation LBrace,\n const ParsedAttributesView &AttrList,\n UsingDirectiveDecl *&UsingDecl);\n void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);\n\n NamespaceDecl *getStdNamespace() const;\n NamespaceDecl *getOrCreateStdNamespace();\n\n NamespaceDecl *lookupStdExperimentalNamespace();\n\n CXXRecordDecl *getStdBadAlloc() const;\n EnumDecl *getStdAlignValT() const;\n\nprivate:\n // A cache representing if we've fully checked the various comparison category\n // types stored in ASTContext. The bit-index corresponds to the integer value\n // of a ComparisonCategoryType enumerator.\n llvm::SmallBitVector FullyCheckedComparisonCategories;\n\n ValueDecl *tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,\n CXXScopeSpec &SS,\n ParsedType TemplateTypeTy,\n IdentifierInfo *MemberOrBase);\n\npublic:\n enum class ComparisonCategoryUsage {\n /// The '<=>' operator was used in an expression and a builtin operator\n /// was selected.\n OperatorInExpression,\n /// A defaulted 'operator<=>' needed the comparison category. This\n /// typically only applies to 'std::strong_ordering', due to the implicit\n /// fallback return value.\n DefaultedOperator,\n };\n\n /// Lookup the specified comparison category types in the standard\n /// library, an check the VarDecls possibly returned by the operator<=>\n /// builtins for that type.\n ///\n /// \\return The type of the comparison category type corresponding to the\n /// specified Kind, or a null type if an error occurs\n QualType CheckComparisonCategoryType(ComparisonCategoryType Kind,\n SourceLocation Loc,\n ComparisonCategoryUsage Usage);\n\n /// Tests whether Ty is an instance of std::initializer_list and, if\n /// it is and Element is not NULL, assigns the element type to Element.\n bool isStdInitializerList(QualType Ty, QualType *Element);\n\n /// Looks for the std::initializer_list template and instantiates it\n /// with Element, or emits an error if it's not found.\n ///\n /// \\returns The instantiated template, or null on error.\n QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);\n\n /// Determine whether Ctor is an initializer-list constructor, as\n /// defined in [dcl.init.list]p2.\n bool isInitListConstructor(const FunctionDecl *Ctor);\n\n Decl *ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc,\n SourceLocation NamespcLoc, CXXScopeSpec &SS,\n SourceLocation IdentLoc,\n IdentifierInfo *NamespcName,\n const ParsedAttributesView &AttrList);\n\n void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);\n\n Decl *ActOnNamespaceAliasDef(Scope *CurScope,\n SourceLocation NamespaceLoc,\n SourceLocation AliasLoc,\n IdentifierInfo *Alias,\n CXXScopeSpec &SS,\n SourceLocation IdentLoc,\n IdentifierInfo *Ident);\n\n void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);\n bool CheckUsingShadowDecl(UsingDecl *UD, NamedDecl *Target,\n const LookupResult &PreviousDecls,\n UsingShadowDecl *&PrevShadow);\n UsingShadowDecl *BuildUsingShadowDecl(Scope *S, UsingDecl *UD,\n NamedDecl *Target,\n UsingShadowDecl *PrevDecl);\n\n bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,\n bool HasTypenameKeyword,\n const CXXScopeSpec &SS,\n SourceLocation NameLoc,\n const LookupResult &Previous);\n bool CheckUsingDeclQualifier(SourceLocation UsingLoc,\n bool HasTypename,\n const CXXScopeSpec &SS,\n const DeclarationNameInfo &NameInfo,\n SourceLocation NameLoc);\n\n NamedDecl *BuildUsingDeclaration(\n Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,\n bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,\n DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,\n const ParsedAttributesView &AttrList, bool IsInstantiation);\n NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,\n ArrayRef Expansions);\n\n bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);\n\n /// Given a derived-class using shadow declaration for a constructor and the\n /// correspnding base class constructor, find or create the implicit\n /// synthesized derived class constructor to use for this initialization.\n CXXConstructorDecl *\n findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,\n ConstructorUsingShadowDecl *DerivedShadow);\n\n Decl *ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS,\n SourceLocation UsingLoc,\n SourceLocation TypenameLoc, CXXScopeSpec &SS,\n UnqualifiedId &Name, SourceLocation EllipsisLoc,\n const ParsedAttributesView &AttrList);\n Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS,\n MultiTemplateParamsArg TemplateParams,\n SourceLocation UsingLoc, UnqualifiedId &Name,\n const ParsedAttributesView &AttrList,\n TypeResult Type, Decl *DeclFromDeclSpec);\n\n /// BuildCXXConstructExpr - Creates a complete call to a constructor,\n /// including handling of its default argument expressions.\n ///\n /// \\param ConstructKind - a CXXConstructExpr::ConstructionKind\n ExprResult\n BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,\n NamedDecl *FoundDecl,\n CXXConstructorDecl *Constructor, MultiExprArg Exprs,\n bool HadMultipleCandidates, bool IsListInitialization,\n bool IsStdInitListInitialization,\n bool RequiresZeroInit, unsigned ConstructKind,\n SourceRange ParenRange);\n\n /// Build a CXXConstructExpr whose constructor has already been resolved if\n /// it denotes an inherited constructor.\n ExprResult\n BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,\n CXXConstructorDecl *Constructor, bool Elidable,\n MultiExprArg Exprs,\n bool HadMultipleCandidates, bool IsListInitialization,\n bool IsStdInitListInitialization,\n bool RequiresZeroInit, unsigned ConstructKind,\n SourceRange ParenRange);\n\n // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if\n // the constructor can be elidable?\n ExprResult\n BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,\n NamedDecl *FoundDecl,\n CXXConstructorDecl *Constructor, bool Elidable,\n MultiExprArg Exprs, bool HadMultipleCandidates,\n bool IsListInitialization,\n bool IsStdInitListInitialization, bool RequiresZeroInit,\n unsigned ConstructKind, SourceRange ParenRange);\n\n ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);\n\n\n /// Instantiate or parse a C++ default argument expression as necessary.\n /// Return true on error.\n bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,\n ParmVarDecl *Param);\n\n /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating\n /// the default expr if needed.\n ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,\n FunctionDecl *FD,\n ParmVarDecl *Param);\n\n /// FinalizeVarWithDestructor - Prepare for calling destructor on the\n /// constructed variable.\n void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType);\n\n /// Helper class that collects exception specifications for\n /// implicitly-declared special member functions.\n class ImplicitExceptionSpecification {\n // Pointer to allow copying\n Sema *Self;\n // We order exception specifications thus:\n // noexcept is the most restrictive, but is only used in C++11.\n // throw() comes next.\n // Then a throw(collected exceptions)\n // Finally no specification, which is expressed as noexcept(false).\n // throw(...) is used instead if any called function uses it.\n ExceptionSpecificationType ComputedEST;\n llvm::SmallPtrSet ExceptionsSeen;\n SmallVector Exceptions;\n\n void ClearExceptions() {\n ExceptionsSeen.clear();\n Exceptions.clear();\n }\n\n public:\n explicit ImplicitExceptionSpecification(Sema &Self)\n : Self(&Self), ComputedEST(EST_BasicNoexcept) {\n if (!Self.getLangOpts().CPlusPlus11)\n ComputedEST = EST_DynamicNone;\n }\n\n /// Get the computed exception specification type.\n ExceptionSpecificationType getExceptionSpecType() const {\n assert(!isComputedNoexcept(ComputedEST) &&\n \"noexcept(expr) should not be a possible result\");\n return ComputedEST;\n }\n\n /// The number of exceptions in the exception specification.\n unsigned size() const { return Exceptions.size(); }\n\n /// The set of exceptions in the exception specification.\n const QualType *data() const { return Exceptions.data(); }\n\n /// Integrate another called method into the collected data.\n void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method);\n\n /// Integrate an invoked expression into the collected data.\n void CalledExpr(Expr *E) { CalledStmt(E); }\n\n /// Integrate an invoked statement into the collected data.\n void CalledStmt(Stmt *S);\n\n /// Overwrite an EPI's exception specification with this\n /// computed exception specification.\n FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const {\n FunctionProtoType::ExceptionSpecInfo ESI;\n ESI.Type = getExceptionSpecType();\n if (ESI.Type == EST_Dynamic) {\n ESI.Exceptions = Exceptions;\n } else if (ESI.Type == EST_None) {\n /// C++11 [except.spec]p14:\n /// The exception-specification is noexcept(false) if the set of\n /// potential exceptions of the special member function contains \"any\"\n ESI.Type = EST_NoexceptFalse;\n ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(),\n tok::kw_false).get();\n }\n return ESI;\n }\n };\n\n /// Evaluate the implicit exception specification for a defaulted\n /// special member function.\n void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD);\n\n /// Check the given noexcept-specifier, convert its expression, and compute\n /// the appropriate ExceptionSpecificationType.\n ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr,\n ExceptionSpecificationType &EST);\n\n /// Check the given exception-specification and update the\n /// exception specification information with the results.\n void checkExceptionSpecification(bool IsTopLevel,\n ExceptionSpecificationType EST,\n ArrayRef DynamicExceptions,\n ArrayRef DynamicExceptionRanges,\n Expr *NoexceptExpr,\n SmallVectorImpl &Exceptions,\n FunctionProtoType::ExceptionSpecInfo &ESI);\n\n /// Determine if we're in a case where we need to (incorrectly) eagerly\n /// parse an exception specification to work around a libstdc++ bug.\n bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D);\n\n /// Add an exception-specification to the given member function\n /// (or member function template). The exception-specification was parsed\n /// after the method itself was declared.\n void actOnDelayedExceptionSpecification(Decl *Method,\n ExceptionSpecificationType EST,\n SourceRange SpecificationRange,\n ArrayRef DynamicExceptions,\n ArrayRef DynamicExceptionRanges,\n Expr *NoexceptExpr);\n\n class InheritedConstructorInfo;\n\n /// Determine if a special member function should have a deleted\n /// definition when it is defaulted.\n bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,\n InheritedConstructorInfo *ICI = nullptr,\n bool Diagnose = false);\n\n /// Produce notes explaining why a defaulted function was defined as deleted.\n void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD);\n\n /// Declare the implicit default constructor for the given class.\n ///\n /// \\param ClassDecl The class declaration into which the implicit\n /// default constructor will be added.\n ///\n /// \\returns The implicitly-declared default constructor.\n CXXConstructorDecl *DeclareImplicitDefaultConstructor(\n CXXRecordDecl *ClassDecl);\n\n /// DefineImplicitDefaultConstructor - Checks for feasibility of\n /// defining this constructor as the default constructor.\n void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,\n CXXConstructorDecl *Constructor);\n\n /// Declare the implicit destructor for the given class.\n ///\n /// \\param ClassDecl The class declaration into which the implicit\n /// destructor will be added.\n ///\n /// \\returns The implicitly-declared destructor.\n CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl);\n\n /// DefineImplicitDestructor - Checks for feasibility of\n /// defining this destructor as the default destructor.\n void DefineImplicitDestructor(SourceLocation CurrentLocation,\n CXXDestructorDecl *Destructor);\n\n /// Build an exception spec for destructors that don't have one.\n ///\n /// C++11 says that user-defined destructors with no exception spec get one\n /// that looks as if the destructor was implicitly declared.\n void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor);\n\n /// Define the specified inheriting constructor.\n void DefineInheritingConstructor(SourceLocation UseLoc,\n CXXConstructorDecl *Constructor);\n\n /// Declare the implicit copy constructor for the given class.\n ///\n /// \\param ClassDecl The class declaration into which the implicit\n /// copy constructor will be added.\n ///\n /// \\returns The implicitly-declared copy constructor.\n CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl);\n\n /// DefineImplicitCopyConstructor - Checks for feasibility of\n /// defining this constructor as the copy constructor.\n void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,\n CXXConstructorDecl *Constructor);\n\n /// Declare the implicit move constructor for the given class.\n ///\n /// \\param ClassDecl The Class declaration into which the implicit\n /// move constructor will be added.\n ///\n /// \\returns The implicitly-declared move constructor, or NULL if it wasn't\n /// declared.\n CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl);\n\n /// DefineImplicitMoveConstructor - Checks for feasibility of\n /// defining this constructor as the move constructor.\n void DefineImplicitMoveConstructor(SourceLocation CurrentLocation,\n CXXConstructorDecl *Constructor);\n\n /// Declare the implicit copy assignment operator for the given class.\n ///\n /// \\param ClassDecl The class declaration into which the implicit\n /// copy assignment operator will be added.\n ///\n /// \\returns The implicitly-declared copy assignment operator.\n CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl);\n\n /// Defines an implicitly-declared copy assignment operator.\n void DefineImplicitCopyAssignment(SourceLocation CurrentLocation,\n CXXMethodDecl *MethodDecl);\n\n /// Declare the implicit move assignment operator for the given class.\n ///\n /// \\param ClassDecl The Class declaration into which the implicit\n /// move assignment operator will be added.\n ///\n /// \\returns The implicitly-declared move assignment operator, or NULL if it\n /// wasn't declared.\n CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl);\n\n /// Defines an implicitly-declared move assignment operator.\n void DefineImplicitMoveAssignment(SourceLocation CurrentLocation,\n CXXMethodDecl *MethodDecl);\n\n /// Force the declaration of any implicitly-declared members of this\n /// class.\n void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class);\n\n /// Check a completed declaration of an implicit special member.\n void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD);\n\n /// Determine whether the given function is an implicitly-deleted\n /// special member function.\n bool isImplicitlyDeleted(FunctionDecl *FD);\n\n /// Check whether 'this' shows up in the type of a static member\n /// function after the (naturally empty) cv-qualifier-seq would be.\n ///\n /// \\returns true if an error occurred.\n bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method);\n\n /// Whether this' shows up in the exception specification of a static\n /// member function.\n bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method);\n\n /// Check whether 'this' shows up in the attributes of the given\n /// static member function.\n ///\n /// \\returns true if an error occurred.\n bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);\n\n /// MaybeBindToTemporary - If the passed in expression has a record type with\n /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise\n /// it simply returns the passed in expression.\n ExprResult MaybeBindToTemporary(Expr *E);\n\n /// Wrap the expression in a ConstantExpr if it is a potential immediate\n /// invocation.\n ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl);\n\n bool CompleteConstructorCall(CXXConstructorDecl *Constructor,\n QualType DeclInitType, MultiExprArg ArgsPtr,\n SourceLocation Loc,\n SmallVectorImpl &ConvertedArgs,\n bool AllowExplicit = false,\n bool IsListInitialization = false);\n\n ParsedType getInheritingConstructorName(CXXScopeSpec &SS,\n SourceLocation NameLoc,\n IdentifierInfo &Name);\n\n ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc,\n Scope *S, CXXScopeSpec &SS,\n bool EnteringContext);\n ParsedType getDestructorName(SourceLocation TildeLoc,\n IdentifierInfo &II, SourceLocation NameLoc,\n Scope *S, CXXScopeSpec &SS,\n ParsedType ObjectType,\n bool EnteringContext);\n\n ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,\n ParsedType ObjectType);\n\n // Checks that reinterpret casts don't have undefined behavior.\n void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,\n bool IsDereference, SourceRange Range);\n\n /// ActOnCXXNamedCast - Parse\n /// {dynamic,static,reinterpret,const,addrspace}_cast's.\n ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,\n tok::TokenKind Kind,\n SourceLocation LAngleBracketLoc,\n Declarator &D,\n SourceLocation RAngleBracketLoc,\n SourceLocation LParenLoc,\n Expr *E,\n SourceLocation RParenLoc);\n\n ExprResult BuildCXXNamedCast(SourceLocation OpLoc,\n tok::TokenKind Kind,\n TypeSourceInfo *Ty,\n Expr *E,\n SourceRange AngleBrackets,\n SourceRange Parens);\n\n ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl,\n ExprResult Operand,\n SourceLocation RParenLoc);\n\n ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI,\n Expr *Operand, SourceLocation RParenLoc);\n\n ExprResult BuildCXXTypeId(QualType TypeInfoType,\n SourceLocation TypeidLoc,\n TypeSourceInfo *Operand,\n SourceLocation RParenLoc);\n ExprResult BuildCXXTypeId(QualType TypeInfoType,\n SourceLocation TypeidLoc,\n Expr *Operand,\n SourceLocation RParenLoc);\n\n /// ActOnCXXTypeid - Parse typeid( something ).\n ExprResult ActOnCXXTypeid(SourceLocation OpLoc,\n SourceLocation LParenLoc, bool isType,\n void *TyOrExpr,\n SourceLocation RParenLoc);\n\n ExprResult BuildCXXUuidof(QualType TypeInfoType,\n SourceLocation TypeidLoc,\n TypeSourceInfo *Operand,\n SourceLocation RParenLoc);\n ExprResult BuildCXXUuidof(QualType TypeInfoType,\n SourceLocation TypeidLoc,\n Expr *Operand,\n SourceLocation RParenLoc);\n\n /// ActOnCXXUuidof - Parse __uuidof( something ).\n ExprResult ActOnCXXUuidof(SourceLocation OpLoc,\n SourceLocation LParenLoc, bool isType,\n void *TyOrExpr,\n SourceLocation RParenLoc);\n\n /// Handle a C++1z fold-expression: ( expr op ... op expr ).\n ExprResult ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS,\n tok::TokenKind Operator,\n SourceLocation EllipsisLoc, Expr *RHS,\n SourceLocation RParenLoc);\n ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee,\n SourceLocation LParenLoc, Expr *LHS,\n BinaryOperatorKind Operator,\n SourceLocation EllipsisLoc, Expr *RHS,\n SourceLocation RParenLoc,\n Optional NumExpansions);\n ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,\n BinaryOperatorKind Operator);\n\n //// ActOnCXXThis - Parse 'this' pointer.\n ExprResult ActOnCXXThis(SourceLocation loc);\n\n /// Build a CXXThisExpr and mark it referenced in the current context.\n Expr *BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit);\n void MarkThisReferenced(CXXThisExpr *This);\n\n /// Try to retrieve the type of the 'this' pointer.\n ///\n /// \\returns The type of 'this', if possible. Otherwise, returns a NULL type.\n QualType getCurrentThisType();\n\n /// When non-NULL, the C++ 'this' expression is allowed despite the\n /// current context not being a non-static member function. In such cases,\n /// this provides the type used for 'this'.\n QualType CXXThisTypeOverride;\n\n /// RAII object used to temporarily allow the C++ 'this' expression\n /// to be used, with the given qualifiers on the current class type.\n class CXXThisScopeRAII {\n Sema &S;\n QualType OldCXXThisTypeOverride;\n bool Enabled;\n\n public:\n /// Introduce a new scope where 'this' may be allowed (when enabled),\n /// using the given declaration (which is either a class template or a\n /// class) along with the given qualifiers.\n /// along with the qualifiers placed on '*this'.\n CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals,\n bool Enabled = true);\n\n ~CXXThisScopeRAII();\n };\n\n /// Make sure the value of 'this' is actually available in the current\n /// context, if it is a potentially evaluated context.\n ///\n /// \\param Loc The location at which the capture of 'this' occurs.\n ///\n /// \\param Explicit Whether 'this' is explicitly captured in a lambda\n /// capture list.\n ///\n /// \\param FunctionScopeIndexToStopAt If non-null, it points to the index\n /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.\n /// This is useful when enclosing lambdas must speculatively capture\n /// 'this' that may or may not be used in certain specializations of\n /// a nested generic lambda (depending on whether the name resolves to\n /// a non-static member function or a static function).\n /// \\return returns 'true' if failed, 'false' if success.\n bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false,\n bool BuildAndDiagnose = true,\n const unsigned *const FunctionScopeIndexToStopAt = nullptr,\n bool ByCopy = false);\n\n /// Determine whether the given type is the type of *this that is used\n /// outside of the body of a member function for a type that is currently\n /// being defined.\n bool isThisOutsideMemberFunctionBody(QualType BaseType);\n\n /// ActOnCXXBoolLiteral - Parse {true,false} literals.\n ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);\n\n\n /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.\n ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);\n\n ExprResult\n ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef AvailSpecs,\n SourceLocation AtLoc, SourceLocation RParen);\n\n /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.\n ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);\n\n //// ActOnCXXThrow - Parse throw expressions.\n ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);\n ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,\n bool IsThrownVarInScope);\n bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);\n\n /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.\n /// Can be interpreted either as function-style casting (\"int(x)\")\n /// or class type construction (\"ClassType(x,y,z)\")\n /// or creation of a value-initialized type (\"int()\").\n ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep,\n SourceLocation LParenOrBraceLoc,\n MultiExprArg Exprs,\n SourceLocation RParenOrBraceLoc,\n bool ListInitialization);\n\n ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type,\n SourceLocation LParenLoc,\n MultiExprArg Exprs,\n SourceLocation RParenLoc,\n bool ListInitialization);\n\n /// ActOnCXXNew - Parsed a C++ 'new' expression.\n ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,\n SourceLocation PlacementLParen,\n MultiExprArg PlacementArgs,\n SourceLocation PlacementRParen,\n SourceRange TypeIdParens, Declarator &D,\n Expr *Initializer);\n ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal,\n SourceLocation PlacementLParen,\n MultiExprArg PlacementArgs,\n SourceLocation PlacementRParen,\n SourceRange TypeIdParens,\n QualType AllocType,\n TypeSourceInfo *AllocTypeInfo,\n Optional ArraySize,\n SourceRange DirectInitRange,\n Expr *Initializer);\n\n /// Determine whether \\p FD is an aligned allocation or deallocation\n /// function that is unavailable.\n bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const;\n\n /// Produce diagnostics if \\p FD is an aligned allocation or deallocation\n /// function that is unavailable.\n void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD,\n SourceLocation Loc);\n\n bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,\n SourceRange R);\n\n /// The scope in which to find allocation functions.\n enum AllocationFunctionScope {\n /// Only look for allocation functions in the global scope.\n AFS_Global,\n /// Only look for allocation functions in the scope of the\n /// allocated class.\n AFS_Class,\n /// Look for allocation functions in both the global scope\n /// and in the scope of the allocated class.\n AFS_Both\n };\n\n /// Finds the overloads of operator new and delete that are appropriate\n /// for the allocation.\n bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,\n AllocationFunctionScope NewScope,\n AllocationFunctionScope DeleteScope,\n QualType AllocType, bool IsArray,\n bool &PassAlignment, MultiExprArg PlaceArgs,\n FunctionDecl *&OperatorNew,\n FunctionDecl *&OperatorDelete,\n bool Diagnose = true);\n void DeclareGlobalNewDelete();\n void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,\n ArrayRef Params);\n\n bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,\n DeclarationName Name, FunctionDecl* &Operator,\n bool Diagnose = true);\n FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,\n bool CanProvideSize,\n bool Overaligned,\n DeclarationName Name);\n FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,\n CXXRecordDecl *RD);\n\n /// ActOnCXXDelete - Parsed a C++ 'delete' expression\n ExprResult ActOnCXXDelete(SourceLocation StartLoc,\n bool UseGlobal, bool ArrayForm,\n Expr *Operand);\n void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,\n bool IsDelete, bool CallCanBeVirtual,\n bool WarnOnNonAbstractTypes,\n SourceLocation DtorLoc);\n\n ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen,\n Expr *Operand, SourceLocation RParen);\n ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,\n SourceLocation RParen);\n\n /// Parsed one of the type trait support pseudo-functions.\n ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,\n ArrayRef Args,\n SourceLocation RParenLoc);\n ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,\n ArrayRef Args,\n SourceLocation RParenLoc);\n\n /// ActOnArrayTypeTrait - Parsed one of the binary type trait support\n /// pseudo-functions.\n ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT,\n SourceLocation KWLoc,\n ParsedType LhsTy,\n Expr *DimExpr,\n SourceLocation RParen);\n\n ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT,\n SourceLocation KWLoc,\n TypeSourceInfo *TSInfo,\n Expr *DimExpr,\n SourceLocation RParen);\n\n /// ActOnExpressionTrait - Parsed one of the unary type trait support\n /// pseudo-functions.\n ExprResult ActOnExpressionTrait(ExpressionTrait OET,\n SourceLocation KWLoc,\n Expr *Queried,\n SourceLocation RParen);\n\n ExprResult BuildExpressionTrait(ExpressionTrait OET,\n SourceLocation KWLoc,\n Expr *Queried,\n SourceLocation RParen);\n\n ExprResult ActOnStartCXXMemberReference(Scope *S,\n Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n ParsedType &ObjectType,\n bool &MayBePseudoDestructor);\n\n ExprResult BuildPseudoDestructorExpr(Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n const CXXScopeSpec &SS,\n TypeSourceInfo *ScopeType,\n SourceLocation CCLoc,\n SourceLocation TildeLoc,\n PseudoDestructorTypeStorage DestroyedType);\n\n ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n CXXScopeSpec &SS,\n UnqualifiedId &FirstTypeName,\n SourceLocation CCLoc,\n SourceLocation TildeLoc,\n UnqualifiedId &SecondTypeName);\n\n ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,\n SourceLocation OpLoc,\n tok::TokenKind OpKind,\n SourceLocation TildeLoc,\n const DeclSpec& DS);\n\n /// MaybeCreateExprWithCleanups - If the current full-expression\n /// requires any cleanups, surround it with a ExprWithCleanups node.\n /// Otherwise, just returns the passed-in expression.\n Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);\n Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);\n ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);\n\n MaterializeTemporaryExpr *\n CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,\n bool BoundToLvalueReference);\n\n ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue) {\n return ActOnFinishFullExpr(\n Expr, Expr ? Expr->getExprLoc() : SourceLocation(), DiscardedValue);\n }\n ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,\n bool DiscardedValue, bool IsConstexpr = false);\n StmtResult ActOnFinishFullStmt(Stmt *Stmt);\n\n // Marks SS invalid if it represents an incomplete type.\n bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);\n\n DeclContext *computeDeclContext(QualType T);\n DeclContext *computeDeclContext(const CXXScopeSpec &SS,\n bool EnteringContext = false);\n bool isDependentScopeSpecifier(const CXXScopeSpec &SS);\n CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);\n\n /// The parser has parsed a global nested-name-specifier '::'.\n ///\n /// \\param CCLoc The location of the '::'.\n ///\n /// \\param SS The nested-name-specifier, which will be updated in-place\n /// to reflect the parsed nested-name-specifier.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS);\n\n /// The parser has parsed a '__super' nested-name-specifier.\n ///\n /// \\param SuperLoc The location of the '__super' keyword.\n ///\n /// \\param ColonColonLoc The location of the '::'.\n ///\n /// \\param SS The nested-name-specifier, which will be updated in-place\n /// to reflect the parsed nested-name-specifier.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc,\n SourceLocation ColonColonLoc, CXXScopeSpec &SS);\n\n bool isAcceptableNestedNameSpecifier(const NamedDecl *SD,\n bool *CanCorrect = nullptr);\n NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);\n\n /// Keeps information about an identifier in a nested-name-spec.\n ///\n struct NestedNameSpecInfo {\n /// The type of the object, if we're parsing nested-name-specifier in\n /// a member access expression.\n ParsedType ObjectType;\n\n /// The identifier preceding the '::'.\n IdentifierInfo *Identifier;\n\n /// The location of the identifier.\n SourceLocation IdentifierLoc;\n\n /// The location of the '::'.\n SourceLocation CCLoc;\n\n /// Creates info object for the most typical case.\n NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,\n SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType())\n : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc),\n CCLoc(ColonColonLoc) {\n }\n\n NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,\n SourceLocation ColonColonLoc, QualType ObjectType)\n : ObjectType(ParsedType::make(ObjectType)), Identifier(II),\n IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) {\n }\n };\n\n bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,\n NestedNameSpecInfo &IdInfo);\n\n bool BuildCXXNestedNameSpecifier(Scope *S,\n NestedNameSpecInfo &IdInfo,\n bool EnteringContext,\n CXXScopeSpec &SS,\n NamedDecl *ScopeLookupResult,\n bool ErrorRecoveryLookup,\n bool *IsCorrectedToColon = nullptr,\n bool OnlyNamespace = false);\n\n /// The parser has parsed a nested-name-specifier 'identifier::'.\n ///\n /// \\param S The scope in which this nested-name-specifier occurs.\n ///\n /// \\param IdInfo Parser information about an identifier in the\n /// nested-name-spec.\n ///\n /// \\param EnteringContext Whether we're entering the context nominated by\n /// this nested-name-specifier.\n ///\n /// \\param SS The nested-name-specifier, which is both an input\n /// parameter (the nested-name-specifier before this type) and an\n /// output parameter (containing the full nested-name-specifier,\n /// including this new type).\n ///\n /// \\param ErrorRecoveryLookup If true, then this method is called to improve\n /// error recovery. In this case do not emit error message.\n ///\n /// \\param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'\n /// are allowed. The bool value pointed by this parameter is set to 'true'\n /// if the identifier is treated as if it was followed by ':', not '::'.\n ///\n /// \\param OnlyNamespace If true, only considers namespaces in lookup.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool ActOnCXXNestedNameSpecifier(Scope *S,\n NestedNameSpecInfo &IdInfo,\n bool EnteringContext,\n CXXScopeSpec &SS,\n bool ErrorRecoveryLookup = false,\n bool *IsCorrectedToColon = nullptr,\n bool OnlyNamespace = false);\n\n ExprResult ActOnDecltypeExpression(Expr *E);\n\n bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,\n const DeclSpec &DS,\n SourceLocation ColonColonLoc);\n\n bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,\n NestedNameSpecInfo &IdInfo,\n bool EnteringContext);\n\n /// The parser has parsed a nested-name-specifier\n /// 'template[opt] template-name < template-args >::'.\n ///\n /// \\param S The scope in which this nested-name-specifier occurs.\n ///\n /// \\param SS The nested-name-specifier, which is both an input\n /// parameter (the nested-name-specifier before this type) and an\n /// output parameter (containing the full nested-name-specifier,\n /// including this new type).\n ///\n /// \\param TemplateKWLoc the location of the 'template' keyword, if any.\n /// \\param TemplateName the template name.\n /// \\param TemplateNameLoc The location of the template name.\n /// \\param LAngleLoc The location of the opening angle bracket ('<').\n /// \\param TemplateArgs The template arguments.\n /// \\param RAngleLoc The location of the closing angle bracket ('>').\n /// \\param CCLoc The location of the '::'.\n ///\n /// \\param EnteringContext Whether we're entering the context of the\n /// nested-name-specifier.\n ///\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool ActOnCXXNestedNameSpecifier(Scope *S,\n CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n TemplateTy TemplateName,\n SourceLocation TemplateNameLoc,\n SourceLocation LAngleLoc,\n ASTTemplateArgsPtr TemplateArgs,\n SourceLocation RAngleLoc,\n SourceLocation CCLoc,\n bool EnteringContext);\n\n /// Given a C++ nested-name-specifier, produce an annotation value\n /// that the parser can use later to reconstruct the given\n /// nested-name-specifier.\n ///\n /// \\param SS A nested-name-specifier.\n ///\n /// \\returns A pointer containing all of the information in the\n /// nested-name-specifier \\p SS.\n void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS);\n\n /// Given an annotation pointer for a nested-name-specifier, restore\n /// the nested-name-specifier structure.\n ///\n /// \\param Annotation The annotation pointer, produced by\n /// \\c SaveNestedNameSpecifierAnnotation().\n ///\n /// \\param AnnotationRange The source range corresponding to the annotation.\n ///\n /// \\param SS The nested-name-specifier that will be updated with the contents\n /// of the annotation pointer.\n void RestoreNestedNameSpecifierAnnotation(void *Annotation,\n SourceRange AnnotationRange,\n CXXScopeSpec &SS);\n\n bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);\n\n /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global\n /// scope or nested-name-specifier) is parsed, part of a declarator-id.\n /// After this method is called, according to [C++ 3.4.3p3], names should be\n /// looked up in the declarator-id's scope, until the declarator is parsed and\n /// ActOnCXXExitDeclaratorScope is called.\n /// The 'SS' should be a non-empty valid CXXScopeSpec.\n bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS);\n\n /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously\n /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same\n /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.\n /// Used to indicate that names should revert to being looked up in the\n /// defining scope.\n void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);\n\n /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an\n /// initializer for the declaration 'Dcl'.\n /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a\n /// static data member of class X, names should be looked up in the scope of\n /// class X.\n void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl);\n\n /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an\n /// initializer for the declaration 'Dcl'.\n void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);\n\n /// Create a new lambda closure type.\n CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,\n TypeSourceInfo *Info,\n bool KnownDependent,\n LambdaCaptureDefault CaptureDefault);\n\n /// Start the definition of a lambda expression.\n CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,\n SourceRange IntroducerRange,\n TypeSourceInfo *MethodType,\n SourceLocation EndLoc,\n ArrayRef Params,\n ConstexprSpecKind ConstexprKind,\n Expr *TrailingRequiresClause);\n\n /// Number lambda for linkage purposes if necessary.\n void handleLambdaNumbering(\n CXXRecordDecl *Class, CXXMethodDecl *Method,\n Optional> Mangling = None);\n\n /// Endow the lambda scope info with the relevant properties.\n void buildLambdaScope(sema::LambdaScopeInfo *LSI,\n CXXMethodDecl *CallOperator,\n SourceRange IntroducerRange,\n LambdaCaptureDefault CaptureDefault,\n SourceLocation CaptureDefaultLoc,\n bool ExplicitParams,\n bool ExplicitResultType,\n bool Mutable);\n\n /// Perform initialization analysis of the init-capture and perform\n /// any implicit conversions such as an lvalue-to-rvalue conversion if\n /// not being used to initialize a reference.\n ParsedType actOnLambdaInitCaptureInitialization(\n SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,\n IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) {\n return ParsedType::make(buildLambdaInitCaptureInitialization(\n Loc, ByRef, EllipsisLoc, None, Id,\n InitKind != LambdaCaptureInitKind::CopyInit, Init));\n }\n QualType buildLambdaInitCaptureInitialization(\n SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,\n Optional NumExpansions, IdentifierInfo *Id, bool DirectInit,\n Expr *&Init);\n\n /// Create a dummy variable within the declcontext of the lambda's\n /// call operator, for name lookup purposes for a lambda init capture.\n ///\n /// CodeGen handles emission of lambda captures, ignoring these dummy\n /// variables appropriately.\n VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,\n QualType InitCaptureType,\n SourceLocation EllipsisLoc,\n IdentifierInfo *Id,\n unsigned InitStyle, Expr *Init);\n\n /// Add an init-capture to a lambda scope.\n void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var);\n\n /// Note that we have finished the explicit captures for the\n /// given lambda.\n void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);\n\n /// \\brief This is called after parsing the explicit template parameter list\n /// on a lambda (if it exists) in C++2a.\n void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,\n ArrayRef TParams,\n SourceLocation RAngleLoc,\n ExprResult RequiresClause);\n\n /// Introduce the lambda parameters into scope.\n void addLambdaParameters(\n ArrayRef Captures,\n CXXMethodDecl *CallOperator, Scope *CurScope);\n\n /// Deduce a block or lambda's return type based on the return\n /// statements present in the body.\n void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);\n\n /// ActOnStartOfLambdaDefinition - This is called just before we start\n /// parsing the body of a lambda; it analyzes the explicit captures and\n /// arguments, and sets up various data-structures for the body of the\n /// lambda.\n void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,\n Declarator &ParamInfo, Scope *CurScope);\n\n /// ActOnLambdaError - If there is an error parsing a lambda, this callback\n /// is invoked to pop the information about the lambda.\n void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,\n bool IsInstantiation = false);\n\n /// ActOnLambdaExpr - This is called when the body of a lambda expression\n /// was successfully completed.\n ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,\n Scope *CurScope);\n\n /// Does copying/destroying the captured variable have side effects?\n bool CaptureHasSideEffects(const sema::Capture &From);\n\n /// Diagnose if an explicit lambda capture is unused. Returns true if a\n /// diagnostic is emitted.\n bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange,\n const sema::Capture &From);\n\n /// Build a FieldDecl suitable to hold the given capture.\n FieldDecl *BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture);\n\n /// Initialize the given capture with a suitable expression.\n ExprResult BuildCaptureInit(const sema::Capture &Capture,\n SourceLocation ImplicitCaptureLoc,\n bool IsOpenMPMapping = false);\n\n /// Complete a lambda-expression having processed and attached the\n /// lambda body.\n ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,\n sema::LambdaScopeInfo *LSI);\n\n /// Get the return type to use for a lambda's conversion function(s) to\n /// function pointer type, given the type of the call operator.\n QualType\n getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType,\n CallingConv CC);\n\n /// Define the \"body\" of the conversion from a lambda object to a\n /// function pointer.\n ///\n /// This routine doesn't actually define a sensible body; rather, it fills\n /// in the initialization expression needed to copy the lambda object into\n /// the block, and IR generation actually generates the real body of the\n /// block pointer conversion.\n void DefineImplicitLambdaToFunctionPointerConversion(\n SourceLocation CurrentLoc, CXXConversionDecl *Conv);\n\n /// Define the \"body\" of the conversion from a lambda object to a\n /// block pointer.\n ///\n /// This routine doesn't actually define a sensible body; rather, it fills\n /// in the initialization expression needed to copy the lambda object into\n /// the block, and IR generation actually generates the real body of the\n /// block pointer conversion.\n void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc,\n CXXConversionDecl *Conv);\n\n ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,\n SourceLocation ConvLocation,\n CXXConversionDecl *Conv,\n Expr *Src);\n\n /// Check whether the given expression is a valid constraint expression.\n /// A diagnostic is emitted if it is not, false is returned, and\n /// PossibleNonPrimary will be set to true if the failure might be due to a\n /// non-primary expression being used as an atomic constraint.\n bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(),\n bool *PossibleNonPrimary = nullptr,\n bool IsTrailingRequiresClause = false);\n\nprivate:\n /// Caches pairs of template-like decls whose associated constraints were\n /// checked for subsumption and whether or not the first's constraints did in\n /// fact subsume the second's.\n llvm::DenseMap, bool> SubsumptionCache;\n /// Caches the normalized associated constraints of declarations (concepts or\n /// constrained declarations). If an error occurred while normalizing the\n /// associated constraints of the template or concept, nullptr will be cached\n /// here.\n llvm::DenseMap\n NormalizationCache;\n\n llvm::ContextualFoldingSet\n SatisfactionCache;\n\npublic:\n const NormalizedConstraint *\n getNormalizedAssociatedConstraints(\n NamedDecl *ConstrainedDecl, ArrayRef AssociatedConstraints);\n\n /// \\brief Check whether the given declaration's associated constraints are\n /// at least as constrained than another declaration's according to the\n /// partial ordering of constraints.\n ///\n /// \\param Result If no error occurred, receives the result of true if D1 is\n /// at least constrained than D2, and false otherwise.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef AC1,\n NamedDecl *D2, ArrayRef AC2,\n bool &Result);\n\n /// If D1 was not at least as constrained as D2, but would've been if a pair\n /// of atomic constraints involved had been declared in a concept and not\n /// repeated in two separate places in code.\n /// \\returns true if such a diagnostic was emitted, false otherwise.\n bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,\n ArrayRef AC1, NamedDecl *D2, ArrayRef AC2);\n\n /// \\brief Check whether the given list of constraint expressions are\n /// satisfied (as if in a 'conjunction') given template arguments.\n /// \\param Template the template-like entity that triggered the constraints\n /// check (either a concept or a constrained entity).\n /// \\param ConstraintExprs a list of constraint expressions, treated as if\n /// they were 'AND'ed together.\n /// \\param TemplateArgs the list of template arguments to substitute into the\n /// constraint expression.\n /// \\param TemplateIDRange The source range of the template id that\n /// caused the constraints check.\n /// \\param Satisfaction if true is returned, will contain details of the\n /// satisfaction, with enough information to diagnose an unsatisfied\n /// expression.\n /// \\returns true if an error occurred and satisfaction could not be checked,\n /// false otherwise.\n bool CheckConstraintSatisfaction(\n const NamedDecl *Template, ArrayRef ConstraintExprs,\n ArrayRef TemplateArgs,\n SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);\n\n /// \\brief Check whether the given non-dependent constraint expression is\n /// satisfied. Returns false and updates Satisfaction with the satisfaction\n /// verdict if successful, emits a diagnostic and returns true if an error\n /// occured and satisfaction could not be determined.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,\n ConstraintSatisfaction &Satisfaction);\n\n /// Check whether the given function decl's trailing requires clause is\n /// satisfied, if any. Returns false and updates Satisfaction with the\n /// satisfaction verdict if successful, emits a diagnostic and returns true if\n /// an error occured and satisfaction could not be determined.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool CheckFunctionConstraints(const FunctionDecl *FD,\n ConstraintSatisfaction &Satisfaction,\n SourceLocation UsageLoc = SourceLocation());\n\n\n /// \\brief Ensure that the given template arguments satisfy the constraints\n /// associated with the given template, emitting a diagnostic if they do not.\n ///\n /// \\param Template The template to which the template arguments are being\n /// provided.\n ///\n /// \\param TemplateArgs The converted, canonicalized template arguments.\n ///\n /// \\param TemplateIDRange The source range of the template id that\n /// caused the constraints check.\n ///\n /// \\returns true if the constrains are not satisfied or could not be checked\n /// for satisfaction, false if the constraints are satisfied.\n bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template,\n ArrayRef TemplateArgs,\n SourceRange TemplateIDRange);\n\n /// \\brief Emit diagnostics explaining why a constraint expression was deemed\n /// unsatisfied.\n /// \\param First whether this is the first time an unsatisfied constraint is\n /// diagnosed for this error.\n void\n DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction,\n bool First = true);\n\n /// \\brief Emit diagnostics explaining why a constraint expression was deemed\n /// unsatisfied.\n void\n DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction,\n bool First = true);\n\n // ParseObjCStringLiteral - Parse Objective-C string literals.\n ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,\n ArrayRef Strings);\n\n ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);\n\n /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the\n /// numeric literal expression. Type of the expression will be \"NSNumber *\"\n /// or \"id\" if NSNumber is unavailable.\n ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);\n ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc,\n bool Value);\n ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements);\n\n /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the\n /// '@' prefixed parenthesized expression. The type of the expression will\n /// either be \"NSNumber *\", \"NSString *\" or \"NSValue *\" depending on the type\n /// of ValueType, which is allowed to be a built-in numeric type, \"char *\",\n /// \"const char *\" or C structure with attribute 'objc_boxable'.\n ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);\n\n ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,\n Expr *IndexExpr,\n ObjCMethodDecl *getterMethod,\n ObjCMethodDecl *setterMethod);\n\n ExprResult BuildObjCDictionaryLiteral(SourceRange SR,\n MutableArrayRef Elements);\n\n ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc,\n TypeSourceInfo *EncodedTypeInfo,\n SourceLocation RParenLoc);\n ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,\n CXXConversionDecl *Method,\n bool HadMultipleCandidates);\n\n ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,\n SourceLocation EncodeLoc,\n SourceLocation LParenLoc,\n ParsedType Ty,\n SourceLocation RParenLoc);\n\n /// ParseObjCSelectorExpression - Build selector expression for \\@selector\n ExprResult ParseObjCSelectorExpression(Selector Sel,\n SourceLocation AtLoc,\n SourceLocation SelLoc,\n SourceLocation LParenLoc,\n SourceLocation RParenLoc,\n bool WarnMultipleSelectors);\n\n /// ParseObjCProtocolExpression - Build protocol expression for \\@protocol\n ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,\n SourceLocation AtLoc,\n SourceLocation ProtoLoc,\n SourceLocation LParenLoc,\n SourceLocation ProtoIdLoc,\n SourceLocation RParenLoc);\n\n //===--------------------------------------------------------------------===//\n // C++ Declarations\n //\n Decl *ActOnStartLinkageSpecification(Scope *S,\n SourceLocation ExternLoc,\n Expr *LangStr,\n SourceLocation LBraceLoc);\n Decl *ActOnFinishLinkageSpecification(Scope *S,\n Decl *LinkageSpec,\n SourceLocation RBraceLoc);\n\n\n //===--------------------------------------------------------------------===//\n // C++ Classes\n //\n CXXRecordDecl *getCurrentClass(Scope *S, const CXXScopeSpec *SS);\n bool isCurrentClassName(const IdentifierInfo &II, Scope *S,\n const CXXScopeSpec *SS = nullptr);\n bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS);\n\n bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc,\n SourceLocation ColonLoc,\n const ParsedAttributesView &Attrs);\n\n NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,\n Declarator &D,\n MultiTemplateParamsArg TemplateParameterLists,\n Expr *BitfieldWidth, const VirtSpecifiers &VS,\n InClassInitStyle InitStyle);\n\n void ActOnStartCXXInClassMemberInitializer();\n void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl,\n SourceLocation EqualLoc,\n Expr *Init);\n\n MemInitResult ActOnMemInitializer(Decl *ConstructorD,\n Scope *S,\n CXXScopeSpec &SS,\n IdentifierInfo *MemberOrBase,\n ParsedType TemplateTypeTy,\n const DeclSpec &DS,\n SourceLocation IdLoc,\n SourceLocation LParenLoc,\n ArrayRef Args,\n SourceLocation RParenLoc,\n SourceLocation EllipsisLoc);\n\n MemInitResult ActOnMemInitializer(Decl *ConstructorD,\n Scope *S,\n CXXScopeSpec &SS,\n IdentifierInfo *MemberOrBase,\n ParsedType TemplateTypeTy,\n const DeclSpec &DS,\n SourceLocation IdLoc,\n Expr *InitList,\n SourceLocation EllipsisLoc);\n\n MemInitResult BuildMemInitializer(Decl *ConstructorD,\n Scope *S,\n CXXScopeSpec &SS,\n IdentifierInfo *MemberOrBase,\n ParsedType TemplateTypeTy,\n const DeclSpec &DS,\n SourceLocation IdLoc,\n Expr *Init,\n SourceLocation EllipsisLoc);\n\n MemInitResult BuildMemberInitializer(ValueDecl *Member,\n Expr *Init,\n SourceLocation IdLoc);\n\n MemInitResult BuildBaseInitializer(QualType BaseType,\n TypeSourceInfo *BaseTInfo,\n Expr *Init,\n CXXRecordDecl *ClassDecl,\n SourceLocation EllipsisLoc);\n\n MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo,\n Expr *Init,\n CXXRecordDecl *ClassDecl);\n\n bool SetDelegatingInitializer(CXXConstructorDecl *Constructor,\n CXXCtorInitializer *Initializer);\n\n bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,\n ArrayRef Initializers = None);\n\n void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation);\n\n\n /// MarkBaseAndMemberDestructorsReferenced - Given a record decl,\n /// mark all the non-trivial destructors of its members and bases as\n /// referenced.\n void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc,\n CXXRecordDecl *Record);\n\n /// Mark destructors of virtual bases of this class referenced. In the Itanium\n /// C++ ABI, this is done when emitting a destructor for any non-abstract\n /// class. In the Microsoft C++ ABI, this is done any time a class's\n /// destructor is referenced.\n void MarkVirtualBaseDestructorsReferenced(\n SourceLocation Location, CXXRecordDecl *ClassDecl,\n llvm::SmallPtrSetImpl *DirectVirtualBases = nullptr);\n\n /// Do semantic checks to allow the complete destructor variant to be emitted\n /// when the destructor is defined in another translation unit. In the Itanium\n /// C++ ABI, destructor variants are emitted together. In the MS C++ ABI, they\n /// can be emitted in separate TUs. To emit the complete variant, run a subset\n /// of the checks performed when emitting a regular destructor.\n void CheckCompleteDestructorVariant(SourceLocation CurrentLocation,\n CXXDestructorDecl *Dtor);\n\n /// The list of classes whose vtables have been used within\n /// this translation unit, and the source locations at which the\n /// first use occurred.\n typedef std::pair VTableUse;\n\n /// The list of vtables that are required but have not yet been\n /// materialized.\n SmallVector VTableUses;\n\n /// The set of classes whose vtables have been used within\n /// this translation unit, and a bit that will be true if the vtable is\n /// required to be emitted (otherwise, it should be emitted only if needed\n /// by code generation).\n llvm::DenseMap VTablesUsed;\n\n /// Load any externally-stored vtable uses.\n void LoadExternalVTableUses();\n\n /// Note that the vtable for the given class was used at the\n /// given location.\n void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,\n bool DefinitionRequired = false);\n\n /// Mark the exception specifications of all virtual member functions\n /// in the given class as needed.\n void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,\n const CXXRecordDecl *RD);\n\n /// MarkVirtualMembersReferenced - Will mark all members of the given\n /// CXXRecordDecl referenced.\n void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD,\n bool ConstexprOnly = false);\n\n /// Define all of the vtables that have been used in this\n /// translation unit and reference any virtual members used by those\n /// vtables.\n ///\n /// \\returns true if any work was done, false otherwise.\n bool DefineUsedVTables();\n\n void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);\n\n void ActOnMemInitializers(Decl *ConstructorDecl,\n SourceLocation ColonLoc,\n ArrayRef MemInits,\n bool AnyErrors);\n\n /// Check class-level dllimport/dllexport attribute. The caller must\n /// ensure that referenceDLLExportedClassMethods is called some point later\n /// when all outer classes of Class are complete.\n void checkClassLevelDLLAttribute(CXXRecordDecl *Class);\n void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class);\n\n void referenceDLLExportedClassMethods();\n\n void propagateDLLAttrToBaseClassTemplate(\n CXXRecordDecl *Class, Attr *ClassAttr,\n ClassTemplateSpecializationDecl *BaseTemplateSpec,\n SourceLocation BaseLoc);\n\n /// Add gsl::Pointer attribute to std::container::iterator\n /// \\param ND The declaration that introduces the name\n /// std::container::iterator. \\param UnderlyingRecord The record named by ND.\n void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord);\n\n /// Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.\n void inferGslOwnerPointerAttribute(CXXRecordDecl *Record);\n\n /// Add [[gsl::Pointer]] attributes for std:: types.\n void inferGslPointerAttribute(TypedefNameDecl *TD);\n\n void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record);\n\n /// Check that the C++ class annoated with \"trivial_abi\" satisfies all the\n /// conditions that are needed for the attribute to have an effect.\n void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD);\n\n void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc,\n Decl *TagDecl, SourceLocation LBrac,\n SourceLocation RBrac,\n const ParsedAttributesView &AttrList);\n void ActOnFinishCXXMemberDecls();\n void ActOnFinishCXXNonNestedClass();\n\n void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param);\n unsigned ActOnReenterTemplateScope(Decl *Template,\n llvm::function_ref EnterScope);\n void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record);\n void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method);\n void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param);\n void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record);\n void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method);\n void ActOnFinishDelayedMemberInitializers(Decl *Record);\n void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,\n CachedTokens &Toks);\n void UnmarkAsLateParsedTemplate(FunctionDecl *FD);\n bool IsInsideALocalClassWithinATemplateFunction();\n\n Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,\n Expr *AssertExpr,\n Expr *AssertMessageExpr,\n SourceLocation RParenLoc);\n Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,\n Expr *AssertExpr,\n StringLiteral *AssertMessageExpr,\n SourceLocation RParenLoc,\n bool Failed);\n\n FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart,\n SourceLocation FriendLoc,\n TypeSourceInfo *TSInfo);\n Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,\n MultiTemplateParamsArg TemplateParams);\n NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D,\n MultiTemplateParamsArg TemplateParams);\n\n QualType CheckConstructorDeclarator(Declarator &D, QualType R,\n StorageClass& SC);\n void CheckConstructor(CXXConstructorDecl *Constructor);\n QualType CheckDestructorDeclarator(Declarator &D, QualType R,\n StorageClass& SC);\n bool CheckDestructor(CXXDestructorDecl *Destructor);\n void CheckConversionDeclarator(Declarator &D, QualType &R,\n StorageClass& SC);\n Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);\n void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,\n StorageClass &SC);\n void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);\n\n void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD);\n\n bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,\n CXXSpecialMember CSM);\n void CheckDelayedMemberExceptionSpecs();\n\n bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD,\n DefaultedComparisonKind DCK);\n void DeclareImplicitEqualityComparison(CXXRecordDecl *RD,\n FunctionDecl *Spaceship);\n void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD,\n DefaultedComparisonKind DCK);\n\n //===--------------------------------------------------------------------===//\n // C++ Derived Classes\n //\n\n /// ActOnBaseSpecifier - Parsed a base specifier\n CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,\n SourceRange SpecifierRange,\n bool Virtual, AccessSpecifier Access,\n TypeSourceInfo *TInfo,\n SourceLocation EllipsisLoc);\n\n BaseResult ActOnBaseSpecifier(Decl *classdecl,\n SourceRange SpecifierRange,\n ParsedAttributes &Attrs,\n bool Virtual, AccessSpecifier Access,\n ParsedType basetype,\n SourceLocation BaseLoc,\n SourceLocation EllipsisLoc);\n\n bool AttachBaseSpecifiers(CXXRecordDecl *Class,\n MutableArrayRef Bases);\n void ActOnBaseSpecifiers(Decl *ClassDecl,\n MutableArrayRef Bases);\n\n bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);\n bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,\n CXXBasePaths &Paths);\n\n // FIXME: I don't like this name.\n void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath);\n\n bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,\n SourceLocation Loc, SourceRange Range,\n CXXCastPath *BasePath = nullptr,\n bool IgnoreAccess = false);\n bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,\n unsigned InaccessibleBaseID,\n unsigned AmbiguousBaseConvID,\n SourceLocation Loc, SourceRange Range,\n DeclarationName Name,\n CXXCastPath *BasePath,\n bool IgnoreAccess = false);\n\n std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);\n\n bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,\n const CXXMethodDecl *Old);\n\n /// CheckOverridingFunctionReturnType - Checks whether the return types are\n /// covariant, according to C++ [class.virtual]p5.\n bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,\n const CXXMethodDecl *Old);\n\n /// CheckOverridingFunctionExceptionSpec - Checks whether the exception\n /// spec is a subset of base spec.\n bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,\n const CXXMethodDecl *Old);\n\n bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);\n\n /// CheckOverrideControl - Check C++11 override control semantics.\n void CheckOverrideControl(NamedDecl *D);\n\n /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was\n /// not used in the declaration of an overriding method.\n void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent);\n\n /// CheckForFunctionMarkedFinal - Checks whether a virtual member function\n /// overrides a virtual member function marked 'final', according to\n /// C++11 [class.virtual]p4.\n bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,\n const CXXMethodDecl *Old);\n\n\n //===--------------------------------------------------------------------===//\n // C++ Access Control\n //\n\n enum AccessResult {\n AR_accessible,\n AR_inaccessible,\n AR_dependent,\n AR_delayed\n };\n\n bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,\n NamedDecl *PrevMemberDecl,\n AccessSpecifier LexicalAS);\n\n AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,\n DeclAccessPair FoundDecl);\n AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,\n DeclAccessPair FoundDecl);\n AccessResult CheckAllocationAccess(SourceLocation OperatorLoc,\n SourceRange PlacementRange,\n CXXRecordDecl *NamingClass,\n DeclAccessPair FoundDecl,\n bool Diagnose = true);\n AccessResult CheckConstructorAccess(SourceLocation Loc,\n CXXConstructorDecl *D,\n DeclAccessPair FoundDecl,\n const InitializedEntity &Entity,\n bool IsCopyBindingRefToTemp = false);\n AccessResult CheckConstructorAccess(SourceLocation Loc,\n CXXConstructorDecl *D,\n DeclAccessPair FoundDecl,\n const InitializedEntity &Entity,\n const PartialDiagnostic &PDiag);\n AccessResult CheckDestructorAccess(SourceLocation Loc,\n CXXDestructorDecl *Dtor,\n const PartialDiagnostic &PDiag,\n QualType objectType = QualType());\n AccessResult CheckFriendAccess(NamedDecl *D);\n AccessResult CheckMemberAccess(SourceLocation UseLoc,\n CXXRecordDecl *NamingClass,\n DeclAccessPair Found);\n AccessResult\n CheckStructuredBindingMemberAccess(SourceLocation UseLoc,\n CXXRecordDecl *DecomposedClass,\n DeclAccessPair Field);\n AccessResult CheckMemberOperatorAccess(SourceLocation Loc,\n Expr *ObjectExpr,\n Expr *ArgExpr,\n DeclAccessPair FoundDecl);\n AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,\n DeclAccessPair FoundDecl);\n AccessResult CheckBaseClassAccess(SourceLocation AccessLoc,\n QualType Base, QualType Derived,\n const CXXBasePath &Path,\n unsigned DiagID,\n bool ForceCheck = false,\n bool ForceUnprivileged = false);\n void CheckLookupAccess(const LookupResult &R);\n bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass,\n QualType BaseType);\n bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,\n DeclAccessPair Found, QualType ObjectType,\n SourceLocation Loc,\n const PartialDiagnostic &Diag);\n bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,\n DeclAccessPair Found,\n QualType ObjectType) {\n return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType,\n SourceLocation(), PDiag());\n }\n\n void HandleDependentAccessCheck(const DependentDiagnostic &DD,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n void PerformDependentDiagnostics(const DeclContext *Pattern,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);\n\n /// When true, access checking violations are treated as SFINAE\n /// failures rather than hard errors.\n bool AccessCheckingSFINAE;\n\n enum AbstractDiagSelID {\n AbstractNone = -1,\n AbstractReturnType,\n AbstractParamType,\n AbstractVariableType,\n AbstractFieldType,\n AbstractIvarType,\n AbstractSynthesizedIvarType,\n AbstractArrayType\n };\n\n bool isAbstractType(SourceLocation Loc, QualType T);\n bool RequireNonAbstractType(SourceLocation Loc, QualType T,\n TypeDiagnoser &Diagnoser);\n template \n bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,\n const Ts &...Args) {\n BoundTypeDiagnoser Diagnoser(DiagID, Args...);\n return RequireNonAbstractType(Loc, T, Diagnoser);\n }\n\n void DiagnoseAbstractType(const CXXRecordDecl *RD);\n\n //===--------------------------------------------------------------------===//\n // C++ Overloaded Operators [C++ 13.5]\n //\n\n bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);\n\n bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl);\n\n //===--------------------------------------------------------------------===//\n // C++ Templates [C++ 14]\n //\n void FilterAcceptableTemplateNames(LookupResult &R,\n bool AllowFunctionTemplates = true,\n bool AllowDependent = true);\n bool hasAnyAcceptableTemplateNames(LookupResult &R,\n bool AllowFunctionTemplates = true,\n bool AllowDependent = true,\n bool AllowNonTemplateFunctions = false);\n /// Try to interpret the lookup result D as a template-name.\n ///\n /// \\param D A declaration found by name lookup.\n /// \\param AllowFunctionTemplates Whether function templates should be\n /// considered valid results.\n /// \\param AllowDependent Whether unresolved using declarations (that might\n /// name templates) should be considered valid results.\n static NamedDecl *getAsTemplateNameDecl(NamedDecl *D,\n bool AllowFunctionTemplates = true,\n bool AllowDependent = true);\n\n enum TemplateNameIsRequiredTag { TemplateNameIsRequired };\n /// Whether and why a template name is required in this lookup.\n class RequiredTemplateKind {\n public:\n /// Template name is required if TemplateKWLoc is valid.\n RequiredTemplateKind(SourceLocation TemplateKWLoc = SourceLocation())\n : TemplateKW(TemplateKWLoc) {}\n /// Template name is unconditionally required.\n RequiredTemplateKind(TemplateNameIsRequiredTag) : TemplateKW() {}\n\n SourceLocation getTemplateKeywordLoc() const {\n return TemplateKW.getValueOr(SourceLocation());\n }\n bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }\n bool isRequired() const { return TemplateKW != SourceLocation(); }\n explicit operator bool() const { return isRequired(); }\n\n private:\n llvm::Optional TemplateKW;\n };\n\n enum class AssumedTemplateKind {\n /// This is not assumed to be a template name.\n None,\n /// This is assumed to be a template name because lookup found nothing.\n FoundNothing,\n /// This is assumed to be a template name because lookup found one or more\n /// functions (but no function templates).\n FoundFunctions,\n };\n bool LookupTemplateName(\n LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType,\n bool EnteringContext, bool &MemberOfUnknownSpecialization,\n RequiredTemplateKind RequiredTemplate = SourceLocation(),\n AssumedTemplateKind *ATK = nullptr, bool AllowTypoCorrection = true);\n\n TemplateNameKind isTemplateName(Scope *S,\n CXXScopeSpec &SS,\n bool hasTemplateKeyword,\n const UnqualifiedId &Name,\n ParsedType ObjectType,\n bool EnteringContext,\n TemplateTy &Template,\n bool &MemberOfUnknownSpecialization,\n bool Disambiguation = false);\n\n /// Try to resolve an undeclared template name as a type template.\n ///\n /// Sets II to the identifier corresponding to the template name, and updates\n /// Name to a corresponding (typo-corrected) type template name and TNK to\n /// the corresponding kind, if possible.\n void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name,\n TemplateNameKind &TNK,\n SourceLocation NameLoc,\n IdentifierInfo *&II);\n\n bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,\n SourceLocation NameLoc,\n bool Diagnose = true);\n\n /// Determine whether a particular identifier might be the name in a C++1z\n /// deduction-guide declaration.\n bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,\n SourceLocation NameLoc,\n ParsedTemplateTy *Template = nullptr);\n\n bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,\n SourceLocation IILoc,\n Scope *S,\n const CXXScopeSpec *SS,\n TemplateTy &SuggestedTemplate,\n TemplateNameKind &SuggestedKind);\n\n bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,\n NamedDecl *Instantiation,\n bool InstantiatedFromMember,\n const NamedDecl *Pattern,\n const NamedDecl *PatternDef,\n TemplateSpecializationKind TSK,\n bool Complain = true);\n\n void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);\n TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl);\n\n NamedDecl *ActOnTypeParameter(Scope *S, bool Typename,\n SourceLocation EllipsisLoc,\n SourceLocation KeyLoc,\n IdentifierInfo *ParamName,\n SourceLocation ParamNameLoc,\n unsigned Depth, unsigned Position,\n SourceLocation EqualLoc,\n ParsedType DefaultArg, bool HasTypeConstraint);\n\n bool ActOnTypeConstraint(const CXXScopeSpec &SS,\n TemplateIdAnnotation *TypeConstraint,\n TemplateTypeParmDecl *ConstrainedParameter,\n SourceLocation EllipsisLoc);\n\n bool AttachTypeConstraint(NestedNameSpecifierLoc NS,\n DeclarationNameInfo NameInfo,\n ConceptDecl *NamedConcept,\n const TemplateArgumentListInfo *TemplateArgs,\n TemplateTypeParmDecl *ConstrainedParameter,\n SourceLocation EllipsisLoc);\n\n bool AttachTypeConstraint(AutoTypeLoc TL,\n NonTypeTemplateParmDecl *ConstrainedParameter,\n SourceLocation EllipsisLoc);\n\n bool RequireStructuralType(QualType T, SourceLocation Loc);\n\n QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,\n SourceLocation Loc);\n QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);\n\n NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,\n unsigned Depth,\n unsigned Position,\n SourceLocation EqualLoc,\n Expr *DefaultArg);\n NamedDecl *ActOnTemplateTemplateParameter(Scope *S,\n SourceLocation TmpLoc,\n TemplateParameterList *Params,\n SourceLocation EllipsisLoc,\n IdentifierInfo *ParamName,\n SourceLocation ParamNameLoc,\n unsigned Depth,\n unsigned Position,\n SourceLocation EqualLoc,\n ParsedTemplateArgument DefaultArg);\n\n TemplateParameterList *\n ActOnTemplateParameterList(unsigned Depth,\n SourceLocation ExportLoc,\n SourceLocation TemplateLoc,\n SourceLocation LAngleLoc,\n ArrayRef Params,\n SourceLocation RAngleLoc,\n Expr *RequiresClause);\n\n /// The context in which we are checking a template parameter list.\n enum TemplateParamListContext {\n TPC_ClassTemplate,\n TPC_VarTemplate,\n TPC_FunctionTemplate,\n TPC_ClassTemplateMember,\n TPC_FriendClassTemplate,\n TPC_FriendFunctionTemplate,\n TPC_FriendFunctionTemplateDefinition,\n TPC_TypeAliasTemplate\n };\n\n bool CheckTemplateParameterList(TemplateParameterList *NewParams,\n TemplateParameterList *OldParams,\n TemplateParamListContext TPC,\n SkipBodyInfo *SkipBody = nullptr);\n TemplateParameterList *MatchTemplateParametersToScopeSpecifier(\n SourceLocation DeclStartLoc, SourceLocation DeclLoc,\n const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId,\n ArrayRef ParamLists,\n bool IsFriend, bool &IsMemberSpecialization, bool &Invalid,\n bool SuppressDiagnostic = false);\n\n DeclResult CheckClassTemplate(\n Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,\n CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,\n const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,\n AccessSpecifier AS, SourceLocation ModulePrivateLoc,\n SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,\n TemplateParameterList **OuterTemplateParamLists,\n SkipBodyInfo *SkipBody = nullptr);\n\n TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,\n QualType NTTPType,\n SourceLocation Loc);\n\n /// Get a template argument mapping the given template parameter to itself,\n /// e.g. for X in \\c template, this would return an expression template\n /// argument referencing X.\n TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param,\n SourceLocation Location);\n\n void translateTemplateArguments(const ASTTemplateArgsPtr &In,\n TemplateArgumentListInfo &Out);\n\n ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType);\n\n void NoteAllFoundTemplates(TemplateName Name);\n\n QualType CheckTemplateIdType(TemplateName Template,\n SourceLocation TemplateLoc,\n TemplateArgumentListInfo &TemplateArgs);\n\n TypeResult\n ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,\n TemplateTy Template, IdentifierInfo *TemplateII,\n SourceLocation TemplateIILoc, SourceLocation LAngleLoc,\n ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc,\n bool IsCtorOrDtorName = false, bool IsClassName = false);\n\n /// Parsed an elaborated-type-specifier that refers to a template-id,\n /// such as \\c class T::template apply.\n TypeResult ActOnTagTemplateIdType(TagUseKind TUK,\n TypeSpecifierType TagSpec,\n SourceLocation TagLoc,\n CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n TemplateTy TemplateD,\n SourceLocation TemplateLoc,\n SourceLocation LAngleLoc,\n ASTTemplateArgsPtr TemplateArgsIn,\n SourceLocation RAngleLoc);\n\n DeclResult ActOnVarTemplateSpecialization(\n Scope *S, Declarator &D, TypeSourceInfo *DI,\n SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,\n StorageClass SC, bool IsPartialSpecialization);\n\n /// Get the specialization of the given variable template corresponding to\n /// the specified argument list, or a null-but-valid result if the arguments\n /// are dependent.\n DeclResult CheckVarTemplateId(VarTemplateDecl *Template,\n SourceLocation TemplateLoc,\n SourceLocation TemplateNameLoc,\n const TemplateArgumentListInfo &TemplateArgs);\n\n /// Form a reference to the specialization of the given variable template\n /// corresponding to the specified argument list, or a null-but-valid result\n /// if the arguments are dependent.\n ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,\n const DeclarationNameInfo &NameInfo,\n VarTemplateDecl *Template,\n SourceLocation TemplateLoc,\n const TemplateArgumentListInfo *TemplateArgs);\n\n ExprResult\n CheckConceptTemplateId(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n const DeclarationNameInfo &ConceptNameInfo,\n NamedDecl *FoundDecl, ConceptDecl *NamedConcept,\n const TemplateArgumentListInfo *TemplateArgs);\n\n void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc);\n\n ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n LookupResult &R,\n bool RequiresADL,\n const TemplateArgumentListInfo *TemplateArgs);\n\n ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,\n SourceLocation TemplateKWLoc,\n const DeclarationNameInfo &NameInfo,\n const TemplateArgumentListInfo *TemplateArgs);\n\n TemplateNameKind ActOnTemplateName(\n Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,\n const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext,\n TemplateTy &Template, bool AllowInjectedClassName = false);\n\n DeclResult ActOnClassTemplateSpecialization(\n Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,\n SourceLocation ModulePrivateLoc, CXXScopeSpec &SS,\n TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr,\n MultiTemplateParamsArg TemplateParameterLists,\n SkipBodyInfo *SkipBody = nullptr);\n\n bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc,\n TemplateDecl *PrimaryTemplate,\n unsigned NumExplicitArgs,\n ArrayRef Args);\n void CheckTemplatePartialSpecialization(\n ClassTemplatePartialSpecializationDecl *Partial);\n void CheckTemplatePartialSpecialization(\n VarTemplatePartialSpecializationDecl *Partial);\n\n Decl *ActOnTemplateDeclarator(Scope *S,\n MultiTemplateParamsArg TemplateParameterLists,\n Declarator &D);\n\n bool\n CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,\n TemplateSpecializationKind NewTSK,\n NamedDecl *PrevDecl,\n TemplateSpecializationKind PrevTSK,\n SourceLocation PrevPtOfInstantiation,\n bool &SuppressNew);\n\n bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,\n const TemplateArgumentListInfo &ExplicitTemplateArgs,\n LookupResult &Previous);\n\n bool CheckFunctionTemplateSpecialization(\n FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,\n LookupResult &Previous, bool QualifiedFriend = false);\n bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);\n void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous);\n\n DeclResult ActOnExplicitInstantiation(\n Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,\n unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,\n TemplateTy Template, SourceLocation TemplateNameLoc,\n SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs,\n SourceLocation RAngleLoc, const ParsedAttributesView &Attr);\n\n DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,\n SourceLocation TemplateLoc,\n unsigned TagSpec, SourceLocation KWLoc,\n CXXScopeSpec &SS, IdentifierInfo *Name,\n SourceLocation NameLoc,\n const ParsedAttributesView &Attr);\n\n DeclResult ActOnExplicitInstantiation(Scope *S,\n SourceLocation ExternLoc,\n SourceLocation TemplateLoc,\n Declarator &D);\n\n TemplateArgumentLoc\n SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,\n SourceLocation TemplateLoc,\n SourceLocation RAngleLoc,\n Decl *Param,\n SmallVectorImpl\n &Converted,\n bool &HasDefaultArg);\n\n /// Specifies the context in which a particular template\n /// argument is being checked.\n enum CheckTemplateArgumentKind {\n /// The template argument was specified in the code or was\n /// instantiated with some deduced template arguments.\n CTAK_Specified,\n\n /// The template argument was deduced via template argument\n /// deduction.\n CTAK_Deduced,\n\n /// The template argument was deduced from an array bound\n /// via template argument deduction.\n CTAK_DeducedFromArrayBound\n };\n\n bool CheckTemplateArgument(NamedDecl *Param,\n TemplateArgumentLoc &Arg,\n NamedDecl *Template,\n SourceLocation TemplateLoc,\n SourceLocation RAngleLoc,\n unsigned ArgumentPackIndex,\n SmallVectorImpl &Converted,\n CheckTemplateArgumentKind CTAK = CTAK_Specified);\n\n /// Check that the given template arguments can be be provided to\n /// the given template, converting the arguments along the way.\n ///\n /// \\param Template The template to which the template arguments are being\n /// provided.\n ///\n /// \\param TemplateLoc The location of the template name in the source.\n ///\n /// \\param TemplateArgs The list of template arguments. If the template is\n /// a template template parameter, this function may extend the set of\n /// template arguments to also include substituted, defaulted template\n /// arguments.\n ///\n /// \\param PartialTemplateArgs True if the list of template arguments is\n /// intentionally partial, e.g., because we're checking just the initial\n /// set of template arguments.\n ///\n /// \\param Converted Will receive the converted, canonicalized template\n /// arguments.\n ///\n /// \\param UpdateArgsWithConversions If \\c true, update \\p TemplateArgs to\n /// contain the converted forms of the template arguments as written.\n /// Otherwise, \\p TemplateArgs will not be modified.\n ///\n /// \\param ConstraintsNotSatisfied If provided, and an error occured, will\n /// receive true if the cause for the error is the associated constraints of\n /// the template not being satisfied by the template arguments.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool CheckTemplateArgumentList(TemplateDecl *Template,\n SourceLocation TemplateLoc,\n TemplateArgumentListInfo &TemplateArgs,\n bool PartialTemplateArgs,\n SmallVectorImpl &Converted,\n bool UpdateArgsWithConversions = true,\n bool *ConstraintsNotSatisfied = nullptr);\n\n bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,\n TemplateArgumentLoc &Arg,\n SmallVectorImpl &Converted);\n\n bool CheckTemplateArgument(TemplateTypeParmDecl *Param,\n TypeSourceInfo *Arg);\n ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,\n QualType InstantiatedParamType, Expr *Arg,\n TemplateArgument &Converted,\n CheckTemplateArgumentKind CTAK = CTAK_Specified);\n bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,\n TemplateParameterList *Params,\n TemplateArgumentLoc &Arg);\n\n ExprResult\n BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,\n QualType ParamType,\n SourceLocation Loc);\n ExprResult\n BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,\n SourceLocation Loc);\n\n /// Enumeration describing how template parameter lists are compared\n /// for equality.\n enum TemplateParameterListEqualKind {\n /// We are matching the template parameter lists of two templates\n /// that might be redeclarations.\n ///\n /// \\code\n /// template struct X;\n /// template struct X;\n /// \\endcode\n TPL_TemplateMatch,\n\n /// We are matching the template parameter lists of two template\n /// template parameters as part of matching the template parameter lists\n /// of two templates that might be redeclarations.\n ///\n /// \\code\n /// template class TT> struct X;\n /// template class Other> struct X;\n /// \\endcode\n TPL_TemplateTemplateParmMatch,\n\n /// We are matching the template parameter lists of a template\n /// template argument against the template parameter lists of a template\n /// template parameter.\n ///\n /// \\code\n /// template class Metafun> struct X;\n /// template struct integer_c;\n /// X xic;\n /// \\endcode\n TPL_TemplateTemplateArgumentMatch\n };\n\n bool TemplateParameterListsAreEqual(TemplateParameterList *New,\n TemplateParameterList *Old,\n bool Complain,\n TemplateParameterListEqualKind Kind,\n SourceLocation TemplateArgLoc\n = SourceLocation());\n\n bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);\n\n /// Called when the parser has parsed a C++ typename\n /// specifier, e.g., \"typename T::type\".\n ///\n /// \\param S The scope in which this typename type occurs.\n /// \\param TypenameLoc the location of the 'typename' keyword\n /// \\param SS the nested-name-specifier following the typename (e.g., 'T::').\n /// \\param II the identifier we're retrieving (e.g., 'type' in the example).\n /// \\param IdLoc the location of the identifier.\n TypeResult\n ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,\n const CXXScopeSpec &SS, const IdentifierInfo &II,\n SourceLocation IdLoc);\n\n /// Called when the parser has parsed a C++ typename\n /// specifier that ends in a template-id, e.g.,\n /// \"typename MetaFun::template apply\".\n ///\n /// \\param S The scope in which this typename type occurs.\n /// \\param TypenameLoc the location of the 'typename' keyword\n /// \\param SS the nested-name-specifier following the typename (e.g., 'T::').\n /// \\param TemplateLoc the location of the 'template' keyword, if any.\n /// \\param TemplateName The template name.\n /// \\param TemplateII The identifier used to name the template.\n /// \\param TemplateIILoc The location of the template name.\n /// \\param LAngleLoc The location of the opening angle bracket ('<').\n /// \\param TemplateArgs The template arguments.\n /// \\param RAngleLoc The location of the closing angle bracket ('>').\n TypeResult\n ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,\n const CXXScopeSpec &SS,\n SourceLocation TemplateLoc,\n TemplateTy TemplateName,\n IdentifierInfo *TemplateII,\n SourceLocation TemplateIILoc,\n SourceLocation LAngleLoc,\n ASTTemplateArgsPtr TemplateArgs,\n SourceLocation RAngleLoc);\n\n QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,\n SourceLocation KeywordLoc,\n NestedNameSpecifierLoc QualifierLoc,\n const IdentifierInfo &II,\n SourceLocation IILoc,\n TypeSourceInfo **TSI,\n bool DeducedTSTContext);\n\n QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,\n SourceLocation KeywordLoc,\n NestedNameSpecifierLoc QualifierLoc,\n const IdentifierInfo &II,\n SourceLocation IILoc,\n bool DeducedTSTContext = true);\n\n\n TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,\n SourceLocation Loc,\n DeclarationName Name);\n bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS);\n\n ExprResult RebuildExprInCurrentInstantiation(Expr *E);\n bool RebuildTemplateParamsInCurrentInstantiation(\n TemplateParameterList *Params);\n\n std::string\n getTemplateArgumentBindingsText(const TemplateParameterList *Params,\n const TemplateArgumentList &Args);\n\n std::string\n getTemplateArgumentBindingsText(const TemplateParameterList *Params,\n const TemplateArgument *Args,\n unsigned NumArgs);\n\n //===--------------------------------------------------------------------===//\n // C++ Concepts\n //===--------------------------------------------------------------------===//\n Decl *ActOnConceptDefinition(\n Scope *S, MultiTemplateParamsArg TemplateParameterLists,\n IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr);\n\n RequiresExprBodyDecl *\n ActOnStartRequiresExpr(SourceLocation RequiresKWLoc,\n ArrayRef LocalParameters,\n Scope *BodyScope);\n void ActOnFinishRequiresExpr();\n concepts::Requirement *ActOnSimpleRequirement(Expr *E);\n concepts::Requirement *ActOnTypeRequirement(\n SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc,\n IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId);\n concepts::Requirement *ActOnCompoundRequirement(Expr *E,\n SourceLocation NoexceptLoc);\n concepts::Requirement *\n ActOnCompoundRequirement(\n Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS,\n TemplateIdAnnotation *TypeConstraint, unsigned Depth);\n concepts::Requirement *ActOnNestedRequirement(Expr *Constraint);\n concepts::ExprRequirement *\n BuildExprRequirement(\n Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc,\n concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);\n concepts::ExprRequirement *\n BuildExprRequirement(\n concepts::Requirement::SubstitutionDiagnostic *ExprSubstDiag,\n bool IsSatisfied, SourceLocation NoexceptLoc,\n concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);\n concepts::TypeRequirement *BuildTypeRequirement(TypeSourceInfo *Type);\n concepts::TypeRequirement *\n BuildTypeRequirement(\n concepts::Requirement::SubstitutionDiagnostic *SubstDiag);\n concepts::NestedRequirement *BuildNestedRequirement(Expr *E);\n concepts::NestedRequirement *\n BuildNestedRequirement(\n concepts::Requirement::SubstitutionDiagnostic *SubstDiag);\n ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc,\n RequiresExprBodyDecl *Body,\n ArrayRef LocalParameters,\n ArrayRef Requirements,\n SourceLocation ClosingBraceLoc);\n\n //===--------------------------------------------------------------------===//\n // C++ Variadic Templates (C++0x [temp.variadic])\n //===--------------------------------------------------------------------===//\n\n /// Determine whether an unexpanded parameter pack might be permitted in this\n /// location. Useful for error recovery.\n bool isUnexpandedParameterPackPermitted();\n\n /// The context in which an unexpanded parameter pack is\n /// being diagnosed.\n ///\n /// Note that the values of this enumeration line up with the first\n /// argument to the \\c err_unexpanded_parameter_pack diagnostic.\n enum UnexpandedParameterPackContext {\n /// An arbitrary expression.\n UPPC_Expression = 0,\n\n /// The base type of a class type.\n UPPC_BaseType,\n\n /// The type of an arbitrary declaration.\n UPPC_DeclarationType,\n\n /// The type of a data member.\n UPPC_DataMemberType,\n\n /// The size of a bit-field.\n UPPC_BitFieldWidth,\n\n /// The expression in a static assertion.\n UPPC_StaticAssertExpression,\n\n /// The fixed underlying type of an enumeration.\n UPPC_FixedUnderlyingType,\n\n /// The enumerator value.\n UPPC_EnumeratorValue,\n\n /// A using declaration.\n UPPC_UsingDeclaration,\n\n /// A friend declaration.\n UPPC_FriendDeclaration,\n\n /// A declaration qualifier.\n UPPC_DeclarationQualifier,\n\n /// An initializer.\n UPPC_Initializer,\n\n /// A default argument.\n UPPC_DefaultArgument,\n\n /// The type of a non-type template parameter.\n UPPC_NonTypeTemplateParameterType,\n\n /// The type of an exception.\n UPPC_ExceptionType,\n\n /// Partial specialization.\n UPPC_PartialSpecialization,\n\n /// Microsoft __if_exists.\n UPPC_IfExists,\n\n /// Microsoft __if_not_exists.\n UPPC_IfNotExists,\n\n /// Lambda expression.\n UPPC_Lambda,\n\n /// Block expression.\n UPPC_Block,\n\n /// A type constraint.\n UPPC_TypeConstraint,\n\n // A requirement in a requires-expression.\n UPPC_Requirement,\n\n // A requires-clause.\n UPPC_RequiresClause,\n };\n\n /// Diagnose unexpanded parameter packs.\n ///\n /// \\param Loc The location at which we should emit the diagnostic.\n ///\n /// \\param UPPC The context in which we are diagnosing unexpanded\n /// parameter packs.\n ///\n /// \\param Unexpanded the set of unexpanded parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc,\n UnexpandedParameterPackContext UPPC,\n ArrayRef Unexpanded);\n\n /// If the given type contains an unexpanded parameter pack,\n /// diagnose the error.\n ///\n /// \\param Loc The source location where a diagnostc should be emitted.\n ///\n /// \\param T The type that is being checked for unexpanded parameter\n /// packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T,\n UnexpandedParameterPackContext UPPC);\n\n /// If the given expression contains an unexpanded parameter\n /// pack, diagnose the error.\n ///\n /// \\param E The expression that is being checked for unexpanded\n /// parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(Expr *E,\n UnexpandedParameterPackContext UPPC = UPPC_Expression);\n\n /// If the given requirees-expression contains an unexpanded reference to one\n /// of its own parameter packs, diagnose the error.\n ///\n /// \\param RE The requiress-expression that is being checked for unexpanded\n /// parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE);\n\n /// If the given nested-name-specifier contains an unexpanded\n /// parameter pack, diagnose the error.\n ///\n /// \\param SS The nested-name-specifier that is being checked for\n /// unexpanded parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,\n UnexpandedParameterPackContext UPPC);\n\n /// If the given name contains an unexpanded parameter pack,\n /// diagnose the error.\n ///\n /// \\param NameInfo The name (with source location information) that\n /// is being checked for unexpanded parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,\n UnexpandedParameterPackContext UPPC);\n\n /// If the given template name contains an unexpanded parameter pack,\n /// diagnose the error.\n ///\n /// \\param Loc The location of the template name.\n ///\n /// \\param Template The template name that is being checked for unexpanded\n /// parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(SourceLocation Loc,\n TemplateName Template,\n UnexpandedParameterPackContext UPPC);\n\n /// If the given template argument contains an unexpanded parameter\n /// pack, diagnose the error.\n ///\n /// \\param Arg The template argument that is being checked for unexpanded\n /// parameter packs.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,\n UnexpandedParameterPackContext UPPC);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// template argument.\n ///\n /// \\param Arg The template argument that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(TemplateArgument Arg,\n SmallVectorImpl &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// template argument.\n ///\n /// \\param Arg The template argument that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,\n SmallVectorImpl &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// type.\n ///\n /// \\param T The type that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(QualType T,\n SmallVectorImpl &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// type.\n ///\n /// \\param TL The type that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(TypeLoc TL,\n SmallVectorImpl &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// nested-name-specifier.\n ///\n /// \\param NNS The nested-name-specifier that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS,\n SmallVectorImpl &Unexpanded);\n\n /// Collect the set of unexpanded parameter packs within the given\n /// name.\n ///\n /// \\param NameInfo The name that will be traversed to find\n /// unexpanded parameter packs.\n void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,\n SmallVectorImpl &Unexpanded);\n\n /// Invoked when parsing a template argument followed by an\n /// ellipsis, which creates a pack expansion.\n ///\n /// \\param Arg The template argument preceding the ellipsis, which\n /// may already be invalid.\n ///\n /// \\param EllipsisLoc The location of the ellipsis.\n ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg,\n SourceLocation EllipsisLoc);\n\n /// Invoked when parsing a type followed by an ellipsis, which\n /// creates a pack expansion.\n ///\n /// \\param Type The type preceding the ellipsis, which will become\n /// the pattern of the pack expansion.\n ///\n /// \\param EllipsisLoc The location of the ellipsis.\n TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc);\n\n /// Construct a pack expansion type from the pattern of the pack\n /// expansion.\n TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern,\n SourceLocation EllipsisLoc,\n Optional NumExpansions);\n\n /// Construct a pack expansion type from the pattern of the pack\n /// expansion.\n QualType CheckPackExpansion(QualType Pattern,\n SourceRange PatternRange,\n SourceLocation EllipsisLoc,\n Optional NumExpansions);\n\n /// Invoked when parsing an expression followed by an ellipsis, which\n /// creates a pack expansion.\n ///\n /// \\param Pattern The expression preceding the ellipsis, which will become\n /// the pattern of the pack expansion.\n ///\n /// \\param EllipsisLoc The location of the ellipsis.\n ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);\n\n /// Invoked when parsing an expression followed by an ellipsis, which\n /// creates a pack expansion.\n ///\n /// \\param Pattern The expression preceding the ellipsis, which will become\n /// the pattern of the pack expansion.\n ///\n /// \\param EllipsisLoc The location of the ellipsis.\n ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,\n Optional NumExpansions);\n\n /// Determine whether we could expand a pack expansion with the\n /// given set of parameter packs into separate arguments by repeatedly\n /// transforming the pattern.\n ///\n /// \\param EllipsisLoc The location of the ellipsis that identifies the\n /// pack expansion.\n ///\n /// \\param PatternRange The source range that covers the entire pattern of\n /// the pack expansion.\n ///\n /// \\param Unexpanded The set of unexpanded parameter packs within the\n /// pattern.\n ///\n /// \\param ShouldExpand Will be set to \\c true if the transformer should\n /// expand the corresponding pack expansions into separate arguments. When\n /// set, \\c NumExpansions must also be set.\n ///\n /// \\param RetainExpansion Whether the caller should add an unexpanded\n /// pack expansion after all of the expanded arguments. This is used\n /// when extending explicitly-specified template argument packs per\n /// C++0x [temp.arg.explicit]p9.\n ///\n /// \\param NumExpansions The number of separate arguments that will be in\n /// the expanded form of the corresponding pack expansion. This is both an\n /// input and an output parameter, which can be set by the caller if the\n /// number of expansions is known a priori (e.g., due to a prior substitution)\n /// and will be set by the callee when the number of expansions is known.\n /// The callee must set this value when \\c ShouldExpand is \\c true; it may\n /// set this value in other cases.\n ///\n /// \\returns true if an error occurred (e.g., because the parameter packs\n /// are to be instantiated with arguments of different lengths), false\n /// otherwise. If false, \\c ShouldExpand (and possibly \\c NumExpansions)\n /// must be set.\n bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,\n SourceRange PatternRange,\n ArrayRef Unexpanded,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n bool &ShouldExpand,\n bool &RetainExpansion,\n Optional &NumExpansions);\n\n /// Determine the number of arguments in the given pack expansion\n /// type.\n ///\n /// This routine assumes that the number of arguments in the expansion is\n /// consistent across all of the unexpanded parameter packs in its pattern.\n ///\n /// Returns an empty Optional if the type can't be expanded.\n Optional getNumArgumentsInExpansion(QualType T,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n /// Determine whether the given declarator contains any unexpanded\n /// parameter packs.\n ///\n /// This routine is used by the parser to disambiguate function declarators\n /// with an ellipsis prior to the ')', e.g.,\n ///\n /// \\code\n /// void f(T...);\n /// \\endcode\n ///\n /// To determine whether we have an (unnamed) function parameter pack or\n /// a variadic function.\n ///\n /// \\returns true if the declarator contains any unexpanded parameter packs,\n /// false otherwise.\n bool containsUnexpandedParameterPacks(Declarator &D);\n\n /// Returns the pattern of the pack expansion for a template argument.\n ///\n /// \\param OrigLoc The template argument to expand.\n ///\n /// \\param Ellipsis Will be set to the location of the ellipsis.\n ///\n /// \\param NumExpansions Will be set to the number of expansions that will\n /// be generated from this pack expansion, if known a priori.\n TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(\n TemplateArgumentLoc OrigLoc,\n SourceLocation &Ellipsis,\n Optional &NumExpansions) const;\n\n /// Given a template argument that contains an unexpanded parameter pack, but\n /// which has already been substituted, attempt to determine the number of\n /// elements that will be produced once this argument is fully-expanded.\n ///\n /// This is intended for use when transforming 'sizeof...(Arg)' in order to\n /// avoid actually expanding the pack where possible.\n Optional getFullyPackExpandedSize(TemplateArgument Arg);\n\n //===--------------------------------------------------------------------===//\n // C++ Template Argument Deduction (C++ [temp.deduct])\n //===--------------------------------------------------------------------===//\n\n /// Adjust the type \\p ArgFunctionType to match the calling convention,\n /// noreturn, and optionally the exception specification of \\p FunctionType.\n /// Deduction often wants to ignore these properties when matching function\n /// types.\n QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType,\n bool AdjustExceptionSpec = false);\n\n /// Describes the result of template argument deduction.\n ///\n /// The TemplateDeductionResult enumeration describes the result of\n /// template argument deduction, as returned from\n /// DeduceTemplateArguments(). The separate TemplateDeductionInfo\n /// structure provides additional information about the results of\n /// template argument deduction, e.g., the deduced template argument\n /// list (if successful) or the specific template parameters or\n /// deduced arguments that were involved in the failure.\n enum TemplateDeductionResult {\n /// Template argument deduction was successful.\n TDK_Success = 0,\n /// The declaration was invalid; do nothing.\n TDK_Invalid,\n /// Template argument deduction exceeded the maximum template\n /// instantiation depth (which has already been diagnosed).\n TDK_InstantiationDepth,\n /// Template argument deduction did not deduce a value\n /// for every template parameter.\n TDK_Incomplete,\n /// Template argument deduction did not deduce a value for every\n /// expansion of an expanded template parameter pack.\n TDK_IncompletePack,\n /// Template argument deduction produced inconsistent\n /// deduced values for the given template parameter.\n TDK_Inconsistent,\n /// Template argument deduction failed due to inconsistent\n /// cv-qualifiers on a template parameter type that would\n /// otherwise be deduced, e.g., we tried to deduce T in \"const T\"\n /// but were given a non-const \"X\".\n TDK_Underqualified,\n /// Substitution of the deduced template argument values\n /// resulted in an error.\n TDK_SubstitutionFailure,\n /// After substituting deduced template arguments, a dependent\n /// parameter type did not match the corresponding argument.\n TDK_DeducedMismatch,\n /// After substituting deduced template arguments, an element of\n /// a dependent parameter type did not match the corresponding element\n /// of the corresponding argument (when deducing from an initializer list).\n TDK_DeducedMismatchNested,\n /// A non-depnedent component of the parameter did not match the\n /// corresponding component of the argument.\n TDK_NonDeducedMismatch,\n /// When performing template argument deduction for a function\n /// template, there were too many call arguments.\n TDK_TooManyArguments,\n /// When performing template argument deduction for a function\n /// template, there were too few call arguments.\n TDK_TooFewArguments,\n /// The explicitly-specified template arguments were not valid\n /// template arguments for the given template.\n TDK_InvalidExplicitArguments,\n /// Checking non-dependent argument conversions failed.\n TDK_NonDependentConversionFailure,\n /// The deduced arguments did not satisfy the constraints associated\n /// with the template.\n TDK_ConstraintsNotSatisfied,\n /// Deduction failed; that's all we know.\n TDK_MiscellaneousDeductionFailure,\n /// CUDA Target attributes do not match.\n TDK_CUDATargetMismatch\n };\n\n TemplateDeductionResult\n DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,\n const TemplateArgumentList &TemplateArgs,\n sema::TemplateDeductionInfo &Info);\n\n TemplateDeductionResult\n DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,\n const TemplateArgumentList &TemplateArgs,\n sema::TemplateDeductionInfo &Info);\n\n TemplateDeductionResult SubstituteExplicitTemplateArguments(\n FunctionTemplateDecl *FunctionTemplate,\n TemplateArgumentListInfo &ExplicitTemplateArgs,\n SmallVectorImpl &Deduced,\n SmallVectorImpl &ParamTypes, QualType *FunctionType,\n sema::TemplateDeductionInfo &Info);\n\n /// brief A function argument from which we performed template argument\n // deduction for a call.\n struct OriginalCallArg {\n OriginalCallArg(QualType OriginalParamType, bool DecomposedParam,\n unsigned ArgIdx, QualType OriginalArgType)\n : OriginalParamType(OriginalParamType),\n DecomposedParam(DecomposedParam), ArgIdx(ArgIdx),\n OriginalArgType(OriginalArgType) {}\n\n QualType OriginalParamType;\n bool DecomposedParam;\n unsigned ArgIdx;\n QualType OriginalArgType;\n };\n\n TemplateDeductionResult FinishTemplateArgumentDeduction(\n FunctionTemplateDecl *FunctionTemplate,\n SmallVectorImpl &Deduced,\n unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,\n sema::TemplateDeductionInfo &Info,\n SmallVectorImpl const *OriginalCallArgs = nullptr,\n bool PartialOverloading = false,\n llvm::function_ref CheckNonDependent = []{ return false; });\n\n TemplateDeductionResult DeduceTemplateArguments(\n FunctionTemplateDecl *FunctionTemplate,\n TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef Args,\n FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,\n bool PartialOverloading,\n llvm::function_ref)> CheckNonDependent);\n\n TemplateDeductionResult\n DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,\n TemplateArgumentListInfo *ExplicitTemplateArgs,\n QualType ArgFunctionType,\n FunctionDecl *&Specialization,\n sema::TemplateDeductionInfo &Info,\n bool IsAddressOfFunction = false);\n\n TemplateDeductionResult\n DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,\n QualType ToType,\n CXXConversionDecl *&Specialization,\n sema::TemplateDeductionInfo &Info);\n\n TemplateDeductionResult\n DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,\n TemplateArgumentListInfo *ExplicitTemplateArgs,\n FunctionDecl *&Specialization,\n sema::TemplateDeductionInfo &Info,\n bool IsAddressOfFunction = false);\n\n /// Substitute Replacement for \\p auto in \\p TypeWithAuto\n QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);\n /// Substitute Replacement for auto in TypeWithAuto\n TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,\n QualType Replacement);\n /// Completely replace the \\c auto in \\p TypeWithAuto by\n /// \\p Replacement. This does not retain any \\c auto type sugar.\n QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);\n TypeSourceInfo *ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,\n QualType Replacement);\n\n /// Result type of DeduceAutoType.\n enum DeduceAutoResult {\n DAR_Succeeded,\n DAR_Failed,\n DAR_FailedAlreadyDiagnosed\n };\n\n DeduceAutoResult\n DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,\n Optional DependentDeductionDepth = None,\n bool IgnoreConstraints = false);\n DeduceAutoResult\n DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,\n Optional DependentDeductionDepth = None,\n bool IgnoreConstraints = false);\n void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);\n bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,\n bool Diagnose = true);\n\n /// Declare implicit deduction guides for a class template if we've\n /// not already done so.\n void DeclareImplicitDeductionGuides(TemplateDecl *Template,\n SourceLocation Loc);\n\n QualType DeduceTemplateSpecializationFromInitializer(\n TypeSourceInfo *TInfo, const InitializedEntity &Entity,\n const InitializationKind &Kind, MultiExprArg Init);\n\n QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,\n QualType Type, TypeSourceInfo *TSI,\n SourceRange Range, bool DirectInit,\n Expr *Init);\n\n TypeLoc getReturnTypeLoc(FunctionDecl *FD) const;\n\n bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,\n SourceLocation ReturnLoc,\n Expr *&RetExpr, AutoType *AT);\n\n FunctionTemplateDecl *getMoreSpecializedTemplate(\n FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc,\n TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1,\n unsigned NumCallArguments2, bool Reversed = false);\n UnresolvedSetIterator\n getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,\n TemplateSpecCandidateSet &FailedCandidates,\n SourceLocation Loc,\n const PartialDiagnostic &NoneDiag,\n const PartialDiagnostic &AmbigDiag,\n const PartialDiagnostic &CandidateDiag,\n bool Complain = true, QualType TargetType = QualType());\n\n ClassTemplatePartialSpecializationDecl *\n getMoreSpecializedPartialSpecialization(\n ClassTemplatePartialSpecializationDecl *PS1,\n ClassTemplatePartialSpecializationDecl *PS2,\n SourceLocation Loc);\n\n bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T,\n sema::TemplateDeductionInfo &Info);\n\n VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(\n VarTemplatePartialSpecializationDecl *PS1,\n VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);\n\n bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,\n sema::TemplateDeductionInfo &Info);\n\n bool isTemplateTemplateParameterAtLeastAsSpecializedAs(\n TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc);\n\n void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced,\n unsigned Depth, llvm::SmallBitVector &Used);\n\n void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,\n bool OnlyDeduced,\n unsigned Depth,\n llvm::SmallBitVector &Used);\n void MarkDeducedTemplateParameters(\n const FunctionTemplateDecl *FunctionTemplate,\n llvm::SmallBitVector &Deduced) {\n return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);\n }\n static void MarkDeducedTemplateParameters(ASTContext &Ctx,\n const FunctionTemplateDecl *FunctionTemplate,\n llvm::SmallBitVector &Deduced);\n\n //===--------------------------------------------------------------------===//\n // C++ Template Instantiation\n //\n\n MultiLevelTemplateArgumentList\n getTemplateInstantiationArgs(NamedDecl *D,\n const TemplateArgumentList *Innermost = nullptr,\n bool RelativeToPrimary = false,\n const FunctionDecl *Pattern = nullptr);\n\n /// A context in which code is being synthesized (where a source location\n /// alone is not sufficient to identify the context). This covers template\n /// instantiation and various forms of implicitly-generated functions.\n struct CodeSynthesisContext {\n /// The kind of template instantiation we are performing\n enum SynthesisKind {\n /// We are instantiating a template declaration. The entity is\n /// the declaration we're instantiating (e.g., a CXXRecordDecl).\n TemplateInstantiation,\n\n /// We are instantiating a default argument for a template\n /// parameter. The Entity is the template parameter whose argument is\n /// being instantiated, the Template is the template, and the\n /// TemplateArgs/NumTemplateArguments provide the template arguments as\n /// specified.\n DefaultTemplateArgumentInstantiation,\n\n /// We are instantiating a default argument for a function.\n /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs\n /// provides the template arguments as specified.\n DefaultFunctionArgumentInstantiation,\n\n /// We are substituting explicit template arguments provided for\n /// a function template. The entity is a FunctionTemplateDecl.\n ExplicitTemplateArgumentSubstitution,\n\n /// We are substituting template argument determined as part of\n /// template argument deduction for either a class template\n /// partial specialization or a function template. The\n /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or\n /// a TemplateDecl.\n DeducedTemplateArgumentSubstitution,\n\n /// We are substituting prior template arguments into a new\n /// template parameter. The template parameter itself is either a\n /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.\n PriorTemplateArgumentSubstitution,\n\n /// We are checking the validity of a default template argument that\n /// has been used when naming a template-id.\n DefaultTemplateArgumentChecking,\n\n /// We are computing the exception specification for a defaulted special\n /// member function.\n ExceptionSpecEvaluation,\n\n /// We are instantiating the exception specification for a function\n /// template which was deferred until it was needed.\n ExceptionSpecInstantiation,\n\n /// We are instantiating a requirement of a requires expression.\n RequirementInstantiation,\n\n /// We are checking the satisfaction of a nested requirement of a requires\n /// expression.\n NestedRequirementConstraintsCheck,\n\n /// We are declaring an implicit special member function.\n DeclaringSpecialMember,\n\n /// We are declaring an implicit 'operator==' for a defaulted\n /// 'operator<=>'.\n DeclaringImplicitEqualityComparison,\n\n /// We are defining a synthesized function (such as a defaulted special\n /// member).\n DefiningSynthesizedFunction,\n\n // We are checking the constraints associated with a constrained entity or\n // the constraint expression of a concept. This includes the checks that\n // atomic constraints have the type 'bool' and that they can be constant\n // evaluated.\n ConstraintsCheck,\n\n // We are substituting template arguments into a constraint expression.\n ConstraintSubstitution,\n\n // We are normalizing a constraint expression.\n ConstraintNormalization,\n\n // We are substituting into the parameter mapping of an atomic constraint\n // during normalization.\n ParameterMappingSubstitution,\n\n /// We are rewriting a comparison operator in terms of an operator<=>.\n RewritingOperatorAsSpaceship,\n\n /// We are initializing a structured binding.\n InitializingStructuredBinding,\n\n /// We are marking a class as __dllexport.\n MarkingClassDllexported,\n\n /// Added for Template instantiation observation.\n /// Memoization means we are _not_ instantiating a template because\n /// it is already instantiated (but we entered a context where we\n /// would have had to if it was not already instantiated).\n Memoization\n } Kind;\n\n /// Was the enclosing context a non-instantiation SFINAE context?\n bool SavedInNonInstantiationSFINAEContext;\n\n /// The point of instantiation or synthesis within the source code.\n SourceLocation PointOfInstantiation;\n\n /// The entity that is being synthesized.\n Decl *Entity;\n\n /// The template (or partial specialization) in which we are\n /// performing the instantiation, for substitutions of prior template\n /// arguments.\n NamedDecl *Template;\n\n /// The list of template arguments we are substituting, if they\n /// are not part of the entity.\n const TemplateArgument *TemplateArgs;\n\n // FIXME: Wrap this union around more members, or perhaps store the\n // kind-specific members in the RAII object owning the context.\n union {\n /// The number of template arguments in TemplateArgs.\n unsigned NumTemplateArgs;\n\n /// The special member being declared or defined.\n CXXSpecialMember SpecialMember;\n };\n\n ArrayRef template_arguments() const {\n assert(Kind != DeclaringSpecialMember);\n return {TemplateArgs, NumTemplateArgs};\n }\n\n /// The template deduction info object associated with the\n /// substitution or checking of explicit or deduced template arguments.\n sema::TemplateDeductionInfo *DeductionInfo;\n\n /// The source range that covers the construct that cause\n /// the instantiation, e.g., the template-id that causes a class\n /// template instantiation.\n SourceRange InstantiationRange;\n\n CodeSynthesisContext()\n : Kind(TemplateInstantiation),\n SavedInNonInstantiationSFINAEContext(false), Entity(nullptr),\n Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(0),\n DeductionInfo(nullptr) {}\n\n /// Determines whether this template is an actual instantiation\n /// that should be counted toward the maximum instantiation depth.\n bool isInstantiationRecord() const;\n };\n\n /// List of active code synthesis contexts.\n ///\n /// This vector is treated as a stack. As synthesis of one entity requires\n /// synthesis of another, additional contexts are pushed onto the stack.\n SmallVector CodeSynthesisContexts;\n\n /// Specializations whose definitions are currently being instantiated.\n llvm::DenseSet> InstantiatingSpecializations;\n\n /// Non-dependent types used in templates that have already been instantiated\n /// by some template instantiation.\n llvm::DenseSet InstantiatedNonDependentTypes;\n\n /// Extra modules inspected when performing a lookup during a template\n /// instantiation. Computed lazily.\n SmallVector CodeSynthesisContextLookupModules;\n\n /// Cache of additional modules that should be used for name lookup\n /// within the current template instantiation. Computed lazily; use\n /// getLookupModules() to get a complete set.\n llvm::DenseSet LookupModulesCache;\n\n /// Get the set of additional modules that should be checked during\n /// name lookup. A module and its imports become visible when instanting a\n /// template defined within it.\n llvm::DenseSet &getLookupModules();\n\n /// Map from the most recent declaration of a namespace to the most\n /// recent visible declaration of that namespace.\n llvm::DenseMap VisibleNamespaceCache;\n\n /// Whether we are in a SFINAE context that is not associated with\n /// template instantiation.\n ///\n /// This is used when setting up a SFINAE trap (\\c see SFINAETrap) outside\n /// of a template instantiation or template argument deduction.\n bool InNonInstantiationSFINAEContext;\n\n /// The number of \\p CodeSynthesisContexts that are not template\n /// instantiations and, therefore, should not be counted as part of the\n /// instantiation depth.\n ///\n /// When the instantiation depth reaches the user-configurable limit\n /// \\p LangOptions::InstantiationDepth we will abort instantiation.\n // FIXME: Should we have a similar limit for other forms of synthesis?\n unsigned NonInstantiationEntries;\n\n /// The depth of the context stack at the point when the most recent\n /// error or warning was produced.\n ///\n /// This value is used to suppress printing of redundant context stacks\n /// when there are multiple errors or warnings in the same instantiation.\n // FIXME: Does this belong in Sema? It's tough to implement it anywhere else.\n unsigned LastEmittedCodeSynthesisContextDepth = 0;\n\n /// The template instantiation callbacks to trace or track\n /// instantiations (objects can be chained).\n ///\n /// This callbacks is used to print, trace or track template\n /// instantiations as they are being constructed.\n std::vector>\n TemplateInstCallbacks;\n\n /// The current index into pack expansion arguments that will be\n /// used for substitution of parameter packs.\n ///\n /// The pack expansion index will be -1 to indicate that parameter packs\n /// should be instantiated as themselves. Otherwise, the index specifies\n /// which argument within the parameter pack will be used for substitution.\n int ArgumentPackSubstitutionIndex;\n\n /// RAII object used to change the argument pack substitution index\n /// within a \\c Sema object.\n ///\n /// See \\c ArgumentPackSubstitutionIndex for more information.\n class ArgumentPackSubstitutionIndexRAII {\n Sema &Self;\n int OldSubstitutionIndex;\n\n public:\n ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)\n : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) {\n Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex;\n }\n\n ~ArgumentPackSubstitutionIndexRAII() {\n Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex;\n }\n };\n\n friend class ArgumentPackSubstitutionRAII;\n\n /// For each declaration that involved template argument deduction, the\n /// set of diagnostics that were suppressed during that template argument\n /// deduction.\n ///\n /// FIXME: Serialize this structure to the AST file.\n typedef llvm::DenseMap >\n SuppressedDiagnosticsMap;\n SuppressedDiagnosticsMap SuppressedDiagnostics;\n\n /// A stack object to be created when performing template\n /// instantiation.\n ///\n /// Construction of an object of type \\c InstantiatingTemplate\n /// pushes the current instantiation onto the stack of active\n /// instantiations. If the size of this stack exceeds the maximum\n /// number of recursive template instantiations, construction\n /// produces an error and evaluates true.\n ///\n /// Destruction of this object will pop the named instantiation off\n /// the stack.\n struct InstantiatingTemplate {\n /// Note that we are instantiating a class template,\n /// function template, variable template, alias template,\n /// or a member thereof.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n Decl *Entity,\n SourceRange InstantiationRange = SourceRange());\n\n struct ExceptionSpecification {};\n /// Note that we are instantiating an exception specification\n /// of a function template.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n FunctionDecl *Entity, ExceptionSpecification,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating a default argument in a\n /// template-id.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n TemplateParameter Param, TemplateDecl *Template,\n ArrayRef TemplateArgs,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are substituting either explicitly-specified or\n /// deduced template arguments during function template argument deduction.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n FunctionTemplateDecl *FunctionTemplate,\n ArrayRef TemplateArgs,\n CodeSynthesisContext::SynthesisKind Kind,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating as part of template\n /// argument deduction for a class template declaration.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n TemplateDecl *Template,\n ArrayRef TemplateArgs,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating as part of template\n /// argument deduction for a class template partial\n /// specialization.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ClassTemplatePartialSpecializationDecl *PartialSpec,\n ArrayRef TemplateArgs,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating as part of template\n /// argument deduction for a variable template partial\n /// specialization.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n VarTemplatePartialSpecializationDecl *PartialSpec,\n ArrayRef TemplateArgs,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are instantiating a default argument for a function\n /// parameter.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ParmVarDecl *Param,\n ArrayRef TemplateArgs,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we are substituting prior template arguments into a\n /// non-type parameter.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n NamedDecl *Template,\n NonTypeTemplateParmDecl *Param,\n ArrayRef TemplateArgs,\n SourceRange InstantiationRange);\n\n /// Note that we are substituting prior template arguments into a\n /// template template parameter.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n NamedDecl *Template,\n TemplateTemplateParmDecl *Param,\n ArrayRef TemplateArgs,\n SourceRange InstantiationRange);\n\n /// Note that we are checking the default template argument\n /// against the template parameter for a given template-id.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n TemplateDecl *Template,\n NamedDecl *Param,\n ArrayRef TemplateArgs,\n SourceRange InstantiationRange);\n\n struct ConstraintsCheck {};\n /// \\brief Note that we are checking the constraints associated with some\n /// constrained entity (a concept declaration or a template with associated\n /// constraints).\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ConstraintsCheck, NamedDecl *Template,\n ArrayRef TemplateArgs,\n SourceRange InstantiationRange);\n\n struct ConstraintSubstitution {};\n /// \\brief Note that we are checking a constraint expression associated\n /// with a template declaration or as part of the satisfaction check of a\n /// concept.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ConstraintSubstitution, NamedDecl *Template,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange);\n\n struct ConstraintNormalization {};\n /// \\brief Note that we are normalizing a constraint expression.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ConstraintNormalization, NamedDecl *Template,\n SourceRange InstantiationRange);\n\n struct ParameterMappingSubstitution {};\n /// \\brief Note that we are subtituting into the parameter mapping of an\n /// atomic constraint during constraint normalization.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n ParameterMappingSubstitution, NamedDecl *Template,\n SourceRange InstantiationRange);\n\n /// \\brief Note that we are substituting template arguments into a part of\n /// a requirement of a requires expression.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n concepts::Requirement *Req,\n sema::TemplateDeductionInfo &DeductionInfo,\n SourceRange InstantiationRange = SourceRange());\n\n /// \\brief Note that we are checking the satisfaction of the constraint\n /// expression inside of a nested requirement.\n InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,\n concepts::NestedRequirement *Req, ConstraintsCheck,\n SourceRange InstantiationRange = SourceRange());\n\n /// Note that we have finished instantiating this template.\n void Clear();\n\n ~InstantiatingTemplate() { Clear(); }\n\n /// Determines whether we have exceeded the maximum\n /// recursive template instantiations.\n bool isInvalid() const { return Invalid; }\n\n /// Determine whether we are already instantiating this\n /// specialization in some surrounding active instantiation.\n bool isAlreadyInstantiating() const { return AlreadyInstantiating; }\n\n private:\n Sema &SemaRef;\n bool Invalid;\n bool AlreadyInstantiating;\n bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,\n SourceRange InstantiationRange);\n\n InstantiatingTemplate(\n Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,\n SourceLocation PointOfInstantiation, SourceRange InstantiationRange,\n Decl *Entity, NamedDecl *Template = nullptr,\n ArrayRef TemplateArgs = None,\n sema::TemplateDeductionInfo *DeductionInfo = nullptr);\n\n InstantiatingTemplate(const InstantiatingTemplate&) = delete;\n\n InstantiatingTemplate&\n operator=(const InstantiatingTemplate&) = delete;\n };\n\n void pushCodeSynthesisContext(CodeSynthesisContext Ctx);\n void popCodeSynthesisContext();\n\n /// Determine whether we are currently performing template instantiation.\n bool inTemplateInstantiation() const {\n return CodeSynthesisContexts.size() > NonInstantiationEntries;\n }\n\n void PrintContextStack() {\n if (!CodeSynthesisContexts.empty() &&\n CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) {\n PrintInstantiationStack();\n LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size();\n }\n if (PragmaAttributeCurrentTargetDecl)\n PrintPragmaAttributeInstantiationPoint();\n }\n void PrintInstantiationStack();\n\n void PrintPragmaAttributeInstantiationPoint();\n\n /// Determines whether we are currently in a context where\n /// template argument substitution failures are not considered\n /// errors.\n ///\n /// \\returns An empty \\c Optional if we're not in a SFINAE context.\n /// Otherwise, contains a pointer that, if non-NULL, contains the nearest\n /// template-deduction context object, which can be used to capture\n /// diagnostics that will be suppressed.\n Optional isSFINAEContext() const;\n\n /// Determines whether we are currently in a context that\n /// is not evaluated as per C++ [expr] p5.\n bool isUnevaluatedContext() const {\n assert(!ExprEvalContexts.empty() &&\n \"Must be in an expression evaluation context\");\n return ExprEvalContexts.back().isUnevaluated();\n }\n\n /// RAII class used to determine whether SFINAE has\n /// trapped any errors that occur during template argument\n /// deduction.\n class SFINAETrap {\n Sema &SemaRef;\n unsigned PrevSFINAEErrors;\n bool PrevInNonInstantiationSFINAEContext;\n bool PrevAccessCheckingSFINAE;\n bool PrevLastDiagnosticIgnored;\n\n public:\n explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)\n : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),\n PrevInNonInstantiationSFINAEContext(\n SemaRef.InNonInstantiationSFINAEContext),\n PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE),\n PrevLastDiagnosticIgnored(\n SemaRef.getDiagnostics().isLastDiagnosticIgnored())\n {\n if (!SemaRef.isSFINAEContext())\n SemaRef.InNonInstantiationSFINAEContext = true;\n SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE;\n }\n\n ~SFINAETrap() {\n SemaRef.NumSFINAEErrors = PrevSFINAEErrors;\n SemaRef.InNonInstantiationSFINAEContext\n = PrevInNonInstantiationSFINAEContext;\n SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE;\n SemaRef.getDiagnostics().setLastDiagnosticIgnored(\n PrevLastDiagnosticIgnored);\n }\n\n /// Determine whether any SFINAE errors have been trapped.\n bool hasErrorOccurred() const {\n return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;\n }\n };\n\n /// RAII class used to indicate that we are performing provisional\n /// semantic analysis to determine the validity of a construct, so\n /// typo-correction and diagnostics in the immediate context (not within\n /// implicitly-instantiated templates) should be suppressed.\n class TentativeAnalysisScope {\n Sema &SemaRef;\n // FIXME: Using a SFINAETrap for this is a hack.\n SFINAETrap Trap;\n bool PrevDisableTypoCorrection;\n public:\n explicit TentativeAnalysisScope(Sema &SemaRef)\n : SemaRef(SemaRef), Trap(SemaRef, true),\n PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) {\n SemaRef.DisableTypoCorrection = true;\n }\n ~TentativeAnalysisScope() {\n SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection;\n }\n };\n\n /// The current instantiation scope used to store local\n /// variables.\n LocalInstantiationScope *CurrentInstantiationScope;\n\n /// Tracks whether we are in a context where typo correction is\n /// disabled.\n bool DisableTypoCorrection;\n\n /// The number of typos corrected by CorrectTypo.\n unsigned TyposCorrected;\n\n typedef llvm::SmallSet SrcLocSet;\n typedef llvm::DenseMap IdentifierSourceLocations;\n\n /// A cache containing identifiers for which typo correction failed and\n /// their locations, so that repeated attempts to correct an identifier in a\n /// given location are ignored if typo correction already failed for it.\n IdentifierSourceLocations TypoCorrectionFailures;\n\n /// Worker object for performing CFG-based warnings.\n sema::AnalysisBasedWarnings AnalysisWarnings;\n threadSafety::BeforeSet *ThreadSafetyDeclCache;\n\n /// An entity for which implicit template instantiation is required.\n ///\n /// The source location associated with the declaration is the first place in\n /// the source code where the declaration was \"used\". It is not necessarily\n /// the point of instantiation (which will be either before or after the\n /// namespace-scope declaration that triggered this implicit instantiation),\n /// However, it is the location that diagnostics should generally refer to,\n /// because users will need to know what code triggered the instantiation.\n typedef std::pair PendingImplicitInstantiation;\n\n /// The queue of implicit template instantiations that are required\n /// but have not yet been performed.\n std::deque PendingInstantiations;\n\n /// Queue of implicit template instantiations that cannot be performed\n /// eagerly.\n SmallVector LateParsedInstantiations;\n\n class GlobalEagerInstantiationScope {\n public:\n GlobalEagerInstantiationScope(Sema &S, bool Enabled)\n : S(S), Enabled(Enabled) {\n if (!Enabled) return;\n\n SavedPendingInstantiations.swap(S.PendingInstantiations);\n SavedVTableUses.swap(S.VTableUses);\n }\n\n void perform() {\n if (Enabled) {\n S.DefineUsedVTables();\n S.PerformPendingInstantiations();\n }\n }\n\n ~GlobalEagerInstantiationScope() {\n if (!Enabled) return;\n\n // Restore the set of pending vtables.\n assert(S.VTableUses.empty() &&\n \"VTableUses should be empty before it is discarded.\");\n S.VTableUses.swap(SavedVTableUses);\n\n // Restore the set of pending implicit instantiations.\n if (S.TUKind != TU_Prefix || !S.LangOpts.PCHInstantiateTemplates) {\n assert(S.PendingInstantiations.empty() &&\n \"PendingInstantiations should be empty before it is discarded.\");\n S.PendingInstantiations.swap(SavedPendingInstantiations);\n } else {\n // Template instantiations in the PCH may be delayed until the TU.\n S.PendingInstantiations.swap(SavedPendingInstantiations);\n S.PendingInstantiations.insert(S.PendingInstantiations.end(),\n SavedPendingInstantiations.begin(),\n SavedPendingInstantiations.end());\n }\n }\n\n private:\n Sema &S;\n SmallVector SavedVTableUses;\n std::deque SavedPendingInstantiations;\n bool Enabled;\n };\n\n /// The queue of implicit template instantiations that are required\n /// and must be performed within the current local scope.\n ///\n /// This queue is only used for member functions of local classes in\n /// templates, which must be instantiated in the same scope as their\n /// enclosing function, so that they can reference function-local\n /// types, static variables, enumerators, etc.\n std::deque PendingLocalImplicitInstantiations;\n\n class LocalEagerInstantiationScope {\n public:\n LocalEagerInstantiationScope(Sema &S) : S(S) {\n SavedPendingLocalImplicitInstantiations.swap(\n S.PendingLocalImplicitInstantiations);\n }\n\n void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); }\n\n ~LocalEagerInstantiationScope() {\n assert(S.PendingLocalImplicitInstantiations.empty() &&\n \"there shouldn't be any pending local implicit instantiations\");\n SavedPendingLocalImplicitInstantiations.swap(\n S.PendingLocalImplicitInstantiations);\n }\n\n private:\n Sema &S;\n std::deque\n SavedPendingLocalImplicitInstantiations;\n };\n\n /// A helper class for building up ExtParameterInfos.\n class ExtParameterInfoBuilder {\n SmallVector Infos;\n bool HasInteresting = false;\n\n public:\n /// Set the ExtParameterInfo for the parameter at the given index,\n ///\n void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {\n assert(Infos.size() <= index);\n Infos.resize(index);\n Infos.push_back(info);\n\n if (!HasInteresting)\n HasInteresting = (info != FunctionProtoType::ExtParameterInfo());\n }\n\n /// Return a pointer (suitable for setting in an ExtProtoInfo) to the\n /// ExtParameterInfo array we've built up.\n const FunctionProtoType::ExtParameterInfo *\n getPointerOrNull(unsigned numParams) {\n if (!HasInteresting) return nullptr;\n Infos.resize(numParams);\n return Infos.data();\n }\n };\n\n void PerformPendingInstantiations(bool LocalOnly = false);\n\n TypeSourceInfo *SubstType(TypeSourceInfo *T,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SourceLocation Loc, DeclarationName Entity,\n bool AllowDeducedTST = false);\n\n QualType SubstType(QualType T,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SourceLocation Loc, DeclarationName Entity);\n\n TypeSourceInfo *SubstType(TypeLoc TL,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SourceLocation Loc, DeclarationName Entity);\n\n TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SourceLocation Loc,\n DeclarationName Entity,\n CXXRecordDecl *ThisContext,\n Qualifiers ThisTypeQuals);\n void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,\n const MultiLevelTemplateArgumentList &Args);\n bool SubstExceptionSpec(SourceLocation Loc,\n FunctionProtoType::ExceptionSpecInfo &ESI,\n SmallVectorImpl &ExceptionStorage,\n const MultiLevelTemplateArgumentList &Args);\n ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n int indexAdjustment,\n Optional NumExpansions,\n bool ExpectParameterPack);\n bool SubstParmTypes(SourceLocation Loc, ArrayRef Params,\n const FunctionProtoType::ExtParameterInfo *ExtParamInfos,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SmallVectorImpl &ParamTypes,\n SmallVectorImpl *OutParams,\n ExtParameterInfoBuilder &ParamInfos);\n ExprResult SubstExpr(Expr *E,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n /// Substitute the given template arguments into a list of\n /// expressions, expanding pack expansions if required.\n ///\n /// \\param Exprs The list of expressions to substitute into.\n ///\n /// \\param IsCall Whether this is some form of call, in which case\n /// default arguments will be dropped.\n ///\n /// \\param TemplateArgs The set of template arguments to substitute.\n ///\n /// \\param Outputs Will receive all of the substituted arguments.\n ///\n /// \\returns true if an error occurred, false otherwise.\n bool SubstExprs(ArrayRef Exprs, bool IsCall,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n SmallVectorImpl &Outputs);\n\n StmtResult SubstStmt(Stmt *S,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n TemplateParameterList *\n SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n bool\n SubstTemplateArguments(ArrayRef Args,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n TemplateArgumentListInfo &Outputs);\n\n\n Decl *SubstDecl(Decl *D, DeclContext *Owner,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n /// Substitute the name and return type of a defaulted 'operator<=>' to form\n /// an implicit 'operator=='.\n FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,\n FunctionDecl *Spaceship);\n\n ExprResult SubstInitializer(Expr *E,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n bool CXXDirectInit);\n\n bool\n SubstBaseSpecifiers(CXXRecordDecl *Instantiation,\n CXXRecordDecl *Pattern,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n bool\n InstantiateClass(SourceLocation PointOfInstantiation,\n CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n TemplateSpecializationKind TSK,\n bool Complain = true);\n\n bool InstantiateEnum(SourceLocation PointOfInstantiation,\n EnumDecl *Instantiation, EnumDecl *Pattern,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n TemplateSpecializationKind TSK);\n\n bool InstantiateInClassInitializer(\n SourceLocation PointOfInstantiation, FieldDecl *Instantiation,\n FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs);\n\n struct LateInstantiatedAttribute {\n const Attr *TmplAttr;\n LocalInstantiationScope *Scope;\n Decl *NewDecl;\n\n LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S,\n Decl *D)\n : TmplAttr(A), Scope(S), NewDecl(D)\n { }\n };\n typedef SmallVector LateInstantiatedAttrVec;\n\n void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,\n const Decl *Pattern, Decl *Inst,\n LateInstantiatedAttrVec *LateAttrs = nullptr,\n LocalInstantiationScope *OuterMostScope = nullptr);\n\n void\n InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,\n const Decl *Pattern, Decl *Inst,\n LateInstantiatedAttrVec *LateAttrs = nullptr,\n LocalInstantiationScope *OuterMostScope = nullptr);\n\n void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor);\n\n bool usesPartialOrExplicitSpecialization(\n SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);\n\n bool\n InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,\n ClassTemplateSpecializationDecl *ClassTemplateSpec,\n TemplateSpecializationKind TSK,\n bool Complain = true);\n\n void InstantiateClassMembers(SourceLocation PointOfInstantiation,\n CXXRecordDecl *Instantiation,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n TemplateSpecializationKind TSK);\n\n void InstantiateClassTemplateSpecializationMembers(\n SourceLocation PointOfInstantiation,\n ClassTemplateSpecializationDecl *ClassTemplateSpec,\n TemplateSpecializationKind TSK);\n\n NestedNameSpecifierLoc\n SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n DeclarationNameInfo\n SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n TemplateName\n SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,\n SourceLocation Loc,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,\n TemplateArgumentListInfo &Result,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,\n ParmVarDecl *Param);\n void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,\n FunctionDecl *Function);\n bool CheckInstantiatedFunctionTemplateConstraints(\n SourceLocation PointOfInstantiation, FunctionDecl *Decl,\n ArrayRef TemplateArgs,\n ConstraintSatisfaction &Satisfaction);\n FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,\n const TemplateArgumentList *Args,\n SourceLocation Loc);\n void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,\n FunctionDecl *Function,\n bool Recursive = false,\n bool DefinitionRequired = false,\n bool AtEndOfTU = false);\n VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(\n VarTemplateDecl *VarTemplate, VarDecl *FromVar,\n const TemplateArgumentList &TemplateArgList,\n const TemplateArgumentListInfo &TemplateArgsInfo,\n SmallVectorImpl &Converted,\n SourceLocation PointOfInstantiation,\n LateInstantiatedAttrVec *LateAttrs = nullptr,\n LocalInstantiationScope *StartingScope = nullptr);\n VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(\n VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n void\n BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n LateInstantiatedAttrVec *LateAttrs,\n DeclContext *Owner,\n LocalInstantiationScope *StartingScope,\n bool InstantiatingVarTemplate = false,\n VarTemplateSpecializationDecl *PrevVTSD = nullptr);\n\n void InstantiateVariableInitializer(\n VarDecl *Var, VarDecl *OldVar,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,\n VarDecl *Var, bool Recursive = false,\n bool DefinitionRequired = false,\n bool AtEndOfTU = false);\n\n void InstantiateMemInitializers(CXXConstructorDecl *New,\n const CXXConstructorDecl *Tmpl,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,\n const MultiLevelTemplateArgumentList &TemplateArgs,\n bool FindingInstantiatedContext = false);\n DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,\n const MultiLevelTemplateArgumentList &TemplateArgs);\n\n // Objective-C declarations.\n enum ObjCContainerKind {\n OCK_None = -1,\n OCK_Interface = 0,\n OCK_Protocol,\n OCK_Category,\n OCK_ClassExtension,\n OCK_Implementation,\n OCK_CategoryImplementation\n };\n ObjCContainerKind getObjCContainerKind() const;\n\n DeclResult actOnObjCTypeParam(Scope *S,\n ObjCTypeParamVariance variance,\n SourceLocation varianceLoc,\n unsigned index,\n IdentifierInfo *paramName,\n SourceLocation paramLoc,\n SourceLocation colonLoc,\n ParsedType typeBound);\n\n ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc,\n ArrayRef typeParams,\n SourceLocation rAngleLoc);\n void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList);\n\n Decl *ActOnStartClassInterface(\n Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,\n SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,\n IdentifierInfo *SuperName, SourceLocation SuperLoc,\n ArrayRef SuperTypeArgs, SourceRange SuperTypeArgsRange,\n Decl *const *ProtoRefs, unsigned NumProtoRefs,\n const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,\n const ParsedAttributesView &AttrList);\n\n void ActOnSuperClassOfClassInterface(Scope *S,\n SourceLocation AtInterfaceLoc,\n ObjCInterfaceDecl *IDecl,\n IdentifierInfo *ClassName,\n SourceLocation ClassLoc,\n IdentifierInfo *SuperName,\n SourceLocation SuperLoc,\n ArrayRef SuperTypeArgs,\n SourceRange SuperTypeArgsRange);\n\n void ActOnTypedefedProtocols(SmallVectorImpl &ProtocolRefs,\n SmallVectorImpl &ProtocolLocs,\n IdentifierInfo *SuperName,\n SourceLocation SuperLoc);\n\n Decl *ActOnCompatibilityAlias(\n SourceLocation AtCompatibilityAliasLoc,\n IdentifierInfo *AliasName, SourceLocation AliasLocation,\n IdentifierInfo *ClassName, SourceLocation ClassLocation);\n\n bool CheckForwardProtocolDeclarationForCircularDependency(\n IdentifierInfo *PName,\n SourceLocation &PLoc, SourceLocation PrevLoc,\n const ObjCList &PList);\n\n Decl *ActOnStartProtocolInterface(\n SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName,\n SourceLocation ProtocolLoc, Decl *const *ProtoRefNames,\n unsigned NumProtoRefs, const SourceLocation *ProtoLocs,\n SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList);\n\n Decl *ActOnStartCategoryInterface(\n SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,\n SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,\n IdentifierInfo *CategoryName, SourceLocation CategoryLoc,\n Decl *const *ProtoRefs, unsigned NumProtoRefs,\n const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,\n const ParsedAttributesView &AttrList);\n\n Decl *ActOnStartClassImplementation(SourceLocation AtClassImplLoc,\n IdentifierInfo *ClassName,\n SourceLocation ClassLoc,\n IdentifierInfo *SuperClassname,\n SourceLocation SuperClassLoc,\n const ParsedAttributesView &AttrList);\n\n Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc,\n IdentifierInfo *ClassName,\n SourceLocation ClassLoc,\n IdentifierInfo *CatName,\n SourceLocation CatLoc,\n const ParsedAttributesView &AttrList);\n\n DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,\n ArrayRef Decls);\n\n DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,\n IdentifierInfo **IdentList,\n SourceLocation *IdentLocs,\n ArrayRef TypeParamLists,\n unsigned NumElts);\n\n DeclGroupPtrTy\n ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,\n ArrayRef IdentList,\n const ParsedAttributesView &attrList);\n\n void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,\n ArrayRef ProtocolId,\n SmallVectorImpl &Protocols);\n\n void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,\n SourceLocation ProtocolLoc,\n IdentifierInfo *TypeArgId,\n SourceLocation TypeArgLoc,\n bool SelectProtocolFirst = false);\n\n /// Given a list of identifiers (and their locations), resolve the\n /// names to either Objective-C protocol qualifiers or type\n /// arguments, as appropriate.\n void actOnObjCTypeArgsOrProtocolQualifiers(\n Scope *S,\n ParsedType baseType,\n SourceLocation lAngleLoc,\n ArrayRef identifiers,\n ArrayRef identifierLocs,\n SourceLocation rAngleLoc,\n SourceLocation &typeArgsLAngleLoc,\n SmallVectorImpl &typeArgs,\n SourceLocation &typeArgsRAngleLoc,\n SourceLocation &protocolLAngleLoc,\n SmallVectorImpl &protocols,\n SourceLocation &protocolRAngleLoc,\n bool warnOnIncompleteProtocols);\n\n /// Build a an Objective-C protocol-qualified 'id' type where no\n /// base type was specified.\n TypeResult actOnObjCProtocolQualifierType(\n SourceLocation lAngleLoc,\n ArrayRef protocols,\n ArrayRef protocolLocs,\n SourceLocation rAngleLoc);\n\n /// Build a specialized and/or protocol-qualified Objective-C type.\n TypeResult actOnObjCTypeArgsAndProtocolQualifiers(\n Scope *S,\n SourceLocation Loc,\n ParsedType BaseType,\n SourceLocation TypeArgsLAngleLoc,\n ArrayRef TypeArgs,\n SourceLocation TypeArgsRAngleLoc,\n SourceLocation ProtocolLAngleLoc,\n ArrayRef Protocols,\n ArrayRef ProtocolLocs,\n SourceLocation ProtocolRAngleLoc);\n\n /// Build an Objective-C type parameter type.\n QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,\n SourceLocation ProtocolLAngleLoc,\n ArrayRef Protocols,\n ArrayRef ProtocolLocs,\n SourceLocation ProtocolRAngleLoc,\n bool FailOnError = false);\n\n /// Build an Objective-C object pointer type.\n QualType BuildObjCObjectType(QualType BaseType,\n SourceLocation Loc,\n SourceLocation TypeArgsLAngleLoc,\n ArrayRef TypeArgs,\n SourceLocation TypeArgsRAngleLoc,\n SourceLocation ProtocolLAngleLoc,\n ArrayRef Protocols,\n ArrayRef ProtocolLocs,\n SourceLocation ProtocolRAngleLoc,\n bool FailOnError = false);\n\n /// Ensure attributes are consistent with type.\n /// \\param [in, out] Attributes The attributes to check; they will\n /// be modified to be consistent with \\p PropertyTy.\n void CheckObjCPropertyAttributes(Decl *PropertyPtrTy,\n SourceLocation Loc,\n unsigned &Attributes,\n bool propertyInPrimaryClass);\n\n /// Process the specified property declaration and create decls for the\n /// setters and getters as needed.\n /// \\param property The property declaration being processed\n void ProcessPropertyDecl(ObjCPropertyDecl *property);\n\n\n void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,\n ObjCPropertyDecl *SuperProperty,\n const IdentifierInfo *Name,\n bool OverridingProtocolProperty);\n\n void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,\n ObjCInterfaceDecl *ID);\n\n Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd,\n ArrayRef allMethods = None,\n ArrayRef allTUVars = None);\n\n Decl *ActOnProperty(Scope *S, SourceLocation AtLoc,\n SourceLocation LParenLoc,\n FieldDeclarator &FD, ObjCDeclSpec &ODS,\n Selector GetterSel, Selector SetterSel,\n tok::ObjCKeywordKind MethodImplKind,\n DeclContext *lexicalDC = nullptr);\n\n Decl *ActOnPropertyImplDecl(Scope *S,\n SourceLocation AtLoc,\n SourceLocation PropertyLoc,\n bool ImplKind,\n IdentifierInfo *PropertyId,\n IdentifierInfo *PropertyIvar,\n SourceLocation PropertyIvarLoc,\n ObjCPropertyQueryKind QueryKind);\n\n enum ObjCSpecialMethodKind {\n OSMK_None,\n OSMK_Alloc,\n OSMK_New,\n OSMK_Copy,\n OSMK_RetainingInit,\n OSMK_NonRetainingInit\n };\n\n struct ObjCArgInfo {\n IdentifierInfo *Name;\n SourceLocation NameLoc;\n // The Type is null if no type was specified, and the DeclSpec is invalid\n // in this case.\n ParsedType Type;\n ObjCDeclSpec DeclSpec;\n\n /// ArgAttrs - Attribute list for this argument.\n ParsedAttributesView ArgAttrs;\n };\n\n Decl *ActOnMethodDeclaration(\n Scope *S,\n SourceLocation BeginLoc, // location of the + or -.\n SourceLocation EndLoc, // location of the ; or {.\n tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType,\n ArrayRef SelectorLocs, Selector Sel,\n // optional arguments. The number of types/arguments is obtained\n // from the Sel.getNumArgs().\n ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo,\n unsigned CNumArgs, // c-style args\n const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind,\n bool isVariadic, bool MethodDefinition);\n\n ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel,\n const ObjCObjectPointerType *OPT,\n bool IsInstance);\n ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty,\n bool IsInstance);\n\n bool CheckARCMethodDecl(ObjCMethodDecl *method);\n bool inferObjCARCLifetime(ValueDecl *decl);\n\n void deduceOpenCLAddressSpace(ValueDecl *decl);\n\n ExprResult\n HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,\n Expr *BaseExpr,\n SourceLocation OpLoc,\n DeclarationName MemberName,\n SourceLocation MemberLoc,\n SourceLocation SuperLoc, QualType SuperType,\n bool Super);\n\n ExprResult\n ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,\n IdentifierInfo &propertyName,\n SourceLocation receiverNameLoc,\n SourceLocation propertyNameLoc);\n\n ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc);\n\n /// Describes the kind of message expression indicated by a message\n /// send that starts with an identifier.\n enum ObjCMessageKind {\n /// The message is sent to 'super'.\n ObjCSuperMessage,\n /// The message is an instance message.\n ObjCInstanceMessage,\n /// The message is a class message, and the identifier is a type\n /// name.\n ObjCClassMessage\n };\n\n ObjCMessageKind getObjCMessageKind(Scope *S,\n IdentifierInfo *Name,\n SourceLocation NameLoc,\n bool IsSuper,\n bool HasTrailingDot,\n ParsedType &ReceiverType);\n\n ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,\n Selector Sel,\n SourceLocation LBracLoc,\n ArrayRef SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args);\n\n ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,\n QualType ReceiverType,\n SourceLocation SuperLoc,\n Selector Sel,\n ObjCMethodDecl *Method,\n SourceLocation LBracLoc,\n ArrayRef SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args,\n bool isImplicit = false);\n\n ExprResult BuildClassMessageImplicit(QualType ReceiverType,\n bool isSuperReceiver,\n SourceLocation Loc,\n Selector Sel,\n ObjCMethodDecl *Method,\n MultiExprArg Args);\n\n ExprResult ActOnClassMessage(Scope *S,\n ParsedType Receiver,\n Selector Sel,\n SourceLocation LBracLoc,\n ArrayRef SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args);\n\n ExprResult BuildInstanceMessage(Expr *Receiver,\n QualType ReceiverType,\n SourceLocation SuperLoc,\n Selector Sel,\n ObjCMethodDecl *Method,\n SourceLocation LBracLoc,\n ArrayRef SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args,\n bool isImplicit = false);\n\n ExprResult BuildInstanceMessageImplicit(Expr *Receiver,\n QualType ReceiverType,\n SourceLocation Loc,\n Selector Sel,\n ObjCMethodDecl *Method,\n MultiExprArg Args);\n\n ExprResult ActOnInstanceMessage(Scope *S,\n Expr *Receiver,\n Selector Sel,\n SourceLocation LBracLoc,\n ArrayRef SelectorLocs,\n SourceLocation RBracLoc,\n MultiExprArg Args);\n\n ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc,\n ObjCBridgeCastKind Kind,\n SourceLocation BridgeKeywordLoc,\n TypeSourceInfo *TSInfo,\n Expr *SubExpr);\n\n ExprResult ActOnObjCBridgedCast(Scope *S,\n SourceLocation LParenLoc,\n ObjCBridgeCastKind Kind,\n SourceLocation BridgeKeywordLoc,\n ParsedType Type,\n SourceLocation RParenLoc,\n Expr *SubExpr);\n\n void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);\n\n void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);\n\n bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,\n CastKind &Kind);\n\n bool checkObjCBridgeRelatedComponents(SourceLocation Loc,\n QualType DestType, QualType SrcType,\n ObjCInterfaceDecl *&RelatedClass,\n ObjCMethodDecl *&ClassMethod,\n ObjCMethodDecl *&InstanceMethod,\n TypedefNameDecl *&TDNDecl,\n bool CfToNs, bool Diagnose = true);\n\n bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,\n QualType DestType, QualType SrcType,\n Expr *&SrcExpr, bool Diagnose = true);\n\n bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr,\n bool Diagnose = true);\n\n bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);\n\n /// Check whether the given new method is a valid override of the\n /// given overridden method, and set any properties that should be inherited.\n void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,\n const ObjCMethodDecl *Overridden);\n\n /// Describes the compatibility of a result type with its method.\n enum ResultTypeCompatibilityKind {\n RTC_Compatible,\n RTC_Incompatible,\n RTC_Unknown\n };\n\n void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method,\n ObjCMethodDecl *overridden);\n\n void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,\n ObjCInterfaceDecl *CurrentClass,\n ResultTypeCompatibilityKind RTC);\n\n enum PragmaOptionsAlignKind {\n POAK_Native, // #pragma options align=native\n POAK_Natural, // #pragma options align=natural\n POAK_Packed, // #pragma options align=packed\n POAK_Power, // #pragma options align=power\n POAK_Mac68k, // #pragma options align=mac68k\n POAK_Reset // #pragma options align=reset\n };\n\n /// ActOnPragmaClangSection - Called on well formed \\#pragma clang section\n void ActOnPragmaClangSection(SourceLocation PragmaLoc,\n PragmaClangSectionAction Action,\n PragmaClangSectionKind SecKind, StringRef SecName);\n\n /// ActOnPragmaOptionsAlign - Called on well formed \\#pragma options align.\n void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,\n SourceLocation PragmaLoc);\n\n /// ActOnPragmaPack - Called on well formed \\#pragma pack(...).\n void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,\n StringRef SlotLabel, Expr *Alignment);\n\n enum class PragmaAlignPackDiagnoseKind {\n NonDefaultStateAtInclude,\n ChangedStateAtExit\n };\n\n void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind,\n SourceLocation IncludeLoc);\n void DiagnoseUnterminatedPragmaAlignPack();\n\n /// ActOnPragmaMSStruct - Called on well formed \\#pragma ms_struct [on|off].\n void ActOnPragmaMSStruct(PragmaMSStructKind Kind);\n\n /// ActOnPragmaMSComment - Called on well formed\n /// \\#pragma comment(kind, \"arg\").\n void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind,\n StringRef Arg);\n\n /// ActOnPragmaMSPointersToMembers - called on well formed \\#pragma\n /// pointers_to_members(representation method[, general purpose\n /// representation]).\n void ActOnPragmaMSPointersToMembers(\n LangOptions::PragmaMSPointersToMembersKind Kind,\n SourceLocation PragmaLoc);\n\n /// Called on well formed \\#pragma vtordisp().\n void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,\n SourceLocation PragmaLoc,\n MSVtorDispMode Value);\n\n enum PragmaSectionKind {\n PSK_DataSeg,\n PSK_BSSSeg,\n PSK_ConstSeg,\n PSK_CodeSeg,\n };\n\n bool UnifySection(StringRef SectionName, int SectionFlags,\n NamedDecl *TheDecl);\n bool UnifySection(StringRef SectionName,\n int SectionFlags,\n SourceLocation PragmaSectionLocation);\n\n /// Called on well formed \\#pragma bss_seg/data_seg/const_seg/code_seg.\n void ActOnPragmaMSSeg(SourceLocation PragmaLocation,\n PragmaMsStackAction Action,\n llvm::StringRef StackSlotLabel,\n StringLiteral *SegmentName,\n llvm::StringRef PragmaName);\n\n /// Called on well formed \\#pragma section().\n void ActOnPragmaMSSection(SourceLocation PragmaLocation,\n int SectionFlags, StringLiteral *SegmentName);\n\n /// Called on well-formed \\#pragma init_seg().\n void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,\n StringLiteral *SegmentName);\n\n /// Called on #pragma clang __debug dump II\n void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II);\n\n /// ActOnPragmaDetectMismatch - Call on well-formed \\#pragma detect_mismatch\n void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,\n StringRef Value);\n\n /// Are precise floating point semantics currently enabled?\n bool isPreciseFPEnabled() {\n return !CurFPFeatures.getAllowFPReassociate() &&\n !CurFPFeatures.getNoSignedZero() &&\n !CurFPFeatures.getAllowReciprocal() &&\n !CurFPFeatures.getAllowApproxFunc();\n }\n\n /// ActOnPragmaFloatControl - Call on well-formed \\#pragma float_control\n void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action,\n PragmaFloatControlKind Value);\n\n /// ActOnPragmaUnused - Called on well-formed '\\#pragma unused'.\n void ActOnPragmaUnused(const Token &Identifier,\n Scope *curScope,\n SourceLocation PragmaLoc);\n\n /// ActOnPragmaVisibility - Called on well formed \\#pragma GCC visibility... .\n void ActOnPragmaVisibility(const IdentifierInfo* VisType,\n SourceLocation PragmaLoc);\n\n NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,\n SourceLocation Loc);\n void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);\n\n /// ActOnPragmaWeakID - Called on well formed \\#pragma weak ident.\n void ActOnPragmaWeakID(IdentifierInfo* WeakName,\n SourceLocation PragmaLoc,\n SourceLocation WeakNameLoc);\n\n /// ActOnPragmaRedefineExtname - Called on well formed\n /// \\#pragma redefine_extname oldname newname.\n void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName,\n IdentifierInfo* AliasName,\n SourceLocation PragmaLoc,\n SourceLocation WeakNameLoc,\n SourceLocation AliasNameLoc);\n\n /// ActOnPragmaWeakAlias - Called on well formed \\#pragma weak ident = ident.\n void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,\n IdentifierInfo* AliasName,\n SourceLocation PragmaLoc,\n SourceLocation WeakNameLoc,\n SourceLocation AliasNameLoc);\n\n /// ActOnPragmaFPContract - Called on well formed\n /// \\#pragma {STDC,OPENCL} FP_CONTRACT and\n /// \\#pragma clang fp contract\n void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC);\n\n /// Called on well formed\n /// \\#pragma clang fp reassociate\n void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled);\n\n /// ActOnPragmaFenvAccess - Called on well formed\n /// \\#pragma STDC FENV_ACCESS\n void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled);\n\n /// Called on well formed '\\#pragma clang fp' that has option 'exceptions'.\n void ActOnPragmaFPExceptions(SourceLocation Loc,\n LangOptions::FPExceptionModeKind);\n\n /// Called to set constant rounding mode for floating point operations.\n void setRoundingMode(SourceLocation Loc, llvm::RoundingMode);\n\n /// Called to set exception behavior for floating point operations.\n void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind);\n\n /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to\n /// a the record decl, to handle '\\#pragma pack' and '\\#pragma options align'.\n void AddAlignmentAttributesForRecord(RecordDecl *RD);\n\n /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.\n void AddMsStructLayoutForRecord(RecordDecl *RD);\n\n /// PushNamespaceVisibilityAttr - Note that we've entered a\n /// namespace with a visibility attribute.\n void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,\n SourceLocation Loc);\n\n /// AddPushedVisibilityAttribute - If '\\#pragma GCC visibility' was used,\n /// add an appropriate visibility attribute.\n void AddPushedVisibilityAttribute(Decl *RD);\n\n /// PopPragmaVisibility - Pop the top element of the visibility stack; used\n /// for '\\#pragma GCC visibility' and visibility attributes on namespaces.\n void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc);\n\n /// FreeVisContext - Deallocate and null out VisContext.\n void FreeVisContext();\n\n /// AddCFAuditedAttribute - Check whether we're currently within\n /// '\\#pragma clang arc_cf_code_audited' and, if so, consider adding\n /// the appropriate attribute.\n void AddCFAuditedAttribute(Decl *D);\n\n void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute,\n SourceLocation PragmaLoc,\n attr::ParsedSubjectMatchRuleSet Rules);\n void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,\n const IdentifierInfo *Namespace);\n\n /// Called on well-formed '\\#pragma clang attribute pop'.\n void ActOnPragmaAttributePop(SourceLocation PragmaLoc,\n const IdentifierInfo *Namespace);\n\n /// Adds the attributes that have been specified using the\n /// '\\#pragma clang attribute push' directives to the given declaration.\n void AddPragmaAttributes(Scope *S, Decl *D);\n\n void DiagnoseUnterminatedPragmaAttribute();\n\n /// Called on well formed \\#pragma clang optimize.\n void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);\n\n /// Get the location for the currently active \"\\#pragma clang optimize\n /// off\". If this location is invalid, then the state of the pragma is \"on\".\n SourceLocation getOptimizeOffPragmaLocation() const {\n return OptimizeOffPragmaLocation;\n }\n\n /// Only called on function definitions; if there is a pragma in scope\n /// with the effect of a range-based optnone, consider marking the function\n /// with attribute optnone.\n void AddRangeBasedOptnone(FunctionDecl *FD);\n\n /// Adds the 'optnone' attribute to the function declaration if there\n /// are no conflicts; Loc represents the location causing the 'optnone'\n /// attribute to be added (usually because of a pragma).\n void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);\n\n /// AddAlignedAttr - Adds an aligned attribute to a particular declaration.\n void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,\n bool IsPackExpansion);\n void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *T,\n bool IsPackExpansion);\n\n /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular\n /// declaration.\n void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,\n Expr *OE);\n\n /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular\n /// declaration.\n void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI,\n Expr *ParamExpr);\n\n /// AddAlignValueAttr - Adds an align_value attribute to a particular\n /// declaration.\n void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);\n\n /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.\n void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,\n StringRef Annot, MutableArrayRef Args);\n\n /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular\n /// declaration.\n void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI,\n Expr *MaxThreads, Expr *MinBlocks);\n\n /// AddModeAttr - Adds a mode attribute to a particular declaration.\n void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name,\n bool InInstantiation = false);\n\n void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI,\n ParameterABI ABI);\n\n enum class RetainOwnershipKind {NS, CF, OS};\n void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI,\n RetainOwnershipKind K, bool IsTemplateInstantiation);\n\n /// addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size\n /// attribute to a particular declaration.\n void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI,\n Expr *Min, Expr *Max);\n\n /// addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a\n /// particular declaration.\n void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI,\n Expr *Min, Expr *Max);\n\n bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);\n\n //===--------------------------------------------------------------------===//\n // C++ Coroutines TS\n //\n bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,\n StringRef Keyword);\n ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);\n ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);\n StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);\n\n ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,\n bool IsImplicit = false);\n ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,\n UnresolvedLookupExpr* Lookup);\n ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);\n StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,\n bool IsImplicit = false);\n StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);\n bool buildCoroutineParameterMoves(SourceLocation Loc);\n VarDecl *buildCoroutinePromise(SourceLocation Loc);\n void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);\n ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc,\n SourceLocation FuncLoc);\n /// Check that the expression co_await promise.final_suspend() shall not be\n /// potentially-throwing.\n bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend);\n\n //===--------------------------------------------------------------------===//\n // OpenCL extensions.\n //\nprivate:\n std::string CurrOpenCLExtension;\n /// Extensions required by an OpenCL type.\n llvm::DenseMap> OpenCLTypeExtMap;\n /// Extensions required by an OpenCL declaration.\n llvm::DenseMap