clang 20.0.0git
Macros | Functions
Decl.cpp File Reference
#include "clang/AST/Decl.h"
#include "Linkage.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/ASTDiagnostic.h"
#include "clang/AST/ASTLambda.h"
#include "clang/AST/ASTMutationListener.h"
#include "clang/AST/Attr.h"
#include "clang/AST/CanonicalType.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclOpenMP.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DeclarationName.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/ExternalASTSource.h"
#include "clang/AST/ODRHash.h"
#include "clang/AST/PrettyDeclStackTrace.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/Randstruct.h"
#include "clang/AST/RecordLayout.h"
#include "clang/AST/Redeclarable.h"
#include "clang/AST/Stmt.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/Linkage.h"
#include "clang/Basic/Module.h"
#include "clang/Basic/NoSanitizeList.h"
#include "clang/Basic/PartialDiagnostic.h"
#include "clang/Basic/Sanitizers.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/Specifiers.h"
#include "clang/Basic/TargetCXXABI.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Basic/Visibility.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/Triple.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstring>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <type_traits>
#include "clang/AST/DeclNodes.inc"

Go to the source code of this file.

Macros

#define DECL(Type, Base)
 
#define ABSTRACT_DECL(DECL)
 

Functions

static bool hasExplicitVisibilityAlready (LVComputationKind computation)
 Does this computation kind permit us to consider additional visibility settings from attributes and the like?
 
static LVComputationKind withExplicitVisibilityAlready (LVComputationKind Kind)
 Given an LVComputationKind, return one of the same type/value sort that records that it already has explicit visibility.
 
static std::optional< VisibilitygetExplicitVisibility (const NamedDecl *D, LVComputationKind kind)
 
static bool usesTypeVisibility (const NamedDecl *D)
 Is the given declaration a "type" or a "value" for the purposes of visibility computation?
 
template<class T >
static std::enable_if_t<!std::is_base_of_v< RedeclarableTemplateDecl, T >, boolisExplicitMemberSpecialization (const T *D)
 Does the given declaration have member specialization information, and if so, is it an explicit specialization?
 
static bool isExplicitMemberSpecialization (const RedeclarableTemplateDecl *D)
 For templates, this question is easier: a member template can't be explicitly instantiated, so there's a single bit indicating whether or not this is an explicit member specialization.
 
template<class T >
static Visibility getVisibilityFromAttr (const T *attr)
 Given a visibility attribute, return the explicit visibility associated with it.
 
static std::optional< VisibilitygetVisibilityOf (const NamedDecl *D, NamedDecl::ExplicitVisibilityKind kind)
 Return the explicit visibility of the given declaration.
 
static const DeclgetOutermostFuncOrBlockContext (const Decl *D)
 
static bool shouldConsiderTemplateVisibility (const FunctionDecl *fn, const FunctionTemplateSpecializationInfo *specInfo)
 
static bool hasDirectVisibilityAttribute (const NamedDecl *D, LVComputationKind computation)
 Does the given declaration have a direct visibility attribute that would match the given rules?
 
static bool shouldConsiderTemplateVisibility (const ClassTemplateSpecializationDecl *spec, LVComputationKind computation)
 Should we consider visibility associated with the template arguments and parameters of the given class template specialization?
 
static bool shouldConsiderTemplateVisibility (const VarTemplateSpecializationDecl *spec, LVComputationKind computation)
 Should we consider visibility associated with the template arguments and parameters of the given variable template specialization? As usual, follow class template specialization logic up to initialization.
 
static bool useInlineVisibilityHidden (const NamedDecl *D)
 
template<typename T >
static bool isFirstInExternCContext (T *D)
 
static bool isSingleLineLanguageLinkage (const Decl &D)
 
static LinkageInfo getExternalLinkageFor (const NamedDecl *D)
 
static StorageClass getStorageClass (const Decl *D)
 
static bool isExportedFromModuleInterfaceUnit (const NamedDecl *D)
 
static std::optional< VisibilitygetExplicitVisibilityAux (const NamedDecl *ND, NamedDecl::ExplicitVisibilityKind kind, bool IsMostRecent)
 
template<typename T >
static bool isRedeclarableImpl (Redeclarable< T > *)
 
static bool isRedeclarableImpl (...)
 
static bool isRedeclarable (Decl::Kind K)
 
template<typename DeclT >
static SourceLocation getTemplateOrInnerLocStart (const DeclT *decl)
 
static bool typeIsPostfix (QualType QT)
 
template<typename T >
static LanguageLinkage getDeclLanguageLinkage (const T &D)
 
template<typename T >
static bool isDeclExternC (const T &D)
 
template<typename DeclT >
static DeclT * getDefinitionOrSelf (DeclT *D)
 
template<std::size_t Len>
static bool isNamed (const NamedDecl *ND, const char(&Str)[Len])
 
static bool redeclForcesDefMSVC (const FunctionDecl *Redecl)
 
static bool RedeclForcesDefC99 (const FunctionDecl *Redecl)
 
static unsigned getNumModuleIdentifiers (Module *Mod)
 Retrieve the number of module identifiers needed to name the given module.
 

Macro Definition Documentation

◆ ABSTRACT_DECL

#define ABSTRACT_DECL (   DECL)

◆ DECL

#define DECL (   Type,
  Base 
)
Value:
case Decl::Type: \
return isRedeclarableImpl((Type##Decl *)nullptr);
static bool isRedeclarableImpl(Redeclarable< T > *)
Definition: Decl.cpp:1820
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
The base class of the type hierarchy.
Definition: Type.h:1829

Function Documentation

◆ getDeclLanguageLinkage()

template<typename T >
static LanguageLinkage getDeclLanguageLinkage ( const T &  D)
static

◆ getDefinitionOrSelf()

template<typename DeclT >
static DeclT * getDefinitionOrSelf ( DeclT *  D)
static

◆ getExplicitVisibility()

static std::optional< Visibility > getExplicitVisibility ( const NamedDecl D,
LVComputationKind  kind 
)
static

Definition at line 172 of file Decl.cpp.

References D.

◆ getExplicitVisibilityAux()

static std::optional< Visibility > getExplicitVisibilityAux ( const NamedDecl ND,
NamedDecl::ExplicitVisibilityKind  kind,
bool  IsMostRecent 
)
static

◆ getExternalLinkageFor()

static LinkageInfo getExternalLinkageFor ( const NamedDecl D)
static

Definition at line 586 of file Decl.cpp.

References clang::LinkageInfo::external().

Referenced by clang::LinkageComputer::computeLVForDecl().

◆ getNumModuleIdentifiers()

static unsigned getNumModuleIdentifiers ( Module Mod)
static

Retrieve the number of module identifiers needed to name the given module.

Definition at line 5664 of file Decl.cpp.

References clang::Module::Parent, and clang::Result.

Referenced by clang::ImportDecl::getIdentifierLocs().

◆ getOutermostFuncOrBlockContext()

static const Decl * getOutermostFuncOrBlockContext ( const Decl D)
static

◆ getStorageClass()

static StorageClass getStorageClass ( const Decl D)
static

Definition at line 590 of file Decl.cpp.

References D, and clang::SC_None.

◆ getTemplateOrInnerLocStart()

template<typename DeclT >
static SourceLocation getTemplateOrInnerLocStart ( const DeclT *  decl)
static

◆ getVisibilityFromAttr()

template<class T >
static Visibility getVisibilityFromAttr ( const T *  attr)
static

Given a visibility attribute, return the explicit visibility associated with it.

Definition at line 209 of file Decl.cpp.

References clang::ast_matchers::attr, clang::DefaultVisibility, clang::HiddenVisibility, and clang::ProtectedVisibility.

Referenced by getVisibilityOf().

◆ getVisibilityOf()

static std::optional< Visibility > getVisibilityOf ( const NamedDecl D,
NamedDecl::ExplicitVisibilityKind  kind 
)
static

Return the explicit visibility of the given declaration.

Definition at line 223 of file Decl.cpp.

References D, clang::Decl::getAttr(), getVisibilityFromAttr(), and clang::NamedDecl::VisibilityForType.

Referenced by getExplicitVisibilityAux().

◆ hasDirectVisibilityAttribute()

static bool hasDirectVisibilityAttribute ( const NamedDecl D,
LVComputationKind  computation 
)
static

Does the given declaration have a direct visibility attribute that would match the given rules?

Definition at line 419 of file Decl.cpp.

References D, clang::Decl::hasAttr(), clang::LVComputationKind::IgnoreAllVisibility, and clang::LVComputationKind::isTypeVisibility().

Referenced by shouldConsiderTemplateVisibility().

◆ hasExplicitVisibilityAlready()

static bool hasExplicitVisibilityAlready ( LVComputationKind  computation)
static

Does this computation kind permit us to consider additional visibility settings from attributes and the like?

Definition at line 160 of file Decl.cpp.

References clang::LVComputationKind::IgnoreExplicitVisibility.

Referenced by shouldConsiderTemplateVisibility().

◆ isDeclExternC()

template<typename T >
static bool isDeclExternC ( const T &  D)
static

◆ isExplicitMemberSpecialization() [1/2]

static bool isExplicitMemberSpecialization ( const RedeclarableTemplateDecl D)
static

For templates, this question is easier: a member template can't be explicitly instantiated, so there's a single bit indicating whether or not this is an explicit member specialization.

Definition at line 202 of file Decl.cpp.

References D.

◆ isExplicitMemberSpecialization() [2/2]

template<class T >
static std::enable_if_t<!std::is_base_of_v< RedeclarableTemplateDecl, T >, bool > isExplicitMemberSpecialization ( const T *  D)
static

Does the given declaration have member specialization information, and if so, is it an explicit specialization?

Definition at line 191 of file Decl.cpp.

References D.

◆ isExportedFromModuleInterfaceUnit()

static bool isExportedFromModuleInterfaceUnit ( const NamedDecl D)
static

◆ isFirstInExternCContext()

template<typename T >
static bool isFirstInExternCContext ( T *  D)
static

Definition at line 574 of file Decl.cpp.

References D, clang::First, and clang::T.

Referenced by getDeclLanguageLinkage().

◆ isNamed()

template<std::size_t Len>
static bool isNamed ( const NamedDecl ND,
const char(&)  Str[Len] 
)
static

◆ isRedeclarable()

static bool isRedeclarable ( Decl::Kind  K)
static

Definition at line 1824 of file Decl.cpp.

Referenced by clang::NamedDecl::declarationReplaces().

◆ isRedeclarableImpl() [1/2]

static bool isRedeclarableImpl (   ...)
static

Definition at line 1823 of file Decl.cpp.

◆ isRedeclarableImpl() [2/2]

template<typename T >
static bool isRedeclarableImpl ( Redeclarable< T > *  )
static

Definition at line 1820 of file Decl.cpp.

◆ isSingleLineLanguageLinkage()

static bool isSingleLineLanguageLinkage ( const Decl D)
static

Definition at line 579 of file Decl.cpp.

References D, and clang::Decl::getDeclContext().

Referenced by clang::VarDecl::isThisDeclarationADefinition().

◆ RedeclForcesDefC99()

static bool RedeclForcesDefC99 ( const FunctionDecl Redecl)
static

◆ redeclForcesDefMSVC()

static bool redeclForcesDefMSVC ( const FunctionDecl Redecl)
static

◆ shouldConsiderTemplateVisibility() [1/3]

static bool shouldConsiderTemplateVisibility ( const ClassTemplateSpecializationDecl spec,
LVComputationKind  computation 
)
static

Should we consider visibility associated with the template arguments and parameters of the given class template specialization?

Definition at line 430 of file Decl.cpp.

References hasDirectVisibilityAttribute(), hasExplicitVisibilityAlready(), clang::ClassTemplateSpecializationDecl::isExplicitInstantiationOrSpecialization(), and clang::ClassTemplateSpecializationDecl::isExplicitSpecialization().

◆ shouldConsiderTemplateVisibility() [2/3]

static bool shouldConsiderTemplateVisibility ( const FunctionDecl fn,
const FunctionTemplateSpecializationInfo specInfo 
)
static

◆ shouldConsiderTemplateVisibility() [3/3]

static bool shouldConsiderTemplateVisibility ( const VarTemplateSpecializationDecl spec,
LVComputationKind  computation 
)
static

Should we consider visibility associated with the template arguments and parameters of the given variable template specialization? As usual, follow class template specialization logic up to initialization.

Definition at line 499 of file Decl.cpp.

References hasDirectVisibilityAttribute(), hasExplicitVisibilityAlready(), clang::VarTemplateSpecializationDecl::isExplicitInstantiationOrSpecialization(), and clang::VarTemplateSpecializationDecl::isExplicitSpecialization().

◆ typeIsPostfix()

static bool typeIsPostfix ( QualType  QT)
static

◆ useInlineVisibilityHidden()

static bool useInlineVisibilityHidden ( const NamedDecl D)
static

◆ usesTypeVisibility()

static bool usesTypeVisibility ( const NamedDecl D)
static

Is the given declaration a "type" or a "value" for the purposes of visibility computation?

Definition at line 181 of file Decl.cpp.

References D.

Referenced by clang::LinkageComputer::getDeclLinkageAndVisibility().

◆ withExplicitVisibilityAlready()

static LVComputationKind withExplicitVisibilityAlready ( LVComputationKind  Kind)
static

Given an LVComputationKind, return one of the same type/value sort that records that it already has explicit visibility.

Definition at line 167 of file Decl.cpp.