Semantics

API > API/Runtime > API/Runtime/VerseCompiler > API/Runtime/VerseCompiler/uLang

Classes

  Type Name Description
Public class CAliasType Encodes a type alias as a non-normal CTypeBase.  
Public class CArrayType A parametric type of arrays with a specific element type: []t where t:type  
Public class CAstCompilationUnit A group of packages that must be compiled as a unit (= a strongly connected component (SCC) in the dependency graph)  
Public class CAstNode Abstract base class for AST nodes.  
Public class CAstPackage Represents a package in the AST.  
Public class CAstPackageRef Encapsulates a reference to an AST/IR package  
Public class CAstProject Represents a project in the AST.  
Public class CAttributable Base class for everything that can have attributes attached to it (classes, expressions, etc.)  
Public class CClass Class defining a class instance / object [Might break off CStructType to differentiate stack based types.]  
Public class CClassDefinition    
Public class CCompatConstraintRoot Serves as an alternate root scope for definitions in packages that define compatibility constraints.  
Public class CControlScope Represents a function body or a nested scope within a function body.  
Public class CDataDefinition Joining structure, making data-members attributable.  
Public class CDefinition The base class of scoped definitions.  
Public class CEnumeration Enumeration type @jira SOL-1013 : Make enums derive from Class?  
Public class CEnumerator Description for a single enumerator  
Public class CExprArchetypeInstantiation Represents an initializer-list style construction for certain object types; i.e.: Type{expr1, id=expr2, ...}  
Public class CExprArrayTypeFormer    
Public class CExprArrow Create a function type from a parameter and return type.  
Public class CExprAssignment Assignment expr1 = expr2, expr1 := expr2, expr1 += expr2, etc.  
Public class CExprBinaryArithmetic    
Public class CExprBinaryOp Base class of binary operators.  
Public class CExprBranch Branch concurrency primitive - branch {Coro()} One async expression started and next expression executed immediately while the started expression continues independently until completion or the surrounding context (such as a coroutine) completes in which case it aborts early.  
Public class CExprBreak Control flow early exitloop: if (IsEarlyExit[]): break DoLoopStuff()  
Public class CExprChar Character literal - 'H' '' '{0c00}' '{0u1f600}'  
Public class CExprClassDefinition Represents a class definition in the AST.  
Public class CExprCodeBlock Code block - {expr1; expr2}_ or do {expr1; expr2}_ Can have zero or more subexpressions  
Public class CExprComparison Comparison operators.  
Public class CExprCompoundBase Base for expressions that have an array of subexpressions Subclasses: CExprMakeArray, CExprMakeMap, CExprMakeTuple, CExprCodeBlock, CExprConcurrentBlockBase  
Public class CExprConcurrentBlockBase Block based concurrency primitives - sync{}, rush{} or race{} Can have two or more async subexpressions - 0 or 1 is a warning or error.  
Public class CExprConcurrentIteratedBase Iteration based concurrency primitives - sync(item:collection){}, rush(item:collection){} or race(item:collection){}  
Public class CExprDataDefinition Represents a data definition in the AST.  
Public class CExprDefer Defer macro - defer {Expr1; Expr2} Defers expressions until end of current scope.  
Public class CExprDefinition Represents all definitions (and assignments) supported by Verse.  
Public class CExprEnumDefinition Represents an enum definition in the AST.  
Public class CExprEnumerationType Enum identifier @jira SOL-1013 : Shouldn't this inherit from CExprIdentifierClass?  
Public class CExprEnumLiteral Enumerator - #GlobalEnum.enumeration, #.enumeration, MyType#Confirm.yes, #Confirm.yes, #.yes, MyType@set_size#size.medium, #size.medium, #.medium, #position.upper, #.upper  
Public class CExprError Error expression - "~er~" produced when an expression couldn't be analyzed due to an error.  
Public class CExpressionBase Abstract base class for AST expressions.  
Public class CExprExternal Note - if these subclasses of CExpressionBase become more sophisticated they should probably be moved to their own files.  
Public class CExprFunctionDefinition Represents a function definition in the AST.  
Public class CExprFunctionLiteral Function literal - a=>b or function(a){b}  
Public class CExprGeneratorTypeFormer    
Public class CExprIdentifierBase The base class of identifiers expressions.  
Public class CExprIdentifierBuiltInMacro Represents a name of a a compiler built-in macro; e.g. option, array.  
Public class CExprIdentifierClass Type identifier - MyType  
Public class CExprIdentifierData Local or class identifier - temp, arg, captured  
Public class CExprIdentifierFunction Access to instance function members  
Public class CExprIdentifierModule Module identifier  
Public class CExprIdentifierModuleAlias Module alias identifier  
Public class CExprIdentifierOverloadedFunction An overloaded function identifier that hasn't been resolved to a specific overload.  
Public class CExprIdentifierTypeAlias Access to a type alias  
Public class CExprIdentifierTypeVariable Access to a type variable  
Public class CExprIdentifierUnresolved An unresolved type identifier that is produced by desugaring, and consumed by analysis.  
Public class CExprIf Conditional with failable tests- if (test[]) {clause1}, if (test[]) {clause1} else {else_clause}  
Public class CExprImport Represents a import declaration in the AST.  
Public class CExprInterfaceDefinition Represents a interface definition in the AST.  
Public class CExprInterfaceType Interface identifier @jira SOL-1013 : Shouldn't this inherit from CExprIdentifierClass?  
Public class CExprInvocation Routine call - expr1.call(expr2, expr3)  
Public class CExprInvokeType Invoke a type as a function on a value - type(expr) or type[expr].  
Public class CExprIteration Note that CExprSyncIterated, CExprRushIterated and CExprRaceIterated are subclasses.  
Public class CExprIterationPairDefinition Represents a map pair definition in the AST: (Key=>Value):Map  
Public class CExprLet    
Public class CExprLocal Represents the `(local:) qualifier_.  
Public class CExprLogic Logic literal - true/false  
Public class CExprLogicalNot Logical not operator  
Public class CExprLoop Loop flow/concurrency primitive/macro - loop {Expr1; Expr2} Loops one or more expressions.  
Public class CExprMacroCall A macro call of the form m1{}, m2(){}, or more generally m(){}keyword_1{}keyword_2{}...keyword_N{}  
Public class CExprMakeArray Create an array value Can have zero or more subexpressions  
Public class CExprMakeMap Create a map value Can have zero or more subexpressions  
Public class CExprMakeNamed Represents a named value / default value placeholder in the AST.  
Public class CExprMakeOption Box an option value  
Public class CExprMakeRange Create a range value  
Public class CExprMakeTuple Create a tuple value  
Public class CExprMapTypeFormer    
Public class CExprModuleDefinition Represents a module definition in the AST.  
Public class CExprNewPointer Create a new pointer from an initial value.  
Public class CExprNumber Integer literal - 42, 0, -123, 123_456_789, 0x12fe, 0b101010  
Public class CExprOptionTypeFormer    
Public class CExprPath Path literal - /unrealengine.com/UnrealEngine  
Public class CExprPathPlusSymbol Expression that evaluates to the path of the current scope, plus a given symbol, semantic analysis replaces this node with a CExprString  
Public class CExprPlaceholder Placeholder expression - "~ph~" produced by placeholder nodes in the Vst.  
Public class CExprPointerToReference Read the value of a variable.  
Public class CExprProfileBlock Represents a profile block macro invocation in the AST.  
Public class CExprQueryValue Query the value of a boolean or option value.  
Public class CExprRace Race concurrency primitive - race {coro1() _coro2()} 2+ Async expressions run concurrently and next expression executed when _fastest/first expression completed and all other expressions are aborted.  
Public class CExprRaceIterated Iterated Race (collection form) concurrency primitive - race(item:collection) {_coro1() _coro2()}  
Public class CExprReferenceToValue Evaluates the value of an expression yielding a reference type.  
Public class CExprReturn Return statement - return expr  
Public class CExprRush Rush concurrency primitive - rush {coro1() _coro2()} 2+ Async expressions run concurrently and next expression executed when _fastest/first expression completed and all other expressions continue independently until each is fully completed.  
Public class CExprRushIterated Iterated Rush (collection form) concurrency primitive - rush(item:collection) {_coro1() _coro2()}  
Public class CExprScopedAccessLevelDefinition Represents both named and anonymous scoped access level definitions in the AST.  
Public class CExprSelf Access to the instance the current function is being invoked on.  
Public class CExprSet Evaluate operand to an l-expression.  
Public class CExprShortCircuitAnd Short-circuit evaluation of a Boolean and  
Public class CExprShortCircuitOr Short-circuit evaluation of a Boolean or  
Public class CExprSnippet Represents a snippet in the AST.  
Public class CExprSpawn Spawn concurrency primitive - spawn {Coro()} [future: spawn {Expr1; Expr2}] Async expression treated as a closure/lambda with next expression executed immediately while the started async expression continues independently.  
Public class CExprString String literal - "Hello, world!", "Line 1\nLine2"  
Public class CExprSubBlockBase Expressions with a sub-block - branch, spawn, loop, defer  
Public class CExprSubtype    
Public class CExprSync Sync concurrency primitive - sync {coro1() _coro2()} 2+ Async expressions run concurrently and next expression executed when _all expressions completed.  
Public class CExprSyncIterated Iterated Sync (collection form) concurrency primitive - sync(item:collection) {_coro1() _coro2()}  
Public class CExprTupleElement Tuple element access `TupleExpr(Idx)_  
Public class CExprTupleType Get or create a tuple tuple based on `tuple(type1, type2, ...)_  
Public class CExprType Type expression - type{}  
Public class CExprTypeAliasDefinition Represents a type alias definition in the AST.  
Public class CExprTypeFormer Base class for all expressions that form a type out of input type(s)  
Public class CExprUnaryArithmetic    
Public class CExprUnaryOp Base class of unary operators.  
Public class CExprUnaryTypeFormer    
Public class CExprUsing Represents a using declaration in the AST.  
Public class CExprVar    
Public class CExprWhere    
Public class CFloatType The float type is a special form of CFloatType where _MaxInclusive is NaN.  
Public class CFlowType    
Public class CFunction Function scope, signature and body.  
Public class CFunctionType    
Public class CGeneratorType A parametric type of generators with a specific element type: generator(t) where t:type  
Public class CGlobalType Global type: used for various kinds of types of which there are one per program: false, unit, void, any.  
Public class CInstantiatedClass    
Public class CInstantiatedInterface    
Public class CInstantiatedType Type representing an instantiation of some underlying type.  
Public class CInterface A interface: a named set of function signatures that can be implemented for other types.  
Public class CIntrinsicSymbols Container structure for the various pre-defined, intrinsic symbols.  
Public class CIntType    
Public class CInvariantValueType    
Public class CIrArrayAdd Add an item to an array The array itself is not included in the node, instead the result destination in the code generator is used.  
Public class CIrArrayUnsafeCall    
Public class CIrConvertFromDynamic Converts a value to a dynamically typed value. Only present in the IR, not the AST.  
Public class CIrConvertToDynamic Converts a value to a dynamically typed value. Only present in the IR, not the AST.  
Public class CIrFor Bounded iteration  
Public class CIrForBody Wraps the innermost body of CIrFor It wraps the code not inside the failure context of CIrFor.  
Public class CIrMapAdd    
Public class CLogicalScope A scope that can contain definitions  
Public class CMapType A parametric type of maps with specific key and value types: [t]u where t&u:type  
Public class CMemberDefinitions Represents members of a class/interface/module/snippet definition node  
Public class CModule Semantically represents a module  
Public class CModuleAlias An imported module: Alias := import(...)  
Public class CModulePart Semantically represents a partial module aka a module definition either via vmodule file or module macro Always is directly parented to a CModule  
Public class CNamedType    
Public class CNominalType Class defining instance and class objects.  
Public class CNormalType A normal type: a head normal form of types where the head is not a parametric type instantiation.  
Public class COptionType Option type  
Public class CPointerType Represents a pointer to mutable inner type.  
Public class CReferenceType Represents a reference to (possibly mutable) inner type.  
Public class CScope A nested scope - program, module or class  
Public class CScopedAccessLevelDefinition AccessLevelDefinition type HACK! This is convoluted, but attributes need to be CClass types because the semantic attribute processing demands it right now HACK! CClass expects its associated definition to be a CClassDefinition type, so our CScopedAccessLevelDefinition also needs to be a CClassDefinition type HACK! Ordinarily, we could just use CClassDefinition directly without this extra child type, except the CClassDefinition linkage to the AST demands HACK! that the CExpr* type be CExprClassDefinition even though it ultimately relaxes to CExpressionBase.  
Public class CSemanticProgram Stores whole parsed semantic hierarchy/infrastructure  
Public class CSnippet Semantically represents a snippet  
Public class CTupleType    
Public class CTypeAlias Maps a name to a type  
Public class CTypeBase Base class for all types.  
Public class CTypeScope The implicit scope of a type.  
Public class CTypeType    
Public class CTypeVariable    
Public class CUnknownType An unknown type - can optionally contain a list of possibly valid types  
Public class CValueType Abstract type that has an additional sub-type representing a value (ex: List)  
Public struct SAccessibilityScope    
Public struct SAccessLevel Mostly a wrapper around SAccessLevel::EKind with the addition of an optional list of modules for the 'scoped' access level.  
Public struct SAstNodeTypeInfo    
Public struct SAstVisitor Abstract base for applying some operation / iterating through AST structures.  
Public struct SAttribute    
Public struct SClassVarAccessorFunctions    
Public struct SDecompositionMapping    
Public struct SDigestScope    
Public struct SEffectDescriptor    
Public struct SEffectInfo    
Public struct SEffectSet    
Public struct SEffectSetBase    
Public struct SInstantiatedTypeVariable    
Public struct SQualifier Information about a given qualifier.  
Public struct SResolvedDefinition Stores a resolved definition and the context that it was resolved from  
Public struct SSignature Type signature / parameter interface for routines/invokables  
Public struct STypeVariableSubstitution    
Public struct TAsNullableTraitsOf    
Public struct TAstFunctionVisitor CAstNode Implementations.  
Public class TAstNodeRef Reference to a pair of AST and IR nodes  
Public class TFilteredDefinitionRange Filters a range of definitions to only include definitions of the kind corresponding to FilterClass.  

Constants

Name Description
uLang::DefaultVarAccessLevelKind  

Typedefs

Name Description
CAnyType  
CAstNodeRef  
CChar32Type  
CChar8Type  
CComparableType  
CFalseType  
CLogicType  
CPathType  
CPersistableType  
CRangeType  
CRationalType  
CTrueType  
CVoidType  
SemanticRevision For storing revisions of functions, classes etc.
SmallDefinitionArray  
SResolvedDefinitionArray An array of resolved definitions and their associated contexts
VisitStampType Used to mark scopes already visited during a search.

Enums

  Type Name Description
Public enum uLang::EAstNodeType 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.  
Public enum uLang::EComparability Characterizes whether a type is comparable and hashable, just comparable, or incomparable.  
Public enum uLang::EEffect Copyright Epic Games, Inc. All Rights Reserved.  
Public enum uLang::EExtensionFieldAccessorKind No longer used, but good ideas enum class EFunctionStringFlag : uint16t { / Name part - omitted or one of: Name = 1<<0, // Prepend name of function Qualified = 1<<1, // Prepends the scope `(/MyModule:) and then the name of the function/ Type signature part - omitted or one of: SigSimple = 1<<2, // Include just parentheses () SigTyped = 1<<3, // Include parentheses (), any parameter names and types and result type (param1 : Type1, param2 : Type2) : ResultType SigDefaults = 1<<4, // Include parentheses (), any parameter names, types and defaults and result type (param1 : Type1, param2 : Type2 = default2 ) : ResultType/ Body - omitted or one of: BodyIndicator = 1<<5, // {...} for uLang body and empty for atomic C++ body Body = 1<<6, // full uLang body or empty for atomic C++ body/ Spacing - omitted (canonical with multi-line) or: Inline = 1<<7, // try to have everything on one line/ Masks Default_ = Qualified|SigDefaults|Body, // MyClass@function(param1 : Type1, param2 : Type2 = default2 ) : ResultType { } DefaultUnnamed_ = SigDefaults|Body, // (param1 : Type1, param2 : Type2 = default2 ) : ResultType { } DefaultIdent_ = Qualified|SigSimple, // MyClass@function()Named_ = Name|Qualified, Signature_ = SigSimple|SigTyped|SigDefaults, Body_ = BodyIndicator|Body, Unimplemented_ = SigTyped|SigDefaults|Body }; Distinguishes extension field accessor functions from other functions.  
Public enum uLang::EFunctionStringFlag Copyright Epic Games, Inc. All Rights Reserved.  
Public enum uLang::EInvokeTime Indicates whether an expression should return immediately - such as functions, after a duration (including immediately) such as coroutines or either.  
Public enum uLang::EMacroClauseTag Copyright Epic Games, Inc. All Rights Reserved.  
Public enum uLang::EMemberOrigin Specifies whether to find only member definitions originating in the current type, or inherited, or either.  
Public enum uLang::EStructOrClass Copyright Epic Games, Inc. All Rights Reserved.  
Public enum uLang::ETypeKind Copyright Epic Games, Inc. All Rights Reserved.  
Public enum uLang::ETypePolarity Copyright Epic Games, Inc. All Rights Reserved.  
Public enum uLang::ETypeSyntaxPrecedence Copyright Epic Games, Inc. All Rights Reserved.  
Public enum uLang::EVstMappingType Copyright Epic Games, Inc. All Rights Reserved.  
Public enum uLang::SemanticTypeUtils::EIsEditable Returns whether a type can be used with @editable.  

Functions

  Type Name Description
Public function Traits::TResult

uLang::AsNullable ( TIn Expr
)

  
Public function TIterator

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

  
Public function ETypePolarity  
Public function bool  
Public function bool  
Public function const char *  
Public function const char *  
Public function const char *  
Public function EMacroClauseTag  
Public function SEffectSet

uLang::operator| ( const EEffect Lhs,
const EEffect Rhs
)

  
Public function bool

uLang::SemanticTypeUtils::AreDomainsDistinct ( const CTypeBase* DomainType1,
const CTypeBase* DomainType2
)

 Determine whether there two types are distinct; i.e. that there are no values that are members of both types.
Public function const CTypeBase &  
Public function const CTypeBase &  
Public function const CTypeBase &  
Public function const CClass *

uLang::SemanticTypeUtils::AsSingleClass ( const CNormalType& NegativeType,
const CNormalType& PositiveType
)

  
Public function const CInterface *

uLang::SemanticTypeUtils::AsSingleInterface ( const CNormalType& NegativeType,
const CNormalType& PositiveType
)

  
Public function const CTupleType &  
Public function const CFunctionType &  
Public function const CTypeBase & Replace all types with equivalent representations with a single canonical type - the type used when emitting code.
Public function bool

uLang::SemanticTypeUtils::Constrain ( const CTypeBase* PositiveType1,
const CTypeBase* NegativeType2
)

 Constrain PositiveType1_ to be a subtype of NegativeType2_
Public function void Apply a function to each immediately possibly contained value's type.
Public function void `ForEachDataType_, but recursive, and depth-first, top-down, including the immediately passed type.
Public function const CFunctionType *  
Public function TArray< STypeVariableSubstitution >

uLang::SemanticTypeUtils::Instantiate ( const TArray< const CTypeVariable* >& TypeVariables
)

  
Public function bool  
Public function const char *  
Public function EIsEditable

uLang::SemanticTypeUtils::IsEditableType ( const uLang::CTypeBase* Type,
bool bAllowNonConcreteClasses
)

  
Public function bool

uLang::SemanticTypeUtils::IsEquivalent ( const CTypeBase* PositiveType1,
const CTypeBase* PositiveType2
)

 Determine if PositiveType1_ is equivalent to PositiveType2_
Public function bool Returns whether the type is string, i.e. []char8.
Public function bool

uLang::SemanticTypeUtils::IsSubtype ( const CTypeBase* PositiveType1,
const CTypeBase* PositiveType2
)

 Determine if PositiveType1_ is a subtype of PositiveType2_
Public function bool  
Public function const CTypeBase *

uLang::SemanticTypeUtils::Join ( const CTypeBase* Type1,
const CTypeBase* Type2
)

 Compute the join of Type1 and Type2: the "least" type that contains all values contained by either Type1 or Type2.
Public function bool

uLang::SemanticTypeUtils::Matches ( const CTypeBase* PositiveType1,
const CTypeBase* NegativeType2
)

 Determine if argument PositiveType1_ is a match for parameter NegativeType2_
Public function const CTypeBase *

uLang::SemanticTypeUtils::Meet ( const CTypeBase* Type1,
const CTypeBase* Type2
)

 Compute the meet of Type1 and Type2: the "greatest" type that contains only values contained by both Type1 and Type2.
Public function const CTypeBase &  
Public function const CTypeBase &  
Public function const CTypeBase &  
Public function const CTypeBase *  
Public function void

uLang::SemanticTypeUtils::VisitAllDefinitions ( const CTypeBase* Type,
const TFunction< void(const CDefinition&, const CSymbol&)>& Functor
)

  

Variables

  Type Name Description
Public variable SEffectSet Allocates  
Public variable SEffectSet ClassDefault Contextual defaults.
Public variable SEffectSet Computes  
Public variable SEffectSet Converges Singular effects.
Public variable SEffectSet Decides  
Public variable SEffectSet FunctionDefault  
Public variable SEffectSet ModuleDefault  
Public variable SEffectSet NoRollback  
Public variable SEffectSet Reads  
Public variable SEffectSet Suspends  
Public variable SEffectSet Transacts Aggregate effects.
Public variable SEffectSet VariesDeprecated  
Public variable SEffectSet Writes  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page