Namespaces
namespace	Algo

namespace	AlgoImpl

namespace	CommandLine

namespace	CommandLine_Impl

namespace	CppMangling

namespace	DigestGenerator

namespace	EffectSets

namespace	FilePathUtils

namespace	Private

namespace	Private_ModularFeatureManagerImpl

namespace	Private_ToolchainImpl

namespace	SemanticTypeUtils

namespace	VerseStringEscaping

Classes
class	CAliasType

class	CAllocatorInstance

class	CArchive

class	CArenaAllocator

class	CArrayType

class	CAstCompilationUnit

class	CAstNode

class	CAstPackage

class	CAstPackageRef

class	CAstProject

class	CAttributable
	Base class for everything that can have attributes attached to it (classes, expressions, etc.) More...

class	CAvailableAttributeVstFilter

class	CCaptureControlScope

class	CCaptureScope

class	CCastableType

class	CClass

class	CClassDefinition

class	CCompatConstraintRoot

class	CConcreteType

class	CControlScope

class	CCRC16

class	CCRC32

class	CCRC64

class	CDataDefinition

class	CDefinition

class	CDiagnostics

class	CDigestGeneratorImpl
	Helper class that does the actual digest generation. More...

class	CEnumeration

class	CEnumerator

class	CExprArchetypeInstantiation

class	CExprArrayTypeFormer

class	CExprArrow

class	CExprAssignment

class	CExprAwait

class	CExprBinaryArithmetic

class	CExprBinaryAwaitOp

class	CExprBinaryOp

class	CExprBranch

class	CExprBreak

class	CExprChar

class	CExprClassDefinition

class	CExprCodeBlock

class	CExprComparison

class	CExprCompoundBase

class	CExprConcurrentBlockBase

class	CExprConcurrentIteratedBase

class	CExprDataDefinition

class	CExprDefer

class	CExprDefinition

class	CExprEnumDefinition

class	CExprEnumerationType

class	CExprEnumLiteral

class	CExprError

class	CExpressionBase

class	CExprExternal

class	CExprFunctionDefinition

class	CExprFunctionLiteral

class	CExprGeneratorTypeFormer

class	CExprIdentifierBase

class	CExprIdentifierBuiltInMacro

class	CExprIdentifierClass

class	CExprIdentifierData

class	CExprIdentifierFunction

class	CExprIdentifierModule

class	CExprIdentifierModuleAlias

class	CExprIdentifierOverloadedFunction

class	CExprIdentifierTypeAlias

class	CExprIdentifierTypeVariable

class	CExprIdentifierUnresolved

class	CExprIf

class	CExprImport

class	CExprInterfaceDefinition

class	CExprInterfaceType

class	CExprInvocation

class	CExprInvokeType

class	CExprIteration

class	CExprIterationPairDefinition

class	CExprLet

class	CExprLive

class	CExprLocal
	Represents the `(local:) qualifier`. More...

class	CExprLogic

class	CExprLogicalNot

class	CExprLoop

class	CExprMacroCall

class	CExprMakeArray

class	CExprMakeMap

class	CExprMakeNamed

class	CExprMakeOption

class	CExprMakeRange

class	CExprMakeTuple

class	CExprMapTypeFormer

class	CExprModuleDefinition

class	CExprNewPointer

class	CExprNumber

class	CExprOptionTypeFormer

class	CExprPath

class	CExprPathPlusSymbol

class	CExprPlaceholder

class	CExprPointerToReference

class	CExprProfileBlock

class	CExprQueryValue

class	CExprRace

class	CExprRaceIterated

class	CExprReferenceToValue

class	CExprReturn

class	CExprRush

class	CExprRushIterated

class	CExprScopedAccessLevelDefinition

class	CExprSelf

class	CExprSet

class	CExprShortCircuitAnd

class	CExprShortCircuitOr

class	CExprSnippet

class	CExprSpawn

class	CExprString

class	CExprSubBlockBase

class	CExprSubtype

class	CExprSync

class	CExprSyncIterated

class	CExprTupleElement

class	CExprTupleType

class	CExprType

class	CExprTypeAliasDefinition

class	CExprTypeFormer
	Base class for all expressions that form a type out of input type(s) More...

class	CExprUnaryArithmetic

class	CExprUnaryOp

class	CExprUnaryTypeFormer

class	CExprUpon

class	CExprUsing

class	CExprVar

class	CExprWhen

class	CExprWhere

class	CFindResolvedIdentifiersWithoutDefinitionsAstVisitor

class	CFindUnresolvedIdentifiersAstVisitor

class	CFloatStateCheckOnly

class	CFloatStateDoNothing

class	CFloatStateSaveRestore

class	CFloatType

class	CFlowType

class	CFunction

class	CFunctionType

class	CGeneratorType

class	CGlobalType

class	CHeapRawAllocator
	Raw memory allocator that allocates memory from the global heap. More...

class	CInstancedRawAllocator
	Raw memory allocator that keeps a pointer to an allocator instance which is used for allocation. More...

class	CInstantiatedClass

class	CInstantiatedInterface

class	CInstantiatedType

class	CInterface

class	CIntrinsicSymbols

class	CIntType

class	CInvariantValueType

class	CIrArrayAdd

class	CIrArrayUnsafeCall

class	CIrConvertFromDynamic

class	CIrConvertToDynamic

class	CIrFor

class	CIrForBody

class	CIrGeneratorImpl

class	CIrGeneratorPass
	Generates an IR from the Ast in the CSemanticProgram. The CSemanticProgram is updated with the generated IR. More...

class	CIrMapAdd

class	CLibAllocator

class	CLogicalScope

class	CMapType

class	CMath

class	CMemberDefinitions

class	CModule

class	CModuleAlias

class	CModulePart

class	CNamed

class	CNamedType

class	CNominalType
	Class defining instance and class objects. More...

class	CNoncopyable

class	CNormalType
	A normal type: a head normal form of types where the head is not a parametric type instantiation. More...

class	CObservedMix

class	COptionType

class	CParserPass

class	CPointerType

class	CProgramBuildManager

class	CRandomStream

class	CReferenceType

class	CScope

class	CScopedAccessLevelDefinition

class	CSemanticAnalyzer
	Stand-alone semantic analyzer, converts from a syntax program to a semantic program. More...

class	CSemanticAnalyzerPass
	Converts a CSyntaxProgram to a CSemanticProgram and identifies any semantic issues. More...

class	CSemanticProgram

class	CSharedMix

class	CSnippet

class	CSourceDataPackage

class	CSourceDataSnippet

class	CSourceFileModule

class	CSourceFilePackage

class	CSourceFileProject

class	CSourceFileSnippet

class	CSourceModule

class	CSourcePackage

class	CSourceProject

class	CSourceProjectWriter

class	CSymbol
	Symbol representing a text string with an associated id. More...

class	CSymbolTable
	Database keeping track of symbols and their text equivalent. More...

class	CToolchain

class	CToolchainPluginManager

class	CTupleType

class	CTypeAlias

class	CTypeBase
	Base class for all types. More...

class	CTypeScope

class	CTypeType

class	CTypeVariable

class	CUnicode
	Helper class providing useful unicode functionality. More...

class	CUnknownType

class	CUTF8StringView

class	CValueType

struct	FIdentityFunctor

class	FNull

struct	FSolFingerprint

struct	FSolFingerprintDiagnostics

struct	FSolLocalizationInfo

struct	FVerseLocalizationGen

struct	generate_common

struct	generate_vst

struct	generate_vst_capture
	Storage for an accumulated capture of source text from a parse operation. More...

class	IAssemblerPass

class	IFileSystem

class	IIntraSemAnalysisInjection

class	IIrGeneratorPass

class	ILibLoader

class	IParserPass

class	IPostIrFilter

class	IPostParseInjection

class	IPostSemAnalysisInjection

class	IPostSemanticAnalysisFilter

class	IPostVstFilter

class	IPreLinkInjection

class	IPreParseInjection

class	IPreSemAnalysisInjection

class	IPreTranslateInjection

class	ISemanticAnalyzerPass

class	ISolFingerprintGenerator

class	ISourceSnippet

class	IToolchainPlugin

class	JSONAllocator

struct	LocusDistanceResult
	This is used as a helper struct for storing the result of a signed distance check. More...

struct	SAccessibilityScope

struct	SAccessLevel

struct	SAssignmentLhsIdentifier

struct	SAstNodeTypeInfo

struct	SAstVisitor

struct	SAttribute

struct	SBuildContext

struct	SBuildEventInfo

struct	SBuildManagerParams

struct	SBuildParams

struct	SBuildResults

struct	SBuildStatistics
	Various statistics for a given build that can be used in analytics. More...

struct	SBuildVersionInfo

struct	SCachedEffectSetToEffectClassesKey

struct	SClassVarAccessorFunctions

struct	SCommandLine

struct	SConvertEffectClassesToEffectSetError

struct	SDecompositionMapping

struct	SDiagnosticInfo

struct	SDigestScope

struct	SEffectDescriptor

struct	SEffectInfo

struct	SEffectSet

struct	SEffectSetBase

struct	SGlitch

struct	SGlitchLocus

struct	SGlitchResult

struct	SIdentityFunctor

struct	SIdxRange

struct	SIndexedSourceText

struct	SInstantiatedTypeVariable

struct	SIntraSemInjectArgs

struct	SNormalTypePolarity

struct	SPackageDesc

struct	SPackageRef

struct	SPackageUsage

struct	SPackageUsageEntry

struct	SProgramContext

struct	SProjectDesc

struct	SQualifier
	Information about a given qualifier. More...

struct	SQualifierResult

struct	SReservedSymbol

struct	SResolvedDefinition

struct	SScriptContainerElement

struct	SSignature

struct	SSystemParams
	Parameters to initialize the uLang module. More...

struct	STextPosition

struct	STextRange

struct	SToolchainInjections

struct	SToolchainOverrides

struct	SToolchainParams

struct	STypeVariablePolarity

struct	STypeVariableSubstitution

struct	SUniCodePointLength
	Pair of code point and its length in bytes in UTF-8. More...

struct	SUTF8CodePoint

struct	SWorkspaceDesc

struct	SWorkspacePackageRef

struct	TAllocatorTraits

struct	TAllocatorTraits< TDefaultElementAllocator< RawAllocatorType > >

struct	TAllocatorTraits< TInlineElementAllocator< NumInlineElements, SecondaryAllocator > >

struct	TAllocatorTraitsBase

struct	TAnd

struct	TAnd< LHS, RHS... >

struct	TAnd<>

struct	TAndValue

struct	TAndValue< false, RHS... >

class	TApiLayerInjection

struct	TAreTypesEqual

struct	TAreTypesEqual< A, A >

class	TArrayG

struct	TAsNullableTraitsOf

struct	TAsNullableTraitsOf< CExpressionBase *, TOut >

struct	TAsNullableTraitsOf< const CExpressionBase *, TOut >

struct	TAsNullableTraitsOf< TSPtr< CExpressionBase >, TOut >

struct	TAsNullableTraitsOf< TSRef< CExpressionBase >, TOut >

struct	TAstFunctionVisitor

class	TAstNodeRef

struct	TCallTraits

struct	TCallTraits< const T[N]>

struct	TCallTraits< T & >

struct	TCallTraits< T[N]>

struct	TCallTraitsBase

struct	TCallTraitsParamTypeHelper

struct	TCallTraitsParamTypeHelper< T *, true >

struct	TCallTraitsParamTypeHelper< T, true >

struct	TCases

class	TChooseClass

class	TChooseClass< false, TrueClass, FalseClass >

class	TChooseClass< true, TrueClass, FalseClass >

struct	TContainerTraits

struct	TContainerTraits< TArrayG< ElementType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TContainerTraits< TSPtrArrayG< ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TContainerTraits< TSPtrSetG< ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TContainerTraits< TUPtrArrayG< ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TContainerTraits< TUPtrSetG< ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TContainerTraitsBase

struct	TDecay

class	TDefaultElementAllocator

struct	TDefaultHashTraits

struct	TDereferenceWrapper

struct	TDiGraphConstTopologicalIterator

struct	TDiGraphTopologicalIterator

struct	TDiGraphTopologicalIterator_Base

struct	TDiGraphVisitor

class	TDirectedGraph

struct	TDisambiguater

class	TEnableIf

class	TEnableIf< false, Result >

class	TEnableIf< true, Result >

class	TEvent

class	TEventRegistrar

class	TFilteredDefinitionRange
	Filters a range of definitions to only include definitions of the kind corresponding to FilterClass. More...

class	TFunction

class	TFunctionRef

struct	TGuard

struct	TGuardValue

class	THashTable

class	TInlineElementAllocator

struct	TIntOrInfinity

struct	TIsArithmetic

struct	TIsArithmetic< bool >

struct	TIsArithmetic< char >

struct	TIsArithmetic< const T >

struct	TIsArithmetic< const volatile T >

struct	TIsArithmetic< double >

struct	TIsArithmetic< float >

struct	TIsArithmetic< int16_t >

struct	TIsArithmetic< int32_t >

struct	TIsArithmetic< int64_t >

struct	TIsArithmetic< int8_t >

struct	TIsArithmetic< long double >

struct	TIsArithmetic< uint16_t >

struct	TIsArithmetic< uint32_t >

struct	TIsArithmetic< uint64_t >

struct	TIsArithmetic< uint8_t >

struct	TIsArithmetic< volatile T >

struct	TIsArithmetic< wchar_t >

struct	TIsBitwiseConstructible

struct	TIsBitwiseConstructible< const T , T >

struct	TIsBitwiseConstructible< const T, U >

struct	TIsBitwiseConstructible< int16_t, uint16_t >

struct	TIsBitwiseConstructible< int32_t, uint32_t >

struct	TIsBitwiseConstructible< int64_t, uint64_t >

struct	TIsBitwiseConstructible< int8_t, uint8_t >

struct	TIsBitwiseConstructible< T, T >

struct	TIsBitwiseConstructible< uint16_t, int16_t >

struct	TIsBitwiseConstructible< uint32_t, int32_t >

struct	TIsBitwiseConstructible< uint64_t, int64_t >

struct	TIsBitwiseConstructible< uint8_t, int8_t >

struct	TIsConstructible

struct	TIsContiguousContainer

struct	TIsContiguousContainer< const T >

struct	TIsContiguousContainer< const T[N]>

struct	TIsContiguousContainer< const volatile T >

struct	TIsContiguousContainer< const volatile T[N]>

struct	TIsContiguousContainer< std::initializer_list< T > >

struct	TIsContiguousContainer< T & >

struct	TIsContiguousContainer< T && >

struct	TIsContiguousContainer< T[N]>

struct	TIsContiguousContainer< TArrayG< ElementType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsContiguousContainer< TSPtrArrayG< ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsContiguousContainer< TSPtrSetG< ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsContiguousContainer< TUPtrArrayG< ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsContiguousContainer< TUPtrSetG< ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsContiguousContainer< volatile T >

struct	TIsContiguousContainer< volatile T[N]>

struct	TIsEnum

struct	TIsIntegral

struct	TIsIntegral< bool >

struct	TIsIntegral< char >

struct	TIsIntegral< char16_t >

struct	TIsIntegral< char32_t >

struct	TIsIntegral< const T >

struct	TIsIntegral< const volatile T >

struct	TIsIntegral< int >

struct	TIsIntegral< long >

struct	TIsIntegral< long long >

struct	TIsIntegral< short >

struct	TIsIntegral< signed char >

struct	TIsIntegral< unsigned char >

struct	TIsIntegral< unsigned int >

struct	TIsIntegral< unsigned long >

struct	TIsIntegral< unsigned long long >

struct	TIsIntegral< unsigned short >

struct	TIsIntegral< volatile T >

struct	TIsIntegral< wchar_t >

struct	TIsInvocable

struct	TIsLValueReferenceType

struct	TIsLValueReferenceType< T & >

struct	TIsMemberPointer

struct	TIsMemberPointer< const T >

struct	TIsMemberPointer< const volatile T >

struct	TIsMemberPointer< T U::* >

struct	TIsMemberPointer< volatile T >

struct	TIsOptional

struct	TIsOptional< TOptional< T > >

struct	TIsPODType

struct	TIsPointer

struct	TIsPointer< const T >

struct	TIsPointer< const volatile T >

struct	TIsPointer< T * >

struct	TIsPointer< volatile T >

struct	TIsReferenceType

struct	TIsReferenceType< T & >

struct	TIsReferenceType< T && >

struct	TIsRValueReferenceType

struct	TIsRValueReferenceType< T && >

struct	TIsSame

struct	TIsSame< T, T >

struct	TIsTArray

struct	TIsTArray< const TArrayG< ElementType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsTArray< const volatile TArrayG< ElementType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsTArray< TArrayG< ElementType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsTArray< volatile TArrayG< ElementType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsTFunction

struct	TIsTFunction< const T >

struct	TIsTFunction< const volatile T >

struct	TIsTFunction< TFunction< T > >

struct	TIsTFunction< volatile T >

struct	TIsTFunctionRef

struct	TIsTFunctionRef< const T >

struct	TIsTFunctionRef< const volatile T >

struct	TIsTFunctionRef< TFunctionRef< T > >

struct	TIsTFunctionRef< volatile T >

struct	TIsTriviallyDestructible

struct	TIsTUniqueFunction

struct	TIsTUniqueFunction< const T >

struct	TIsTUniqueFunction< const volatile T >

struct	TIsTUniqueFunction< TUniqueFunction< T > >

struct	TIsTUniqueFunction< volatile T >

struct	TIsZeroConstructType

struct	TIsZeroConstructType< TArrayG< ElementType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsZeroConstructType< TSPtrArrayG< ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsZeroConstructType< TSPtrSetG< ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsZeroConstructType< TUPtrArrayG< ElementType, AllowNull, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TIsZeroConstructType< TUPtrSetG< ElementType, AllowNull, KeyType, ElementAllocatorType, RawAllocatorArgsType... > >

struct	TKeyValuePair

struct	TLess

struct	TLess< void >

class	TMapG

class	TModularFeature

class	TModularFeatureIterator

class	TModularFeatureRegHandle

struct	TNot

struct	TOptional

class	TOPtr

struct	TOr

struct	TOr< LHS, RHS... >

struct	TOr<>

struct	TOrValue

struct	TOrValue< true, RHS... >

struct	TPointerIsConvertibleFromTo

class	TPointerIsConvertibleFromTo_TestBase

class	TPointerIsConvertibleFromTo_TestDerived

class	TPointerIsConvertibleFromTo_Unrelated

struct	TPointerIsStaticCastableFromTo

class	TPointerSetHelper

class	TQueueG

struct	TRangeView

struct	TRemoveCV

struct	TRemoveCV< const T >

struct	TRemoveCV< const volatile T >

struct	TRemoveCV< volatile T >

struct	TRemovePointer

struct	TRemovePointer< T * >

struct	TRemoveReference

struct	TRemoveReference< T & >

struct	TRemoveReference< T && >

class	TReversePredicate

class	TSetG

class	TSPtrArrayG

class	TSPtrG

class	TSPtrSetG

struct	TTypeCompatibleBytes

struct	TTypeTraits

struct	TTypeTraitsBase

class	TUnion

class	TUniqueFunction

struct	TUntil

class	TUPtrArrayG

class	TUPtrG

class	TUPtrSetG

struct	TUseBitwiseSwap

class	TUTF8String

class	TUTF8StringBuilder

struct	TValueIterator

Typedefs
using	NullPtrType = std::nullptr_t

using	Integer = int64_t

using	Float = double
	Default size for uLang Integer Type.

using	Boolean = bool
	Default size for uLang Float Type.

template<class ElementType >
using	TArray = TArrayG< ElementType, TDefaultElementAllocator< CHeapRawAllocator > >
	Array that allocates elements on the heap.

template<class ElementType >
using	TArrayA = TArrayG< ElementType, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Array that allocates object using a given allocator instance.

template<class KeyType , class ValueType >
using	TMap = TMapG< KeyType, ValueType, TDefaultHashTraits< KeyType >, CHeapRawAllocator >

template<typename InElementType >
using	TQueue = TQueueG< InElementType >
	Queue that allocates elements on the heap.

template<typename InElementType >
using	TMQueue = TQueueG< InElementType, EQueueMode::MultipleProducersSingleConsumer >
	Queue that supports multiple producers adding elements that are allocated on the heap.

template<class ElementType , class KeyType = ElementType>
using	TSet = TSetG< ElementType, KeyType, TDefaultHashTraits< ElementType >, CHeapRawAllocator >

template<class ObjectType >
using	TSPtr = TSPtrG< ObjectType, true, CHeapRawAllocator >
	Shared pointer that allocates object on the heap.

template<class ObjectType >
using	TSRef = TSPtrG< ObjectType, false, CHeapRawAllocator >
	Shared reference that allocates object on the heap.

template<class ObjectType >
using	TSPtrA = TSPtrG< ObjectType, true, CInstancedRawAllocator, CAllocatorInstance * >
	Shared pointer that allocates object using a given allocator instance.

template<class ObjectType >
using	TSRefA = TSPtrG< ObjectType, false, CInstancedRawAllocator, CAllocatorInstance * >
	Shared reference that allocates object using a given allocator instance.

template<typename ElementType >
using	TSPtrArray = TSPtrArrayG< ElementType, true, TDefaultElementAllocator< CHeapRawAllocator > >
	Array of shared pointers that allocates elements on the heap.

template<typename ElementType >
using	TSRefArray = TSPtrArrayG< ElementType, false, TDefaultElementAllocator< CHeapRawAllocator > >
	Array of shared references that allocates elements on the heap.

template<typename ElementType >
using	TSPtrArrayA = TSPtrArrayG< ElementType, true, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Array of shared pointers that allocates object using a given allocator instance.

template<typename ElementType >
using	TSRefArrayA = TSPtrArrayG< ElementType, false, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Array of shared references that allocates object using a given allocator instance.

template<typename ElementType , typename KeyType >
using	TSPtrSet = TSPtrSetG< ElementType, true, KeyType, TDefaultElementAllocator< CHeapRawAllocator > >
	Set of shared pointers that allocates elements on the heap.

template<typename ElementType , typename KeyType >
using	TSRefSet = TSPtrSetG< ElementType, false, KeyType, TDefaultElementAllocator< CHeapRawAllocator > >
	Set of shared references that allocates elements on the heap.

template<typename ElementType , typename KeyType >
using	TSPtrSetA = TSPtrSetG< ElementType, true, KeyType, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Set of shared pointers that allocates object using a given allocator instance.

template<typename ElementType , typename KeyType >
using	TSRefSetA = TSPtrSetG< ElementType, false, KeyType, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Set of shared references that allocates object using a given allocator instance.

template<class ObjectType >
using	TUPtr = TUPtrG< ObjectType, true, CHeapRawAllocator >
	Unique pointer that allocates object on the heap.

template<class ObjectType >
using	TURef = TUPtrG< ObjectType, false, CHeapRawAllocator >
	Unique reference that allocates object on the heap.

template<class ObjectType >
using	TUPtrA = TUPtrG< ObjectType, true, CInstancedRawAllocator, CAllocatorInstance * >
	Unique pointer that allocates object using a given allocator instance.

template<class ObjectType >
using	TURefA = TUPtrG< ObjectType, false, CInstancedRawAllocator, CAllocatorInstance * >
	Unique reference that allocates object using a given allocator instance.

template<typename ElementType >
using	TUPtrArray = TUPtrArrayG< ElementType, true, TDefaultElementAllocator< CHeapRawAllocator > >
	Array of unique pointers that allocates elements on the heap.

template<typename ElementType >
using	TURefArray = TUPtrArrayG< ElementType, false, TDefaultElementAllocator< CHeapRawAllocator > >
	Array of unique references that allocates elements on the heap.

template<typename ElementType >
using	TUPtrArrayA = TUPtrArrayG< ElementType, true, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Array of unique pointers that allocates object using a given allocator instance.

template<typename ElementType >
using	TURefArrayA = TUPtrArrayG< ElementType, false, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Array of unique references that allocates object using a given allocator instance.

template<typename ElementType , typename KeyType >
using	TUPtrSet = TUPtrSetG< ElementType, true, KeyType, TDefaultElementAllocator< CHeapRawAllocator > >
	Set of unique pointers that allocates elements on the heap.

template<typename ElementType , typename KeyType >
using	TURefSet = TUPtrSetG< ElementType, false, KeyType, TDefaultElementAllocator< CHeapRawAllocator > >
	Set of unique references that allocates elements on the heap.

template<typename ElementType , typename KeyType >
using	TUPtrSetA = TUPtrSetG< ElementType, true, KeyType, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Set of unique pointers that allocates object using a given allocator instance.

template<typename ElementType , typename KeyType >
using	TURefSetA = TUPtrSetG< ElementType, false, KeyType, TDefaultElementAllocator< CInstancedRawAllocator >, CAllocatorInstance * >
	Set of unique references that allocates object using a given allocator instance.

using	EventSubscriberId = uint32_t

template<bool Predicate, typename Result = void>
using	TEnableIfT = typename TEnableIf< Predicate, Result >::Type

template<typename T >
using	TDecayT = typename TDecay< T >::Type

using	SymbolId = uint32_t
	A unique id representing a symbol.

using	UTF8Char = uint8_t
	UTF-8 octet.

using	UniCodePoint = uint32_t
	UTF-32 character / code point.

using	CUTF8String = uLang::TUTF8String< CHeapRawAllocator >
	A string allocated on the heap.

using	CUTF8StringA = uLang::TUTF8String< CInstancedRawAllocator, CAllocatorInstance * >
	A string allocated using a given allocator instance.

using	CUTF8StringBuilder = TUTF8StringBuilder< CHeapRawAllocator >
	A string allocated on the heap.

using	CUTF8StringBuilderA = TUTF8StringBuilder< CInstancedRawAllocator, CAllocatorInstance * >
	A string allocated using a given allocator instance.

using	JSONMemoryPoolAllocator = rapidjson::MemoryPoolAllocator< JSONAllocator >

using	JSONDocument = rapidjson::GenericDocument< rapidjson::UTF8< char >, JSONMemoryPoolAllocator, JSONAllocator >

using	JSONGenericMemberIterator = rapidjson::GenericMemberIterator< false, rapidjson::UTF8< char >, JSONMemoryPoolAllocator >

using	JSONValue = JSONDocument::ValueType

using	JSONStringBuffer = rapidjson::StringBuffer

using	JSONStringWriter = rapidjson::PrettyWriter< JSONStringBuffer >

using	JSONStringRef = rapidjson::GenericStringRef< char >

using	SLocus = Verse::SLocus

using	char8 = Verse::Grammar::char8

using	char32 = Verse::Grammar::char32

using	nat = Verse::Grammar::nat

using	nat8 = Verse::Grammar::nat8

using	VstSharedRef = TSRef< Verse::Vst::Node >

using	CAstNodeRef = TAstNodeRef< CExpressionBase >

using	FIntOrNegativeInfinity = TIntOrInfinity< EInfinitySign::Negative >

using	FIntOrPositiveInfinity = TIntOrInfinity< EInfinitySign::Positive >

using	SemanticRevision = uint32_t
	For storing revisions of functions, classes etc.

using	SSymbolDefinitionArray = TArrayG< const CDefinition *, TInlineElementAllocator< 1 > >

using	SResolvedDefinitionArray = TArrayG< SResolvedDefinition, TInlineElementAllocator< 1 > >

using	CFalseType = CGlobalType< ETypeKind::False >

using	CTrueType = CGlobalType< ETypeKind::True >

using	CVoidType = CGlobalType< ETypeKind::Void >

using	CAnyType = CGlobalType< ETypeKind::Any >

using	CComparableType = CGlobalType< ETypeKind::Comparable >

using	CLogicType = CGlobalType< ETypeKind::Logic >

using	CRationalType = CGlobalType< ETypeKind::Rational >

using	CChar8Type = CGlobalType< ETypeKind::Char8 >

using	CChar32Type = CGlobalType< ETypeKind::Char32 >

using	CPathType = CGlobalType< ETypeKind::Path >

using	CRangeType = CGlobalType< ETypeKind::Range >

using	CPersistableType = CGlobalType< ETypeKind::Persistable >

using	STypeVariablePolarities = TArray< STypeVariablePolarity >

using	SmallDefinitionArray = TArrayG< CDefinition *, TInlineElementAllocator< 1 > >

using	VisitStampType = uint32_t
	Used to mark scopes already visited during a search.

Enumerations
enum class	EVisitResult : int8_t { Continue = 0 , SkipChildren = 1 , Stop = 2 }
	Result returned from a visitor functor indicating how to continue or to quit early. More...

enum class	EIterateResult : int8_t { Stopped = 0 , Completed = 1 }
	Iteration result returned from an iteration. More...

enum class	EResult : int8_t { Unspecified = -1 , OK = 0 , Error }
	Generic error codes. More...

enum class	EErrorAction : int8_t { Continue = 0 , Break }
	Generic action after error has occurred. More...

enum class	EEquate : int8_t { Less = -1 , Equal = 0 , Greater = 1 }

enum	ENoInit { NoInit }
	Enum used in constructors to indicate they should not initialize anything. More...

enum	EDefaultInit { DefaultInit }
	Enum used to force default initialization. More...

enum	EIndex { IndexNone = -1 }
	Used to signify an unspecified index. More...

enum class	EAssertSeverity : int8_t { Fatal = 0 , Recoverable }

enum class	ELogVerbosity : int8_t { Error , Warning , Display , Verbose , Log }

enum class	EQueueMode : int8_t { MultipleProducersSingleConsumer , SingleProducerSingleConsumer }
	Concurrent queue modes. More...

enum	EObserverId : uint32_t { ObserverId_Null = 0 }
	Id type for observer pointers. More...

enum	{ DEFAULT_ALIGNMENT = 0 , MIN_ALIGNMENT = 8 }

enum	{ SymbolId_Null = 0 }
	The id of the empty string, hardcoded to a fixed value. More...

enum class	EContains { Local , Path , NotYet , No }

enum class	ELinkerResult { Link_Skipped = -1 , Link_Success = 0 , Link_Failure , Link_Skipped_ByInjection , Link_Skipped_ByEmptyPass }

enum class	ESemanticPass { SemanticPass_Invalid = 0 , SemanticPass_Types , SemanticPass_Attributes , SemanticPass_Code , SemanticPass__MinValid = SemanticPass_Types , SemanticPass__MaxValid = SemanticPass_Code }

enum class	EBuildEvent { UseOfExperimentalDefinition , PersistentWeakMapDefinition , FunctionDefinition , ClassDefinition , TopLevelDefinition }

enum class	EDiagnosticSeverity : uint8_t { Ok , Info , Warning , Error }

enum class	EDiagnostic : uint16_t { VISIT_DIAGNOSTIC }

enum class	EIsReservedSymbolResult : uint8_t { NotReserved , Reserved , ReservedFuture }

enum class	EReservedSymbol : uint32_t
	Represents the set of reserved symbols in the semantic analyzer (not the parser!) More...

enum class	EEffect : uint8_t { VISIT_EFFECT }

enum class	EAstNodeType : uint8_t { VISIT_AST_NODE_TYPE }

enum class	EInvokeTime : uint8_t { Immediate = 1 << 0 , Async = 1 << 1 , Any_ = Immediate \| Async }

enum class	EVstMappingType { Ast , AstNonReciprocal , Ir }

enum class	EMacroClauseTag : uint32_t { None = 0x1 << 0 , Of = 0x1 << 1 , Do = 0x1 << 2 }

enum class	EInfinitySign { Negative , Positive }

enum class	EMemberOrigin { Original , InheritedOrOriginal , Inherited }
	Specifies whether to find only member definitions originating in the current type, or inherited, or either. More...

enum class	EFunctionStringFlag : uint16_t { Simple = 0x0 , Qualified = 1<<1 , QualifiedParams = 1<<2 , QualifiedVersion1 = Qualified , QualifiedVersion2 = Qualified\|QualifiedParams }

enum class	EExtensionFieldAccessorKind { Function , ExtensionDataMember , ExtensionMethod }

enum class	EPathMode : uint8_t { Default , PrefixSeparator , PackageRelative , PackageRelativeWithRoot }

enum class	ETypeKind : uint8_t { VISIT_KIND }

enum class	ETypeSyntaxPrecedence : uint8_t { Min = 0 , List = 0 , Definition = 1 , Comparison = 2 , To = 3 , Call = 4 }

enum class	EComparability : uint8_t { Incomparable , Comparable , ComparableAndHashable }

enum class	ETypeStringFlag : uint8_t { Simple , Qualified }

enum class	ETypeConstraintFlags : uint8_t { None = 0 , Castable = 1 << 0 , Concrete = 1 << 1 }

enum class	ETypePolarity : char { Negative , Positive }

enum class	EStructOrClass { Class , Struct }

enum class	EPackageRole : uint8_t { Source , External , GeneralCompatConstraint , PersistenceCompatConstraint , PersistenceSoftCompatConstraint }

enum class	EVerseScope : uint8_t { PublicAPI , InternalAPI , PublicUser , InternalUser }

enum class	ECompilerResult : uint32_t { Compile_NoOp = (0x00) , Compile_RanSyntaxPass = (1<<0) , Compile_RanSemanticPass = (1<<1) , Compile_RanLocalizationPass = (1<<2) , Compile_RanIrPass = (1<<3) , Compile_RanCodeGenPass = (1<<4) , Compile_SkippedByInjection = (1<<5) , Compile_SkippedByEmptyPass = (1<<6) , Compile_SyntaxError = (1<<7) , Compile_SemanticError = (1<<8) , Compile_IrError = (1<<9) , Compile_LocalizationError = (1<<10) , Compile_CodeGenError = (1<<11) , CompileMask_Failure = (Compile_SyntaxError \| Compile_SemanticError \| Compile_IrError \| Compile_LocalizationError \| Compile_CodeGenError) , CompileMask_Skipped = (Compile_SkippedByInjection \| Compile_SkippedByEmptyPass) , CompileMask_Aborted = (CompileMask_Failure \| CompileMask_Skipped) }

Functions
SSystemParams &	GetSystemParams ()
	Global variable for efficient access.

bool	operator== (const SSystemParams &Lhs, const SSystemParams &Rhs)

EResult	Initialize (const SSystemParams &Params)

bool	IsInitialized ()

EResult	DeInitialize ()

void	SetGlobalVerbosity (const uLang::ELogVerbosity GlobalVerbosity)

void	AssertExpectedFloatingPointState ()
	Asserts that the active FP state is what is expected (IEEE compliant, round to nearest)

UE_AUTORTFM_NOAUTORTFM void	SetProblematicFloatingPointStateForTesting ()

bool	SplitString (const char ToSplit, const char Delim, CUTF8StringView &OutLeft, CUTF8StringView &OutRight)

bool	SplitString (const char *ToSplit, const UTF8Char Delim, CUTF8StringView &OutLeft, CUTF8StringView &OutRight, bool bReverse)

CUTF8String	ToUpper (const CUTF8StringView &Str)

STextRange	IndexRangeToTextRange (const SIdxRange &IndexRange, const CUTF8StringView &SourceText)

int32_t	CountNumLeadingNewLines (const CUTF8StringView &Text)

int32_t	CountNumTrailingNewLines (const CUTF8StringView &Text)

bool	HasTrailingNewLine (const CUTF8StringView &Text)

int32_t	GetCurrentIndentationLevel (const int32_t IndentSize, const CUTF8StringView &Text)

uLang::CUTF8String	FindLongestCommonPrefix (const uLang::TArray< uLang::CUTF8String > Strings)

template<typename FirstIterator , typename LastIterator , typename Function >
bool	AllOf (FirstIterator First, LastIterator Last, Function F)

template<typename Range , typename Function >
bool	AllOf (Range &&R, Function &&F)

template<typename FirstIterator , typename LastIterator , typename Function >
bool	AnyOf (FirstIterator First, LastIterator Last, Function F)

template<typename Range , typename Function >
bool	AnyOf (Range &&R, Function &&F)

template<typename TFirst , typename TLast , typename T >
bool	Contains (TFirst First, TLast Last, T &&Arg)

template<typename TRange , typename T >
bool	Contains (TRange &&Range, T &&Arg)

template<typename TFirst , typename TLast , typename T >
TFirst	Find (TFirst First, TLast Last, T &&Arg)

template<typename TFirst , typename TLast , typename TFunction >
TFirst	FindIf (TFirst First, TLast Last, TFunction Function)

template<typename T >
ULANG_FORCEINLINE uint32_t	GetTypeHash (const TArray< T > Array)

template<typename FuncType >
ULANG_FORCEINLINE bool	operator== (NullPtrType, const TFunction< FuncType > &Func)

template<typename FuncType >
ULANG_FORCEINLINE bool	operator== (const TFunction< FuncType > &Func, NullPtrType)

template<typename FuncType >
ULANG_FORCEINLINE bool	operator!= (NullPtrType, const TFunction< FuncType > &Func)

template<typename FuncType >
ULANG_FORCEINLINE bool	operator!= (const TFunction< FuncType > &Func, NullPtrType)

uint32_t	GetTypeHash (const void *Key)

uint32_t	MurmurFinalize32 (uint32_t Hash)

constexpr uint32_t	HashCombineFast (uint32_t A, uint32_t B)

uint32_t	GetTypeHash (uint32_t I)

uint32_t	GetTypeHash (int32_t I)

uint32_t	GetTypeHash (uint64_t I)

uint32_t	GetTypeHash (int64_t I)

template<typename T >
	TRangeView (T &&Arg) -> TRangeView< decltype(Arg.begin()), decltype(Arg.end())>

template<typename TFirst , typename TLast >
TFirst	begin (TRangeView< TFirst, TLast > const &Range)

template<typename TFirst , typename TLast >
TLast	end (TRangeView< TFirst, TLast > const &Range)

template<typename T >
TRangeView< T , T >	SingletonRangeView (T &Arg)

template<typename T >
	TValueIterator (T &&) -> TValueIterator< TDecayT< T > >

template<typename T >
	TUntil (T &&) -> TUntil< TDecayT< T > >

ULANG_FORCEINLINE uint32_t	RotateCRC32 (uint32_t CRC)

ULANG_FORCEINLINE size_t	DefaultQuantizeSize (size_t Count, uint32_t Alignment)

ULANG_FORCEINLINE int32_t	DefaultCalculateSlackShrink (int32_t NumElements, int32_t NumAllocatedElements, size_t BytesPerElement, bool bAllowQuantize, uint32_t Alignment=DEFAULT_ALIGNMENT)

ULANG_FORCEINLINE int32_t	DefaultCalculateSlackGrow (int32_t NumElements, int32_t NumAllocatedElements, size_t BytesPerElement, bool bAllowQuantize, uint32_t Alignment=DEFAULT_ALIGNMENT)

ULANG_FORCEINLINE int32_t	DefaultCalculateSlackReserve (int32_t NumElements, size_t BytesPerElement, bool bAllowQuantize, uint32_t Alignment=DEFAULT_ALIGNMENT)

template<typename ElementType >
ULANG_FORCEINLINE TEnableIf<!TIsZeroConstructType< ElementType >::Value >::Type	DefaultConstructElements (void *Address, int32_t Count)

template<typename ElementType >
ULANG_FORCEINLINE TEnableIf< TIsZeroConstructType< ElementType >::Value >::Type	DefaultConstructElements (void *Elements, int32_t Count)

template<typename ElementType >
ULANG_FORCEINLINE TEnableIf<!TIsTriviallyDestructible< ElementType >::Value >::Type	DestructElement (ElementType *Element)

template<typename ElementType >
ULANG_FORCEINLINE TEnableIf< TIsTriviallyDestructible< ElementType >::Value >::Type	DestructElement (ElementType *Element)

template<typename ElementType >
ULANG_FORCEINLINE TEnableIf<!TIsTriviallyDestructible< ElementType >::Value >::Type	DestructElements (ElementType *Element, int32_t Count)

template<typename ElementType >
ULANG_FORCEINLINE TEnableIf< TIsTriviallyDestructible< ElementType >::Value >::Type	DestructElements (ElementType *Elements, int32_t Count)

template<typename DestinationElementType , typename SourceElementType >
ULANG_FORCEINLINE TEnableIf<!TIsBitwiseConstructible< DestinationElementType, SourceElementType >::Value >::Type	ConstructElements (void Dest, const SourceElementType Source, int32_t Count)

template<typename DestinationElementType , typename SourceElementType >
ULANG_FORCEINLINE TEnableIf< TIsBitwiseConstructible< DestinationElementType, SourceElementType >::Value >::Type	ConstructElements (void Dest, const SourceElementType Source, int32_t Count)

template<typename DestinationElementType , typename SourceElementType >
ULANG_FORCEINLINE TEnableIf<!Private::TCanBitwiseRelocate< DestinationElementType, SourceElementType >::Value >::Type	RelocateConstructElements (void Dest, const SourceElementType Source, int32_t Count)

template<typename DestinationElementType , typename SourceElementType >
ULANG_FORCEINLINE TEnableIf< Private::TCanBitwiseRelocate< DestinationElementType, SourceElementType >::Value >::Type	RelocateConstructElements (void Dest, const SourceElementType Source, int32_t Count)

template<typename ElementType >
ULANG_FORCEINLINE TEnableIf< TTypeTraits< ElementType >::IsBytewiseComparable, bool >::Type	CompareElements (const ElementType A, const ElementType B, int32_t Count)

template<typename ElementType >
ULANG_FORCEINLINE TEnableIf<!TTypeTraits< ElementType >::IsBytewiseComparable, bool >::Type	CompareElements (const ElementType A, const ElementType B, int32_t Count)

constexpr bool	CheckedI64Negate (int64_t Rhs, int64_t *OutResult)

constexpr bool	CheckedI64Abs (int64_t Rhs, int64_t *OutResult)

constexpr bool	CheckedConvertI32I64 (int64_t Rhs, int32_t *OutResult)

constexpr bool	CheckedI64Add (int64_t Lhs, int64_t Rhs, int64_t *OutResult)

constexpr bool	CheckedI64Subtract (int64_t Lhs, int64_t Rhs, int64_t *OutResult)

constexpr bool	CheckedI64Multiply (int64_t Lhs, int64_t Rhs, int64_t *OutResult)

constexpr bool	CheckedI64Divide (int64_t Lhs, int64_t Rhs, int64_t *OutResult)

constexpr bool	CheckedI64Modulo (int64_t Lhs, int64_t Rhs, int64_t *OutResult)

constexpr bool	IsFactor (int64_t Left, int64_t Right)

constexpr bool	SameSign (int64_t Left, int64_t Right)

TOptional< int64_t >	CheckedI64DivideAndRoundUp (int64_t Left, int64_t Right)

TOptional< int64_t >	CheckedI64DivideAndRoundDown (int64_t Left, int64_t Right)

template<typename Enum >
bool	Enum_HasAllFlags (Enum Flags, Enum Contains)

template<typename Enum >
bool	Enum_HasAnyFlags (Enum Flags, Enum Contains)

bool	IsDebuggerPresent ()

void	LogDebugMessage (const char *Message)

ULANG_FORCEINLINE uint32_t	InterlockedCompareExchange (volatile uint32_t *Value, uint32_t ReplaceWithThis, uint32_t IfEqualToThis)

ULANG_FORCEINLINE void *	InterlockedCompareExchange (void volatile Value, void ReplaceWithThis, void IfEqualToThis)

template<typename FuncType , typename... ArgTypes>
ULANG_FORCEINLINE auto	Invoke (FuncType &&Func, ArgTypes &&... Args) -> decltype(uLang::ForwardArg< FuncType >(Func)(uLang::ForwardArg< ArgTypes >(Args)...))

template<typename ReturnType , typename ObjType , typename CallableType >
ULANG_FORCEINLINE auto	Invoke (ReturnType ObjType::pdm, CallableType &&Callable) -> decltype(Private::DereferenceIfNecessary< ObjType >(uLang::ForwardArg< CallableType >(Callable)).pdm)

template<typename ReturnType , typename ObjType , typename... PMFArgTypes, typename CallableType , typename... ArgTypes>
ULANG_FORCEINLINE auto	Invoke (ReturnType(ObjType::PtrMemFun)(PMFArgTypes...), CallableType &&Callable, ArgTypes &&... Args) -> decltype((Private::DereferenceIfNecessary< ObjType >(uLang::ForwardArg< CallableType >(Callable)).PtrMemFun)(uLang::ForwardArg< ArgTypes >(Args)...))

template<typename T >
ULANG_FORCEINLINE TRemoveReference< T >::Type &&	Move (T &&Obj)

template<typename T >
ULANG_FORCEINLINE TRemoveReference< T >::Type &&	MoveIfPossible (T &&Obj)

template<typename T >
ULANG_FORCEINLINE T &&	ForwardArg (typename TRemoveReference< T >::Type &Obj)

template<typename T >
ULANG_FORCEINLINE T &&	ForwardArg (typename TRemoveReference< T >::Type &&Obj)

template<typename T , typename = typename TEnableIf<TIsContiguousContainer<T>::Value>::Type>
auto	ULangGetData (T &&Container) -> decltype(Container.GetData())

template<typename T , size_t N>
constexpr T *	ULangGetData (T(&Container)[N])

template<typename T >
constexpr T *	ULangGetData (std::initializer_list< T > List)

template<typename FirstIterator , typename LastIterator >
constexpr FirstIterator	ULangGetData (const TRangeView< FirstIterator, LastIterator > &View)

template<typename T , typename = typename TEnableIf<TIsContiguousContainer<T>::Value>::Type>
size_t	ULangGetNum (T &&Container)

template<typename T , size_t N>
constexpr size_t	ULangGetNum (T(&Container)[N])

template<typename T >
constexpr size_t	ULangGetNum (std::initializer_list< T > List)

template<typename FirstIterator , typename LastIterator >
constexpr int32_t	ULangGetNum (const TRangeView< FirstIterator, LastIterator > &View)

template<typename T >
ULANG_FORCEINLINE constexpr T	AlignUp (T Val, uint64_t Alignment)

template<typename T >
TEnableIf< TUseBitwiseSwap< T >::Value >::Type	Swap (T &A, T &B)

template<typename T >
TEnableIf<!TUseBitwiseSwap< T >::Value >::Type	Swap (T &A, T &B)

template<typename Function >
	TGuard (Function &&) -> TGuard< std::decay_t< Function > >

ULANGCORE_API CUTF8String	FindLongestCommonPrefix (const TArray< CUTF8String > Strings)

template<class AllocatorType , typename... AllocatorArgsType>
ULANG_FORCEINLINE uint32_t	GetTypeHash (const TUTF8String< AllocatorType, AllocatorArgsType... > &String)
	Hash function for maps, sets.

ULANG_FORCEINLINE uint32_t	GetTypeHash (const CUTF8StringView &String)
	Hash function for maps, sets.

CUTF8String	EscapeJSON (const UTF8Char Ch)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

CUTF8String	EscapeJSON (const CUTF8StringView &RawText)

bool	FromJSON (const JSONValue &JSON, bool *Value)

bool	FromJSON (const JSONValue &JSON, int *Value)

bool	FromJSON (const JSONValue &JSON, uint32_t *Value)

bool	FromJSON (const JSONValue &JSON, uint64_t *Value)

bool	FromJSON (const JSONValue &JSON, CUTF8String *Value)

bool	FromJSON (const JSONValue &JSON, CUTF8StringView *Value)

template<class T >
bool	FromJSON (const JSONValue &JSON, TOptional< T > *OptionalValue)

template<class T >
bool	FromJSON (const JSONValue &JSON, TArray< T > *ArrayValue)

template<class T >
bool	FromJSON (const JSONValue &JSON, const char MemberName, T MemberValue, TOptional< bool > bRequired=EResult::Unspecified)

bool	ToJSON (bool Value, JSONValue *JSON, JSONMemoryPoolAllocator &)

bool	ToJSON (int Value, JSONValue *JSON, JSONMemoryPoolAllocator &)

bool	ToJSON (uint32_t Value, JSONValue *JSON, JSONMemoryPoolAllocator &)

bool	ToJSON (CUTF8StringView Value, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

template<class T >
bool	ToJSON (const TOptional< T > &OptionalValue, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

template<class T >
bool	ToJSON (const TArray< T > &ArrayValue, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

template<class T >
bool	ToJSON (const T &MemberValue, const char MemberName, JSONValue JSON, JSONMemoryPoolAllocator &Allocator)

template<class T >
bool	ToJSON (const TOptional< T > &MemberValue, const char MemberName, JSONValue JSON, JSONMemoryPoolAllocator &Allocator)

uint32	GetTypeHash (const STextPosition &TextPosition)

const SDiagnosticInfo &	GetDiagnosticInfo (EDiagnostic ResultId)

EDiagnostic	GetDiagnosticFromReferenceCode (uint16_t ReferenceCode)

TOptional< int32_t >	ScanToRowCol (CUTF8StringView const &Source, const STextPosition &Position)

TOptional< int32_t >	ScanToRowCol (const SIndexedSourceText &SourceText, const STextPosition &Position)

CUTF8StringView	TextRangeToStringView (CUTF8StringView const &Source, STextRange const &Range)

CUTF8StringView	TextRangeToStringView (const uLang::SIndexedSourceText &SourceText, STextRange const &Range)

CUTF8StringView	GetReservedSymbol (const EReservedSymbol Identifier)
	Gets the corresponding reserved string.

EIsReservedSymbolResult	GetReservationForSymbol (const EReservedSymbol Identifier, const uint32_t CurrentVerseVersion, const uint32_t CurrentUploadedAtFNVersion)
	Gets the type of reservation this symbol has.

EIsReservedSymbolResult	GetReservationForSymbol (const CSymbol &Identifier, const uint32_t CurrentVerseVersion, const uint32_t CurrentUploadedAtFNVersion)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

TSet< CUTF8String >	GetReservedSymbols (const uint32_t CurrentVerseVersion, const uint32_t CurrentUploadedAtFNVersion)
	Gets all reserved tokens (both the parser and semantic analyzer).

TSRef< CAstProject >	DesugarVstToAst (const Verse::Vst::Project &VstProject, CSymbolTable &Symbols, CDiagnostics &Diagnostics)

bool	GenerateIr (const TSRef< CSemanticProgram > &Program, const TSRef< CDiagnostics > &Diagnostics, SBuildParams::EWhichVM TargetVM)
	Stand-alone IR generator, use _AstProject to fill in _IrProject in CSemanticProgram.

bool	HasDefinition (const CExprIdentifierBase &IdentifierBase)

TArray< const CExpressionBase * >	FindResolvedIdentifiersWithoutDefinitions (const TSRef< CSemanticProgram > &, const CAstNode &RootNode)

TArray< const CExpressionBase * >	FindUnresolvedIdentifiers (const TSRef< CSemanticProgram > &Program, const CAstNode &RootNode)

EContains	ContainsExpr (const CExpressionBase Argument, const CExprIdentifierUnresolved Expr)

TArray< VstSharedRef >	QualifyAllAnalyzedIdentifiers (bool bVerbose, const TSRef< CSemanticProgram > &Program, VstSharedRef &Root)

SAccessibilityScope	GetAccessibilityScope (const CDefinition &Definition, const SAccessLevel &InitialAccessLevel)

SAccessibilityScope	GetAccessibilityScope (const CDefinition &Definition)

SAccessibilityScope	GetConstructorAccessibilityScope (const CClassDefinition &Class)

SAccessibilityScope	GetConstructorAccessibilityScope (const CInterface &Interface)

CUTF8String	PrintAst (const CSemanticProgram &Program, const CAstNode &RootNode)

bool	IsAttributeHack (const SAttribute &Attribute, const CClass *AttributeClass, const CSemanticProgram &Program)

bool	IsAttributeHack (const SAttribute &Attribute, const CFunction *AttributeFunction, const CSemanticProgram &Program)

TOptional< uint64_t >	GetAvailableAttributeVersion (const SAttribute &AvailableAttribute, const CSemanticProgram &SemanticProgram)

TOptional< uint64_t >	GetAvailableAttributeVersion (const CDefinition &Definition, const CSemanticProgram &SemanticProgram)

uint64_t	CalculateCombinedAvailableAttributeVersion (const CDefinition &Definition, const CSemanticProgram &SemanticProgram)

bool	IsDefinitionAvailableAtVersion (const CDefinition &Definition, uint64_t Version, const CSemanticProgram &SemanticProgram)

CUTF8String	GetQualifiedNameString (const CDefinition &Definition)

CUTF8String	GetCrcNameString (const CDefinition &Definition)

const char *	DefinitionKindAsCString (CDefinition::EKind Kind)

TRangeView< SEffectInfo , SEffectInfo >	AllEffectInfos ()

SEffectInfo	GetEffectInfo (EEffect Effect)

SAstNodeTypeInfo	GetAstNodeTypeInfo (EAstNodeType NodeType)

const CExprIdentifierFunction *	GetConstructorInvocationCallee (const CExprInvocation &Invocation)

const CExprIdentifierFunction *	GetConstructorInvocationCallee (const CExpressionBase &Expression)

bool	IsConstructorInvocation (const CExprInvocation &Invocation)

bool	IsConstructorInvocation (const CExpressionBase &Expression)

TOptional< SAssignmentLhsIdentifier >	IdentifierOfAssignmentLhs (const CExprAssignment *Assignment)

bool	HasImplicitClassSelf (const CExprIdentifierData *Expr)

bool	IsClassMemberAccess (const CExprIdentifierData *Expr)

const CExprInvocation *	AsSubscriptCall (const CExpressionBase *Expr, const CSemanticProgram &Program)

const CExpressionBase *	RemoveSubscripts (const CExpressionBase *Expr, const CSemanticProgram &Program)

CClass *	InstantiatePositiveClass (const CClass &Class, const TArray< STypeVariableSubstitution > &Substitutions)

CClass *	InstantiateClass (const CClass &Class, ETypePolarity Polarity, const TArray< STypeVariableSubstitution > &Substitutions)

void	SetNegativeClassMemberDefinitionTypes (const CClass &PositiveClass)

CInterface *	InstantiatePositiveInterface (const CInterface &Interface, const TArray< STypeVariableSubstitution > &Substitutions)

TArray< STypeVariableSubstitution >	InstantiateTypeVariableSubstitutions (const TArray< STypeVariableSubstitution > &TypeVariables, const TArray< STypeVariableSubstitution > &Substitutions)

CInterface *	InstantiateInterface (const CInterface &Interface, ETypePolarity Polarity, const TArray< STypeVariableSubstitution > &Substitutions)

TArray< CInterface * >	InstantiatePositiveInterfaces (const TArray< CInterface * > &Interfaces, const TArray< STypeVariableSubstitution > &Substitutions)

TArray< CInterface * >	GetNegativeInterfaces (const TArray< CInterface * > &Interfaces)

void	SetInstantiatedOverriddenDefinition (CDefinition &InstDefinition, const CNormalType &InstType, const CDefinition &Definition)

void	InstantiatePositiveFunction (CLogicalScope &InstScope, const CNormalType &InstType, const CFunction &Function, const TArray< STypeVariableSubstitution > &Substitutions)

TSRef< CFunction >	CreateNegativeMemberFunction (CLogicalScope &NegativeScope, const CFunction &PositiveFunction)

void	SetNegativeInterfaceMemberDefinitionTypes (const CInterface &PositiveInterface)

void	SetNegativeMemberDefinitionType (CFunction &NegativeFunction, const CFunction &PositiveFunction)

const char *	TypeKindAsCString (ETypeKind Type)

const char *	GetConstraintTypeAsCString (ETypeConstraintFlags TypeConstraints, bool bIsSubtype)

bool	FromJSON (const JSONValue &JSON, EVerseScope *Value)

bool	FromJSON (const JSONValue &JSON, EPackageRole *Value)

bool	FromJSON (const JSONValue &JSON, CSourcePackage::SSettings *Value)

bool	FromJSON (const JSONValue &JSON, SPackageDesc *Value)

bool	FromJSON (const JSONValue &JSON, SPackageRef *Value)

bool	FromJSON (const JSONValue &JSON, SProjectDesc *Value)

bool	ToJSON (const SWorkspacePackageRef &Value, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

bool	ToJSON (const SWorkspaceDesc &Value, JSONDocument *JSON)

bool	ToJSON (const CSourceModule &Value, JSONDocument *JSON)

bool	ToJSON (const EVerseScope Scope, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

bool	ToJSON (const EPackageRole Role, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

bool	ToJSON (const CSourcePackage::SSettings &Value, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

bool	ToJSON (const CSourcePackage &Value, JSONDocument *JSON)

bool	ToJSON (const SPackageDesc &Value, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

bool	ToJSON (const SPackageRef &Value, JSONValue *JSON, JSONMemoryPoolAllocator &Allocator)

bool	ToJSON (const SProjectDesc &Value, JSONDocument *JSON)

TSRef< CToolchain >	CreateToolchain (const SToolchainParams &Params)

ULANG_FORCEINLINE bool	operator! (ELinkerResult E)

template<typename TIterator , typename ClassOrFunction >
TIterator	FindAttributeHack (TIterator First, TIterator Last, const ClassOrFunction *AttributeClassOrFunction, const CSemanticProgram &Program)

constexpr SEffectSet	operator\| (const EEffect Lhs, const EEffect Rhs)

ULANG_FORCEINLINE uint32_t	GetTypeHash (const SEffectSet &Effects)

const char *	InvokeTimeAsCString (EInvokeTime InvokeTime)

constexpr EMacroClauseTag	operator\| (EMacroClauseTag A, EMacroClauseTag B)

constexpr bool	HasAnyTags (EMacroClauseTag A, EMacroClauseTag B)

constexpr bool	HasAllTags (EMacroClauseTag A, EMacroClauseTag RequiredTags)

const char *	MacroClauseTagAsCString (EMacroClauseTag Tag)

const char *	MacroClauseFormAsCString (Verse::Vst::Clause::EForm Form)

template<typename TOut , typename TIn , typename Traits = TAsNullableTraitsOf<TIn, TOut>>
Traits::TResult	AsNullable (TIn Expr)

const char *	AsStringLiteral (EAstNodeType Node)

constexpr EInfinitySign	operator- (EInfinitySign Sign)

template<EInfinitySign LhsSign, EInfinitySign RhsSign>
bool	operator== (const TIntOrInfinity< LhsSign > &Lhs, const TIntOrInfinity< RhsSign > &Rhs)

template<EInfinitySign LhsSign, EInfinitySign RhsSign>
bool	operator< (const TIntOrInfinity< LhsSign > &Lhs, const TIntOrInfinity< RhsSign > &Rhs)

template<EInfinitySign LhsSign, EInfinitySign RhsSign>
bool	operator<= (const TIntOrInfinity< LhsSign > &Lhs, const TIntOrInfinity< RhsSign > &Rhs)

template<EInfinitySign LhsSign, EInfinitySign RhsSign>
bool	operator> (const TIntOrInfinity< LhsSign > &Lhs, const TIntOrInfinity< RhsSign > &Rhs)

template<EInfinitySign LhsSign, EInfinitySign RhsSign>
bool	operator>= (const TIntOrInfinity< LhsSign > &Lhs, const TIntOrInfinity< RhsSign > &Rhs)

template<EInfinitySign OperandSign>
TIntOrInfinity<-OperandSign >	operator- (const TIntOrInfinity< OperandSign > &Operand)

TArray< TSRef< Verse::Vst::Node > >	QualifyAllAnalyzedIdentifiers (bool bVerbose, const TSRef< CSemanticProgram > &Program, TSRef< Verse::Vst::Node > &Root)

bool	VerifyAllQualified (const TSRef< CSemanticProgram > &Program)

ULANG_FORCEINLINE uint32_t	GetTypeHash (const SCachedEffectSetToEffectClassesKey &Key)

	ULANG_ENUM_BIT_FLAGS (ETypeConstraintFlags, inline)

ETypePolarity	FlipPolarity (ETypePolarity Polarity)

template<class FeatureType >
int32_t	GetModularFeatureCount ()

template<class FeatureType >
TOptional< TSRef< FeatureType > >	GetModularFeature (const int32_t Index=0)

template<class FeatureType >
TSRefArray< FeatureType >	GetModularFeaturesOfType ()

template<class FeatureType >
ULANG_FORCEINLINE int32_t	GetModularFeatureCount ()

	ULANG_ENUM_BIT_FLAGS (ECompilerResult, inline)

ULANG_FORCEINLINE bool	IsCompileFailure (ECompilerResult E)

ULANG_FORCEINLINE bool	IsAbortedCompile (ECompilerResult E)

ULANG_FORCEINLINE bool	IsCompileIncomplete (ECompilerResult E)

ULANG_FORCEINLINE bool	IsCompileComplete (ECompilerResult E)

Variables
const CAllocatorInstance	GSystemAllocatorInstance ([](const CAllocatorInstance , size_t NumBytes) -> void { return GetSystemParams()._HeapMalloc(NumBytes);}, [](const CAllocatorInstance , void Memory, size_t NumBytes) -> void { return GetSystemParams()._HeapRealloc(Memory, NumBytes);}, [](const CAllocatorInstance , void *Memory) { GetSystemParams()._HeapFree(Memory);})

template<auto... Args>
constexpr TCases< Args... >	Cases {}

const uint32_t	uint32_invalid = UINT32_MAX
	Default size for uLang Boolean Type.

constexpr int32_t	Int32Min = INT32_MIN

constexpr int32_t	Int32Max = INT32_MAX

constexpr uint32_t	Int32MaxMagnitude = ((uint32_t)(INT32_MAX))+1

constexpr uint32_t	UInt32Max = UINT32_MAX

constexpr int64_t	Int64Min = INT64_MIN

constexpr int64_t	Int64Max = INT64_MAX

constexpr uint64_t	Int64MaxMagnitude = ((uint64_t)(INT64_MAX))+1

constexpr uint64_t	UInt64Max = UINT64_MAX

constexpr float	Float32Min = FLT_MIN

constexpr float	Float32Max = FLT_MAX

constexpr double	Float64Min = DBL_MIN

constexpr double	Float64Max = DBL_MAX

constexpr size_t	ASCII_RANGE = 128

constexpr size_t	BYTE_RANGE = 256

constexpr int32_t	MaxNumPersistentVarsDefault = 4

constexpr int32_t	EEffectNum = VERSE_ENUM_EFFECTS(VISIT) 0

constexpr auto	ExternalPackageRole

constexpr auto	ConstraintPackageRole

Typedef Documentation

◆ Boolean

using uLang::Boolean = typedef bool

Default size for uLang Float Type.

◆ CAnyType

using uLang::CAnyType = typedef CGlobalType<ETypeKind::Any>

◆ CAstNodeRef

using uLang::CAstNodeRef = typedef TAstNodeRef<CExpressionBase>

◆ CChar32Type

using uLang::CChar32Type = typedef CGlobalType<ETypeKind::Char32>

◆ CChar8Type

using uLang::CChar8Type = typedef CGlobalType<ETypeKind::Char8>

◆ CComparableType

using uLang::CComparableType = typedef CGlobalType<ETypeKind::Comparable>

◆ CFalseType

using uLang::CFalseType = typedef CGlobalType<ETypeKind::False>

◆ char32

using uLang::char32 = typedef Verse::Grammar::char32

◆ char8

using uLang::char8 = typedef Verse::Grammar::char8

◆ CLogicType

using uLang::CLogicType = typedef CGlobalType<ETypeKind::Logic>

◆ CPathType

using uLang::CPathType = typedef CGlobalType<ETypeKind::Path>

◆ CPersistableType

using uLang::CPersistableType = typedef CGlobalType<ETypeKind::Persistable>

◆ CRangeType

using uLang::CRangeType = typedef CGlobalType<ETypeKind::Range>

◆ CRationalType

using uLang::CRationalType = typedef CGlobalType<ETypeKind::Rational>

◆ CTrueType

using uLang::CTrueType = typedef CGlobalType<ETypeKind::True>

◆ CUTF8String

using uLang::CUTF8String = typedef uLang::TUTF8String<CHeapRawAllocator>

A string allocated on the heap.

◆ CUTF8StringA

using uLang::CUTF8StringA = typedef uLang::TUTF8String<CInstancedRawAllocator, CAllocatorInstance*>

A string allocated using a given allocator instance.

◆ CUTF8StringBuilder

using uLang::CUTF8StringBuilder = typedef TUTF8StringBuilder<CHeapRawAllocator>

A string allocated on the heap.

◆ CUTF8StringBuilderA

using uLang::CUTF8StringBuilderA = typedef TUTF8StringBuilder<CInstancedRawAllocator, CAllocatorInstance*>

A string allocated using a given allocator instance.

◆ CVoidType

using uLang::CVoidType = typedef CGlobalType<ETypeKind::Void>

◆ EventSubscriberId

using uLang::EventSubscriberId = typedef uint32_t

◆ FIntOrNegativeInfinity

using uLang::FIntOrNegativeInfinity = typedef TIntOrInfinity<EInfinitySign::Negative>

◆ FIntOrPositiveInfinity

using uLang::FIntOrPositiveInfinity = typedef TIntOrInfinity<EInfinitySign::Positive>

◆ Float

using uLang::Float = typedef double

Default size for uLang Integer Type.

◆ Integer

using uLang::Integer = typedef int64_t

◆ JSONDocument

using uLang::JSONDocument = typedef rapidjson::GenericDocument<rapidjson::UTF8<char>, JSONMemoryPoolAllocator, JSONAllocator>

◆ JSONGenericMemberIterator

using uLang::JSONGenericMemberIterator = typedef rapidjson::GenericMemberIterator<false, rapidjson::UTF8<char>, JSONMemoryPoolAllocator>

◆ JSONMemoryPoolAllocator

using uLang::JSONMemoryPoolAllocator = typedef rapidjson::MemoryPoolAllocator<JSONAllocator>

◆ JSONStringBuffer

using uLang::JSONStringBuffer = typedef rapidjson::StringBuffer

◆ JSONStringRef

using uLang::JSONStringRef = typedef rapidjson::GenericStringRef<char>

◆ JSONStringWriter

using uLang::JSONStringWriter = typedef rapidjson::PrettyWriter<JSONStringBuffer>

◆ JSONValue

using uLang::JSONValue = typedef JSONDocument::ValueType

◆ nat

using uLang::nat = typedef Verse::Grammar::nat

◆ nat8

using uLang::nat8 = typedef Verse::Grammar::nat8

◆ NullPtrType

using uLang::NullPtrType = typedef std::nullptr_t

◆ SemanticRevision

using uLang::SemanticRevision = typedef uint32_t

For storing revisions of functions, classes etc.

◆ SLocus

using uLang::SLocus = typedef Verse::SLocus

◆ SmallDefinitionArray

using uLang::SmallDefinitionArray = typedef TArrayG<CDefinition*, TInlineElementAllocator<1> >

◆ SResolvedDefinitionArray

using uLang::SResolvedDefinitionArray = typedef TArrayG<SResolvedDefinition, TInlineElementAllocator<1> >

An array of resolved definitions and their associated contexts

◆ SSymbolDefinitionArray

using uLang::SSymbolDefinitionArray = typedef TArrayG<const CDefinition*, TInlineElementAllocator<1> >

◆ STypeVariablePolarities

using uLang::STypeVariablePolarities = typedef TArray<STypeVariablePolarity>

◆ SymbolId

using uLang::SymbolId = typedef uint32_t

A unique id representing a symbol.

◆ TArray

template<class ElementType >

using uLang::TArray = typedef TArrayG<ElementType, TDefaultElementAllocator<CHeapRawAllocator> >

Array that allocates elements on the heap.

◆ TArrayA

template<class ElementType >

using uLang::TArrayA = typedef TArrayG<ElementType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Array that allocates object using a given allocator instance.

◆ TDecayT

template<typename T >

using uLang::TDecayT = typedef typename TDecay<T>::Type

◆ TEnableIfT

template<bool Predicate, typename Result = void>

using uLang::TEnableIfT = typedef typename TEnableIf<Predicate, Result>::Type

◆ TMap

template<class KeyType , class ValueType >

using uLang::TMap = typedef TMapG<KeyType, ValueType, TDefaultHashTraits<KeyType>, CHeapRawAllocator>

◆ TMQueue

template<typename InElementType >

using uLang::TMQueue = typedef TQueueG<InElementType, EQueueMode::MultipleProducersSingleConsumer>

Queue that supports multiple producers adding elements that are allocated on the heap.

◆ TQueue

template<typename InElementType >

using uLang::TQueue = typedef TQueueG<InElementType>

Queue that allocates elements on the heap.

◆ TSet

template<class ElementType , class KeyType = ElementType>

using uLang::TSet = typedef TSetG<ElementType, KeyType, TDefaultHashTraits<ElementType>, CHeapRawAllocator>

◆ TSPtr

template<class ObjectType >

using uLang::TSPtr = typedef TSPtrG<ObjectType, true, CHeapRawAllocator>

Shared pointer that allocates object on the heap.

◆ TSPtrA

template<class ObjectType >

using uLang::TSPtrA = typedef TSPtrG<ObjectType, true, CInstancedRawAllocator, CAllocatorInstance *>

Shared pointer that allocates object using a given allocator instance.

◆ TSPtrArray

template<typename ElementType >

using uLang::TSPtrArray = typedef TSPtrArrayG<ElementType, true, TDefaultElementAllocator<CHeapRawAllocator> >

Array of shared pointers that allocates elements on the heap.

◆ TSPtrArrayA

template<typename ElementType >

using uLang::TSPtrArrayA = typedef TSPtrArrayG<ElementType, true, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Array of shared pointers that allocates object using a given allocator instance.

◆ TSPtrSet

template<typename ElementType , typename KeyType >

using uLang::TSPtrSet = typedef TSPtrSetG<ElementType, true, KeyType, TDefaultElementAllocator<CHeapRawAllocator> >

Set of shared pointers that allocates elements on the heap.

◆ TSPtrSetA

template<typename ElementType , typename KeyType >

using uLang::TSPtrSetA = typedef TSPtrSetG<ElementType, true, KeyType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Set of shared pointers that allocates object using a given allocator instance.

◆ TSRef

template<class ObjectType >

using uLang::TSRef = typedef uLang::TSRef<T>

Shared reference that allocates object on the heap.

◆ TSRefA

template<class ObjectType >

using uLang::TSRefA = typedef TSPtrG<ObjectType, false, CInstancedRawAllocator, CAllocatorInstance *>

Shared reference that allocates object using a given allocator instance.

◆ TSRefArray

template<typename ElementType >

using uLang::TSRefArray = typedef TSPtrArrayG<ElementType, false, TDefaultElementAllocator<CHeapRawAllocator> >

Array of shared references that allocates elements on the heap.

◆ TSRefArrayA

template<typename ElementType >

using uLang::TSRefArrayA = typedef TSPtrArrayG<ElementType, false, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Array of shared references that allocates object using a given allocator instance.

◆ TSRefSet

template<typename ElementType , typename KeyType >

using uLang::TSRefSet = typedef TSPtrSetG<ElementType, false, KeyType, TDefaultElementAllocator<CHeapRawAllocator> >

Set of shared references that allocates elements on the heap.

◆ TSRefSetA

template<typename ElementType , typename KeyType >

using uLang::TSRefSetA = typedef TSPtrSetG<ElementType, false, KeyType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Set of shared references that allocates object using a given allocator instance.

◆ TUPtr

template<class ObjectType >

using uLang::TUPtr = typedef TUPtrG<ObjectType, true, CHeapRawAllocator>

Unique pointer that allocates object on the heap.

◆ TUPtrA

template<class ObjectType >

using uLang::TUPtrA = typedef TUPtrG<ObjectType, true, CInstancedRawAllocator, CAllocatorInstance *>

Unique pointer that allocates object using a given allocator instance.

◆ TUPtrArray

template<typename ElementType >

using uLang::TUPtrArray = typedef TUPtrArrayG<ElementType, true, TDefaultElementAllocator<CHeapRawAllocator> >

Array of unique pointers that allocates elements on the heap.

◆ TUPtrArrayA

template<typename ElementType >

using uLang::TUPtrArrayA = typedef TUPtrArrayG<ElementType, true, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Array of unique pointers that allocates object using a given allocator instance.

◆ TUPtrSet

template<typename ElementType , typename KeyType >

using uLang::TUPtrSet = typedef TUPtrSetG<ElementType, true, KeyType, TDefaultElementAllocator<CHeapRawAllocator> >

Set of unique pointers that allocates elements on the heap.

◆ TUPtrSetA

template<typename ElementType , typename KeyType >

using uLang::TUPtrSetA = typedef TUPtrSetG<ElementType, true, KeyType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Set of unique pointers that allocates object using a given allocator instance.

◆ TURef

template<class ObjectType >

using uLang::TURef = typedef TUPtrG<ObjectType, false, CHeapRawAllocator>

Unique reference that allocates object on the heap.

◆ TURefA

template<class ObjectType >

using uLang::TURefA = typedef TUPtrG<ObjectType, false, CInstancedRawAllocator, CAllocatorInstance *>

Unique reference that allocates object using a given allocator instance.

◆ TURefArray

template<typename ElementType >

using uLang::TURefArray = typedef TUPtrArrayG<ElementType, false, TDefaultElementAllocator<CHeapRawAllocator> >

Array of unique references that allocates elements on the heap.

◆ TURefArrayA

template<typename ElementType >

using uLang::TURefArrayA = typedef TUPtrArrayG<ElementType, false, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Array of unique references that allocates object using a given allocator instance.

◆ TURefSet

template<typename ElementType , typename KeyType >

using uLang::TURefSet = typedef TUPtrSetG<ElementType, false, KeyType, TDefaultElementAllocator<CHeapRawAllocator> >

Set of unique references that allocates elements on the heap.

◆ TURefSetA

template<typename ElementType , typename KeyType >

using uLang::TURefSetA = typedef TUPtrSetG<ElementType, false, KeyType, TDefaultElementAllocator<CInstancedRawAllocator>, CAllocatorInstance *>

Set of unique references that allocates object using a given allocator instance.

◆ UniCodePoint

using uLang::UniCodePoint = typedef uint32_t

UTF-32 character / code point.

◆ UTF8Char

using uLang::UTF8Char = typedef uint8_t

UTF-8 octet.

◆ VisitStampType

using uLang::VisitStampType = typedef uint32_t

Used to mark scopes already visited during a search.

◆ VstSharedRef

using uLang::VstSharedRef = typedef TSRef<Verse::Vst::Node>

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
DEFAULT_ALIGNMENT
MIN_ALIGNMENT

◆ anonymous enum

anonymous enum

The id of the empty string, hardcoded to a fixed value.

Enumerator
SymbolId_Null

◆ EAssertSeverity

enum class uLang::EAssertSeverity : int8_t

strong

Enumerator
Fatal
Recoverable

◆ EAstNodeType

enum class uLang::EAstNodeType : uint8_t

strong

This is used to differentiate between different types of AST nodes when it is only known that an instance is of type CAstNode, but not the specific subclass. It is returned by the method CAstNode::GetNodeType()

Enumerator
VISIT_AST_NODE_TYPE

◆ EBuildEvent

enum class uLang::EBuildEvent

strong

Enumerator
UseOfExperimentalDefinition
PersistentWeakMapDefinition
FunctionDefinition
ClassDefinition
TopLevelDefinition

◆ EComparability

enum class uLang::EComparability : uint8_t

strong

Enumerator
Incomparable
Comparable
ComparableAndHashable

◆ ECompilerResult

enum class uLang::ECompilerResult : uint32_t

strong

Enumerator
Compile_NoOp
Compile_RanSyntaxPass
Compile_RanSemanticPass
Compile_RanLocalizationPass
Compile_RanIrPass
Compile_RanCodeGenPass
Compile_SkippedByInjection
Compile_SkippedByEmptyPass
Compile_SyntaxError
Compile_SemanticError
Compile_IrError
Compile_LocalizationError
Compile_CodeGenError
CompileMask_Failure
CompileMask_Skipped
CompileMask_Aborted

◆ EContains

enum class uLang::EContains

strong

Enumerator
Local
Path
NotYet
No

◆ EDefaultInit

enum uLang::EDefaultInit

Enum used to force default initialization.

Enumerator
DefaultInit

◆ EDiagnostic

enum class uLang::EDiagnostic : uint16_t

strong

Possible errors, warnings, intermediary states and Okay diagnostic/analysis results.

Enumerator
VISIT_DIAGNOSTIC

◆ EDiagnosticSeverity

enum class uLang::EDiagnosticSeverity : uint8_t

strong

The severity of a diagnostic.

Enumerator
Ok
Info
Warning
Error

◆ EEffect

enum class uLang::EEffect : uint8_t

strong

Enumerator
VISIT_EFFECT

◆ EEquate

enum class uLang::EEquate : int8_t

strong

Enumerator
Less
Equal
Greater

◆ EErrorAction

enum class uLang::EErrorAction : int8_t

strong

Generic action after error has occurred.

Enumerator
Continue
Break

◆ EExtensionFieldAccessorKind

enum class uLang::EExtensionFieldAccessorKind

strong

Distinguishes extension field accessor functions from other functions.

Enumerator
Function
ExtensionDataMember
ExtensionMethod

◆ EFunctionStringFlag

enum class uLang::EFunctionStringFlag : uint16_t

strong

Enumerator
Simple
Qualified
QualifiedParams
QualifiedVersion1
QualifiedVersion2

◆ EIndex

enum uLang::EIndex

Used to signify an unspecified index.

Enumerator
IndexNone

◆ EInfinitySign

enum class uLang::EInfinitySign

strong

Enumerator
Negative
Positive

◆ EInvokeTime

enum class uLang::EInvokeTime : uint8_t

strong

Enumerator
Immediate
Async
Any_

◆ EIsReservedSymbolResult

enum class uLang::EIsReservedSymbolResult : uint8_t

strong

Enumerator
NotReserved
Reserved
ReservedFuture

◆ EIterateResult

enum class uLang::EIterateResult : int8_t

strong

Iteration result returned from an iteration.

Enumerator
Stopped
Completed

◆ ELinkerResult

enum class uLang::ELinkerResult

strong

Enumerator
Link_Skipped
Link_Success
Link_Failure
Link_Skipped_ByInjection
Link_Skipped_ByEmptyPass

◆ ELogVerbosity

enum class uLang::ELogVerbosity : int8_t

strong

Enumerator
Error
Warning
Display
Verbose
Log

◆ EMacroClauseTag

enum class uLang::EMacroClauseTag : uint32_t

strong

Enumerator
None
Of
Do

◆ EMemberOrigin

enum class uLang::EMemberOrigin

strong

Specifies whether to find only member definitions originating in the current type, or inherited, or either.

Enumerator
Original
InheritedOrOriginal
Inherited

◆ ENoInit

enum uLang::ENoInit

Enum used in constructors to indicate they should not initialize anything.

Enumerator
NoInit

◆ EObserverId

enum uLang::EObserverId : uint32_t

Id type for observer pointers.

Enumerator
ObserverId_Null

◆ EPackageRole

enum class uLang::EPackageRole : uint8_t

strong

Enumerator
Source
External
GeneralCompatConstraint
PersistenceCompatConstraint
PersistenceSoftCompatConstraint

◆ EPathMode

enum class uLang::EPathMode : uint8_t

strong

Enumerator
Default
PrefixSeparator
PackageRelative
PackageRelativeWithRoot

◆ EQueueMode

enum class uLang::EQueueMode : int8_t

strong

Concurrent queue modes.

Enumerator
MultipleProducersSingleConsumer
SingleProducerSingleConsumer

◆ EReservedSymbol

enum class uLang::EReservedSymbol : uint32_t

strong

Represents the set of reserved symbols in the semantic analyzer (not the parser!)

◆ EResult

enum class uLang::EResult : int8_t

strong

Generic error codes.

Enumerator
Unspecified	Not sure if success or failure.
OK	Success.
Error	Some error occurred.

◆ ESemanticPass

enum class uLang::ESemanticPass

strong

Enumerator
SemanticPass_Invalid
SemanticPass_Types
SemanticPass_Attributes
SemanticPass_Code
SemanticPass__MinValid
SemanticPass__MaxValid

◆ EStructOrClass

enum class uLang::EStructOrClass

strong

Enumerator
Class
Struct

◆ ETypeConstraintFlags

enum class uLang::ETypeConstraintFlags : uint8_t

strong

Enumerator
None
Castable
Concrete

◆ ETypeKind

enum class uLang::ETypeKind : uint8_t

strong

Enumerator
VISIT_KIND

◆ ETypePolarity

enum class uLang::ETypePolarity : char

strong

Enumerator
Negative
Positive

◆ ETypeStringFlag

enum class uLang::ETypeStringFlag : uint8_t

strong

Enumerator
Simple
Qualified

◆ ETypeSyntaxPrecedence

enum class uLang::ETypeSyntaxPrecedence : uint8_t

strong

Enumerator
Min
List
Definition
Comparison
To
Call

◆ EVerseScope

enum class uLang::EVerseScope : uint8_t

strong

Enumerator
PublicAPI
InternalAPI
PublicUser
InternalUser

◆ EVisitResult

enum class uLang::EVisitResult : int8_t

strong

Result returned from a visitor functor indicating how to continue or to quit early.

Enumerator
Continue
SkipChildren
Stop

◆ EVstMappingType

enum class uLang::EVstMappingType

strong

Enumerator
Ast
AstNonReciprocal
Ir

Function Documentation

◆ AlignUp()

template<typename T >

ULANG_FORCEINLINE constexpr T uLang::AlignUp	(	T	Val,
		uint64_t	Alignment
	)

constexpr

Aligns a value to the nearest higher multiple of 'Alignment', which must be a power of two.

Parameters

Val	The value to align.
Alignment	The alignment value, must be a power of two.

Returns: The value aligned up to the specified alignment.

◆ AllEffectInfos()

VERSECOMPILER_API TRangeView< SEffectInfo *, SEffectInfo * > uLang::AllEffectInfos ( )

◆ AllOf() [1/2]

template<typename FirstIterator , typename LastIterator , typename Function >

bool uLang::AllOf	(	FirstIterator	First,
		LastIterator	Last,
		Function	F
	)

◆ AllOf() [2/2]

template<typename Range , typename Function >

bool uLang::AllOf	(	Range &&	R,
		Function &&	F
	)

◆ AnyOf() [1/2]

template<typename FirstIterator , typename LastIterator , typename Function >

bool uLang::AnyOf	(	FirstIterator	First,
		LastIterator	Last,
		Function	F
	)

◆ AnyOf() [2/2]

template<typename Range , typename Function >

bool uLang::AnyOf	(	Range &&	R,
		Function &&	F
	)

◆ AsNullable()

template<typename TOut , typename TIn , typename Traits = TAsNullableTraitsOf<TIn, TOut>>

Traits::TResult uLang::AsNullable ( TIn Expr )

◆ AssertExpectedFloatingPointState()

void ULANGCORE_API uLang::AssertExpectedFloatingPointState ( )

Asserts that the active FP state is what is expected (IEEE compliant, round to nearest)

◆ AsStringLiteral()

const char * uLang::AsStringLiteral ( EAstNodeType Node )

inline

◆ AsSubscriptCall()

UE_API const CExprInvocation * uLang::AsSubscriptCall	(	const CExpressionBase *	Expr,
		const CSemanticProgram &	Program
	)

◆ begin()

template<typename TFirst , typename TLast >

TFirst uLang::begin ( TRangeView< TFirst, TLast > const & Range )

◆ CalculateCombinedAvailableAttributeVersion()

uint64_t uLang::CalculateCombinedAvailableAttributeVersion	(	const CDefinition &	Definition,
		const CSemanticProgram &	SemanticProgram
	)

◆ CheckedConvertI32I64()

constexpr bool uLang::CheckedConvertI32I64	(	int64_t	Rhs,
		int32_t *	OutResult
	)

constexpr

◆ CheckedI64Abs()

constexpr bool uLang::CheckedI64Abs	(	int64_t	Rhs,
		int64_t *	OutResult
	)

constexpr

◆ CheckedI64Add()

constexpr bool uLang::CheckedI64Add	(	int64_t	Lhs,
		int64_t	Rhs,
		int64_t *	OutResult
	)

constexpr

◆ CheckedI64Divide()

constexpr bool uLang::CheckedI64Divide	(	int64_t	Lhs,
		int64_t	Rhs,
		int64_t *	OutResult
	)

constexpr

◆ CheckedI64DivideAndRoundDown()

TOptional< int64_t > uLang::CheckedI64DivideAndRoundDown	(	int64_t	Left,
		int64_t	Right
	)

inline

◆ CheckedI64DivideAndRoundUp()

TOptional< int64_t > uLang::CheckedI64DivideAndRoundUp	(	int64_t	Left,
		int64_t	Right
	)

inline

◆ CheckedI64Modulo()

constexpr bool uLang::CheckedI64Modulo	(	int64_t	Lhs,
		int64_t	Rhs,
		int64_t *	OutResult
	)

constexpr

◆ CheckedI64Multiply()

constexpr bool uLang::CheckedI64Multiply	(	int64_t	Lhs,
		int64_t	Rhs,
		int64_t *	OutResult
	)

constexpr

◆ CheckedI64Negate()

constexpr bool uLang::CheckedI64Negate	(	int64_t	Rhs,
		int64_t *	OutResult
	)

constexpr

◆ CheckedI64Subtract()

constexpr bool uLang::CheckedI64Subtract	(	int64_t	Lhs,
		int64_t	Rhs,
		int64_t *	OutResult
	)

constexpr

◆ CompareElements() [1/2]

template<typename ElementType >

ULANG_FORCEINLINE TEnableIf< TTypeTraits< ElementType >::IsBytewiseComparable, bool >::Type uLang::CompareElements	(	const ElementType *	A,
		const ElementType *	B,
		int32_t	Count
	)

◆ CompareElements() [2/2]

template<typename ElementType >

ULANG_FORCEINLINE TEnableIf<!TTypeTraits< ElementType >::IsBytewiseComparable, bool >::Type uLang::CompareElements	(	const ElementType *	A,
		const ElementType *	B,
		int32_t	Count
	)

◆ ConstructElements() [1/2]

template<typename DestinationElementType , typename SourceElementType >

ULANG_FORCEINLINE TEnableIf<!TIsBitwiseConstructible< DestinationElementType, SourceElementType >::Value >::Type uLang::ConstructElements	(	void *	Dest,
		const SourceElementType *	Source,
		int32_t	Count
	)

Constructs a range of items into memory from a set of arguments. The arguments come from an another array.

Parameters

Dest	The memory location to start copying into.
Source	A pointer to the first argument to pass to the constructor.
Count	The number of elements to copy.

◆ ConstructElements() [2/2]

template<typename DestinationElementType , typename SourceElementType >

ULANG_FORCEINLINE TEnableIf< TIsBitwiseConstructible< DestinationElementType, SourceElementType >::Value >::Type uLang::ConstructElements	(	void *	Dest,
		const SourceElementType *	Source,
		int32_t	Count
	)

◆ Contains() [1/2]

template<typename TFirst , typename TLast , typename T >

bool uLang::Contains	(	TFirst	First,
		TLast	Last,
		T &&	Arg
	)

◆ Contains() [2/2]

template<typename TRange , typename T >

bool uLang::Contains	(	TRange &&	Range,
		T &&	Arg
	)

◆ ContainsExpr()

EContains uLang::ContainsExpr	(	const CExpressionBase *	Argument,
		const CExprIdentifierUnresolved *	Expr
	)

◆ CountNumLeadingNewLines()

ULANGCORE_API int32_t uLang::CountNumLeadingNewLines ( const CUTF8StringView & Text )

◆ CountNumTrailingNewLines()

ULANGCORE_API int32_t uLang::CountNumTrailingNewLines ( const CUTF8StringView & Text )

◆ CreateNegativeMemberFunction()

VERSECOMPILER_API TSRef< CFunction > uLang::CreateNegativeMemberFunction	(	CLogicalScope &	NegativeScope,
		const CFunction &	PositiveFunction
	)

◆ CreateToolchain()

VERSECOMPILER_API TSRef< CToolchain > uLang::CreateToolchain ( const SToolchainParams & Params )

◆ DefaultCalculateSlackGrow()

ULANG_FORCEINLINE int32_t uLang::DefaultCalculateSlackGrow	(	int32_t	NumElements,
		int32_t	NumAllocatedElements,
		size_t	BytesPerElement,
		bool	bAllowQuantize,
		uint32_t	Alignment = `DEFAULT_ALIGNMENT`
	)

◆ DefaultCalculateSlackReserve()

ULANG_FORCEINLINE int32_t uLang::DefaultCalculateSlackReserve	(	int32_t	NumElements,
		size_t	BytesPerElement,
		bool	bAllowQuantize,
		uint32_t	Alignment = `DEFAULT_ALIGNMENT`
	)

◆ DefaultCalculateSlackShrink()

ULANG_FORCEINLINE int32_t uLang::DefaultCalculateSlackShrink	(	int32_t	NumElements,
		int32_t	NumAllocatedElements,
		size_t	BytesPerElement,
		bool	bAllowQuantize,
		uint32_t	Alignment = `DEFAULT_ALIGNMENT`
	)

◆ DefaultConstructElements() [1/2]

template<typename ElementType >

ULANG_FORCEINLINE TEnableIf<!TIsZeroConstructType< ElementType >::Value >::Type uLang::DefaultConstructElements	(	void *	Address,
		int32_t	Count
	)

Default constructs a range of items in memory.

Parameters

Elements	The address of the first memory location to construct at.
Count	The number of elements to destruct.

◆ DefaultConstructElements() [2/2]

template<typename ElementType >

ULANG_FORCEINLINE TEnableIf< TIsZeroConstructType< ElementType >::Value >::Type uLang::DefaultConstructElements	(	void *	Elements,
		int32_t	Count
	)

◆ DefaultQuantizeSize()

ULANG_FORCEINLINE size_t uLang::DefaultQuantizeSize	(	size_t	Count,
		uint32_t	Alignment
	)

TODO: Implement for special allocators such as binned allocators

◆ DefinitionKindAsCString()

VERSECOMPILER_API const char * uLang::DefinitionKindAsCString ( CDefinition::EKind Kind )

◆ DeInitialize()

ULANGCORE_API EResult uLang::DeInitialize ( )

Deinitialize the uLang Module

Returns: EResult indicating outcome of operation

◆ DestructElement() [1/2]

template<typename ElementType >

ULANG_FORCEINLINE TEnableIf<!TIsTriviallyDestructible< ElementType >::Value >::Type uLang::DestructElement ( ElementType * Element )

Destructs a single item in memory.

Parameters

Elements A pointer to the item to destruct.

Note: : This function is optimized for values of T, and so will not dynamically dispatch destructor calls if T's destructor is virtual.

◆ DestructElement() [2/2]

template<typename ElementType >

ULANG_FORCEINLINE TEnableIf< TIsTriviallyDestructible< ElementType >::Value >::Type uLang::DestructElement ( ElementType * Element )

◆ DestructElements() [1/2]

template<typename ElementType >

ULANG_FORCEINLINE TEnableIf<!TIsTriviallyDestructible< ElementType >::Value >::Type uLang::DestructElements	(	ElementType *	Element,
		int32_t	Count
	)

Destructs a range of items in memory.

Parameters

Elements	A pointer to the first item to destruct.
Count	The number of elements to destruct.

Note: : This function is optimized for values of T, and so will not dynamically dispatch destructor calls if T's destructor is virtual.

◆ DestructElements() [2/2]

template<typename ElementType >

ULANG_FORCEINLINE TEnableIf< TIsTriviallyDestructible< ElementType >::Value >::Type uLang::DestructElements	(	ElementType *	Elements,
		int32_t	Count
	)

◆ DesugarVstToAst()

TSRef< CAstProject > uLang::DesugarVstToAst	(	const Verse::Vst::Project &	VstProject,
		CSymbolTable &	Symbols,
		CDiagnostics &	Diagnostics
	)

◆ end()

template<typename TFirst , typename TLast >

TLast uLang::end ( TRangeView< TFirst, TLast > const & Range )

◆ Enum_HasAllFlags()

template<typename Enum >

bool uLang::Enum_HasAllFlags	(	Enum	Flags,
		Enum	Contains
	)

inline

◆ Enum_HasAnyFlags()

template<typename Enum >

bool uLang::Enum_HasAnyFlags	(	Enum	Flags,
		Enum	Contains
	)

inline

◆ EscapeJSON() [1/2]

ULANGJSON_API CUTF8String uLang::EscapeJSON ( const CUTF8StringView & RawText )

Given a raw string, return the escaped JSON encoded string (using backslashes)

◆ EscapeJSON() [2/2]

ULANGJSON_API CUTF8String uLang::EscapeJSON ( const UTF8Char Ch )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ Find()

template<typename TFirst , typename TLast , typename T >

TFirst uLang::Find	(	TFirst	First,
		TLast	Last,
		T &&	Arg
	)

◆ FindAttributeHack()

template<typename TIterator , typename ClassOrFunction >

TIterator uLang::FindAttributeHack	(	TIterator	First,
		TIterator	Last,
		const ClassOrFunction *	AttributeClassOrFunction,
		const CSemanticProgram &	Program
	)

◆ FindIf()

template<typename TFirst , typename TLast , typename TFunction >

TFirst uLang::FindIf	(	TFirst	First,
		TLast	Last,
		TFunction	Function
	)

◆ FindLongestCommonPrefix() [1/2]

ULANGCORE_API CUTF8String uLang::FindLongestCommonPrefix ( const TArray< CUTF8String > Strings )

◆ FindLongestCommonPrefix() [2/2]

uLang::CUTF8String uLang::FindLongestCommonPrefix ( const uLang::TArray< uLang::CUTF8String > Strings )

◆ FindResolvedIdentifiersWithoutDefinitions()

TArray< const CExpressionBase * > uLang::FindResolvedIdentifiersWithoutDefinitions	(	const TSRef< CSemanticProgram > &	,
		const CAstNode &	RootNode
	)

◆ FindUnresolvedIdentifiers()

TArray< const CExpressionBase * > uLang::FindUnresolvedIdentifiers	(	const TSRef< CSemanticProgram > &	Program,
		const CAstNode &	RootNode
	)

◆ FlipPolarity()

ETypePolarity uLang::FlipPolarity ( ETypePolarity Polarity )

inline

◆ ForwardArg() [1/2]

template<typename T >

ULANG_FORCEINLINE T && uLang::ForwardArg ( typename TRemoveReference< T >::Type && Obj )

◆ ForwardArg() [2/2]

template<typename T >

ULANG_FORCEINLINE T && uLang::ForwardArg ( typename TRemoveReference< T >::Type & Obj )

ForwardArg will cast a reference to an rvalue reference. This is UE's equivalent of std::forward.

◆ FromJSON() [1/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		bool *	Value
	)

inline

Read a bool from JSON

◆ FromJSON() [2/15]

template<class T >

bool uLang::FromJSON	(	const JSONValue &	JSON,
		const char *	MemberName,
		T *	MemberValue,
		TOptional< bool >	bRequired = `EResult::Unspecified`
	)

Read member of a JSON object

◆ FromJSON() [3/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		CSourcePackage::SSettings *	Value
	)

◆ FromJSON() [4/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		CUTF8String *	Value
	)

inline

Read a string from JSON

◆ FromJSON() [5/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		CUTF8StringView *	Value
	)

inline

◆ FromJSON() [6/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		EPackageRole *	Value
	)

◆ FromJSON() [7/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		EVerseScope *	Value
	)

◆ FromJSON() [8/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		int *	Value
	)

inline

Read an integer from JSON

◆ FromJSON() [9/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		SPackageDesc *	Value
	)

◆ FromJSON() [10/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		SPackageRef *	Value
	)

◆ FromJSON() [11/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		SProjectDesc *	Value
	)

◆ FromJSON() [12/15]

template<class T >

bool uLang::FromJSON	(	const JSONValue &	JSON,
		TArray< T > *	ArrayValue
	)

Read an array from JSON

◆ FromJSON() [13/15]

template<class T >

bool uLang::FromJSON	(	const JSONValue &	JSON,
		TOptional< T > *	OptionalValue
	)

Read an optional from JSON (which can be null meaning it's unset)

◆ FromJSON() [14/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		uint32_t *	Value
	)

inline

Read an unsigned 32-bit integer from JSON

◆ FromJSON() [15/15]

bool uLang::FromJSON	(	const JSONValue &	JSON,
		uint64_t *	Value
	)

inline

Read an unsigned 64-bit integer from JSON

◆ GenerateIr()

VERSECOMPILER_API bool uLang::GenerateIr	(	const TSRef< CSemanticProgram > &	Program,
		const TSRef< CDiagnostics > &	Diagnostics,
		SBuildParams::EWhichVM	TargetVM
	)

Stand-alone IR generator, use _AstProject to fill in _IrProject in CSemanticProgram.

◆ GetAccessibilityScope() [1/2]

VERSECOMPILER_API SAccessibilityScope uLang::GetAccessibilityScope ( const CDefinition & Definition )

◆ GetAccessibilityScope() [2/2]

VERSECOMPILER_API SAccessibilityScope uLang::GetAccessibilityScope	(	const CDefinition &	Definition,
		const SAccessLevel &	InitialAccessLevel
	)

◆ GetAstNodeTypeInfo()

VERSECOMPILER_API SAstNodeTypeInfo uLang::GetAstNodeTypeInfo ( uLang::EAstNodeType Type )

Returns the name of an AST node type.

◆ GetAvailableAttributeVersion() [1/2]

TOptional< uint64_t > uLang::GetAvailableAttributeVersion	(	const CDefinition &	Definition,
		const CSemanticProgram &	SemanticProgram
	)

◆ GetAvailableAttributeVersion() [2/2]

TOptional< uint64_t > uLang::GetAvailableAttributeVersion	(	const SAttribute &	AvailableAttribute,
		const CSemanticProgram &	SemanticProgram
	)

◆ GetConstraintTypeAsCString()

VERSECOMPILER_API const char * uLang::GetConstraintTypeAsCString	(	ETypeConstraintFlags	TypeConstraints,
		bool	bIsSubtype
	)

◆ GetConstructorAccessibilityScope() [1/2]

VERSECOMPILER_API SAccessibilityScope uLang::GetConstructorAccessibilityScope ( const CClassDefinition & Class )

◆ GetConstructorAccessibilityScope() [2/2]

VERSECOMPILER_API SAccessibilityScope uLang::GetConstructorAccessibilityScope ( const CInterface & Interface )

◆ GetConstructorInvocationCallee() [1/2]

VERSECOMPILER_API const CExprIdentifierFunction * uLang::GetConstructorInvocationCallee ( const CExpressionBase & Expression )

◆ GetConstructorInvocationCallee() [2/2]

VERSECOMPILER_API const CExprIdentifierFunction * uLang::GetConstructorInvocationCallee ( const CExprInvocation & Invocation )

◆ GetCrcNameString()

VERSECOMPILER_API CUTF8String uLang::GetCrcNameString ( const CDefinition & Definition )

◆ GetCurrentIndentationLevel()

ULANGCORE_API int32_t uLang::GetCurrentIndentationLevel	(	const int32_t	IndentSize,
		const CUTF8StringView &	Text
	)

◆ GetDiagnosticFromReferenceCode()

VERSECOMPILER_API EDiagnostic uLang::GetDiagnosticFromReferenceCode ( uint16_t ReferenceCode )

◆ GetDiagnosticInfo()

VERSECOMPILER_API const SDiagnosticInfo & uLang::GetDiagnosticInfo ( EDiagnostic ResultId )

◆ GetEffectInfo()

VERSECOMPILER_API SEffectInfo uLang::GetEffectInfo ( EEffect Effect )

◆ GetModularFeature()

template<class FeatureType >

TOptional< TSRef< FeatureType > > uLang::GetModularFeature ( const int32_t Index = 0 )

Queries for a specific modular feature. Returns an empty TOptional<> if the feature is not available. Does not assert.

Returns: An optional (which could be empty if no features of the specified type are registered), wrapping a shared ModularFeature pointer.

◆ GetModularFeatureCount() [1/2]

template<class FeatureType >

int32_t uLang::GetModularFeatureCount ( )

Returns the number of registered implementations of the specified feature type.

◆ GetModularFeatureCount() [2/2]

template<class FeatureType >

ULANG_FORCEINLINE int32_t uLang::GetModularFeatureCount ( )

Returns the number of registered implementations of the specified feature type.

◆ GetModularFeaturesOfType()

template<class FeatureType >

TSRefArray< FeatureType > uLang::GetModularFeaturesOfType ( )

Queries for a specific modular feature. Returns an empty array if the feature is not available. Does not assert.

Returns: An array of all registered features of a single type – sorted in priority order.

◆ GetNegativeInterfaces()

VERSECOMPILER_API TArray< CInterface * > uLang::GetNegativeInterfaces ( const TArray< CInterface * > & Interfaces )

◆ GetQualifiedNameString()

VERSECOMPILER_API CUTF8String uLang::GetQualifiedNameString ( const CDefinition & Definition )

◆ GetReservationForSymbol() [1/2]

VERSECOMPILER_API EIsReservedSymbolResult uLang::GetReservationForSymbol	(	const CSymbol &	Identifier,
		const uint32_t	CurrentVerseVersion,
		const uint32_t	CurrentUploadedAtFNVersion
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ GetReservationForSymbol() [2/2]

VERSECOMPILER_API EIsReservedSymbolResult uLang::GetReservationForSymbol	(	const EReservedSymbol	Identifier,
		const uint32_t	CurrentVerseVersion,
		const uint32_t	CurrentUploadedAtFNVersion
	)

Gets the type of reservation this symbol has.

◆ GetReservedSymbol()

VERSECOMPILER_API CUTF8StringView uLang::GetReservedSymbol ( const EReservedSymbol Identifier )

Gets the corresponding reserved string.

◆ GetReservedSymbols()

VERSECOMPILER_API TSet< CUTF8String > uLang::GetReservedSymbols	(	const uint32_t	CurrentVerseVersion,
		const uint32_t	CurrentUploadedAtFNVersion
	)

Gets all reserved tokens (both the parser and semantic analyzer).

◆ GetSystemParams()

ULANGCORE_API SSystemParams & uLang::GetSystemParams ( )

Global variable for efficient access.

◆ GetTypeHash() [1/11]

ULANG_FORCEINLINE uint32_t uLang::GetTypeHash ( const CUTF8StringView & String )

Hash function for maps, sets.

◆ GetTypeHash() [2/11]

ULANG_FORCEINLINE uint32_t uLang::GetTypeHash ( const SCachedEffectSetToEffectClassesKey & Key )

◆ GetTypeHash() [3/11]

ULANG_FORCEINLINE uint32_t uLang::GetTypeHash ( const SEffectSet & Effects )

◆ GetTypeHash() [4/11]

uint32 uLang::GetTypeHash ( const STextPosition & TextPosition )

inline

Helper function so STextPosition can be used in a TMap

◆ GetTypeHash() [5/11]

template<typename T >

ULANG_FORCEINLINE uint32_t uLang::GetTypeHash ( const TArray< T > Array )

◆ GetTypeHash() [6/11]

template<class AllocatorType , typename... AllocatorArgsType>

ULANG_FORCEINLINE uint32_t uLang::GetTypeHash ( const TUTF8String< AllocatorType, AllocatorArgsType... > & String )

Hash function for maps, sets.

◆ GetTypeHash() [7/11]

uint32_t uLang::GetTypeHash ( const void * Key )

inline

◆ GetTypeHash() [8/11]

uint32_t uLang::GetTypeHash ( int32_t I )

inline

◆ GetTypeHash() [9/11]

uint32_t uLang::GetTypeHash ( int64_t I )

inline

◆ GetTypeHash() [10/11]

uint32_t uLang::GetTypeHash ( uint32_t I )

inline

◆ GetTypeHash() [11/11]

uint32_t uLang::GetTypeHash ( uint64_t I )

inline

◆ HasAllTags()

constexpr bool uLang::HasAllTags	(	EMacroClauseTag	A,
		EMacroClauseTag	RequiredTags
	)

constexpr

◆ HasAnyTags()

constexpr bool uLang::HasAnyTags	(	EMacroClauseTag	A,
		EMacroClauseTag	B
	)

constexpr

◆ HasDefinition()

bool uLang::HasDefinition ( const CExprIdentifierBase & IdentifierBase )

◆ HashCombineFast()

constexpr uint32_t uLang::HashCombineFast	(	uint32_t	A,
		uint32_t	B
	)

inlineconstexpr

Combines two hash values to get a third. Note - this function is not commutative.

WARNING! This function is subject to change and should only be used for creating combined hash values which don't leave the running process, e.g. GetTypeHash() overloads.

◆ HasImplicitClassSelf()

VERSECOMPILER_API bool uLang::HasImplicitClassSelf ( const CExprIdentifierData * Expr )

◆ HasTrailingNewLine()

ULANGCORE_API bool uLang::HasTrailingNewLine ( const CUTF8StringView & Text )

◆ IdentifierOfAssignmentLhs()

VERSECOMPILER_API TOptional< SAssignmentLhsIdentifier > uLang::IdentifierOfAssignmentLhs ( const CExprAssignment * Assignment )

◆ IndexRangeToTextRange()

ULANGCORE_API STextRange uLang::IndexRangeToTextRange	(	const SIdxRange &	IndexRange,
		const CUTF8StringView &	SourceText
	)

Converts an index-based range of Unicode code points (start, end) to a row/column-based range (start row/column, end row/column).

Parameters

IndexRange	The range of Unicode code points to convert.
SourceText	The full source text that corresponds to the range about to be converted.

Returns: A row-column range that is equivalent to the index-based range.

◆ Initialize()

ULANGCORE_API EResult uLang::Initialize ( const SSystemParams & Params )

Initialize the uLang Module

Parameters

Params Parameters to initialize the uLang module

Returns: EResult indicating outcome of operation

◆ InstantiateClass()

VERSECOMPILER_API CClass * uLang::InstantiateClass	(	const CClass &	Class,
		ETypePolarity	Polarity,
		const TArray< STypeVariableSubstitution > &	Substitutions
	)

◆ InstantiateInterface()

VERSECOMPILER_API CInterface * uLang::InstantiateInterface	(	const CInterface &	Interface,
		ETypePolarity	Polarity,
		const TArray< STypeVariableSubstitution > &	Substitutions
	)

◆ InstantiatePositiveClass()

CClass * uLang::InstantiatePositiveClass	(	const CClass &	Class,
		const TArray< STypeVariableSubstitution > &	Substitutions
	)

◆ InstantiatePositiveFunction()

VERSECOMPILER_API void uLang::InstantiatePositiveFunction	(	CLogicalScope &	InstScope,
		const CNormalType &	InstType,
		const CFunction &	Function,
		const TArray< STypeVariableSubstitution > &	Substitutions
	)

◆ InstantiatePositiveInterface()

VERSECOMPILER_API CInterface * uLang::InstantiatePositiveInterface	(	const CInterface &	Interface,
		const TArray< STypeVariableSubstitution > &	Substitutions
	)

◆ InstantiatePositiveInterfaces()

VERSECOMPILER_API TArray< CInterface * > uLang::InstantiatePositiveInterfaces	(	const TArray< CInterface * > &	Interfaces,
		const TArray< STypeVariableSubstitution > &	Substitutions
	)

◆ InstantiateTypeVariableSubstitutions()

VERSECOMPILER_API TArray< STypeVariableSubstitution > uLang::InstantiateTypeVariableSubstitutions	(	const TArray< STypeVariableSubstitution > &	TypeVariables,
		const TArray< STypeVariableSubstitution > &	Substitutions
	)

◆ InterlockedCompareExchange() [1/2]

ULANG_FORCEINLINE void * uLang::InterlockedCompareExchange	(	void volatile	Value,
		void *	ReplaceWithThis,
		void *	IfEqualToThis
	)

◆ InterlockedCompareExchange() [2/2]

ULANG_FORCEINLINE uint32_t uLang::InterlockedCompareExchange	(	volatile uint32_t *	Value,
		uint32_t	ReplaceWithThis,
		uint32_t	IfEqualToThis
	)

◆ Invoke() [1/3]

template<typename FuncType , typename... ArgTypes>

ULANG_FORCEINLINE auto uLang::Invoke	(	FuncType &&	Func,
		ArgTypes &&...	Args
	)		-> decltype(uLang::ForwardArg<FuncType>(Func)(uLang::ForwardArg<ArgTypes>(Args)...))

Invokes a callable with a set of arguments. Allows the following:

Calling a functor object given a set of arguments.
Calling a function pointer given a set of arguments.
Calling a member function given a reference to an object and a set of arguments.
Calling a member function given a pointer (including smart pointers) to an object and a set of arguments.
Projecting via a data member pointer given a reference to an object.
Projecting via a data member pointer given a pointer (including smart pointers) to an object.

See: http://en.cppreference.com/w/cpp/utility/functional/invoke

◆ Invoke() [2/3]

template<typename ReturnType , typename ObjType , typename CallableType >

ULANG_FORCEINLINE auto uLang::Invoke	(	ReturnType ObjType::*	pdm,
		CallableType &&	Callable
	)		-> decltype(Private::DereferenceIfNecessary<ObjType>(uLang::ForwardArg<CallableType>(Callable)).*pdm)

◆ Invoke() [3/3]

template<typename ReturnType , typename ObjType , typename... PMFArgTypes, typename CallableType , typename... ArgTypes>

ULANG_FORCEINLINE auto uLang::Invoke	(	ReturnType(ObjType::*)(PMFArgTypes...)	PtrMemFun,
		CallableType &&	Callable,
		ArgTypes &&...	Args
	)		-> decltype((Private::DereferenceIfNecessary<ObjType>(uLang::ForwardArg<CallableType>(Callable)).*PtrMemFun)(uLang::ForwardArg<ArgTypes>(Args)...))

◆ InvokeTimeAsCString()

const char * uLang::InvokeTimeAsCString ( EInvokeTime InvokeTime )

inline

◆ IsAbortedCompile()

ULANG_FORCEINLINE bool uLang::IsAbortedCompile ( ECompilerResult E )

◆ IsAttributeHack() [1/2]

VERSECOMPILER_API bool uLang::IsAttributeHack	(	const SAttribute &	Attribute,
		const CClass *	AttributeClass,
		const CSemanticProgram &	Program
	)

◆ IsAttributeHack() [2/2]

VERSECOMPILER_API bool uLang::IsAttributeHack	(	const SAttribute &	Attribute,
		const CFunction *	AttributeFunction,
		const CSemanticProgram &	Program
	)

◆ IsClassMemberAccess()

VERSECOMPILER_API bool uLang::IsClassMemberAccess ( const CExprIdentifierData * Expr )

◆ IsCompileComplete()

ULANG_FORCEINLINE bool uLang::IsCompileComplete ( ECompilerResult E )

◆ IsCompileFailure()

ULANG_FORCEINLINE bool uLang::IsCompileFailure ( ECompilerResult E )

◆ IsCompileIncomplete()

ULANG_FORCEINLINE bool uLang::IsCompileIncomplete ( ECompilerResult E )

◆ IsConstructorInvocation() [1/2]

VERSECOMPILER_API bool uLang::IsConstructorInvocation ( const CExpressionBase & Expression )

◆ IsConstructorInvocation() [2/2]

VERSECOMPILER_API bool uLang::IsConstructorInvocation ( const CExprInvocation & Invocation )

◆ IsDebuggerPresent()

bool uLang::IsDebuggerPresent ( )

inline

◆ IsDefinitionAvailableAtVersion()

bool uLang::IsDefinitionAvailableAtVersion	(	const CDefinition &	Definition,
		uint64_t	Version,
		const CSemanticProgram &	SemanticProgram
	)

◆ IsFactor()

constexpr bool uLang::IsFactor	(	int64_t	Left,
		int64_t	Right
	)

constexpr

◆ IsInitialized()

ULANGCORE_API bool uLang::IsInitialized ( )

Utility function for uLang modules to verify against.

◆ LogDebugMessage()

void uLang::LogDebugMessage ( const char * Message )

inline

◆ MacroClauseFormAsCString()

const char * uLang::MacroClauseFormAsCString ( Verse::Vst::Clause::EForm Form )

inline

◆ MacroClauseTagAsCString()

const char * uLang::MacroClauseTagAsCString ( EMacroClauseTag Tag )

inline

◆ Move()

template<typename T >

ULANG_FORCEINLINE TRemoveReference< T >::Type && uLang::Move ( T && Obj )

Move will cast a reference to an rvalue reference. This is UE's equivalent of std::move except that it will not compile when passed an rvalue or const object, because we would prefer to be informed when Move will have no effect.

◆ MoveIfPossible()

template<typename T >

ULANG_FORCEINLINE TRemoveReference< T >::Type && uLang::MoveIfPossible ( T && Obj )

MoveIfPossible will cast a reference to an rvalue reference. This is UE's equivalent of std::move. It doesn't static assert like Move, because it is useful in templates or macros where it's not obvious what the argument is, but you want to take advantage of move semantics where you can but not stop compilation.

◆ MurmurFinalize32()

uint32_t uLang::MurmurFinalize32 ( uint32_t Hash )

inline

◆ operator!()

ULANG_FORCEINLINE bool uLang::operator! ( ELinkerResult E )

◆ operator!=() [1/2]

template<typename FuncType >

ULANG_FORCEINLINE bool uLang::operator!=	(	const TFunction< FuncType > &	Func,
		NullPtrType
	)

Nullptr inequality operator.

◆ operator!=() [2/2]

template<typename FuncType >

ULANG_FORCEINLINE bool uLang::operator!=	(	NullPtrType	,
		const TFunction< FuncType > &	Func
	)

Nullptr inequality operator.

◆ operator-() [1/2]

template<EInfinitySign OperandSign>

TIntOrInfinity<-OperandSign > uLang::operator- ( const TIntOrInfinity< OperandSign > & Operand )

inline

◆ operator-() [2/2]

constexpr EInfinitySign uLang::operator- ( EInfinitySign Sign )

constexpr

◆ operator<()

template<EInfinitySign LhsSign, EInfinitySign RhsSign>

bool uLang::operator<	(	const TIntOrInfinity< LhsSign > &	Lhs,
		const TIntOrInfinity< RhsSign > &	Rhs
	)

inline

◆ operator<=()

template<EInfinitySign LhsSign, EInfinitySign RhsSign>

bool uLang::operator<=	(	const TIntOrInfinity< LhsSign > &	Lhs,
		const TIntOrInfinity< RhsSign > &	Rhs
	)

inline

◆ operator==() [1/4]

ULANGCORE_API bool uLang::operator==	(	const SSystemParams &	Lhs,
		const SSystemParams &	Rhs
	)

◆ operator==() [2/4]

template<typename FuncType >

ULANG_FORCEINLINE bool uLang::operator==	(	const TFunction< FuncType > &	Func,
		NullPtrType
	)

Nullptr equality operator.

◆ operator==() [3/4]

template<EInfinitySign LhsSign, EInfinitySign RhsSign>

bool uLang::operator==	(	const TIntOrInfinity< LhsSign > &	Lhs,
		const TIntOrInfinity< RhsSign > &	Rhs
	)

inline

◆ operator==() [4/4]

template<typename FuncType >

ULANG_FORCEINLINE bool uLang::operator==	(	NullPtrType	,
		const TFunction< FuncType > &	Func
	)

Nullptr equality operator.

◆ operator>()

template<EInfinitySign LhsSign, EInfinitySign RhsSign>

bool uLang::operator>	(	const TIntOrInfinity< LhsSign > &	Lhs,
		const TIntOrInfinity< RhsSign > &	Rhs
	)

inline

◆ operator>=()

template<EInfinitySign LhsSign, EInfinitySign RhsSign>

bool uLang::operator>=	(	const TIntOrInfinity< LhsSign > &	Lhs,
		const TIntOrInfinity< RhsSign > &	Rhs
	)

inline

◆ operator|() [1/2]

constexpr SEffectSet uLang::operator\|	(	const EEffect	Lhs,
		const EEffect	Rhs
	)

constexpr

◆ operator|() [2/2]

constexpr EMacroClauseTag uLang::operator\|	(	EMacroClauseTag	A,
		EMacroClauseTag	B
	)

constexpr

◆ PrintAst()

VERSECOMPILER_API CUTF8String uLang::PrintAst	(	const CSemanticProgram &	Program,
		const CAstNode &	RootNode
	)

◆ QualifyAllAnalyzedIdentifiers() [1/2]

TArray< TSRef< Verse::Vst::Node > > uLang::QualifyAllAnalyzedIdentifiers	(	bool	bVerbose,
		const TSRef< CSemanticProgram > &	Program,
		TSRef< Verse::Vst::Node > &	Root
	)

◆ QualifyAllAnalyzedIdentifiers() [2/2]

TArray< VstSharedRef > uLang::QualifyAllAnalyzedIdentifiers	(	bool	bVerbose,
		const TSRef< CSemanticProgram > &	Program,
		VstSharedRef &	Root
	)

◆ RelocateConstructElements() [1/2]

template<typename DestinationElementType , typename SourceElementType >

ULANG_FORCEINLINE TEnableIf<!Private::TCanBitwiseRelocate< DestinationElementType, SourceElementType >::Value >::Type uLang::RelocateConstructElements	(	void *	Dest,
		const SourceElementType *	Source,
		int32_t	Count
	)

Relocates a range of items to a new memory location as a new type. This is a so-called 'destructive move' for which there is no single operation in C++ but which can be implemented very efficiently in general.

Parameters

Dest	The memory location to relocate to.
Source	A pointer to the first item to relocate.
Count	The number of elements to relocate.

◆ RelocateConstructElements() [2/2]

template<typename DestinationElementType , typename SourceElementType >

ULANG_FORCEINLINE TEnableIf< Private::TCanBitwiseRelocate< DestinationElementType, SourceElementType >::Value >::Type uLang::RelocateConstructElements	(	void *	Dest,
		const SourceElementType *	Source,
		int32_t	Count
	)

◆ RemoveSubscripts()

UE_API const CExpressionBase * uLang::RemoveSubscripts	(	const CExpressionBase *	Expr,
		const CSemanticProgram &	Program
	)

◆ RotateCRC32()

ULANG_FORCEINLINE uint32_t uLang::RotateCRC32 ( uint32_t CRC )

Compute a new CRC32 from a given CRC32 by rotating one bit Due to the nature of CRCs, this will exactly iterate through all possible 32-bit values except for 0

◆ SameSign()

constexpr bool uLang::SameSign	(	int64_t	Left,
		int64_t	Right
	)

constexpr

◆ ScanToRowCol() [1/2]

VERSECOMPILER_API TOptional< int32_t > uLang::ScanToRowCol	(	const SIndexedSourceText &	SourceText,
		const STextPosition &	Position
	)

◆ ScanToRowCol() [2/2]

VERSECOMPILER_API TOptional< int32_t > uLang::ScanToRowCol	(	CUTF8StringView const &	Source,
		const STextPosition &	Position
	)

Convert a Row/Col offset to a byte offset from beginning of 'Source'

◆ SetGlobalVerbosity()

ULANGCORE_API void uLang::SetGlobalVerbosity ( const uLang::ELogVerbosity GlobalVerbosity )

Setter function for the global verbosity level in SSystemParams

◆ SetInstantiatedOverriddenDefinition()

VERSECOMPILER_API void uLang::SetInstantiatedOverriddenDefinition	(	CDefinition &	InstDefinition,
		const CNormalType &	InstType,
		const CDefinition &	Definition
	)

◆ SetNegativeClassMemberDefinitionTypes()

VERSECOMPILER_API void uLang::SetNegativeClassMemberDefinitionTypes ( const CClass & PositiveClass )

◆ SetNegativeInterfaceMemberDefinitionTypes()

VERSECOMPILER_API void uLang::SetNegativeInterfaceMemberDefinitionTypes ( const CInterface & PositiveInterface )

◆ SetNegativeMemberDefinitionType()

VERSECOMPILER_API void uLang::SetNegativeMemberDefinitionType	(	CFunction &	NegativeFunction,
		const CFunction &	PositiveFunction
	)

◆ SetProblematicFloatingPointStateForTesting()

void ULANGCORE_API uLang::SetProblematicFloatingPointStateForTesting ( )

Sets machine floating point state to problematic values (round to zero, flush-to-zero on). Intended for FP state save/restore tests.

◆ SingletonRangeView()

template<typename T >

TRangeView< T *, T * > uLang::SingletonRangeView ( T & Arg )

◆ SplitString() [1/2]

ULANGCORE_API bool uLang::SplitString	(	const char *	ToSplit,
		const char *	Delim,
		CUTF8StringView &	OutLeft,
		CUTF8StringView &	OutRight
	)

◆ SplitString() [2/2]

ULANGCORE_API bool uLang::SplitString	(	const char *	ToSplit,
		const UTF8Char	Delim,
		CUTF8StringView &	OutLeft,
		CUTF8StringView &	OutRight,
		bool	bReverse
	)

◆ Swap() [1/2]

template<typename T >

TEnableIf< TUseBitwiseSwap< T >::Value >::Type uLang::Swap	(	T &	A,
		T &	B
	)

inline

Swap two values. Assumes the types are trivially relocatable.

◆ Swap() [2/2]

template<typename T >

TEnableIf<!TUseBitwiseSwap< T >::Value >::Type uLang::Swap	(	T &	A,
		T &	B
	)

inline

◆ TextRangeToStringView() [1/2]

VERSECOMPILER_API CUTF8StringView uLang::TextRangeToStringView	(	const uLang::SIndexedSourceText &	SourceText,
		STextRange const &	Range
	)

◆ TextRangeToStringView() [2/2]

VERSECOMPILER_API CUTF8StringView uLang::TextRangeToStringView	(	CUTF8StringView const &	Source,
		STextRange const &	Range
	)

Given a 'Range', return a corresponding string subview of 'Source'

◆ TGuard()

template<typename Function >

uLang::TGuard ( Function && ) -> TGuard< std::decay_t< Function > >

◆ ToJSON() [1/18]

bool uLang::ToJSON	(	bool	Value,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &
	)

inline

Write a bool to JSON

◆ ToJSON() [2/18]

bool uLang::ToJSON	(	const CSourceModule &	Value,
		JSONDocument *	JSON
	)

◆ ToJSON() [3/18]

bool uLang::ToJSON	(	const CSourcePackage &	Value,
		JSONDocument *	JSON
	)

◆ ToJSON() [4/18]

bool uLang::ToJSON	(	const CSourcePackage::SSettings &	Value,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

◆ ToJSON() [5/18]

bool uLang::ToJSON	(	const EPackageRole	Role,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

◆ ToJSON() [6/18]

bool uLang::ToJSON	(	const EVerseScope	Scope,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

◆ ToJSON() [7/18]

bool uLang::ToJSON	(	const SPackageDesc &	Value,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

◆ ToJSON() [8/18]

bool uLang::ToJSON	(	const SPackageRef &	Value,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

◆ ToJSON() [9/18]

bool uLang::ToJSON	(	const SProjectDesc &	Value,
		JSONDocument *	JSON
	)

◆ ToJSON() [10/18]

bool uLang::ToJSON	(	const SWorkspaceDesc &	Value,
		JSONDocument *	JSON
	)

◆ ToJSON() [11/18]

bool uLang::ToJSON	(	const SWorkspacePackageRef &	Value,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

◆ ToJSON() [12/18]

template<class T >

bool uLang::ToJSON	(	const T &	MemberValue,
		const char *	MemberName,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

Write member of a JSON object

◆ ToJSON() [13/18]

template<class T >

bool uLang::ToJSON	(	const TArray< T > &	ArrayValue,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

Write an array to JSON

◆ ToJSON() [14/18]

template<class T >

bool uLang::ToJSON	(	const TOptional< T > &	MemberValue,
		const char *	MemberName,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

Write optional member of a JSON object

◆ ToJSON() [15/18]

template<class T >

bool uLang::ToJSON	(	const TOptional< T > &	OptionalValue,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

Write an optional to JSON (which can be null meaning it's unset)

◆ ToJSON() [16/18]

bool uLang::ToJSON	(	CUTF8StringView	Value,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &	Allocator
	)

inline

Write a string to JSON

◆ ToJSON() [17/18]

bool uLang::ToJSON	(	int	Value,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &
	)

inline

Write an integer to JSON

◆ ToJSON() [18/18]

bool uLang::ToJSON	(	uint32_t	Value,
		JSONValue *	JSON,
		JSONMemoryPoolAllocator &
	)

inline

Write an unsigned integer to JSON

◆ ToUpper()

ULANGCORE_API CUTF8String uLang::ToUpper ( const CUTF8StringView & Str )

◆ TRangeView()

template<typename T >

uLang::TRangeView ( T && Arg ) -> TRangeView< decltype(Arg.begin()), decltype(Arg.end())>

◆ TUntil()

template<typename T >

uLang::TUntil ( T && ) -> TUntil< TDecayT< T > >

◆ TValueIterator()

template<typename T >

uLang::TValueIterator ( T && ) -> TValueIterator< TDecayT< T > >

◆ TypeKindAsCString()

VERSECOMPILER_API const char * uLang::TypeKindAsCString ( ETypeKind Type )

◆ ULANG_ENUM_BIT_FLAGS() [1/2]

uLang::ULANG_ENUM_BIT_FLAGS	(	ECompilerResult	,
		inline
	)

◆ ULANG_ENUM_BIT_FLAGS() [2/2]

uLang::ULANG_ENUM_BIT_FLAGS	(	ETypeConstraintFlags	,
		inline
	)

◆ ULangGetData() [1/4]

template<typename FirstIterator , typename LastIterator >

constexpr FirstIterator uLang::ULangGetData ( const TRangeView< FirstIterator, LastIterator > & View )

constexpr

◆ ULangGetData() [2/4]

template<typename T >

constexpr T * uLang::ULangGetData ( std::initializer_list< T > List )

constexpr

◆ ULangGetData() [3/4]

template<typename T , typename = typename TEnableIf<TIsContiguousContainer<T>::Value>::Type>

auto uLang::ULangGetData ( T && Container ) -> decltype(Container.GetData())

Generically gets the data pointer of a contiguous container Named differently from GetData() in UnrealTemplate.h to avoid ambiguous overload resolution.

◆ ULangGetData() [4/4]

template<typename T , size_t N>

constexpr T * uLang::ULangGetData ( T(&) Container[N] )

constexpr

◆ ULangGetNum() [1/4]

template<typename FirstIterator , typename LastIterator >

constexpr int32_t uLang::ULangGetNum ( const TRangeView< FirstIterator, LastIterator > & View )

constexpr

◆ ULangGetNum() [2/4]

template<typename T >

constexpr size_t uLang::ULangGetNum ( std::initializer_list< T > List )

constexpr

◆ ULangGetNum() [3/4]

template<typename T , typename = typename TEnableIf<TIsContiguousContainer<T>::Value>::Type>

size_t uLang::ULangGetNum ( T && Container )

Generically gets the number of items in a contiguous container Named differently from GetNum() in UnrealTemplate.h to avoid ambiguous overload resolution.

◆ ULangGetNum() [4/4]

template<typename T , size_t N>

constexpr size_t uLang::ULangGetNum ( T(&) Container[N] )

constexpr

◆ VerifyAllQualified()

bool uLang::VerifyAllQualified ( const TSRef< CSemanticProgram > & Program )

Variable Documentation

◆ ASCII_RANGE

constexpr size_t uLang::ASCII_RANGE = 128

inlineconstexpr

◆ BYTE_RANGE

constexpr size_t uLang::BYTE_RANGE = 256

inlineconstexpr

◆ Cases

template<auto... Args>

constexpr TCases<Args...> uLang::Cases {}

constexpr

◆ ConstraintPackageRole

constexpr auto uLang::ConstraintPackageRole

constexpr

Initial value:

= Cases<
    EPackageRole::GeneralCompatConstraint,
    EPackageRole::PersistenceCompatConstraint,
    EPackageRole::PersistenceSoftCompatConstraint>

◆ EEffectNum

constexpr int32_t uLang::EEffectNum = VERSE_ENUM_EFFECTS(VISIT) 0

inlineconstexpr

◆ ExternalPackageRole

constexpr auto uLang::ExternalPackageRole

constexpr

Initial value:

= Cases<
    EPackageRole::External,
    EPackageRole::GeneralCompatConstraint,
    EPackageRole::PersistenceCompatConstraint,
    EPackageRole::PersistenceSoftCompatConstraint>

◆ Float32Max

constexpr float uLang::Float32Max = FLT_MAX

constexpr

◆ Float32Min

constexpr float uLang::Float32Min = FLT_MIN

constexpr

◆ Float64Max

constexpr double uLang::Float64Max = DBL_MAX

constexpr

◆ Float64Min

constexpr double uLang::Float64Min = DBL_MIN

constexpr

◆ GSystemAllocatorInstance

ULANGCORE_API const CAllocatorInstance uLang::GSystemAllocatorInstance	(	[] (const CAllocatorInstance , size_t NumBytes) -> void { return GetSystemParams()._HeapMalloc(NumBytes);}	,
		[] (const CAllocatorInstance , void Memory, size_t NumBytes) -> void *{ return GetSystemParams()._HeapRealloc(Memory, NumBytes);}	,
		[] (const CAllocatorInstance , void Memory) { GetSystemParams()._HeapFree(Memory);}
	)

◆ Int32Max

constexpr int32_t uLang::Int32Max = INT32_MAX

constexpr

◆ Int32MaxMagnitude

constexpr uint32_t uLang::Int32MaxMagnitude = ((uint32_t)(INT32_MAX))+1

constexpr

◆ Int32Min

constexpr int32_t uLang::Int32Min = INT32_MIN

constexpr

◆ Int64Max

constexpr int64_t uLang::Int64Max = INT64_MAX

constexpr

◆ Int64MaxMagnitude

constexpr uint64_t uLang::Int64MaxMagnitude = ((uint64_t)(INT64_MAX))+1

constexpr

◆ Int64Min

constexpr int64_t uLang::Int64Min = INT64_MIN

constexpr

◆ MaxNumPersistentVarsDefault

constexpr int32_t uLang::MaxNumPersistentVarsDefault = 4

constexpr

◆ uint32_invalid

const uint32_t uLang::uint32_invalid = UINT32_MAX

inline

Default size for uLang Boolean Type.

◆ UInt32Max

constexpr uint32_t uLang::UInt32Max = UINT32_MAX

constexpr

◆ UInt64Max

constexpr uint64_t uLang::UInt64Max = UINT64_MAX

constexpr

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ Boolean

◆ CAnyType

◆ CAstNodeRef

◆ CChar32Type

◆ CChar8Type

◆ CComparableType

◆ CFalseType

◆ char32

◆ char8

◆ CLogicType

◆ CPathType

◆ CPersistableType

◆ CRangeType

◆ CRationalType

◆ CTrueType

◆ CUTF8String

◆ CUTF8StringA

◆ CUTF8StringBuilder

◆ CUTF8StringBuilderA

◆ CVoidType

◆ EventSubscriberId

◆ FIntOrNegativeInfinity

◆ FIntOrPositiveInfinity

◆ Float

◆ Integer

◆ JSONDocument

◆ JSONGenericMemberIterator

◆ JSONMemoryPoolAllocator

◆ JSONStringBuffer

◆ JSONStringRef

◆ JSONStringWriter

◆ JSONValue

◆ nat

◆ nat8

◆ NullPtrType

◆ SemanticRevision

◆ SLocus

◆ SmallDefinitionArray

◆ SResolvedDefinitionArray

◆ SSymbolDefinitionArray

◆ STypeVariablePolarities

◆ SymbolId

◆ TArray

◆ TArrayA

◆ TDecayT

◆ TEnableIfT

◆ TMap

◆ TMQueue

◆ TQueue

◆ TSet

◆ TSPtr

◆ TSPtrA

◆ TSPtrArray

◆ TSPtrArrayA

◆ TSPtrSet

◆ TSPtrSetA

◆ TSRef

◆ TSRefA

◆ TSRefArray

◆ TSRefArrayA

◆ TSRefSet

◆ TSRefSetA

◆ TUPtr

◆ TUPtrA

◆ TUPtrArray

◆ TUPtrArrayA

◆ TUPtrSet

◆ TUPtrSetA

◆ TURef

◆ TURefA

◆ TURefArray

◆ TURefArrayA

◆ TURefSet