SemanticTypes.h File Reference

#include "uLang/Common/Algo/Cases.h"
#include "uLang/Common/Containers/Array.h"
#include "uLang/Common/Containers/Function.h"
#include "uLang/Common/Containers/RangeView.h"
#include "uLang/Common/Containers/Set.h"
#include "uLang/Common/Containers/UniquePointerArray.h"
#include "uLang/Common/Misc/EnumUtils.h"
#include "uLang/Common/Text/Named.h"
#include "uLang/Common/Text/UTF8StringBuilder.h"
#include "uLang/Semantics/Effects.h"
#include "uLang/Semantics/IntOrInfinity.h"
#include "uLang/Semantics/MemberOrigin.h"
#include "uLang/Semantics/Revision.h"
#include "uLang/Semantics/SmallDefinitionArray.h"
#include "uLang/Semantics/VisitStamp.h"
#include <cmath>

Go to the source code of this file.

Classes
class	uLang::CTypeBase
	Base class for all types. More...
class	uLang::CNormalType
	A normal type: a head normal form of types where the head is not a parametric type instantiation. More...
class	uLang::CGlobalType< Kind >
class	uLang::CTypeType
struct	uLang::CTypeType::Key
class	uLang::CCastableType
struct	uLang::CCastableType::Key
class	uLang::CConcreteType
struct	uLang::CConcreteType::Key
class	uLang::CNominalType
	Class defining instance and class objects. More...
class	uLang::CInvariantValueType
struct	uLang::CInvariantValueType::Key
class	uLang::CPointerType
class	uLang::CReferenceType
class	uLang::CValueType
class	uLang::COptionType
class	uLang::CArrayType
class	uLang::CGeneratorType
class	uLang::CMapType
struct	uLang::CMapType::SKey
class	uLang::CTupleType
class	uLang::CFunctionType
class	uLang::CFlowType
struct	uLang::STypeVariableSubstitution
struct	uLang::SInstantiatedTypeVariable
class	uLang::CInstantiatedType
class	uLang::CNamedType
struct	uLang::CNamedType::Key
class	uLang::CIntType
class	uLang::CFloatType
struct	uLang::STypeVariablePolarity
struct	uLang::SNormalTypePolarity

Namespaces
namespace	uLang
namespace	uLang::SemanticTypeUtils

Macros
#define	UE_API   VERSECOMPILER_API
#define	VERSE_ENUM_SEMANTIC_TYPE_KINDS(v)
#define	VISIT_KIND(Name, CppType)   Name,

Typedefs
using	uLang::CFalseType = CGlobalType< ETypeKind::False >
using	uLang::CTrueType = CGlobalType< ETypeKind::True >
using	uLang::CVoidType = CGlobalType< ETypeKind::Void >
using	uLang::CAnyType = CGlobalType< ETypeKind::Any >
using	uLang::CComparableType = CGlobalType< ETypeKind::Comparable >
using	uLang::CLogicType = CGlobalType< ETypeKind::Logic >
using	uLang::CRationalType = CGlobalType< ETypeKind::Rational >
using	uLang::CChar8Type = CGlobalType< ETypeKind::Char8 >
using	uLang::CChar32Type = CGlobalType< ETypeKind::Char32 >
using	uLang::CPathType = CGlobalType< ETypeKind::Path >
using	uLang::CRangeType = CGlobalType< ETypeKind::Range >
using	uLang::CPersistableType = CGlobalType< ETypeKind::Persistable >
using	uLang::STypeVariablePolarities = TArray< STypeVariablePolarity >

Enumerations
enum class	uLang::ETypeKind : uint8_t { uLang::VISIT_KIND }
enum class	uLang::ETypeSyntaxPrecedence : uint8_t {   uLang::Min = 0 , uLang::List = 0 , uLang::Definition = 1 , uLang::Comparison = 2 ,   uLang::To = 3 , uLang::Call = 4 }
enum class	uLang::EComparability : uint8_t { uLang::Incomparable , uLang::Comparable , uLang::ComparableAndHashable }
enum class	uLang::ETypeStringFlag : uint8_t { uLang::Simple , uLang::Qualified }
enum class	uLang::ETypeConstraintFlags : uint8_t { uLang::None = 0 , uLang::Castable = 1 << 0 , uLang::Concrete = 1 << 1 }
enum class	uLang::ETypePolarity : char { uLang::Negative , uLang::Positive }
enum class	uLang::SemanticTypeUtils::EIsEditable {   uLang::SemanticTypeUtils::Yes , uLang::SemanticTypeUtils::NotEditableType , uLang::SemanticTypeUtils::MissingConcrete , uLang::SemanticTypeUtils::CastableTypesNotEditable ,   uLang::SemanticTypeUtils::ClassifiableSubsetParametricArgumentInvalid }

Functions
const char *	uLang::TypeKindAsCString (ETypeKind Type)
	uLang::ULANG_ENUM_BIT_FLAGS (ETypeConstraintFlags, inline)
const char *	uLang::GetConstraintTypeAsCString (ETypeConstraintFlags TypeConstraints, bool bIsSubtype)
ETypePolarity	uLang::FlipPolarity (ETypePolarity Polarity)
VERSECOMPILER_API const CClass *	uLang::SemanticTypeUtils::AsSingleClass (const CNormalType &NegativeType, const CNormalType &PositiveType)
VERSECOMPILER_API const CInterface *	uLang::SemanticTypeUtils::AsSingleInterface (const CNormalType &NegativeType, const CNormalType &PositiveType)
VERSECOMPILER_API TArray< STypeVariableSubstitution >	uLang::SemanticTypeUtils::Instantiate (const TArray< const CTypeVariable * > &TypeVariables, const uint32_t UploadedAtFnVersion)
VERSECOMPILER_API const CTypeBase *	uLang::SemanticTypeUtils::Substitute (const CTypeBase &, ETypePolarity Polarity, const TArray< STypeVariableSubstitution > &InstTypeVariables)
VERSECOMPILER_API const CFunctionType *	uLang::SemanticTypeUtils::Instantiate (const CFunctionType *FunctionType, const uint32_t UploadedAtFnVersion)
VERSECOMPILER_API const CTypeBase &	uLang::SemanticTypeUtils::Canonicalize (const CTypeBase &)
VERSECOMPILER_API const CFunctionType &	uLang::SemanticTypeUtils::Canonicalize (const CFunctionType &)
VERSECOMPILER_API const CTupleType &	uLang::SemanticTypeUtils::Canonicalize (const CTupleType &)
VERSECOMPILER_API const CTypeBase &	uLang::SemanticTypeUtils::AsPolarity (const CTypeBase &, const TArray< SInstantiatedTypeVariable > &, ETypePolarity)
VERSECOMPILER_API const CTypeBase &	uLang::SemanticTypeUtils::AsPositive (const CTypeBase &, const TArray< SInstantiatedTypeVariable > &)
VERSECOMPILER_API const CTypeBase &	uLang::SemanticTypeUtils::AsNegative (const CTypeBase &, const TArray< SInstantiatedTypeVariable > &)
VERSECOMPILER_API bool	uLang::SemanticTypeUtils::Constrain (const CTypeBase *PositiveType1, const CTypeBase *NegativeType2, const uint32_t UploadedAtFnVersion)
	Constrain PositiveType1 to be a subtype of NegativeType2
VERSECOMPILER_API bool	uLang::SemanticTypeUtils::IsSubtype (const CTypeBase *PositiveType1, const CTypeBase *PositiveType2, const uint32_t UploadedAtFnVersion)
	Determine if PositiveType1 is a subtype of PositiveType2
VERSECOMPILER_API bool	uLang::SemanticTypeUtils::IsEquivalent (const CTypeBase *PositiveType1, const CTypeBase *PositiveType2, const uint32_t UploadedAtFnVersion)
	Determine if PositiveType1 is equivalent to PositiveType2
VERSECOMPILER_API bool	uLang::SemanticTypeUtils::Matches (const CTypeBase *PositiveType1, const CTypeBase *NegativeType2, const uint32_t UploadedAtFnVersion)
	Determine if argument PositiveType1 is a match for parameter NegativeType2
VERSECOMPILER_API const CTypeBase &	uLang::SemanticTypeUtils::SkipIdentityFlowType (const CFlowType &, ETypePolarity, const uint32_t UploadedAtFnVersion)
VERSECOMPILER_API const CTypeBase &	uLang::SemanticTypeUtils::SkipIdentityFlowType (const CTypeBase &, ETypePolarity, const uint32_t UploadedAtFnVersion)
VERSECOMPILER_API const CTypeBase &	uLang::SemanticTypeUtils::SkipEmptyFlowType (const CTypeBase &)
VERSECOMPILER_API const CTypeBase *	uLang::SemanticTypeUtils::Join (const CTypeBase *Type1, const CTypeBase *Type2, const uint32_t UploadedAtFnVersion)
	Compute the join of Type1 and Type2: the "least" type that contains all values contained by either Type1 or Type2.
VERSECOMPILER_API const CTypeBase *	uLang::SemanticTypeUtils::Meet (const CTypeBase *Type1, const CTypeBase *Type2, const uint32_t UploadedAtFnVersion)
	Compute the meet of Type1 and Type2: the "greatest" type that contains only values contained by both Type1 and Type2.
VERSECOMPILER_API bool	uLang::SemanticTypeUtils::AreDomainsDistinct (const CTypeBase *DomainType1, const CTypeBase *DomainType2, const uint32_t UploadedAtFnVersion)
	Determine whether there two types are distinct; i.e. that there are no values that are members of both types.
VERSECOMPILER_API bool	uLang::SemanticTypeUtils::IsUnknownType (const CTypeBase *Type)
VERSECOMPILER_API bool	uLang::SemanticTypeUtils::IsAttributeType (const CTypeBase *Type)
VERSECOMPILER_API void	uLang::SemanticTypeUtils::VisitAllDefinitions (const CTypeBase *Type, const CAstPackage *VisitorPackage, const TFunction< void(const CDefinition &, const CSymbol &)> &Functor)
VERSECOMPILER_API void	uLang::SemanticTypeUtils::ForEachDataType (const CTypeBase *, const TFunction< void(const CTypeBase *)> &)
VERSECOMPILER_API void	uLang::SemanticTypeUtils::ForEachDataTypeRecursive (const CTypeBase *, const TFunction< void(const CTypeBase *)> &)
bool	uLang::SemanticTypeUtils::IsStringType (const CNormalType &NormalType)
bool	uLang::SemanticTypeUtils::IsMessageType (const CNormalType &NormalType)
bool	uLang::SemanticTypeUtils::IsAgentTypeExclusive (const CTypeBase *Type)
bool	uLang::SemanticTypeUtils::IsLeaderboardType (const CNormalType &NormalType)
VERSECOMPILER_API const char *	uLang::SemanticTypeUtils::IsEditableToCMessage (EIsEditable IsEditable)
VERSECOMPILER_API EIsEditable	uLang::SemanticTypeUtils::IsEditableType (const uLang::CTypeBase *Type, const CAstPackage *ContextPackage)
VERSECOMPILER_API EIsEditable	uLang::SemanticTypeUtils::IsEditableClassType (const uLang::CTypeBase *Type)
VERSECOMPILER_API const CTypeBase *	uLang::SemanticTypeUtils::RemovePointer (const CTypeBase *Type, ETypePolarity Polarity)
VERSECOMPILER_API const CTypeBase *	uLang::SemanticTypeUtils::RemoveReference (const CTypeBase *Type, ETypePolarity Polarity)
VERSECOMPILER_API const CNormalType &	uLang::SemanticTypeUtils::StripVariableAndConstraints (const CNormalType &)
VERSECOMPILER_API const CNormalType &	uLang::SemanticTypeUtils::StripVariableAndConstraints (const CNormalType &, ETypeConstraintFlags &outConstraintFlags)
VERSECOMPILER_API CClassDefinition *	uLang::SemanticTypeUtils::EnclosingClassOfDataDefinition (const CDataDefinition *Def)
VERSECOMPILER_API const CTypeBase *	uLang::SemanticTypeUtils::DecayReference (const CTypeBase *)
VERSECOMPILER_API const CTypeBase *	uLang::SemanticTypeUtils::DecayReference (const CTypeBase &)
VERSECOMPILER_API void	uLang::SemanticTypeUtils::FillTypeVariablePolarities (const CTypeBase *, ETypePolarity, STypeVariablePolarities &)
VERSECOMPILER_API void	uLang::SemanticTypeUtils::FillTypeVariablePolaritiesImpl (const CTypeBase *, ETypePolarity, STypeVariablePolarities &, TArray< SNormalTypePolarity > &Visited)

Macro Definition Documentation

UE_API

#define UE_API   VERSECOMPILER_API

VERSE_ENUM_SEMANTIC_TYPE_KINDS

#define VERSE_ENUM_SEMANTIC_TYPE_KINDS

(

v

)

VISIT_KIND

#define VISIT_KIND	(		Name,
			CppType
	)		Name,