uLang::CSemanticProgram Class Reference

#include <SemanticProgram.h>

Inheritance diagram for uLang::CSemanticProgram:

Classes
struct	SExplicitTypeParam
struct	TCachedIntrinsicDefinition

Public Member Functions
UE_API const CFunction *	GetTaskFunction () const
UE_API const CClass *	GetTaskClass () const
UE_API const CTypeBase *	InstantiateTaskType (const CTypeBase *TypeArgument)
UE_API const CClassDefinition *	GetLeaderboardClassDefinition () const
TSPtr< CAstProject > &	GetIrProject ()
void	SetIrProject (const TSPtr< CAstProject > &project)
ULANG_FORCEINLINE	CSemanticProgram ()
ULANG_FORCEINLINE	~CSemanticProgram ()
UE_API void	Initialize (TSPtr< CSymbolTable > Symbols=TSPtr< CSymbolTable >())
ULANG_FORCEINLINE const TSPtr< CSymbolTable > &	GetSymbols () const
UE_API CSnippet &	GetOrCreateSnippet (const CSymbol &Path, CScope *ParentScope)
UE_API CSnippet *	FindSnippet (const CUTF8StringView &NameStr) const
UE_API CArrayType &	GetOrCreateArrayType (const CTypeBase *ElementType)
UE_API CGeneratorType &	GetOrCreateGeneratorType (const CTypeBase *ElementType)
UE_API CMapType &	GetOrCreateMapType (const CTypeBase *KeyType, const CTypeBase *ValueType)
UE_API CMapType &	GetOrCreateWeakMapType (const CTypeBase &KeyType, const CTypeBase &ValueType)
UE_API CMapType &	GetOrCreateMapType (const CTypeBase &KeyType, const CTypeBase &ValueType, bool bWeak)
UE_API CPointerType &	GetOrCreatePointerType (const CTypeBase *NegativeValueType, const CTypeBase *PositiveValueType)
UE_API CReferenceType &	GetOrCreateReferenceType (const CTypeBase *NegativeValueType, const CTypeBase *PositiveValueType)
UE_API COptionType &	GetOrCreateOptionType (const CTypeBase *ValueType)
UE_API CTypeType &	GetOrCreateTypeType (const CTypeBase *NegativeType, const CTypeBase *PositiveType)
UE_API CTypeType &	GetOrCreateSubtypeType (const CTypeBase *PositiveType)
CCastableType &	GetOrCreateCastableType (const CTypeBase &SuperType)
CConcreteType &	GetOrCreateConcreteType (const CTypeBase &SuperType)
UE_API CTupleType &	GetOrCreateTupleType (CTupleType::ElementArray &&Elements)
UE_API CTupleType &	GetOrCreateTupleType (CTupleType::ElementArray &&Elements, int32_t FirstNamedIndex)
UE_API CNamedType &	GetOrCreateNamedType (CSymbol Name, const CTypeBase *ValueType, bool HasValue)
UE_API const CFunctionType &	GetOrCreateFunctionType (const CTypeBase &ParamsType, const CTypeBase &ReturnType, SEffectSet Effects=EffectSets::FunctionDefault, TArray< const CTypeVariable * > TypeVariables={}, bool ImplicitlySpecialized=false)
UE_API const CIntType &	GetOrCreateConstrainedIntType (FIntOrNegativeInfinity Min, FIntOrPositiveInfinity Max)
UE_API const CFloatType &	GetOrCreateConstrainedFloatType (double Min, double Max)
UE_API CFlowType &	CreateFlowType (ETypePolarity)
UE_API CFlowType &	CreateFlowType (ETypePolarity, const CTypeBase *)
CFlowType &	CreateNegativeFlowType ()
CFlowType &	CreatePositiveFlowType ()
UE_API CInstantiatedClass &	CreateInstantiatedClass (const CClass &, ETypePolarity, TArray< STypeVariableSubstitution >)
UE_API CInstantiatedInterface &	CreateInstantiatedInterface (const CInterface &, ETypePolarity, TArray< STypeVariableSubstitution >)
UE_API SExplicitTypeParam	CreateExplicitTypeParam (CFunction *, CSymbol DataName, CSymbol TypeName, CSymbol NegativeTypeName, const CTypeType *Type)
UE_API void	AddStandardAccessLevelAttributes (CAttributable *NewAccessLevel) const
const CUnknownType *	GetDefaultUnknownType () const
template<class T >
T *	FindDefinitionByVersePath (CUTF8StringView VersePath) const
SemanticRevision	GetNextRevision () const
	Get next revision to use when creating new functions etc.
UE_API void	PopulateCoreAPI ()
	Add common classes and bindings.
virtual CSymbol	GetScopeName () const override
int32_t	NextFunctionIndex ()
UE_API const SEffectDescriptor &	FindEffectDescriptorChecked (const CClass *effectKey, uint32_t UploadedAtFNVersion=VerseFN::UploadedAtFNVersion::Latest) const
const TArray< const CClass * > &	GetAllEffectClasses () const
UE_API TOptional< SEffectSet >	ConvertEffectClassesToEffectSet (const TArray< const CClass * > &EffectClasses, const SEffectSet &DefaultEffectSet, SConvertEffectClassesToEffectSetError *OutError=nullptr, uint32_t UploadedAtFNVersion=VerseFN::UploadedAtFNVersion::Latest) const
UE_API TOptional< TArray< const CClass * > >	ConvertEffectSetToEffectClasses (const SEffectSet &EffectSet, const SEffectSet &DefaultEffectSet) const
UE_API const SSymbolDefinitionArray *	GetDefinitionsBySymbol (CSymbol Symbol) const
Public Member Functions inherited from uLang::CSharedMix
	CSharedMix ()
virtual UE_API	~CSharedMix ()
	CSharedMix (const CSharedMix &Other)=delete
CSharedMix &	operator= (const CSharedMix &Other)=delete
uint32_t	GetRefCount () const
Public Member Functions inherited from uLang::CLogicalScope
	CLogicalScope (EKind Kind, CScope *Parent, CSemanticProgram &Program)
virtual UE_API	~CLogicalScope ()
	CLogicalScope (const CLogicalScope &)=delete
	CLogicalScope (CLogicalScope &&)=delete
UE_API EIterateResult	IterateRecurseLogicalScopes (const TFunction< EVisitResult(const CLogicalScope &)> &Functor) const
	Iterates through all the logical scopes nested inside this scope.
UE_API EIterateResult	IterateRecurseLogicalScopes (TFunction< EVisitResult(const CLogicalScope &)> &&Functor) const
const TArray< TSRef< CDefinition > > &	GetDefinitions () const
TMap< CSymbol, SmallDefinitionArray > &	GetDefinitionNameMap ()
template<typename FilterClass >
TFilteredDefinitionRange< FilterClass >	GetDefinitionsOfKind () const
virtual UE_API SmallDefinitionArray	FindDefinitions (const CSymbol &Name, EMemberOrigin Origin=EMemberOrigin::InheritedOrOriginal, const SQualifier &Qualifier=SQualifier::Unknown(), const CAstPackage *ContextPackage=nullptr, VisitStampType VisitStamp=GenerateNewVisitStamp()) const
template<typename FilterClass >
FilterClass *	FindFirstDefinitionOfKind (const CSymbol &Name, EMemberOrigin Origin=EMemberOrigin::InheritedOrOriginal, const SQualifier &Qualifier=SQualifier::Unknown(), const CAstPackage *ContextPackage=nullptr, VisitStampType VisitStamp=GenerateNewVisitStamp()) const
virtual UE_API void	SetRevision (SemanticRevision Revision)
SemanticRevision	GetRevision () const
ULANG_FORCEINLINE bool	TryMarkVisited (VisitStampType VisitStamp) const
int32_t	AllocateNextDefinitionOrdinal ()
UE_API const CDefinition *	FindOverrideFor (const CDefinition &Definition) const
	Get the matching override definition in this class for the argument, if there is any.
virtual const CLogicalScope *	AsLogicalScopeNullable () const override
	Iff this scope is a logical scope, return it a pointer to it. Otherwise, return null.
virtual CLogicalScope *	AsLogicalScopeNullable () override
UE_API SQualifier	AsQualifier () const
void	AddDefinitionToLogicalScope (TSRef< CDefinition > &&NewDefinition)
Public Member Functions inherited from uLang::CScope
	CScope (EKind Kind, CScope *Parent, CSemanticProgram &Program)
virtual UE_API	~CScope ()
	CScope (const CScope &)=delete
	CScope (CScope &&)=delete
virtual const CTypeBase *	ScopeAsType () const
virtual const CDefinition *	ScopeAsDefinition () const
virtual SAccessLevel	GetDefaultDefinitionAccessLevel () const
ULANG_FORCEINLINE EKind	GetKind () const
ULANG_FORCEINLINE CScope *	GetParentScope () const
UE_API CScope *	GetScopeOfKind (EKind)
UE_API const CScope *	GetScopeOfKind (EKind) const
UE_API CUTF8String	GetScopePath (uLang::UTF8Char SeparatorChar='.', EPathMode Mode=EPathMode::Default) const
UE_API const CModule *	GetModule () const
UE_API CModule *	GetModule ()
UE_API const CModulePart *	GetModulePart () const
UE_API CModulePart *	GetModulePart ()
UE_API CAstPackage *	GetPackage () const
UE_API CAstCompilationUnit *	GetCompilationUnit () const
UE_API const CSnippet *	GetSnippet () const
UE_API CCaptureScope *	GetCaptureScope ()
UE_API const CCaptureScope *	GetCaptureScope () const
UE_API const TSPtr< CSymbolTable > &	GetSymbols () const
ULANG_FORCEINLINE CSemanticProgram &	GetProgram () const
UE_API const CScope &	GetParametricTypeScope () const
	If this is a parametric type, get the scope of those parameters; otherwise returns this scope.
UE_API const CLogicalScope &	GetLogicalScope () const
	Get the innermost logical scope that is or contains this scope.
ULANG_FORCEINLINE CLogicalScope &	GetLogicalScope ()
ULANG_FORCEINLINE bool	IsLogicalScope () const
const CLogicalScope *	GetEnclosingClassOrInterface () const
UE_API CLogicalScope *	GetEnclosingClassOrInterface ()
UE_API bool	IsSameOrChildOf (const CScope *Other) const
bool	IsControlScope () const
UE_API bool	IsInsideTypeScope () const
bool	IsModuleOrSnippet () const
UE_API bool	IsBuiltInScope () const
UE_API CModule &	CreateModule (const CSymbol &ModuleName)
UE_API CClassDefinition &	CreateClass (const CSymbol &ClassName, CClass *Superclass=nullptr, TArray< CInterface * > &&SuperInterfaces={}, EStructOrClass StructOrClass=EStructOrClass::Class)
UE_API CEnumeration &	CreateEnumeration (const CSymbol &EnumerationName)
UE_API CInterface &	CreateInterface (const CSymbol &InterfaceName, const TArray< CInterface * > &SuperInterfaces={})
UE_API TSRef< CFunction >	CreateFunction (const CSymbol FunctionName)
virtual void	CreateNegativeFunction (const CFunction &PositiveFunction) const
UE_API TSRef< CDataDefinition >	CreateDataDefinition (const CSymbol VarName)
UE_API TSRef< CDataDefinition >	CreateDataDefinition (const CSymbol VarName, const CTypeBase *Type)
virtual void	CreateNegativeDataDefinition (const CDataDefinition &PositiveDataDefinition) const
UE_API TSRef< CTypeAlias >	CreateTypeAlias (const CSymbol Name)
UE_API TSRef< CTypeVariable >	CreateTypeVariable (const CSymbol Name, const CTypeBase *NegativeType, const CTypeBase *PositiveType)
UE_API TSRef< CModuleAlias >	CreateModuleAlias (const CSymbol Name)
UE_API TSRef< CScopedAccessLevelDefinition >	CreateScopedAccessLevelDefinition (TOptional< CSymbol > ClassName)
void	AddUsingScope (const CLogicalScope *UsingScope)
const TArray< const CLogicalScope * > &	GetUsingScopes () const
UE_API const CDataDefinition *	AddUsingInstance (const CDataDefinition *UsingContext)
const TArray< const CDataDefinition * > &	GetUsingInstances () const
UE_API SResolvedDefinitionArray	ResolveDefinition (const CSymbol &Name, const SQualifier &Qualifier=SQualifier::Unknown(), const CAstPackage *ContextPackage=nullptr) const
	Look for a definition in this scope and all parent scopes and aliases.
UE_API TSRef< CControlScope >	CreateNestedControlScope ()
TSRef< CCaptureControlScope >	CreateNestedCaptureControlScope ()
const TSRefArray< CControlScope > &	GetNestedControlScopes () const
UE_API TSRef< CTypeScope >	CreateNestedTypeScope ()
UE_API bool	IsAuthoredByEpic () const
UE_API bool	CanAccessEpicInternal () const

Public Attributes
TSPtr< CCompatConstraintRoot >	_GeneralCompatConstraintRoot
TSPtr< CCompatConstraintRoot >	_PersistenceCompatConstraintRoot
TSPtr< CCompatConstraintRoot >	_PersistenceSoftCompatConstraintRoot
TSPtr< CAstPackage >	_BuiltInPackage
CModule *	_VerseModule {nullptr}
CFalseType	_falseType {*this}
CTrueType	_trueType {*this}
CVoidType	_voidType {*this}
CAnyType	_anyType {*this}
CComparableType	_comparableType {*this}
CPersistableType	_persistableType {*this}
CLogicType	_logicType {*this}
CRationalType	_rationalType {*this}
CChar8Type	_char8Type {*this}
CChar32Type	_char32Type {*this}
CPathType	_pathType {*this}
CRangeType	_rangeType {*this}
CTupleType	_EmptyTupleType {*this, {}, 0}
const CTypeType *	_typeType {nullptr}
const CIntType *	_intType {nullptr}
const CFloatType *	_floatType {nullptr}
CTypeAlias *	_falseAlias {nullptr}
CTypeAlias *	_trueAlias {nullptr}
CTypeAlias *	_voidAlias {nullptr}
CTypeAlias *	_anyAlias {nullptr}
CTypeAlias *	_comparableAlias {nullptr}
CTypeAlias *	_logicAlias {nullptr}
CTypeAlias *	_intAlias {nullptr}
CTypeAlias *	_rationalAlias {nullptr}
CTypeAlias *	_floatAlias {nullptr}
CTypeAlias *	_char8Alias {nullptr}
CTypeAlias *	_char32Alias {nullptr}
CTypeAlias *	_stringAlias {nullptr}
CTypeAlias *	_typeAlias {nullptr}
CClass *	_attributeClass {nullptr}
CClass *	_abstractClass {nullptr}
CClass *	_finalClass {nullptr}
CClass *	_concreteClass {nullptr}
CClass *	_uniqueClass {nullptr}
CClass *	_intrinsicClass {nullptr}
CClass *	_nativeClass {nullptr}
CClass *	_nativeCallClass {nullptr}
CClass *	_castableClass {nullptr}
CClass *	_finalSuperClass { nullptr }
CClass *	_finalSuperBaseClass {nullptr}
CClass *	_suspendsClass {nullptr}
CClass *	_decidesClass {nullptr}
CClass *	_variesClassDeprecated {nullptr}
CClass *	_computesClass {nullptr}
CClass *	_convergesClass {nullptr}
CClass *	_transactsClass {nullptr}
CClass *	_readsClass {nullptr}
CClass *	_writesClass {nullptr}
CClass *	_allocatesClass {nullptr}
CClass *	_constructorClass {nullptr}
CClass *	_openClass {nullptr}
CClass *	_closedClass {nullptr}
CClass *	_overrideClass {nullptr}
CClass *	_publicClass {nullptr}
CClass *	_privateClass {nullptr}
CClass *	_protectedClass {nullptr}
CClass *	_internalClass {nullptr}
CClass *	_scopedClass { nullptr }
CClass *	_epicInternalClass {nullptr}
CClass *	_localizes {nullptr}
CClass *	_ignore_unreachable {nullptr}
CClass *	_deprecatedClass {nullptr}
CClass *	_experimentalClass {nullptr}
CClass *	_persistentClass {nullptr}
CClass *	_persistableClass {nullptr}
CClass *	_moduleScopedVarWeakMapKeyClass {nullptr}
CClass *	_rtfmAlwaysOpen {nullptr}
CClass *	_vmNoEffectToken {nullptr}
CClass *	_getterClass {nullptr}
CClass *	_setterClass {nullptr}
CClass *	_predictsClass {nullptr}
CClass *	_attributeScopeAttribute { nullptr }
CClass *	_attributeScopeSpecifier { nullptr }
CClass *	_attributeScopeModule {nullptr}
CClass *	_attributeScopeClass {nullptr}
CClass *	_attributeScopeStruct {nullptr}
CClass *	_attributeScopeData {nullptr}
CClass *	_attributeScopeFunction {nullptr}
CClass *	_attributeScopeEnum {nullptr}
CClass *	_attributeScopeEnumerator {nullptr}
CClass *	_attributeScopeAttributeClass {nullptr}
CClass *	_attributeScopeInterface {nullptr}
CClass *	_attributeScopeIdentifier {nullptr}
CClass *	_attributeScopeExpression {nullptr}
CClass *	_attributeScopeClassMacro {nullptr}
CClass *	_attributeScopeStructMacro {nullptr}
CClass *	_attributeScopeInterfaceMacro {nullptr}
CClass *	_attributeScopeEnumMacro {nullptr}
CClass *	_attributeScopeVar {nullptr}
CClass *	_attributeScopeName {nullptr}
CClass *	_attributeScopeEffect {nullptr}
CClass *	_attributeScopeTypeDefinition {nullptr}
CClass *	_attributeScopeScopedDefinition {nullptr}
CClass *	_customAttributeHandler {nullptr}
CClass *	_availableClass {nullptr}
TCachedIntrinsicDefinition< CClassDefinition >	_editable { *this,"/Verse.org/Simulation/editable" }
TCachedIntrinsicDefinition< CClassDefinition >	_editable_non_concrete { *this,"/Verse.org/Simulation/editable_non_concrete" }
TCachedIntrinsicDefinition< CClassDefinition >	_import_as_attribute { *this,"/Verse.org/Native/import_as_attribute" }
TCachedIntrinsicDefinition< CFunction >	_import_as { *this,"/Verse.org/Native/import_as" }
TCachedIntrinsicDefinition< CClassDefinition >	_doc_attribute { *this,"/Verse.org/Native/doc_attribute" }
TCachedIntrinsicDefinition< CClassDefinition >	_message_class { *this,"/Verse.org/Verse/message" }
TCachedIntrinsicDefinition< CClassDefinition >	_agent_class { *this, "/Verse.org/Simulation/agent" }
TCachedIntrinsicDefinition< CClassDefinition >	_replicated { *this, "/Verse.org/Temporary/EpicGamesRestricted/Network/replicated_attribute" }
CFunction *	_ComparableEqualOp {nullptr}
CFunction *	_ComparableNotEqualOp {nullptr}
CFunction *	_IntNegateOp {nullptr}
CFunction *	_IntAddOp {nullptr}
CFunction *	_IntSubtractOp {nullptr}
CFunction *	_IntMultiplyOp {nullptr}
CFunction *	_IntDivideOp {nullptr}
CFunction *	_IntAddAssignOp {nullptr}
CFunction *	_IntSubtractAssignOp {nullptr}
CFunction *	_IntMultiplyAssignOp {nullptr}
CFunction *	_IntAbs {nullptr}
CFunction *	_IntGreaterOp {nullptr}
CFunction *	_IntGreaterEqualOp {nullptr}
CFunction *	_IntLessOp {nullptr}
CFunction *	_IntLessEqualOp {nullptr}
CFunction *	_MakeRationalFromInt {nullptr}
CFunction *	_RationalCeil {nullptr}
CFunction *	_RationalFloor {nullptr}
CFunction *	_FloatNegateOp {nullptr}
CFunction *	_FloatAddOp {nullptr}
CFunction *	_FloatSubtractOp {nullptr}
CFunction *	_FloatMultiplyOp {nullptr}
CFunction *	_FloatDivideOp {nullptr}
CFunction *	_FloatAddAssignOp {nullptr}
CFunction *	_FloatSubtractAssignOp {nullptr}
CFunction *	_FloatMultiplyAssignOp {nullptr}
CFunction *	_FloatDivideAssignOp {nullptr}
CFunction *	_FloatAbs {nullptr}
CFunction *	_IntMultiplyFloatOp {nullptr}
CFunction *	_FloatMultiplyIntOp {nullptr}
CFunction *	_FloatGreaterOp {nullptr}
CFunction *	_FloatGreaterEqualOp {nullptr}
CFunction *	_FloatLessOp {nullptr}
CFunction *	_FloatLessEqualOp {nullptr}
CFunction *	_ArrayAddOp {nullptr}
CFunction *	_ArrayAddAssignOp {nullptr}
CFunction *	_ArrayLength {nullptr}
CFunction *	_ArrayCallOp {nullptr}
CFunction *	_ArrayRefCallOp0 {nullptr}
CFunction *	_MapRefCallOp {nullptr}
CFunction *	_MapLength {nullptr}
CFunction *	_MapConcatenateMaps {nullptr}
CFunction *	_WeakMapCallOp {nullptr}
CFunction *	_WeakMapRefCallOp0 {nullptr}
CFunction *	_WeakMapOp {nullptr}
CFunction *	_LogicQueryOp {nullptr}
CFunction *	_OptionQueryOp {nullptr}
CFunction *	_FitsInPlayerMap {nullptr}
CDataDefinition *	_InfDefinition {nullptr}
CDataDefinition *	_NaNDefinition {nullptr}
CFunction *	_Getter {nullptr}
CFunction *	_Setter {nullptr}
CFunction *	_UnsafeCast {nullptr}
CFunction *	_PredictsGetDataValue {nullptr}
CFunction *	_PredictsGetDataRef {nullptr}
CIntrinsicSymbols	_IntrinsicSymbols
TArray< CUTF8String >	_EpicInternalModulePrefixes
TSPtr< CAstProject >	_AstProject
TSet< CClassDefinition * >	_PredictsClasses

Friends
class	CScope
class	CLogicalScope
class	CDefinition

Additional Inherited Members
Public Types inherited from uLang::CScope
enum class	EKind : uint8_t {   Program , CompatConstraintRoot , Module , ModulePart ,   Snippet , Class , Function , ControlScope ,   Interface , Type , Enumeration }
using	EPathMode = uLang::EPathMode
Static Public Member Functions inherited from uLang::CScope
static UE_API const char *	KindToCString (EKind Kind)
static UE_API void	ResolvedDefnsAppend (SResolvedDefinitionArray *ResolvedDefns, const SmallDefinitionArray &Definitions)
static UE_API void	ResolvedDefnsAppendWithContext (SResolvedDefinitionArray *ResolvedDefns, const SmallDefinitionArray &Definitions, const CDataDefinition *Context)
static UE_API VisitStampType	GenerateNewVisitStamp ()
	Generates a new stamp id.
Protected Member Functions inherited from uLang::CScope
UE_API bool	CanAccess (const CDefinition &Definition, const SAccessLevel &DefinitionAccessLevel) const
Static Protected Member Functions inherited from uLang::CSharedMix
template<class ObjectType >
static TSPtrG< ObjectType, false, CHeapRawAllocator >	SharedThis (ObjectType *This)
template<class ObjectType >
static TSPtrG< const ObjectType, false, CHeapRawAllocator >	SharedThis (const ObjectType *This)
Protected Attributes inherited from uLang::CLogicalScope
SemanticRevision	_CumulativeRevision = 1
	When anything in this class (methods, data members etc.) or its subclasses was last modified/deleted.
VisitStampType	_LastVisitStamp { 0 }
Protected Attributes inherited from uLang::CScope
EKind	_Kind
CScope *	_Parent
CSemanticProgram &	_Program
TArray< const CLogicalScope * >	_UsingScopes
TArray< const CDataDefinition * >	_UsingInstances
TSRefArray< CControlScope >	_NestedControlScopes
TSRefArray< CTypeScope >	_NestedTypeScopes

Detailed Description

Stores whole parsed semantic hierarchy/infrastructure

Constructor & Destructor Documentation

CSemanticProgram()

ULANG_FORCEINLINE uLang::CSemanticProgram::CSemanticProgram ( )

inline

~CSemanticProgram()

ULANG_FORCEINLINE uLang::CSemanticProgram::~CSemanticProgram ( )

inline

Member Function Documentation

AddStandardAccessLevelAttributes()

void uLang::CSemanticProgram::AddStandardAccessLevelAttributes

(

CAttributable *

NewAccessLevel

)

const

ConvertEffectClassesToEffectSet()

TOptional< SEffectSet > uLang::CSemanticProgram::ConvertEffectClassesToEffectSet	(	const TArray< const CClass * > &	EffectClasses,
		const SEffectSet &	DefaultEffectSet,
		SConvertEffectClassesToEffectSetError *	OutError = nullptr,
		uint32_t	UploadedAtFNVersion = VerseFN::UploadedAtFNVersion::Latest
	)		const

ConvertEffectSetToEffectClasses()

TOptional< TArray< const CClass * > > uLang::CSemanticProgram::ConvertEffectSetToEffectClasses	(	const SEffectSet &	EffectSet,
		const SEffectSet &	DefaultEffectSet
	)		const

CreateExplicitTypeParam()

CSemanticProgram::SExplicitTypeParam uLang::CSemanticProgram::CreateExplicitTypeParam	(	CFunction *	Function,
		CSymbol	DataName,
		CSymbol	TypeName,
		CSymbol	NegativeTypeName,
		const CTypeType *	Type
	)

CreateFlowType() [1/2]

CFlowType & uLang::CSemanticProgram::CreateFlowType

(

ETypePolarity

Polarity

)

CreateFlowType() [2/2]

CFlowType & uLang::CSemanticProgram::CreateFlowType	(	ETypePolarity	Polarity,
		const CTypeBase *	Child
	)

CreateInstantiatedClass()

CInstantiatedClass & uLang::CSemanticProgram::CreateInstantiatedClass	(	const CClass &	Class,
		ETypePolarity	Polarity,
		TArray< STypeVariableSubstitution >	Arguments
	)

CreateInstantiatedInterface()

CInstantiatedInterface & uLang::CSemanticProgram::CreateInstantiatedInterface	(	const CInterface &	Interface,
		ETypePolarity	Polarity,
		TArray< STypeVariableSubstitution >	Arguments
	)

CreateNegativeFlowType()

CFlowType & uLang::CSemanticProgram::CreateNegativeFlowType ( )

inline

CreatePositiveFlowType()

CFlowType & uLang::CSemanticProgram::CreatePositiveFlowType ( )

inline

FindDefinitionByVersePath()

template<class T >

T * uLang::CSemanticProgram::FindDefinitionByVersePath ( CUTF8StringView  VersePath ) const

inline

FindEffectDescriptorChecked()

const SEffectDescriptor & uLang::CSemanticProgram::FindEffectDescriptorChecked	(	const CClass *	effectKey,
		uint32_t	UploadedAtFNVersion = VerseFN::UploadedAtFNVersion::Latest
	)		const

FindSnippet()

CSnippet * uLang::CSemanticProgram::FindSnippet

(

const CUTF8StringView &

NameStr

)

const

GetAllEffectClasses()

const TArray< const CClass * > & uLang::CSemanticProgram::GetAllEffectClasses ( ) const

inline

GetDefaultUnknownType()

const CUnknownType * uLang::CSemanticProgram::GetDefaultUnknownType ( ) const

inline

GetDefinitionsBySymbol()

const SSymbolDefinitionArray * uLang::CSemanticProgram::GetDefinitionsBySymbol

(

CSymbol

Symbol

)

const

GetIrProject()

TSPtr< CAstProject > & uLang::CSemanticProgram::GetIrProject ( )

inline

GetLeaderboardClassDefinition()

const CClassDefinition * uLang::CSemanticProgram::GetLeaderboardClassDefinition

(

)

const

GetNextRevision()

SemanticRevision uLang::CSemanticProgram::GetNextRevision ( ) const

inline

Get next revision to use when creating new functions etc.

GetOrCreateArrayType()

CArrayType & uLang::CSemanticProgram::GetOrCreateArrayType

(

const CTypeBase *

ElementType

)

GetOrCreateCastableType()

CCastableType & uLang::CSemanticProgram::GetOrCreateCastableType

(

const CTypeBase &

SuperType

)

GetOrCreateConcreteType()

CConcreteType & uLang::CSemanticProgram::GetOrCreateConcreteType

(

const CTypeBase &

SuperType

)

GetOrCreateConstrainedFloatType()

const CFloatType & uLang::CSemanticProgram::GetOrCreateConstrainedFloatType	(	double	Min,
		double	Max
	)

GetOrCreateConstrainedIntType()

const CIntType & uLang::CSemanticProgram::GetOrCreateConstrainedIntType	(	FIntOrNegativeInfinity	Min,
		FIntOrPositiveInfinity	Max
	)

GetOrCreateFunctionType()

const CFunctionType & uLang::CSemanticProgram::GetOrCreateFunctionType	(	const CTypeBase &	ParamsType,
		const CTypeBase &	ReturnType,
		SEffectSet	Effects = EffectSets::FunctionDefault,
		TArray< const CTypeVariable * >	TypeVariables = {},
		bool	ImplicitlySpecialized = false
	)

GetOrCreateGeneratorType()

CGeneratorType & uLang::CSemanticProgram::GetOrCreateGeneratorType

(

const CTypeBase *

ElementType

)

GetOrCreateMapType() [1/2]

CMapType & uLang::CSemanticProgram::GetOrCreateMapType	(	const CTypeBase &	KeyType,
		const CTypeBase &	ValueType,
		bool	bWeak
	)

GetOrCreateMapType() [2/2]

CMapType & uLang::CSemanticProgram::GetOrCreateMapType	(	const CTypeBase *	KeyType,
		const CTypeBase *	ValueType
	)

GetOrCreateNamedType()

CNamedType & uLang::CSemanticProgram::GetOrCreateNamedType	(	CSymbol	Name,
		const CTypeBase *	ValueType,
		bool	HasValue
	)

GetOrCreateOptionType()

COptionType & uLang::CSemanticProgram::GetOrCreateOptionType

(

const CTypeBase *

ValueType

)

GetOrCreatePointerType()

CPointerType & uLang::CSemanticProgram::GetOrCreatePointerType	(	const CTypeBase *	NegativeValueType,
		const CTypeBase *	PositiveValueType
	)

GetOrCreateReferenceType()

CReferenceType & uLang::CSemanticProgram::GetOrCreateReferenceType	(	const CTypeBase *	NegativeValueType,
		const CTypeBase *	PositiveValueType
	)

GetOrCreateSnippet()

CSnippet & uLang::CSemanticProgram::GetOrCreateSnippet	(	const CSymbol &	Path,
		CScope *	ParentScope
	)

GetOrCreateSubtypeType()

CTypeType & uLang::CSemanticProgram::GetOrCreateSubtypeType

(

const CTypeBase *

PositiveType

)

GetOrCreateTupleType() [1/2]

CTupleType & uLang::CSemanticProgram::GetOrCreateTupleType

(

CTupleType::ElementArray &&

Elements

)

GetOrCreateTupleType() [2/2]

CTupleType & uLang::CSemanticProgram::GetOrCreateTupleType	(	CTupleType::ElementArray &&	Elements,
		int32_t	FirstNamedIndex
	)

GetOrCreateTypeType()

CTypeType & uLang::CSemanticProgram::GetOrCreateTypeType	(	const CTypeBase *	NegativeType,
		const CTypeBase *	PositiveType
	)

GetOrCreateWeakMapType()

CMapType & uLang::CSemanticProgram::GetOrCreateWeakMapType	(	const CTypeBase &	KeyType,
		const CTypeBase &	ValueType
	)

GetScopeName()

virtual CSymbol uLang::CSemanticProgram::GetScopeName ( ) const

inlineoverridevirtual

Implements uLang::CScope.

GetSymbols()

ULANG_FORCEINLINE const TSPtr< CSymbolTable > & uLang::CSemanticProgram::GetSymbols ( ) const

inline

GetTaskClass()

const CClass * uLang::CSemanticProgram::GetTaskClass

(

)

const

GetTaskFunction()

const CFunction * uLang::CSemanticProgram::GetTaskFunction

(

)

const

Initialize()

void uLang::CSemanticProgram::Initialize

(

TSPtr< CSymbolTable >

Symbols = TSPtr<CSymbolTable>()

)

InstantiateTaskType()

const CTypeBase * uLang::CSemanticProgram::InstantiateTaskType

(

const CTypeBase *

TypeArgument

)

NextFunctionIndex()

int32_t uLang::CSemanticProgram::NextFunctionIndex ( )

inline

PopulateCoreAPI()

void uLang::CSemanticProgram::PopulateCoreAPI

(

)

Add common classes and bindings.

SetIrProject()

void uLang::CSemanticProgram::SetIrProject ( const TSPtr< CAstProject > &  project )

inline

Friends And Related Symbol Documentation

CDefinition

friend class CDefinition

friend

CLogicalScope

friend class CLogicalScope

friend

CScope

friend class CScope

friend

Member Data Documentation

_abstractClass

CClass* uLang::CSemanticProgram::_abstractClass {nullptr}

_agent_class

TCachedIntrinsicDefinition<CClassDefinition> uLang::CSemanticProgram::_agent_class { *this, "/Verse.org/Simulation/agent" }

_allocatesClass

CClass* uLang::CSemanticProgram::_allocatesClass {nullptr}

_anyAlias

CTypeAlias* uLang::CSemanticProgram::_anyAlias {nullptr}

_anyType

CAnyType uLang::CSemanticProgram::_anyType {*this}

_ArrayAddAssignOp

CFunction* uLang::CSemanticProgram::_ArrayAddAssignOp {nullptr}

_ArrayAddOp

CFunction* uLang::CSemanticProgram::_ArrayAddOp {nullptr}

_ArrayCallOp

CFunction* uLang::CSemanticProgram::_ArrayCallOp {nullptr}

_ArrayLength

CFunction* uLang::CSemanticProgram::_ArrayLength {nullptr}

_ArrayRefCallOp0

CFunction* uLang::CSemanticProgram::_ArrayRefCallOp0 {nullptr}

_AstProject

TSPtr<CAstProject> uLang::CSemanticProgram::_AstProject

_attributeClass

CClass* uLang::CSemanticProgram::_attributeClass {nullptr}

_attributeScopeAttribute

CClass* uLang::CSemanticProgram::_attributeScopeAttribute { nullptr }

_attributeScopeAttributeClass

CClass* uLang::CSemanticProgram::_attributeScopeAttributeClass {nullptr}

_attributeScopeClass

CClass* uLang::CSemanticProgram::_attributeScopeClass {nullptr}

_attributeScopeClassMacro

CClass* uLang::CSemanticProgram::_attributeScopeClassMacro {nullptr}

_attributeScopeData

CClass* uLang::CSemanticProgram::_attributeScopeData {nullptr}

_attributeScopeEffect

CClass* uLang::CSemanticProgram::_attributeScopeEffect {nullptr}

_attributeScopeEnum

CClass* uLang::CSemanticProgram::_attributeScopeEnum {nullptr}

_attributeScopeEnumerator

CClass* uLang::CSemanticProgram::_attributeScopeEnumerator {nullptr}

_attributeScopeEnumMacro

CClass* uLang::CSemanticProgram::_attributeScopeEnumMacro {nullptr}

_attributeScopeExpression

CClass* uLang::CSemanticProgram::_attributeScopeExpression {nullptr}

_attributeScopeFunction

CClass* uLang::CSemanticProgram::_attributeScopeFunction {nullptr}

_attributeScopeIdentifier

CClass* uLang::CSemanticProgram::_attributeScopeIdentifier {nullptr}

_attributeScopeInterface

CClass* uLang::CSemanticProgram::_attributeScopeInterface {nullptr}

_attributeScopeInterfaceMacro

CClass* uLang::CSemanticProgram::_attributeScopeInterfaceMacro {nullptr}

_attributeScopeModule

CClass* uLang::CSemanticProgram::_attributeScopeModule {nullptr}

_attributeScopeName

CClass* uLang::CSemanticProgram::_attributeScopeName {nullptr}

_attributeScopeScopedDefinition

CClass* uLang::CSemanticProgram::_attributeScopeScopedDefinition {nullptr}

_attributeScopeSpecifier

CClass* uLang::CSemanticProgram::_attributeScopeSpecifier { nullptr }

_attributeScopeStruct

CClass* uLang::CSemanticProgram::_attributeScopeStruct {nullptr}

_attributeScopeStructMacro

CClass* uLang::CSemanticProgram::_attributeScopeStructMacro {nullptr}

_attributeScopeTypeDefinition

CClass* uLang::CSemanticProgram::_attributeScopeTypeDefinition {nullptr}

_attributeScopeVar

CClass* uLang::CSemanticProgram::_attributeScopeVar {nullptr}

_availableClass

CClass* uLang::CSemanticProgram::_availableClass {nullptr}

_BuiltInPackage

TSPtr<CAstPackage> uLang::CSemanticProgram::_BuiltInPackage

_castableClass

CClass* uLang::CSemanticProgram::_castableClass {nullptr}

_char32Alias

CTypeAlias* uLang::CSemanticProgram::_char32Alias {nullptr}

_char32Type

CChar32Type uLang::CSemanticProgram::_char32Type {*this}

_char8Alias

CTypeAlias* uLang::CSemanticProgram::_char8Alias {nullptr}

_char8Type

CChar8Type uLang::CSemanticProgram::_char8Type {*this}

_closedClass

CClass* uLang::CSemanticProgram::_closedClass {nullptr}

_comparableAlias

CTypeAlias* uLang::CSemanticProgram::_comparableAlias {nullptr}

_ComparableEqualOp

CFunction* uLang::CSemanticProgram::_ComparableEqualOp {nullptr}

_ComparableNotEqualOp

CFunction* uLang::CSemanticProgram::_ComparableNotEqualOp {nullptr}

_comparableType

CComparableType uLang::CSemanticProgram::_comparableType {*this}

_computesClass

CClass* uLang::CSemanticProgram::_computesClass {nullptr}

_concreteClass

CClass* uLang::CSemanticProgram::_concreteClass {nullptr}

_constructorClass

CClass* uLang::CSemanticProgram::_constructorClass {nullptr}

_convergesClass

CClass* uLang::CSemanticProgram::_convergesClass {nullptr}

_customAttributeHandler

CClass* uLang::CSemanticProgram::_customAttributeHandler {nullptr}

_decidesClass

CClass* uLang::CSemanticProgram::_decidesClass {nullptr}

_deprecatedClass

CClass* uLang::CSemanticProgram::_deprecatedClass {nullptr}

_doc_attribute

TCachedIntrinsicDefinition<CClassDefinition> uLang::CSemanticProgram::_doc_attribute { *this,"/Verse.org/Native/doc_attribute" }

_editable

TCachedIntrinsicDefinition<CClassDefinition> uLang::CSemanticProgram::_editable { *this,"/Verse.org/Simulation/editable" }

_editable_non_concrete

TCachedIntrinsicDefinition<CClassDefinition> uLang::CSemanticProgram::_editable_non_concrete { *this,"/Verse.org/Simulation/editable_non_concrete" }

_EmptyTupleType

CTupleType uLang::CSemanticProgram::_EmptyTupleType {*this, {}, 0}

_epicInternalClass

CClass* uLang::CSemanticProgram::_epicInternalClass {nullptr}

_EpicInternalModulePrefixes

TArray<CUTF8String> uLang::CSemanticProgram::_EpicInternalModulePrefixes

_experimentalClass

CClass* uLang::CSemanticProgram::_experimentalClass {nullptr}

_falseAlias

CTypeAlias* uLang::CSemanticProgram::_falseAlias {nullptr}

_falseType

CFalseType uLang::CSemanticProgram::_falseType {*this}

_finalClass

CClass* uLang::CSemanticProgram::_finalClass {nullptr}

_finalSuperBaseClass

CClass* uLang::CSemanticProgram::_finalSuperBaseClass {nullptr}

_finalSuperClass

CClass* uLang::CSemanticProgram::_finalSuperClass { nullptr }

_FitsInPlayerMap

CFunction* uLang::CSemanticProgram::_FitsInPlayerMap {nullptr}

_FloatAbs

CFunction* uLang::CSemanticProgram::_FloatAbs {nullptr}

_FloatAddAssignOp

CFunction* uLang::CSemanticProgram::_FloatAddAssignOp {nullptr}

_FloatAddOp

CFunction* uLang::CSemanticProgram::_FloatAddOp {nullptr}

_floatAlias

CTypeAlias* uLang::CSemanticProgram::_floatAlias {nullptr}

_FloatDivideAssignOp

CFunction* uLang::CSemanticProgram::_FloatDivideAssignOp {nullptr}

_FloatDivideOp

CFunction* uLang::CSemanticProgram::_FloatDivideOp {nullptr}

_FloatGreaterEqualOp

CFunction* uLang::CSemanticProgram::_FloatGreaterEqualOp {nullptr}

_FloatGreaterOp

CFunction* uLang::CSemanticProgram::_FloatGreaterOp {nullptr}

_FloatLessEqualOp

CFunction* uLang::CSemanticProgram::_FloatLessEqualOp {nullptr}

_FloatLessOp

CFunction* uLang::CSemanticProgram::_FloatLessOp {nullptr}

_FloatMultiplyAssignOp

CFunction* uLang::CSemanticProgram::_FloatMultiplyAssignOp {nullptr}

_FloatMultiplyIntOp

CFunction* uLang::CSemanticProgram::_FloatMultiplyIntOp {nullptr}

_FloatMultiplyOp

CFunction* uLang::CSemanticProgram::_FloatMultiplyOp {nullptr}

_FloatNegateOp

CFunction* uLang::CSemanticProgram::_FloatNegateOp {nullptr}

_FloatSubtractAssignOp

CFunction* uLang::CSemanticProgram::_FloatSubtractAssignOp {nullptr}

_FloatSubtractOp

CFunction* uLang::CSemanticProgram::_FloatSubtractOp {nullptr}

_floatType

const CFloatType* uLang::CSemanticProgram::_floatType {nullptr}

_GeneralCompatConstraintRoot

TSPtr<CCompatConstraintRoot> uLang::CSemanticProgram::_GeneralCompatConstraintRoot

_Getter

CFunction* uLang::CSemanticProgram::_Getter {nullptr}

_getterClass

CClass* uLang::CSemanticProgram::_getterClass {nullptr}

_ignore_unreachable

CClass* uLang::CSemanticProgram::_ignore_unreachable {nullptr}

_import_as

TCachedIntrinsicDefinition<CFunction> uLang::CSemanticProgram::_import_as { *this,"/Verse.org/Native/import_as" }

_import_as_attribute

TCachedIntrinsicDefinition<CClassDefinition> uLang::CSemanticProgram::_import_as_attribute { *this,"/Verse.org/Native/import_as_attribute" }

_InfDefinition

CDataDefinition* uLang::CSemanticProgram::_InfDefinition {nullptr}

_IntAbs

CFunction* uLang::CSemanticProgram::_IntAbs {nullptr}

_IntAddAssignOp

CFunction* uLang::CSemanticProgram::_IntAddAssignOp {nullptr}

_IntAddOp

CFunction* uLang::CSemanticProgram::_IntAddOp {nullptr}

_intAlias

CTypeAlias* uLang::CSemanticProgram::_intAlias {nullptr}

_IntDivideOp

CFunction* uLang::CSemanticProgram::_IntDivideOp {nullptr}

_internalClass

CClass* uLang::CSemanticProgram::_internalClass {nullptr}

_IntGreaterEqualOp

CFunction* uLang::CSemanticProgram::_IntGreaterEqualOp {nullptr}

_IntGreaterOp

CFunction* uLang::CSemanticProgram::_IntGreaterOp {nullptr}

_IntLessEqualOp

CFunction* uLang::CSemanticProgram::_IntLessEqualOp {nullptr}

_IntLessOp

CFunction* uLang::CSemanticProgram::_IntLessOp {nullptr}

_IntMultiplyAssignOp

CFunction* uLang::CSemanticProgram::_IntMultiplyAssignOp {nullptr}

_IntMultiplyFloatOp

CFunction* uLang::CSemanticProgram::_IntMultiplyFloatOp {nullptr}

_IntMultiplyOp

CFunction* uLang::CSemanticProgram::_IntMultiplyOp {nullptr}

_IntNegateOp

CFunction* uLang::CSemanticProgram::_IntNegateOp {nullptr}

_intrinsicClass

CClass* uLang::CSemanticProgram::_intrinsicClass {nullptr}

_IntrinsicSymbols

CIntrinsicSymbols uLang::CSemanticProgram::_IntrinsicSymbols

_IntSubtractAssignOp

CFunction* uLang::CSemanticProgram::_IntSubtractAssignOp {nullptr}

_IntSubtractOp

CFunction* uLang::CSemanticProgram::_IntSubtractOp {nullptr}

_intType

const CIntType* uLang::CSemanticProgram::_intType {nullptr}

_localizes

CClass* uLang::CSemanticProgram::_localizes {nullptr}

_logicAlias

CTypeAlias* uLang::CSemanticProgram::_logicAlias {nullptr}

_LogicQueryOp

CFunction* uLang::CSemanticProgram::_LogicQueryOp {nullptr}

_logicType

CLogicType uLang::CSemanticProgram::_logicType {*this}

_MakeRationalFromInt

CFunction* uLang::CSemanticProgram::_MakeRationalFromInt {nullptr}

_MapConcatenateMaps

CFunction* uLang::CSemanticProgram::_MapConcatenateMaps {nullptr}

_MapLength

CFunction* uLang::CSemanticProgram::_MapLength {nullptr}

_MapRefCallOp

CFunction* uLang::CSemanticProgram::_MapRefCallOp {nullptr}

_message_class

TCachedIntrinsicDefinition<CClassDefinition> uLang::CSemanticProgram::_message_class { *this,"/Verse.org/Verse/message" }

_moduleScopedVarWeakMapKeyClass

CClass* uLang::CSemanticProgram::_moduleScopedVarWeakMapKeyClass {nullptr}

_NaNDefinition

CDataDefinition* uLang::CSemanticProgram::_NaNDefinition {nullptr}

_nativeCallClass

CClass* uLang::CSemanticProgram::_nativeCallClass {nullptr}

_nativeClass

CClass* uLang::CSemanticProgram::_nativeClass {nullptr}

_openClass

CClass* uLang::CSemanticProgram::_openClass {nullptr}

_OptionQueryOp

CFunction* uLang::CSemanticProgram::_OptionQueryOp {nullptr}

_overrideClass

CClass* uLang::CSemanticProgram::_overrideClass {nullptr}

_pathType

CPathType uLang::CSemanticProgram::_pathType {*this}

_persistableClass

CClass* uLang::CSemanticProgram::_persistableClass {nullptr}

_persistableType

CPersistableType uLang::CSemanticProgram::_persistableType {*this}

_PersistenceCompatConstraintRoot

TSPtr<CCompatConstraintRoot> uLang::CSemanticProgram::_PersistenceCompatConstraintRoot

_PersistenceSoftCompatConstraintRoot

TSPtr<CCompatConstraintRoot> uLang::CSemanticProgram::_PersistenceSoftCompatConstraintRoot

_persistentClass

CClass* uLang::CSemanticProgram::_persistentClass {nullptr}

_predictsClass

CClass* uLang::CSemanticProgram::_predictsClass {nullptr}

_PredictsClasses

TSet<CClassDefinition*> uLang::CSemanticProgram::_PredictsClasses

_PredictsGetDataRef

CFunction* uLang::CSemanticProgram::_PredictsGetDataRef {nullptr}

_PredictsGetDataValue

CFunction* uLang::CSemanticProgram::_PredictsGetDataValue {nullptr}

_privateClass

CClass* uLang::CSemanticProgram::_privateClass {nullptr}

_protectedClass

CClass* uLang::CSemanticProgram::_protectedClass {nullptr}

_publicClass

CClass* uLang::CSemanticProgram::_publicClass {nullptr}

_rangeType

CRangeType uLang::CSemanticProgram::_rangeType {*this}

_rationalAlias

CTypeAlias* uLang::CSemanticProgram::_rationalAlias {nullptr}

_RationalCeil

CFunction* uLang::CSemanticProgram::_RationalCeil {nullptr}

_RationalFloor

CFunction* uLang::CSemanticProgram::_RationalFloor {nullptr}

_rationalType

CRationalType uLang::CSemanticProgram::_rationalType {*this}

_readsClass

CClass* uLang::CSemanticProgram::_readsClass {nullptr}

_replicated

TCachedIntrinsicDefinition<CClassDefinition> uLang::CSemanticProgram::_replicated { *this, "/Verse.org/Temporary/EpicGamesRestricted/Network/replicated_attribute" }

_rtfmAlwaysOpen

CClass* uLang::CSemanticProgram::_rtfmAlwaysOpen {nullptr}

_scopedClass

CClass* uLang::CSemanticProgram::_scopedClass { nullptr }

_Setter

CFunction* uLang::CSemanticProgram::_Setter {nullptr}

_setterClass

CClass* uLang::CSemanticProgram::_setterClass {nullptr}

_stringAlias

CTypeAlias* uLang::CSemanticProgram::_stringAlias {nullptr}

_suspendsClass

CClass* uLang::CSemanticProgram::_suspendsClass {nullptr}

_transactsClass

CClass* uLang::CSemanticProgram::_transactsClass {nullptr}

_trueAlias

CTypeAlias* uLang::CSemanticProgram::_trueAlias {nullptr}

_trueType

CTrueType uLang::CSemanticProgram::_trueType {*this}

_typeAlias

CTypeAlias* uLang::CSemanticProgram::_typeAlias {nullptr}

_typeType

const CTypeType* uLang::CSemanticProgram::_typeType {nullptr}

_uniqueClass

CClass* uLang::CSemanticProgram::_uniqueClass {nullptr}

_UnsafeCast

CFunction* uLang::CSemanticProgram::_UnsafeCast {nullptr}

_variesClassDeprecated

CClass* uLang::CSemanticProgram::_variesClassDeprecated {nullptr}

_VerseModule

CModule* uLang::CSemanticProgram::_VerseModule {nullptr}

_vmNoEffectToken

CClass* uLang::CSemanticProgram::_vmNoEffectToken {nullptr}

_voidAlias

CTypeAlias* uLang::CSemanticProgram::_voidAlias {nullptr}

_voidType

CVoidType uLang::CSemanticProgram::_voidType {*this}

_WeakMapCallOp

CFunction* uLang::CSemanticProgram::_WeakMapCallOp {nullptr}

_WeakMapOp

CFunction* uLang::CSemanticProgram::_WeakMapOp {nullptr}

_WeakMapRefCallOp0

CFunction* uLang::CSemanticProgram::_WeakMapRefCallOp0 {nullptr}

_writesClass

CClass* uLang::CSemanticProgram::_writesClass {nullptr}

---

The documentation for this class was generated from the following files:

• Engine/Source/Runtime/VerseCompiler/Public/uLang/Semantics/SemanticProgram.h
• Engine/Source/Runtime/VerseCompiler/Private/uLang/Semantics/SemanticProgram.cpp