Type.cpp File Reference

#include "clang/AST/Type.h"
#include "Linkage.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Attr.h"
#include "clang/AST/CharUnits.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclFriend.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/DependenceFlags.h"
#include "clang/AST/Expr.h"
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/TypeVisitor.h"
#include "clang/Basic/AddressSpaces.h"
#include "clang/Basic/ExceptionSpecificationType.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/Linkage.h"
#include "clang/Basic/Specifiers.h"
#include "clang/Basic/TargetCXXABI.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Basic/Visibility.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstring>
#include <optional>
#include "clang/AST/TypeNodes.inc"
#include "clang/Basic/WebAssemblyReferenceTypes.def"
#include "clang/Basic/HLSLIntangibleTypes.def"
#include "clang/Basic/AArch64SVEACLETypes.def"
#include "clang/Basic/RISCVVTypes.def"
#include "clang/Basic/OpenCLImageTypes.def"
#include "clang/Basic/OpenCLExtensionTypes.def"
#include "clang/Basic/PPCTypes.def"
#include "clang/Basic/AMDGPUTypes.def"
#include "clang/AST/BuiltinTypes.def"

Go to the source code of this file.

Classes
class	clang::TypePropertyCache< Private >
	The type-property cache. More...

Namespaces
namespace	clang
	The JSON file list parser is used to communicate input to InstallAPI.

Macros
#define	TYPE(CLASS, BASE)
#define	TYPE(CLASS, BASE)
#define	ABSTRACT_TYPE(Class, Parent)
#define	TYPE(Class, Parent)
#define	ABSTRACT_TYPE(Class, Parent)
#define	TYPE(Class, Parent)
#define	ABSTRACT_TYPE(Class, Parent)
#define	TYPE(Class, Parent)
#define	ABSTRACT_TYPE(Class, Parent)
#define	TYPE(Class, Parent)
#define	ABSTRACT_TYPE(Class, Parent)
#define	TYPE(Class, Parent)
#define	TYPE(Class, Base)
#define	DEPENDENT_TYPE(Class, Base)    QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
#define	TRIVIAL_TYPE_CLASS(Class)    QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
#define	SUGARED_TYPE_CLASS(Class)
#define	WASM_TYPE(Name, Id, SingletonId)   case BuiltinType::Id:
#define	HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId)   case BuiltinType::Id:
#define	SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId)
#define	SVE_OPAQUE_TYPE(Name, MangledName, Id, SingletonId)
#define	SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId)
#define	AARCH64_VECTOR_TYPE(Name, MangledName, Id, SingletonId)
#define	RVV_TYPE(Name, Id, SingletonId)   case BuiltinType::Id:
#define	RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned, IsFP, IsBF)
#define	RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls)
#define	RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls)
#define	ABSTRACT_TYPE(Derived, Base)
#define	TYPE(Derived, Base)   case Derived: return #Derived;
#define	IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)
#define	EXT_OPAQUE_TYPE(ExtType, Id, Ext)
#define	SVE_TYPE(Name, Id, SingletonId)
#define	PPC_VECTOR_TYPE(Name, Id, Size)
#define	RVV_TYPE(Name, Id, SingletonId)
#define	WASM_TYPE(Name, Id, SingletonId)
#define	AMDGPU_TYPE(Name, Id, SingletonId, Width, Align)
#define	HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId)
#define	TYPE(Class, Base)
#define	NON_CANONICAL_TYPE(Class, Base)   case Type::Class:
#define	TYPE(Class, Base)
#define	DEPENDENT_TYPE(Class, Base)   case Type::Class:
#define	NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)   case Type::Class:
#define	TYPE(Class, Base)
#define	NON_CANONICAL_TYPE(Class, Base)   case Type::Class:
#define	TYPE(Class, Base)
#define	DEPENDENT_TYPE(Class, Base)   case Type::Class:
#define	NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)   case Type::Class:
#define	NON_CANONICAL_TYPE(Class, Parent)
#define	TYPE(Class, Parent)
#define	SIGNED_TYPE(Id, SingletonId)   case BuiltinType::Id:
#define	UNSIGNED_TYPE(Id, SingletonId)   case BuiltinType::Id:
#define	FLOATING_TYPE(Id, SingletonId)   case BuiltinType::Id:
#define	BUILTIN_TYPE(Id, SingletonId)
#define	IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)    case BuiltinType::Id:
#define	EXT_OPAQUE_TYPE(ExtType, Id, Ext)    case BuiltinType::Id:
#define	SVE_TYPE(Name, Id, SingletonId)    case BuiltinType::Id:
#define	PPC_VECTOR_TYPE(Name, Id, Size)    case BuiltinType::Id:
#define	RVV_TYPE(Name, Id, SingletonId)   case BuiltinType::Id:
#define	WASM_TYPE(Name, Id, SingletonId)   case BuiltinType::Id:
#define	AMDGPU_TYPE(Name, Id, SingletonId, Width, Align)   case BuiltinType::Id:
#define	HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId)   case BuiltinType::Id:

Typedefs
using	Cache = TypePropertyCache< Private >

Functions
template<typename T >
static const T *	getAsSugar (const Type *Cur)
	This will check for a T (which should be a Type which can act as sugar, such as a TypedefType) by removing any existing sugar until it reaches a T or a non-sugared type.
static bool	isTriviallyCopyableTypeImpl (const QualType &type, const ASTContext &Context, bool IsCopyConstructible)
static TagDecl *	getInterestingTagDecl (TagDecl *decl)
static const TemplateTypeParmDecl *	getReplacedParameter (Decl *D, unsigned Index)
static CachedProperties	computeCachedProperties (const Type *T)
raw_ostream &	clang::operator<< (raw_ostream &OS, const FunctionEffectWithCondition &CFE)

Macro Definition Documentation

AARCH64_VECTOR_TYPE

#define AARCH64_VECTOR_TYPE	(		Name,
			MangledName,
			Id,
			SingletonId
	)

Value:

  case BuiltinType::Id:                                                        \
    return false;

ABSTRACT_TYPE [1/6]

#define ABSTRACT_TYPE	(		Class,
			Parent
	)

ABSTRACT_TYPE [2/6]

#define ABSTRACT_TYPE	(		Class,
			Parent
	)