//===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file implements semantic analysis for declarations. // //===----------------------------------------------------------------------===// #include "TypeLocBuilder.h" #include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTContext.h" #include "clang/AST/ASTLambda.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/CharUnits.h" #include "clang/AST/CommentDiagnostic.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/DeclTemplate.h" #include "clang/AST/EvaluatedExprVisitor.h" #include "clang/AST/Expr.h" #include "clang/AST/ExprCXX.h" #include "clang/AST/NonTrivialTypeVisitor.h" #include "clang/AST/MangleNumberingContext.h" #include "clang/AST/Randstruct.h" #include "clang/AST/StmtCXX.h" #include "clang/AST/Type.h" #include "clang/Basic/Builtins.h" #include "clang/Basic/HLSLRuntime.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering. #include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex #include "clang/Lex/Preprocessor.h" // Included for isCodeCompletionEnabled() #include "clang/Sema/CXXFieldCollector.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/DelayedDiagnostic.h" #include "clang/Sema/Initialization.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaHLSL.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" #include "clang/Sema/SemaOpenMP.h" #include "clang/Sema/SemaPPC.h" #include "clang/Sema/SemaRISCV.h" #include "clang/Sema/SemaSwift.h" #include "clang/Sema/SemaWasm.h" #include "clang/Sema/Template.h" #include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringExtras.h" #include "llvm/TargetParser/Triple.h" #include <algorithm> #include <cstring> #include <functional> #include <optional> #include <unordered_map> usingnamespaceclang; usingnamespacesema; Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) { … } namespace { class TypeNameValidatorCCC final : public CorrectionCandidateCallback { … }; } // end anonymous namespace namespace { enum class UnqualifiedTypeNameLookupResult { … }; } // end anonymous namespace /// Tries to perform unqualified lookup of the type decls in bases for /// dependent class. /// \return \a NotFound if no any decls is found, \a FoundNotType if found not a /// type decl, \a FoundType if only type decls are found. static UnqualifiedTypeNameLookupResult lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc, const CXXRecordDecl *RD) { … } static ParsedType recoverFromTypeInKnownDependentBase(Sema &S, const IdentifierInfo &II, SourceLocation NameLoc) { … } /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier. static ParsedType buildNamedType(Sema &S, const CXXScopeSpec *SS, QualType T, SourceLocation NameLoc, bool WantNontrivialTypeSourceInfo = true) { … } ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS, bool isClassName, bool HasTrailingDot, ParsedType ObjectTypePtr, bool IsCtorOrDtorName, bool WantNontrivialTypeSourceInfo, bool IsClassTemplateDeductionContext, ImplicitTypenameContext AllowImplicitTypename, IdentifierInfo **CorrectedII) { … } // Builds a fake NNS for the given decl context. static NestedNameSpecifier * synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) { … } /// Find the parent class with dependent bases of the innermost enclosing method /// context. Do not look for enclosing CXXRecordDecls directly, or we will end /// up allowing unqualified dependent type names at class-level, which MSVC /// correctly rejects. static const CXXRecordDecl * findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC) { … } ParsedType Sema::ActOnMSVCUnknownTypeName(const IdentifierInfo &II, SourceLocation NameLoc, bool IsTemplateTypeArg) { … } DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) { … } bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) { … } void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName) { … } /// Determine whether the given result set contains either a type name /// or static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) { … } static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc) { … } Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc, const Token &NextToken, CorrectionCandidateCallback *CCC) { … } ExprResult Sema::ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name, SourceLocation NameLoc) { … } ExprResult Sema::ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, bool IsAddressOfOperand) { … } ExprResult Sema::ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS, NamedDecl *Found, SourceLocation NameLoc, const Token &NextToken) { … } ExprResult Sema::ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *E) { … } Sema::TemplateNameKindForDiagnostics Sema::getTemplateNameKindForDiagnostics(TemplateName Name) { … } void Sema::PushDeclContext(Scope *S, DeclContext *DC) { … } void Sema::PopDeclContext() { … } Sema::SkippedDefinitionContext Sema::ActOnTagStartSkippedDefinition(Scope *S, Decl *D) { … } void Sema::ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context) { … } void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) { … } void Sema::ExitDeclaratorContext(Scope *S) { … } void Sema::EnterTemplatedContext(Scope *S, DeclContext *DC) { … } void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) { … } void Sema::ActOnExitFunctionContext() { … } /// Determine whether overloading is allowed for a new function /// declaration considering prior declarations of the same name. /// /// This routine determines whether overloading is possible, not /// whether a new declaration actually overloads a previous one. /// It will return true in C++ (where overloads are always permitted) /// or, as a C extension, when either the new declaration or a /// previous one is declared with the 'overloadable' attribute. static bool AllowOverloadingOfFunction(const LookupResult &Previous, ASTContext &Context, const FunctionDecl *New) { … } void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) { … } bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S, bool AllowInlineNamespace) const { … } Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) { … } static bool isOutOfScopePreviousDeclaration(NamedDecl *, DeclContext*, ASTContext&); void Sema::FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S, bool ConsiderLinkage, bool AllowInlineNamespace) { … } bool Sema::CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old) { … } bool Sema::CheckRedeclarationExported(NamedDecl *New, NamedDecl *Old) { … } bool Sema::CheckRedeclarationInModule(NamedDecl *New, NamedDecl *Old) { … } bool Sema::IsRedefinitionInModule(const NamedDecl *New, const NamedDecl *Old) const { … } static bool isUsingDeclNotAtClassScope(NamedDecl *D) { … } /// Removes using shadow declarations not at class scope from the lookup /// results. static void RemoveUsingDecls(LookupResult &R) { … } /// Check for this common pattern: /// @code /// class S { /// S(const S&); // DO NOT IMPLEMENT /// void operator=(const S&); // DO NOT IMPLEMENT /// }; /// @endcode static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) { … } bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) { … } // FIXME: This needs to be refactored; some other isInMainFile users want // these semantics. static bool isMainFileLoc(const Sema &S, SourceLocation Loc) { … } bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const { … } void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) { … } static bool ShouldDiagnoseUnusedDecl(const LangOptions &LangOpts, const NamedDecl *D) { … } static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx, FixItHint &Hint) { … } void Sema::DiagnoseUnusedNestedTypedefs(const RecordDecl *D) { … } void Sema::DiagnoseUnusedNestedTypedefs(const RecordDecl *D, DiagReceiverTy DiagReceiver) { … } void Sema::DiagnoseUnusedDecl(const NamedDecl *D) { … } void Sema::DiagnoseUnusedDecl(const NamedDecl *D, DiagReceiverTy DiagReceiver) { … } void Sema::DiagnoseUnusedButSetDecl(const VarDecl *VD, DiagReceiverTy DiagReceiver) { … } static void CheckPoppedLabel(LabelDecl *L, Sema &S, Sema::DiagReceiverTy DiagReceiver) { … } void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) { … } Scope *Sema::getNonFieldDeclScope(Scope *S) { … } static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID, ASTContext::GetBuiltinTypeError Error) { … } FunctionDecl *Sema::CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID, SourceLocation Loc) { … } NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc) { … } /// Typedef declarations don't have linkage, but they still denote the same /// entity if their types are the same. /// FIXME: This is notionally doing the same thing as ASTReaderDecl's /// isSameEntity. static void filterNonConflictingPreviousTypedefDecls(Sema &S, const TypedefNameDecl *Decl, LookupResult &Previous) { … } bool Sema::isIncompatibleTypedef(const TypeDecl *Old, TypedefNameDecl *New) { … } void Sema::MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls) { … } /// DeclhasAttr - returns true if decl Declaration already has the target /// attribute. static bool DeclHasAttr(const Decl *D, const Attr *A) { … } static bool isAttributeTargetADefinition(Decl *D) { … } /// Merge alignment attributes from \p Old to \p New, taking into account the /// special semantics of C11's _Alignas specifier and C++11's alignas attribute. /// /// \return \c true if any attributes were added to \p New. static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) { … } #define WANT_DECL_MERGE_LOGIC #include "clang/Sema/AttrParsedAttrImpl.inc" #undef WANT_DECL_MERGE_LOGIC static bool mergeDeclAttribute(Sema &S, NamedDecl *D, const InheritableAttr *Attr, Sema::AvailabilityMergeKind AMK) { … } static const NamedDecl *getDefinition(const Decl *D) { … } static bool hasAttribute(const Decl *D, attr::Kind Kind) { … } /// checkNewAttributesAfterDef - If we already have a definition, check that /// there are no new attributes in this declaration. static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) { … } static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl, const ConstInitAttr *CIAttr, bool AttrBeforeInit) { … } void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK) { … } /// mergeParamDeclAttributes - Copy attributes from the old parameter /// to the new one. static void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S) { … } static bool EquivalentArrayTypes(QualType Old, QualType New, const ASTContext &Ctx) { … } static void mergeParamDeclTypes(ParmVarDecl *NewParam, const ParmVarDecl *OldParam, Sema &S) { … } namespace { /// Used in MergeFunctionDecl to keep track of function parameters in /// C. struct GNUCompatibleParamWarning { … }; } // end anonymous namespace // Determine whether the previous declaration was a definition, implicit // declaration, or a declaration. template <typename T> static std::pair<diag::kind, SourceLocation> getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) { … } /// canRedefineFunction - checks if a function can be redefined. Currently, /// only extern inline functions can be redefined, and even then only in /// GNU89 mode. static bool canRedefineFunction(const FunctionDecl *FD, const LangOptions& LangOpts) { … } const AttributedType *Sema::getCallingConvAttributedType(QualType T) const { … } template <typename T> static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) { … } template<typename T> static bool isExternC(T *D) { … } static bool isExternC(VarTemplateDecl *) { … } static bool isExternC(FunctionTemplateDecl *) { … } /// Check whether a redeclaration of an entity introduced by a /// using-declaration is valid, given that we know it's not an overload /// (nor a hidden tag declaration). template<typename ExpectedDecl> static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New) { … } static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A, const FunctionDecl *B) { … } /// If necessary, adjust the semantic declaration context for a qualified /// declaration to name the correct inline namespace within the qualifier. static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD, DeclaratorDecl *OldD) { … } bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) { … } bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old, Scope *S, bool MergeTypeWithOld) { … } void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod, ObjCMethodDecl *oldMethod) { … } static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl* Old) { … } void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld) { … } static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD, LookupResult &Previous) { … } void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) { … } void Sema::notePreviousDefinition(const NamedDecl *Old, SourceLocation New) { … } bool Sema::checkVarDeclRedefinition(VarDecl *Old, VarDecl *New) { … } Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, RecordDecl *&AnonRecord) { … } // The MS ABI changed between VS2013 and VS2015 with regard to numbers used to // disambiguate entities defined in different scopes. // While the VS2015 ABI fixes potential miscompiles, it is also breaks // compatibility. // We will pick our mangling number depending on which version of MSVC is being // targeted. static unsigned getMSManglingNumber(const LangOptions &LO, Scope *S) { … } void Sema::handleTagNumbering(const TagDecl *Tag, Scope *TagScope) { … } namespace { struct NonCLikeKind { … }; } /// Determine whether a class is C-like, according to the rules of C++ /// [dcl.typedef] for anonymous classes with typedef names for linkage. static NonCLikeKind getNonCLikeKindForAnonymousStruct(const CXXRecordDecl *RD) { … } void Sema::setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec, TypedefNameDecl *NewTD) { … } static unsigned GetDiagnosticTypeSpecifierID(const DeclSpec &DS) { … } Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS, const ParsedAttributesView &DeclAttrs, MultiTemplateParamsArg TemplateParams, bool IsExplicitInstantiation, RecordDecl *&AnonRecord, SourceLocation EllipsisLoc) { … } /// We are trying to inject an anonymous member into the given scope; /// check if there's an existing declaration that can't be overloaded. /// /// \return true if this is a forbidden redeclaration static bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion, StorageClass SC) { … } void Sema::ActOnDefinedDeclarationSpecifier(Decl *D) { … } void Sema::DiagPlaceholderFieldDeclDefinitions(RecordDecl *Record) { … } /// InjectAnonymousStructOrUnionMembers - Inject the members of the /// anonymous struct or union AnonRecord into the owning context Owner /// and scope S. This routine will be invoked just after we realize /// that an unnamed union or struct is actually an anonymous union or /// struct, e.g., /// /// @code /// union { /// int i; /// float f; /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and /// // f into the surrounding scope.x /// @endcode /// /// This routine is recursive, injecting the names of nested anonymous /// structs/unions into the owning context and scope as well. static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S, DeclContext *Owner, RecordDecl *AnonRecord, AccessSpecifier AS, StorageClass SC, SmallVectorImpl<NamedDecl *> &Chaining) { … } /// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to /// a VarDecl::StorageClass. Any error reporting is up to the caller: /// illegal input values are mapped to SC_None. static StorageClass StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) { … } static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) { … } static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, SourceLocation DefaultInitLoc) { … } static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent, CXXRecordDecl *AnonUnion) { … } Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) { … } Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS, RecordDecl *Record) { … } DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) { … } DeclarationNameInfo Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) { … } static QualType getCoreType(QualType Ty) { … } /// hasSimilarParameters - Determine whether the C++ functions Declaration /// and Definition have "nearly" matching parameters. This heuristic is /// used to improve diagnostics in the case where an out-of-line function /// definition doesn't match any declaration within the class or namespace. /// Also sets Params to the list of indices to the parameters that differ /// between the declaration and the definition. If hasSimilarParameters /// returns true and Params is empty, then all of the parameters match. static bool hasSimilarParameters(ASTContext &Context, FunctionDecl *Declaration, FunctionDecl *Definition, SmallVectorImpl<unsigned> &Params) { … } /// RebuildDeclaratorInCurrentInstantiation - Checks whether the given /// declarator needs to be rebuilt in the current instantiation. /// Any bits of declarator which appear before the name are valid for /// consideration here. That's specifically the type in the decl spec /// and the base type in any member-pointer chunks. static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D, DeclarationName Name) { … } /// Returns true if the declaration is declared in a system header or from a /// system macro. static bool isFromSystemHeader(SourceManager &SM, const Decl *D) { … } void Sema::warnOnReservedIdentifier(const NamedDecl *D) { … } Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) { … } bool Sema::DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo NameInfo) { … } bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC, DeclarationName Name, SourceLocation Loc, TemplateIdAnnotation *TemplateId, bool IsMemberSpecialization) { … } NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists) { … } /// Helper method to turn variable array types into constant array /// types in certain situations which would otherwise be errors (for /// GCC compatibility). static QualType TryToFixInvalidVariablyModifiedType(QualType T, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized) { … } static void FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) { … } /// Helper method to turn variable array types into constant array /// types in certain situations which would otherwise be errors (for /// GCC compatibility). static TypeSourceInfo* TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo, ASTContext &Context, bool &SizeIsNegative, llvm::APSInt &Oversized) { … } bool Sema::tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo, QualType &T, SourceLocation Loc, unsigned FailedFoldDiagID) { … } void Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) { … } NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) { … } void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) { … } NamedDecl* Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC, TypeSourceInfo *TInfo, LookupResult &Previous) { … } void Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) { … } NamedDecl* Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD, LookupResult &Previous, bool &Redeclaration) { … } /// Determines whether the given declaration is an out-of-scope /// previous declaration. /// /// This routine should be invoked when name lookup has found a /// previous declaration (PrevDecl) that is not in the scope where a /// new declaration by the same name is being introduced. If the new /// declaration occurs in a local scope, previous declarations with /// linkage may still be considered previous declarations (C99 /// 6.2.2p4-5, C++ [basic.link]p6). /// /// \param PrevDecl the previous declaration found by name /// lookup /// /// \param DC the context in which the new declaration is being /// declared. /// /// \returns true if PrevDecl is an out-of-scope previous declaration /// for a new delcaration with the same name. static bool isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC, ASTContext &Context) { … } static void SetNestedNameSpecifier(Sema &S, DeclaratorDecl *DD, Declarator &D) { … } void Sema::deduceOpenCLAddressSpace(ValueDecl *Decl) { … } static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) { … } static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition) { … } /// Given that we are within the definition of the given function, /// will that definition behave like C99's 'inline', where the /// definition is discarded except for optimization purposes? static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) { … } /// Determine whether a variable is extern "C" prior to attaching /// an initializer. We can't just call isExternC() here, because that /// will also compute and cache whether the declaration is externally /// visible, which might change when we attach the initializer. /// /// This can only be used if the declaration is known to not be a /// redeclaration of an internal linkage declaration. /// /// For instance: /// /// auto x = []{}; /// /// Attaching the initializer here makes this declaration not externally /// visible, because its type has internal linkage. /// /// FIXME: This is a hack. template<typename T> static bool isIncompleteDeclExternC(Sema &S, const T *D) { … } static bool shouldConsiderLinkage(const VarDecl *VD) { … } static bool shouldConsiderLinkage(const FunctionDecl *FD) { … } static bool hasParsedAttr(Scope *S, const Declarator &PD, ParsedAttr::Kind Kind) { … } bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { … } /// Returns true if given declaration has external C language linkage. static bool isDeclExternC(const Decl *D) { … } /// Returns true if there hasn't been any invalid type diagnosed. static bool diagnoseOpenCLTypes(Sema &Se, VarDecl *NewVD) { … } template <typename AttrTy> static void copyAttrFromTypedefToDecl(Sema &S, Decl *D, const TypedefType *TT) { … } // This function emits warning and a corresponding note based on the // ReadOnlyPlacementAttr attribute. The warning checks that all global variable // declarations of an annotated type must be const qualified. static void emitReadOnlyPlacementAttrWarning(Sema &S, const VarDecl *VD) { … } // Checks if VD is declared at global scope or with C language linkage. static bool isMainVar(DeclarationName Name, VarDecl *VD) { … } NamedDecl *Sema::ActOnVariableDeclarator( Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef<BindingDecl *> Bindings) { … } /// Enum describing the %select options in diag::warn_decl_shadow. enum ShadowedDeclKind { … }; /// Determine what kind of declaration we're shadowing. static ShadowedDeclKind computeShadowedDeclKind(const NamedDecl *ShadowedDecl, const DeclContext *OldDC) { … } /// Return the location of the capture if the given lambda captures the given /// variable \p VD, or an invalid source location otherwise. static SourceLocation getCaptureLocation(const LambdaScopeInfo *LSI, const VarDecl *VD) { … } static bool shouldWarnIfShadowedDecl(const DiagnosticsEngine &Diags, const LookupResult &R) { … } NamedDecl *Sema::getShadowedDeclaration(const VarDecl *D, const LookupResult &R) { … } NamedDecl *Sema::getShadowedDeclaration(const TypedefNameDecl *D, const LookupResult &R) { … } NamedDecl *Sema::getShadowedDeclaration(const BindingDecl *D, const LookupResult &R) { … } void Sema::CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R) { … } void Sema::DiagnoseShadowingLambdaDecls(const LambdaScopeInfo *LSI) { … } void Sema::CheckShadow(Scope *S, VarDecl *D) { … } /// Check if 'E', which is an expression that is about to be modified, refers /// to a constructor parameter that shadows a field. void Sema::CheckShadowingDeclModification(Expr *E, SourceLocation Loc) { … } /// Check for conflict between this global or extern "C" declaration and /// previous global or extern "C" declarations. This is only used in C++. template<typename T> static bool checkGlobalOrExternCConflict( Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) { … } /// Apply special rules for handling extern "C" declarations. Returns \c true /// if we have found that this is a redeclaration of some prior entity. /// /// Per C++ [dcl.link]p6: /// Two declarations [for a function or variable] with C language linkage /// with the same name that appear in different scopes refer to the same /// [entity]. An entity with C language linkage shall not be declared with /// the same name as an entity in global scope. template<typename T> static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND, LookupResult &Previous) { … } static bool CheckC23ConstexprVarType(Sema &SemaRef, SourceLocation VarLoc, QualType T) { … } void Sema::CheckVariableDeclarationType(VarDecl *NewVD) { … } bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) { … } bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) { … } namespace { // Struct for holding all of the extra arguments needed by // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator. struct ActOnFDArgs { … }; } // end anonymous namespace namespace { // Callback to only accept typo corrections that have a non-zero edit distance. // Also only accept corrections that have the same parent decl. class DifferentNameValidatorCCC final : public CorrectionCandidateCallback { … }; } // end anonymous namespace void Sema::MarkTypoCorrectedFunctionDefinition(const NamedDecl *F) { … } /// Generate diagnostics for an invalid function redeclaration. /// /// This routine handles generating the diagnostic messages for an invalid /// function redeclaration, including finding possible similar declarations /// or performing typo correction if there are no previous declarations with /// the same name. /// /// Returns a NamedDecl iff typo correction was performed and substituting in /// the new declaration name does not cause new errors. static NamedDecl *DiagnoseInvalidRedeclaration( Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) { … } static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D) { … } static FunctionDecl *CreateNewFunctionDecl(Sema &SemaRef, Declarator &D, DeclContext *DC, QualType &R, TypeSourceInfo *TInfo, StorageClass SC, bool &IsVirtualOkay) { … } enum OpenCLParamType { … }; static bool isOpenCLSizeDependentType(ASTContext &C, QualType Ty) { … } static OpenCLParamType getOpenCLKernelParameterType(Sema &S, QualType PT) { … } static void checkIsValidOpenCLKernelParameter( Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl<const Type *> &ValidTypes) { … } /// Find the DeclContext in which a tag is implicitly declared if we see an /// elaborated type specifier in the specified context, and lookup finds /// nothing. static DeclContext *getTagInjectionContext(DeclContext *DC) { … } /// Find the Scope in which a tag is implicitly declared if we see an /// elaborated type specifier in the specified context, and lookup finds /// nothing. static Scope *getTagInjectionScope(Scope *S, const LangOptions &LangOpts) { … } /// Determine whether a declaration matches a known function in namespace std. static bool isStdBuiltin(ASTContext &Ctx, FunctionDecl *FD, unsigned BuiltinID) { … } NamedDecl* Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) { … } /// Return a CodeSegAttr from a containing class. The Microsoft docs say /// when __declspec(code_seg) "is applied to a class, all member functions of /// the class and nested classes -- this includes compiler-generated special /// member functions -- are put in the specified segment." /// The actual behavior is a little more complicated. The Microsoft compiler /// won't check outer classes if there is an active value from #pragma code_seg. /// The CodeSeg is always applied from the direct parent but only from outer /// classes when the #pragma code_seg stack is empty. See: /// https://reviews.llvm.org/D22931, the Microsoft feedback page is no longer /// available since MS has removed the page. static Attr *getImplicitCodeSegAttrFromClass(Sema &S, const FunctionDecl *FD) { … } Attr *Sema::getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD, bool IsDefinition) { … } bool Sema::canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD, QualType NewT, QualType OldT) { … } bool Sema::shouldLinkDependentDeclWithPrevious(Decl *D, Decl *PrevDecl) { … } /// Check the target or target_version attribute of the function for /// MultiVersion validity. /// /// Returns true if there was an error, false otherwise. static bool CheckMultiVersionValue(Sema &S, const FunctionDecl *FD) { … } // Provide a white-list of attributes that are allowed to be combined with // multiversion functions. static bool AttrCompatibleWithMultiVersion(attr::Kind Kind, MultiVersionKind MVKind) { … } static bool checkNonMultiVersionCompatAttributes(Sema &S, const FunctionDecl *FD, const FunctionDecl *CausedFD, MultiVersionKind MVKind) { … } bool Sema::areMultiversionVariantFunctionsCompatible( const FunctionDecl *OldFD, const FunctionDecl *NewFD, const PartialDiagnostic &NoProtoDiagID, const PartialDiagnosticAt &NoteCausedDiagIDAt, const PartialDiagnosticAt &NoSupportDiagIDAt, const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported, bool ConstexprSupported, bool CLinkageMayDiffer) { … } static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD, const FunctionDecl *NewFD, bool CausesMV, MultiVersionKind MVKind) { … } /// Check the validity of a multiversion function declaration that is the /// first of its kind. Also sets the multiversion'ness' of the function itself. /// /// This sets NewFD->isInvalidDecl() to true if there was an error. /// /// Returns true if there was an error, false otherwise. static bool CheckMultiVersionFirstFunction(Sema &S, FunctionDecl *FD) { … } static bool PreviousDeclsHaveMultiVersionAttribute(const FunctionDecl *FD) { … } static void patchDefaultTargetVersion(FunctionDecl *From, FunctionDecl *To) { … } static bool CheckDeclarationCausesMultiVersioning(Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous) { … } static bool MultiVersionTypesCompatible(FunctionDecl *Old, FunctionDecl *New) { … } /// Check the validity of a new function declaration being added to an existing /// multiversioned declaration collection. static bool CheckMultiVersionAdditionalDecl( Sema &S, FunctionDecl *OldFD, FunctionDecl *NewFD, const CPUDispatchAttr *NewCPUDisp, const CPUSpecificAttr *NewCPUSpec, const TargetClonesAttr *NewClones, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous) { … } /// Check the validity of a mulitversion function declaration. /// Also sets the multiversion'ness' of the function itself. /// /// This sets NewFD->isInvalidDecl() to true if there was an error. /// /// Returns true if there was an error, false otherwise. static bool CheckMultiVersionFunction(Sema &S, FunctionDecl *NewFD, bool &Redeclaration, NamedDecl *&OldDecl, LookupResult &Previous) { … } static void CheckConstPureAttributesUsage(Sema &S, FunctionDecl *NewFD) { … } bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn) { … } void Sema::CheckMain(FunctionDecl *FD, const DeclSpec &DS) { … } static bool isDefaultStdCall(FunctionDecl *FD, Sema &S) { … } void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) { … } bool Sema::CheckForConstantInitializer(Expr *Init, unsigned DiagID) { … } namespace { // Visits an initialization expression to see if OrigDecl is evaluated in // its own initialization and throws a warning if it does. class SelfReferenceChecker : public EvaluatedExprVisitor<SelfReferenceChecker> { … }; /// CheckSelfReference - Warns if OrigDecl is used in expression E. static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E, bool DirectInit) { … } } // end anonymous namespace namespace { // Simple wrapper to add the name of a variable or (if no variable is // available) a DeclarationName into a diagnostic. struct VarDeclOrName { … }; } // end anonymous namespace QualType Sema::deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init) { … } bool Sema::DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit, Expr *Init) { … } void Sema::checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc) { … } namespace { bool shouldIgnoreForRecordTriviality(const FieldDecl *FD) { … } struct DiagNonTrivalCUnionDefaultInitializeVisitor : DefaultInitializedTypeVisitor<DiagNonTrivalCUnionDefaultInitializeVisitor, void> { … }; struct DiagNonTrivalCUnionDestructedTypeVisitor : DestructedTypeVisitor<DiagNonTrivalCUnionDestructedTypeVisitor, void> { … }; struct DiagNonTrivalCUnionCopyVisitor : CopiedTypeVisitor<DiagNonTrivalCUnionCopyVisitor, false, void> { … }; } // namespace void Sema::checkNonTrivialCUnion(QualType QT, SourceLocation Loc, NonTrivialCUnionContext UseContext, unsigned NonTrivialKind) { … } void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) { … } void Sema::ActOnInitializerError(Decl *D) { … } void Sema::ActOnUninitializedDecl(Decl *RealDecl) { … } void Sema::ActOnCXXForRangeDecl(Decl *D) { … } StmtResult Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, IdentifierInfo *Ident, ParsedAttributes &Attrs) { … } void Sema::CheckCompleteVariableDeclaration(VarDecl *var) { … } void Sema::CheckStaticLocalForDllExport(VarDecl *VD) { … } void Sema::CheckThreadLocalForLargeAlignment(VarDecl *VD) { … } void Sema::FinalizeDeclaration(Decl *ThisDecl) { … } static bool hasDeducedAuto(DeclaratorDecl *DD) { … } Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS, ArrayRef<Decl *> Group) { … } Sema::DeclGroupPtrTy Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group) { … } void Sema::ActOnDocumentableDecl(Decl *D) { … } void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) { … } void Sema::CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D) { … } static void CheckExplicitObjectParameter(Sema &S, ParmVarDecl *P, SourceLocation ExplicitThisLoc) { … } Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D, SourceLocation ExplicitThisLoc) { … } ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC, SourceLocation Loc, QualType T) { … } void Sema::DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters) { … } void Sema::DiagnoseSizeOfParametersAndReturnValue( ArrayRef<ParmVarDecl *> Parameters, QualType ReturnTy, NamedDecl *D) { … } ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, const IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC) { … } void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D, SourceLocation LocAfterDecls) { … } Decl * Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D, MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) { … } void Sema::ActOnFinishInlineFunctionDef(FunctionDecl *D) { … } static bool FindPossiblePrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype) { … } static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD, const FunctionDecl *&PossiblePrototype) { … } void Sema::CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition, SkipBodyInfo *SkipBody) { … } LambdaScopeInfo *Sema::RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator) { … } Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) { … } void Sema::applyFunctionAttributesBeforeParsingBody(Decl *FD) { … } void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) { … } bool Sema::canDelayFunctionBody(const Declarator &D) { … } bool Sema::canSkipFunctionBody(Decl *D) { … } Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) { … } Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) { … } /// RAII object that pops an ExpressionEvaluationContext when exiting a function /// body. class ExitFunctionBodyRAII { … }; static void diagnoseImplicitlyRetainedSelf(Sema &S) { … } static bool methodHasName(const FunctionDecl *FD, StringRef Name) { … } bool Sema::CanBeGetReturnObject(const FunctionDecl *FD) { … } bool Sema::CanBeGetReturnTypeOnAllocFailure(const FunctionDecl *FD) { … } void Sema::CheckCoroutineWrapper(FunctionDecl *FD) { … } Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, bool IsInstantiation) { … } /// When we finish delayed parsing of an attribute, we must attach it to the /// relevant Decl. void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs) { … } NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S) { … } void Sema::AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction( FunctionDecl *FD) { … } void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) { … } TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T, TypeSourceInfo *TInfo) { … } bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) { … } bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped, QualType EnumUnderlyingTy, bool IsFixed, const EnumDecl *Prev) { … } /// Get diagnostic %select index for tag kind for /// redeclaration diagnostic message. /// WARNING: Indexes apply to particular diagnostics only! /// /// \returns diagnostic %select index. static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) { … } /// Determine if tag kind is a class-key compatible with /// class for redeclaration (class, struct, or __interface). /// /// \returns true iff the tag kind is compatible. static bool isClassCompatTagKind(TagTypeKind Tag) { … } Sema::NonTagKind Sema::getNonTagTypeDeclKind(const Decl *PrevDecl, TagTypeKind TTK) { … } bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous, TagTypeKind NewTag, bool isDefinition, SourceLocation NewTagLoc, const IdentifierInfo *Name) { … } /// Add a minimal nested name specifier fixit hint to allow lookup of a tag name /// from an outer enclosing namespace or file scope inside a friend declaration. /// This should provide the commented out code in the following snippet: /// namespace N { /// struct X; /// namespace M { /// struct Y { friend struct /*N::*/ X; }; /// } /// } static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S, SourceLocation NameLoc) { … } /// Determine whether a tag originally declared in context \p OldDC can /// be redeclared with an unqualified name in \p NewDC (assuming name lookup /// found a declaration in \p OldDC as a previous decl, perhaps through a /// using-declaration). static bool isAcceptableTagRedeclContext(Sema &S, DeclContext *OldDC, DeclContext *NewDC) { … } DeclResult Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attrs, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody) { … } void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) { … } bool Sema::ActOnDuplicateDefinition(Decl *Prev, SkipBodyInfo &SkipBody) { … } void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, SourceLocation FinalLoc, bool IsFinalSpelledSealed, bool IsAbstract, SourceLocation LBraceLoc) { … } void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD, SourceRange BraceRange) { … } void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) { … } // Note that FieldName may be null for anonymous bitfields. ExprResult Sema::VerifyBitField(SourceLocation FieldLoc, const IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth) { … }Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart, Declarator &D, Expr *BitfieldWidth) { … }FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record, SourceLocation DeclStart, Declarator &D, Expr *BitWidth, InClassInitStyle InitStyle, AccessSpecifier AS) { … }FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D) { … }bool Sema::CheckNontrivialField(FieldDecl *FD) { … }void Sema::ActOnLastBitfield(SourceLocation DeclLoc, SmallVectorImpl<Decl *> &AllIvarDecls) { … }static void ComputeSelectedDestructor(Sema &S, CXXRecordDecl *Record) { … }static bool AreSpecialMemberFunctionsSameKind(ASTContext &Context, CXXMethodDecl *M1, CXXMethodDecl *M2, CXXSpecialMemberKind CSM) { … }static void SetEligibleMethods(Sema &S, CXXRecordDecl *Record, ArrayRef<CXXMethodDecl *> Methods, CXXSpecialMemberKind CSM) { … }static void ComputeSpecialMemberFunctionsEligiblity(Sema &S, CXXRecordDecl *Record) { … }void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, ArrayRef<Decl *> Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &Attrs) { … }static bool isRepresentableIntegerValue(ASTContext &Context, llvm::APSInt &Value, QualType T) { … }static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) { … }EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum, EnumConstantDecl *LastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, Expr *Val) { … }SkipBodyInfo Sema::shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II, SourceLocation IILoc) { … }Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, const ParsedAttributesView &Attrs, SourceLocation EqualLoc, Expr *Val) { … }static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) { … }static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements, EnumDecl *Enum, QualType EnumType) { … }bool Sema::IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const { … }void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange, Decl *EnumDeclX, ArrayRef<Decl *> Elements, Scope *S, const ParsedAttributesView &Attrs) { … }Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr, SourceLocation StartLoc, SourceLocation EndLoc) { … }TopLevelStmtDecl *Sema::ActOnStartTopLevelStmtDecl(Scope *S) { … }void Sema::ActOnFinishTopLevelStmtDecl(TopLevelStmtDecl *D, Stmt *Statement) { … }void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, IdentifierInfo* AliasName, SourceLocation PragmaLoc, SourceLocation NameLoc, SourceLocation AliasNameLoc) { … }void Sema::ActOnPragmaWeakID(IdentifierInfo* Name, SourceLocation PragmaLoc, SourceLocation NameLoc) { … }void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name, IdentifierInfo* AliasName, SourceLocation PragmaLoc, SourceLocation NameLoc, SourceLocation AliasNameLoc) { … }Sema::FunctionEmissionStatus Sema::getEmissionStatus(const FunctionDecl *FD, bool Final) { … }bool Sema::shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee) { … }void Sema::diagnoseFunctionEffectMergeConflicts( const FunctionEffectSet::Conflicts &Errs, SourceLocation NewLoc, SourceLocation OldLoc) { … }bool Sema::diagnoseConflictingFunctionEffect( const FunctionEffectsRef &FX, const FunctionEffectWithCondition &NewEC, SourceLocation NewAttrLoc) { … }
Codebase Browser
llvm