12. AST manipulation library

The AST module implements compilation time reflection for the Daslang syntax tree.

All functions and symbols are in “ast” module, use require to get access to it.

require ast

12.1. Type aliases

TypeDeclFlags is a bitfield

field	bit	value
ref	0	1
constant	1	2
temporary	2	4
_implicit	3	8
removeRef	4	16
removeConstant	5	32
removeDim	6	64
removeTemporary	7	128
explicitConst	8	256
aotAlias	9	512
smartPtr	10	1024
smartPtrNative	11	2048
isExplicit	12	4096
isNativeDim	13	8192
isTag	14	16384
explicitRef	15	32768
isPrivateAlias	16	65536
autoToAlias	17	131072

properties of the TypeDecl object.

FieldDeclarationFlags is a bitfield

field	bit	value
moveSemantics	0	1
parentType	1	2
capturedConstant	2	4
generated	3	8
capturedRef	4	16
doNotDelete	5	32
privateField	6	64
_sealed	7	128
implemented	8	256

properties of the FieldDeclaration object.

StructureFlags is a bitfield

field	bit	value
isClass	0	1
genCtor	1	2
cppLayout	2	4
cppLayoutNotPod	3	8
generated	4	16
persistent	5	32
isLambda	6	64
privateStructure	7	128
macroInterface	8	256
_sealed	9	512
skipLockCheck	10	1024
circular	11	2048
_generator	12	4096
hasStaticMembers	13	8192
hasStaticFunctions	14	16384
hasInitFields	15	32768
safeWhenUninitialized	16	65536

properties of the Structure object.

ExprGenFlags is a bitfield

field	bit	value
alwaysSafe	0	1
generated	1	2
userSaidItsSafe	2	4

generation (genFlags) properties of the Expression object.

ExprLetFlags is a bitfield

field	bit	value
inScope	0	1
hasEarlyOut	1	2
itTupleExpansion	2	4

properties of the ExprLet object.

ExprFlags is a bitfield

field	bit	value
constexpression	0	1
noSideEffects	1	2
noNativeSideEffects	2	4
isForLoopSource	3	8
isCallArgument	4	16

properties of the Expression object.

ExprPrintFlags is a bitfield

field	bit	value
topLevel	0	1
argLevel	1	2
bottomLevel	2	4

printing properties of the Expression object.

FunctionFlags is a bitfield

field	bit	value
builtIn	0	1
policyBased	1	2
callBased	2	4
interopFn	3	8
hasReturn	4	16
copyOnReturn	5	32
moveOnReturn	6	64
exports	7	128
init	8	256
addr	9	512
used	10	1024
fastCall	11	2048
knownSideEffects	12	4096
hasToRunAtCompileTime	13	8192
unsafeOperation	14	16384
unsafeDeref	15	32768
hasMakeBlock	16	65536
aotNeedPrologue	17	131072
noAot	18	262144
aotHybrid	19	524288
aotTemplate	20	1048576
generated	21	2097152
privateFunction	22	4194304
_generator	23	8388608
_lambda	24	16777216
firstArgReturnType	25	33554432
noPointerCast	26	67108864
isClassMethod	27	134217728
isTypeConstructor	28	268435456
shutdown	29	536870912
anyTemplate	30	1073741824
macroInit	31	-2147483648

properties of the Function object.

MoreFunctionFlags is a bitfield

field	bit	value
macroFunction	0	1
needStringCast	1	2
aotHashDeppendsOnArguments	2	4
lateInit	3	8
requestJit	4	16
unsafeOutsideOfFor	5	32
skipLockCheck	6	64
safeImplicit	7	128
deprecated	8	256
aliasCMRES	9	512
neverAliasCMRES	10	1024
addressTaken	11	2048
propertyFunction	12	4096
pinvoke	13	8192
jitOnly	14	16384
isStaticClassMethod	15	32768
requestNoJit	16	65536
jitContextAndLineInfo	17	131072
nodiscard	18	262144
captureString	19	524288
callCaptureString	20	1048576
hasStringBuilder	21	2097152

additional properties of the Function object.

FunctionSideEffectFlags is a bitfield

field	bit	value
_unsafe	0	1
userScenario	1	2
modifyExternal	2	4
modifyArgument	3	8
accessGlobal	4	16
invoke	5	32

side-effect properties of the Function object.

VariableFlags is a bitfield

field	bit	value
init_via_move	0	1
init_via_clone	1	2
used	2	4
aliasCMRES	3	8
marked_used	4	16
global_shared	5	32
do_not_delete	6	64
generated	7	128
capture_as_ref	8	256
can_shadow	9	512
private_variable	10	1024
tag	11	2048
global	12	4096
inScope	13	8192
no_capture	14	16384
early_out	15	32768
used_in_finally	16	65536
static_class_member	17	131072

properties of the Variable object.

VariableAccessFlags is a bitfield

field	bit	value
access_extern	0	1
access_get	1	2
access_ref	2	4
access_init	3	8
access_pass	4	16

access properties of the Variable object.

ExprBlockFlags is a bitfield

field	bit	value
isClosure	0	1
hasReturn	1	2
copyOnReturn	2	4
moveOnReturn	3	8
inTheLoop	4	16
finallyBeforeBody	5	32
finallyDisabled	6	64
aotSkipMakeBlock	7	128
aotDoNotSkipAnnotationData	8	256
isCollapseable	9	512
needCollapse	10	1024
hasMakeBlock	11	2048
hasEarlyOut	12	4096
forLoop	13	8192

properties of the ExrpBlock object.

ExprAtFlags is a bitfield

field	bit	value
r2v	0	1
r2cr	1	2
write	2	4
no_promotion	3	8

properties of the ExprAt object.

ExprMakeLocalFlags is a bitfield

field	bit	value
useStackRef	0	1
useCMRES	1	2
doesNotNeedSp	2	4
doesNotNeedInit	3	8
initAllFields	4	16
alwaysAlias	5	32

properties of the ExprMakeLocal object (ExprMakeArray, ExprMakeStruct, ‘ExprMakeTuple’, ‘ExprMakeVariant’).

ExprAscendFlags is a bitfield

field	bit	value
useStackRef	0	1
needTypeInfo	1	2
isMakeLambda	2	4

properties of the ExprAscend object.

ExprCastFlags is a bitfield

field	bit	value
upcastCast	0	1
reinterpretCast	1	2

properties of the ExprCast object.

ExprVarFlags is a bitfield

field	bit	value
local	0	1
argument	1	2
_block	2	4
thisBlock	3	8
r2v	4	16
r2cr	5	32
write	6	64
under_clone	7	128

properties of the ExprVar object.

ExprMakeStructFlags is a bitfield

field	bit	value
useInitializer	0	1
isNewHandle	1	2
usedInitializer	2	4
nativeClassInitializer	3	8
isNewClass	4	16
forceClass	5	32
forceStruct	6	64
forceVariant	7	128
forceTuple	8	256
alwaysUseInitializer	9	512

properties of the ExprMakeStruct object.

MakeFieldDeclFlags is a bitfield

field	bit	value
moveSemantics	0	1
cloneSemantics	1	2

properties of the MakeFieldDecl object.

ExprFieldDerefFlags is a bitfield

field	bit	value
unsafeDeref	0	1
ignoreCaptureConst	1	2

dereferencing properties of the ExprField object.

ExprFieldFieldFlags is a bitfield

field	bit	value
r2v	0	1
r2cr	1	2
write	2	4
no_promotion	3	8
under_clone	4	16

field properties of the ExprField object.

ExprSwizzleFieldFlags is a bitfield

field	bit	value
r2v	0	1
r2cr	1	2
write	2	4

properties of the ExprSwizzle object.

ExprYieldFlags is a bitfield

field	bit	value
moveSemantics	0	1
skipLockCheck	1	2

properties of the ExprYield object.

ExprReturnFlags is a bitfield

field	bit	value
moveSemantics	0	1
returnReference	1	2
returnInBlock	2	4
takeOverRightStack	3	8
returnCallCMRES	4	16
returnCMRES	5	32
fromYield	6	64
fromComprehension	7	128
skipLockCheck	8	256

properties of the ExprReturn object.

ExprMakeBlockFlags is a bitfield

field	bit	value
isLambda	0	1
isLocalFunction	1	2

properties of the ExprMakeBlock object.

CopyFlags is a bitfield

field	bit	value
allowCopyTemp	0	1
takeOverRightStack	1	2
promoteToClone	2	4

properties of the ExprCopy object.

MoveFlags is a bitfield

field	bit	value
skipLockCheck	0	1
takeOverRightStack	1	2

properties of the ExprMove object.

IfFlags is a bitfield

field	bit	value
isStatic	0	1
doNotFold	1	2

properties of the ExprIf object.

ExpressionPtr = smart_ptr<Expression>

Smart pointer to Expression object.

ProgramPtr = smart_ptr<Program>

Smart pointer to Program object.

TypeDeclPtr = smart_ptr<TypeDecl>

Smart pointer to TypeDecl object.

VectorTypeDeclPtr = dasvector`smart_ptr`TypeDecl

Smart pointer to das::vector<ExpressionPtr>.

EnumerationPtr = smart_ptr<Enumeration>

Smart pointer to Enumeration object.

StructurePtr = smart_ptr<Structure>

Smart pointer to Structure object.

FunctionPtr = smart_ptr<Function>

Smart pointer to Function object.

VariablePtr = smart_ptr<Variable>

Smart pointer to Variable object.

MakeFieldDeclPtr = smart_ptr<MakeFieldDecl>

Smart pointer to MakeFieldDecl object.

FunctionAnnotationPtr = smart_ptr<FunctionAnnotation>

Smart pointer to FunctionAnnotation object.

StructureAnnotationPtr = smart_ptr<StructureAnnotation>

Smart pointer to StructureAnnotation object.

EnumerationAnnotationPtr = smart_ptr<EnumerationAnnotation>

Smart pointer to EnumerationAnnotation object.

PassMacroPtr = smart_ptr<PassMacro>

Smart pointer to PassMacro object.

VariantMacroPtr = smart_ptr<VariantMacro>

Smart pointer to VariantMacro object.

ReaderMacroPtr = smart_ptr<ReaderMacro>

Smart pointer to ReaderMacro object.

CommentReaderPtr = smart_ptr<CommentReader>

Smart pointer to CommentReader object.

CallMacroPtr = smart_ptr<CallMacro>

Smart pointer to CallMacro object.

TypeInfoMacroPtr = smart_ptr<TypeInfoMacro>

Smart pointer to TypeInfoMacro object.

ForLoopMacroPtr = smart_ptr<ForLoopMacro>

Smart pointer to ‘ForLoopMacro’.

CaptureMacroPtr = smart_ptr<CaptureMacro>

Smart pointer to ‘CaptureMacro’.

TypeMacroPtr = smart_ptr<TypeMacro>

Smart pointer to TypeMacro object.

SimulateMacroPtr = smart_ptr<SimulateMacro>

Smart pointer to SimulateMacro object.

12.2. Enumerations

SideEffects

none	0
unsafe	1
userScenario	2
modifyExternal	4
accessExternal	4
modifyArgument	8
modifyArgumentAndExternal	12
worstDefault	12
accessGlobal	16
invoke	32
inferredSideEffects	56

Enumeration with all possible side effects of expression or function.

CaptureMode

capture_any	0
capture_by_copy	1
capture_by_reference	2
capture_by_clone	3
capture_by_move	4

Enumeration with lambda variables capture modes.

12.3. Handled structures

ModuleLibrary

Object which holds list of Module and provides access to them.

Expression

Expression fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Any expression (base class).

TypeDecl

TypeDecl fields are

alias	builtin::das_string
annotation	rtti::TypeAnnotation ?
dimExpr	vector<smart_ptr<Expression>>
argTypes	vector<smart_ptr<TypeDecl>>
dim	vector<int>
_module	rtti::Module ?
secondType	smart_ptr< ast::TypeDecl >
at	rtti::LineInfo
enumType	ast::Enumeration ?
argNames	vector<das_string>
baseType	rtti::Type
firstType	smart_ptr< ast::TypeDecl >
structType	ast::Structure ?
flags	TypeDeclFlags

TypeDecl property operators are

canAot	bool
isExprType	bool
isSimpleType	bool
isArray	bool
isGoodIteratorType	bool
isGoodArrayType	bool
isGoodTableType	bool
isGoodBlockType	bool
isGoodFunctionType	bool
isGoodLambdaType	bool
isGoodTupleType	bool
isGoodVariantType	bool
isVoid	bool
isRef	bool
isRefType	bool
canWrite	bool
isAotAlias	bool
isShareable	bool
isIndex	bool
isBool	bool
isInteger	bool
isSignedInteger	bool
isUnsignedInteger	bool
isSignedIntegerOrIntVec	bool
isUnsignedIntegerOrIntVec	bool
isFloatOrDouble	bool
isNumeric	bool
isNumericComparable	bool
isPointer	bool
isSmartPointer	bool
isVoidPointer	bool
isIterator	bool
isEnum	bool
isEnumT	bool
isHandle	bool
isStructure	bool
isClass	bool
isFunction	bool
isTuple	bool
isVariant	bool
sizeOf	int
countOf	int
alignOf	int
baseSizeOf	int
stride	int
tupleSize	int
tupleAlign	int
variantSize	int
variantAlign	int
canCopy	bool
canMove	bool
canClone	bool
canNew	bool
canDeletePtr	bool
canDelete	bool
needDelete	bool
isPod	bool
isRawPod	bool
isNoHeapType	bool
isWorkhorseType	bool
isPolicyType	bool
isVecPolicyType	bool
isReturnType	bool
isCtorType	bool
isRange	bool
isString	bool
isConst	bool
isFoldable	bool
isAlias	bool
isAutoArrayResolved	bool
isAuto	bool
isAutoOrAlias	bool
isVectorType	bool
isBitfield	bool
isLocal	bool
hasClasses	bool
hasNonTrivialCtor	bool
hasNonTrivialDtor	bool
hasNonTrivialCopy	bool
canBePlacedInContainer	bool
vectorBaseType	rtti::Type
vectorDim	int
canInitWithZero	bool
rangeBaseType	rtti::Type
unsafeInit	bool

Any type declaration.

Structure

Structure fields are

_module	rtti::Module ?
at	rtti::LineInfo
parent	ast::Structure ?
annotations	rtti::AnnotationList
name	builtin::das_string
fields	vector<FieldDeclaration>
flags	StructureFlags

Structure declaration.

FieldDeclaration

FieldDeclaration fields are

annotation	rtti::AnnotationArgumentList
at	rtti::LineInfo
name	builtin::das_string
init	smart_ptr< ast::Expression >
offset	int
_type	smart_ptr< ast::TypeDecl >
flags	FieldDeclarationFlags

Structure field declaration.

EnumEntry

EnumEntry fields are

value	smart_ptr< ast::Expression >
at	rtti::LineInfo
name	builtin::das_string

Entry in the enumeration.

Enumeration

Enumeration fields are

_module	rtti::Module ?
at	rtti::LineInfo
isPrivate	bool
cppName	builtin::das_string
list	vector<EnumEntry>
annotations	rtti::AnnotationList
name	builtin::das_string
external	bool
baseType	rtti::Type

Enumeration declaration.

Function

Function fields are

arguments	vector<smart_ptr<Variable>>
fromGeneric	smart_ptr< ast::Function >
result	smart_ptr< ast::TypeDecl >
aotHash	uint64
totalGenLabel	int
_module	rtti::Module ?
index	int
at	rtti::LineInfo
inferStack	vector<InferHistory>
body	smart_ptr< ast::Expression >
atDecl	rtti::LineInfo
sideEffectFlags	FunctionSideEffectFlags
annotations	rtti::AnnotationList
totalStackSize	uint
name	builtin::das_string
moreFlags	MoreFunctionFlags
hash	uint64
classParent	ast::Structure ?
flags	FunctionFlags

Function property operators are

origin	ast::Function ?
isGeneric	bool

Function declaration.

InferHistory

InferHistory fields are

func	ast::Function ?
at	rtti::LineInfo

Generic function infer history. Contains stack on where the function was first instantiated from (Function and LineInfo pairs).

Variable

Variable fields are

annotation	rtti::AnnotationArgumentList
initStackSize	uint
_module	rtti::Module ?
index	int
at	rtti::LineInfo
stackTop	uint
name	builtin::das_string
init	smart_ptr< ast::Expression >
_aka	builtin::das_string
access_flags	VariableAccessFlags
source	smart_ptr< ast::Expression >
_type	smart_ptr< ast::TypeDecl >
flags	VariableFlags

Variable property operators are

isAccessUnused	bool

Variable declaration.

AstContext

AstContext fields are

func	smart_ptr< ast::Function >
scopes	vector<smart_ptr<Expression>>
blocks	vector<smart_ptr<Expression>>
_loop	vector<smart_ptr<Expression>>
_with	vector<smart_ptr<Expression>>

Lexical context for the particular expression. Contains current function, loops, blocks, scopes, and with sections.

ExprBlock

ExprBlock fields are

stackVarBottom	uint
annotationDataSid	uint64
arguments	vector<smart_ptr<Variable>>
at	rtti::LineInfo
stackCleanVars	vector<pair`uint`uint>
list	vector<smart_ptr<Expression>>
returnType	smart_ptr< ast::TypeDecl >
printFlags	ExprPrintFlags
annotations	rtti::AnnotationList
stackTop	uint
maxLabelIndex	int
blockFlags	ExprBlockFlags
finalList	vector<smart_ptr<Expression>>
genFlags	ExprGenFlags
annotationData	uint64
stackVarTop	uint
flags	ExprFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const

Any block expression, including regular blocks and all types of closures. For the closures block arguments are defined. Finally section is defined, if exists.

ExprLet

ExprLet fields are

atInit	rtti::LineInfo
at	rtti::LineInfo
letFlags	ExprLetFlags
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
variables	vector<smart_ptr<Variable>>
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Local variable declaration (let v = expr;).

ExprStringBuilder

ExprStringBuilder fields are

stringBuilderFlags	StringBuilderFlags
at	rtti::LineInfo
elements	vector<smart_ptr<Expression>>
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

String builder expression (“blah{blah1}blah2”).

MakeFieldDecl

MakeFieldDecl fields are

value	smart_ptr< ast::Expression >
at	rtti::LineInfo
name	builtin::das_string
tag	smart_ptr< ast::Expression >
flags	MakeFieldDeclFlags

Part of ExprMakeStruct, declares single field (a = expr or a <- expr etc)

ExprNamedCall

ExprNamedCall fields are

arguments	ast::MakeStruct
at	rtti::LineInfo
nonNamedArguments	vector<smart_ptr<Expression>>
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Named call (call([argname1=expr1, argname2=expr2])).

ExprLooksLikeCall

ExprLooksLikeCall fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Anything which looks like call (call(expr1,expr2)).

ExprCallFunc

ExprCallFunc fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Actual function call (func(expr1,…)).

ExprNew

ExprNew fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
typeexpr	smart_ptr< ast::TypeDecl >
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
initializer	bool
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

New expression (new Foo, new Bar(expr1..), but NOT new [[Foo …]])

ExprCall

ExprCall fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
arguments	vector<smart_ptr<Expression>>
notDiscarded	bool
at	rtti::LineInfo
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
cmresAlias	bool
doesNotNeedSp	bool
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Anything which looks like call (call(expr1,expr2)).

ExprPtr2Ref

ExprPtr2Ref fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
unsafeDeref	bool
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
assumeNoAlias	bool
__rtti	string const

Pointer dereference (*expr or deref(expr)).

ExprNullCoalescing

ExprNullCoalescing fields are

defaultValue	smart_ptr< ast::Expression >
at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
unsafeDeref	bool
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
assumeNoAlias	bool
__rtti	string const

Null coalescing (expr1 ?? expr2).

ExprAt

ExprAt fields are

index	smart_ptr< ast::Expression >
at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
atFlags	ExprAtFlags

Index lookup (expr[expr1]).

ExprSafeAt

ExprSafeAt fields are

index	smart_ptr< ast::Expression >
at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
atFlags	ExprAtFlags

Safe index lookup (expr?[expr1]).

ExprIs

ExprIs fields are

typeexpr	smart_ptr< ast::TypeDecl >
at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Is expression for variants and such (expr is Foo).

ExprOp

Compilation time only base class for any operator.

ExprOp2

ExprOp2 fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
arguments	vector<smart_ptr<Expression>>
right	smart_ptr< ast::Expression >
at	rtti::LineInfo
op	builtin::das_string
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
left	smart_ptr< ast::Expression >

Two operand operator (expr1 + expr2)

ExprOp3

ExprOp3 fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
arguments	vector<smart_ptr<Expression>>
right	smart_ptr< ast::Expression >
at	rtti::LineInfo
op	builtin::das_string
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
subexpr	smart_ptr< ast::Expression >
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
left	smart_ptr< ast::Expression >

Three operand operator (cond ? expr1 : expr2)

ExprCopy

ExprCopy fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
arguments	vector<smart_ptr<Expression>>
right	smart_ptr< ast::Expression >
at	rtti::LineInfo
copy_flags	CopyFlags
op	builtin::das_string
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
left	smart_ptr< ast::Expression >

Copy operator (expr1 = expr2)

ExprMove

ExprMove fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
arguments	vector<smart_ptr<Expression>>
right	smart_ptr< ast::Expression >
at	rtti::LineInfo
op	builtin::das_string
move_flags	MoveFlags
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
left	smart_ptr< ast::Expression >

Move operator (expr1 <- expr2)

ExprClone

ExprClone fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
arguments	vector<smart_ptr<Expression>>
right	smart_ptr< ast::Expression >
at	rtti::LineInfo
op	builtin::das_string
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
left	smart_ptr< ast::Expression >

Clone operator (expr1 := expr2)

ExprWith

ExprWith fields are

at	rtti::LineInfo
body	smart_ptr< ast::Expression >
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_with	smart_ptr< ast::Expression >
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

With section (with expr {your; block; here}).

ExprAssume

ExprAssume fields are

alias	builtin::das_string
at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Assume expression (assume name = expr).

ExprWhile

ExprWhile fields are

at	rtti::LineInfo
body	smart_ptr< ast::Expression >
cond	smart_ptr< ast::Expression >
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

While loop (while expr {your; block; here;})

ExprTryCatch

ExprTryCatch fields are

try_block	smart_ptr< ast::Expression >
at	rtti::LineInfo
catch_block	smart_ptr< ast::Expression >
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Try-recover expression (try {your; block; here;} recover {your; recover; here;})

ExprIfThenElse

ExprIfThenElse fields are

if_flags	IfFlags
at	rtti::LineInfo
if_false	smart_ptr< ast::Expression >
cond	smart_ptr< ast::Expression >
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
if_true	smart_ptr< ast::Expression >
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

If-then-else expression (if expr1 {your; block; here;} else {your; block; here;}) including static_if’s.

ExprFor

ExprFor fields are

visibility	rtti::LineInfo
allowIteratorOptimization	bool
canShadow	bool
iteratorsTags	vector<smart_ptr<Expression>>
at	rtti::LineInfo
body	smart_ptr< ast::Expression >
iteratorsAt	vector<LineInfo>
printFlags	ExprPrintFlags
iterators	vector<das_string>
iteratorVariables	vector<smart_ptr<Variable>>
genFlags	ExprGenFlags
iteratorsAka	vector<das_string>
sources	vector<smart_ptr<Expression>>
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

For loop (for expr1 in expr2 {your; block; here;})

ExprMakeLocal

ExprMakeLocal fields are

makeType	smart_ptr< ast::TypeDecl >
at	rtti::LineInfo
printFlags	ExprPrintFlags
makeFlags	ExprMakeLocalFlags
stackTop	uint
extraOffset	uint
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Any make expression (ExprMakeBlock, ExprMakeTuple, ExprMakeVariant, ExprMakeStruct)

ExprMakeStruct

ExprMakeStruct fields are

makeType	smart_ptr< ast::TypeDecl >
constructor	ast::Function ?
at	rtti::LineInfo
structs	vector<smart_ptr<MakeStruct>>
printFlags	ExprPrintFlags
makeFlags	ExprMakeLocalFlags
stackTop	uint
extraOffset	uint
genFlags	ExprGenFlags
_block	smart_ptr< ast::Expression >
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
makeStructFlags	ExprMakeStructFlags

Make structure expression ([[YourStruct v1=expr1elem1, v2=expr2elem1, …; v1=expr1elem2, … ]])

ExprMakeVariant

ExprMakeVariant fields are

variants	vector<smart_ptr<MakeFieldDecl>>
makeType	smart_ptr< ast::TypeDecl >
at	rtti::LineInfo
printFlags	ExprPrintFlags
makeFlags	ExprMakeLocalFlags
stackTop	uint
extraOffset	uint
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Make variant expression ([YourVariant variantName=expr1])

ExprMakeArray

ExprMakeArray fields are

makeType	smart_ptr< ast::TypeDecl >
values	vector<smart_ptr<Expression>>
at	rtti::LineInfo
recordType	smart_ptr< ast::TypeDecl >
printFlags	ExprPrintFlags
makeFlags	ExprMakeLocalFlags
stackTop	uint
extraOffset	uint
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Make array expression ([[auto 1;2;3]] or [{auto “foo”;”bar”}] for static and dynamic arrays accordingly).

ExprMakeTuple

ExprMakeTuple fields are

makeType	smart_ptr< ast::TypeDecl >
values	vector<smart_ptr<Expression>>
at	rtti::LineInfo
recordType	smart_ptr< ast::TypeDecl >
printFlags	ExprPrintFlags
makeFlags	ExprMakeLocalFlags
stackTop	uint
extraOffset	uint
genFlags	ExprGenFlags
isKeyValue	bool
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Make tuple expression ([[auto f1,f2,f3]])

ExprArrayComprehension

ExprArrayComprehension fields are

tableSyntax	bool
at	rtti::LineInfo
printFlags	ExprPrintFlags
generatorSyntax	bool
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
exprFor	smart_ptr< ast::Expression >
exprWhere	smart_ptr< ast::Expression >
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Array comprehension ([{for x in 0..3; x}], [[for y in range(100); x*2; where x!=13]] for arrays or generators accordingly).

TypeInfoMacro

TypeInfoMacro fields are

_module	rtti::Module ?
name	builtin::das_string

Compilation time only structure which holds live information about typeinfo expression for the specific macro.

ExprTypeInfo

ExprTypeInfo fields are

typeexpr	smart_ptr< ast::TypeDecl >
extratrait	builtin::das_string
macro	ast::TypeInfoMacro ?
subtrait	builtin::das_string
at	rtti::LineInfo
trait	builtin::das_string
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

typeinfo() expression (typeinfo(dim a), typeinfo(is_ref_type type<int&>))

ExprTypeDecl

ExprTypeDecl fields are

typeexpr	smart_ptr< ast::TypeDecl >
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

typedecl() expression (typedecl(1+2))

ExprLabel

ExprLabel fields are

comment	builtin::das_string
at	rtti::LineInfo
labelName	int
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Label (label 13:)

ExprGoto

ExprGoto fields are

at	rtti::LineInfo
labelName	int
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Goto expression (goto label 13, goto x)

ExprRef2Value

ExprRef2Value fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Compilation time only structure which holds reference to value conversion for the value types, i.e. goes from int& to int and such.

ExprRef2Ptr

ExprRef2Ptr fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Addr expresion (addr(expr))

ExprAddr

ExprAddr fields are

func	ast::Function ?
target	builtin::das_string
at	rtti::LineInfo
funcType	smart_ptr< ast::TypeDecl >
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Function address (@@foobarfunc or @@foobarfunc<(int;int):bool>)

ExprAssert

ExprAssert fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
isVerify	bool
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Assert expression (assert(x<13) or assert(x<13, “x is too big”))

ExprQuote

ExprQuote fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Compilation time expression which holds its subexpressions but does not infer them (quote() <| x+5)

ExprStaticAssert

ExprStaticAssert fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Static assert expression (static_assert(x<13) or static_assert(x<13, “x is too big”))

ExprDebug

ExprDebug fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Debug expression (debug(x) or debug(x,”x=”))

ExprInvoke

ExprInvoke fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
isInvokeMethod	bool
doesNotNeedSp	bool
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Invoke expression (invoke(fn) or invoke(lamb, arg1, arg2, …))

ExprErase

ExprErase fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Erase expression (erase(tab,key))

ExprSetInsert

ExprSetInsert fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

insert(tab, at) for the table<keyType; void> aka table<keyType>

ExprFind

ExprFind fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Find expression (find(tab,key) <| { your; block; here; })

ExprKeyExists

ExprKeyExists fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Key exists expression (key_exists(tab,key))

ExprAscend

ExprAscend fields are

ascType	smart_ptr< ast::TypeDecl >
at	rtti::LineInfo
printFlags	ExprPrintFlags
stackTop	uint
ascendFlags	ExprAscendFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

New expression for ExprMakeLocal (new [[Foo fld=val,…]] or new [[Foo() fld=…]], but NOT new Foo())

ExprCast

ExprCast fields are

castFlags	ExprCastFlags
at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
castType	smart_ptr< ast::TypeDecl >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Any cast expression (cast<int> a, upcast<Foo> b or reinterpret<Bar?> c)

ExprDelete

ExprDelete fields are

at	rtti::LineInfo
sizeexpr	smart_ptr< ast::Expression >
native	bool
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Delete expression (delete blah)

ExprVar

ExprVar fields are

at	rtti::LineInfo
variable	smart_ptr< ast::Variable >
varFlags	ExprVarFlags
printFlags	ExprPrintFlags
argumentIndex	int
name	builtin::das_string
genFlags	ExprGenFlags
pBlock	ast::ExprBlock ?
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Variable access (foo)

ExprTag

ExprTag fields are

value	smart_ptr< ast::Expression >
at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
name	builtin::das_string
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Compilation time only tag expression, used for reification. For example $c(….).

ExprSwizzle

ExprSwizzle fields are

value	smart_ptr< ast::Expression >
at	rtti::LineInfo
fieldFlags	ExprSwizzleFieldFlags
mask	builtin::das_string
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const
fields	vector<uint8>

Vector swizzle operatrion (vec.xxy or vec.y)

ExprField

ExprField fields are

annotation	smart_ptr< rtti::TypeAnnotation >
value	smart_ptr< ast::Expression >
at	rtti::LineInfo
fieldIndex	int
fieldFlags	ExprFieldFieldFlags
field	ast::FieldDeclaration const? const
derefFlags	ExprFieldDerefFlags
printFlags	ExprPrintFlags
name	builtin::das_string
atField	rtti::LineInfo
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Field lookup (foo.bar)

ExprSafeField

ExprSafeField fields are

annotation	smart_ptr< rtti::TypeAnnotation >
value	smart_ptr< ast::Expression >
at	rtti::LineInfo
fieldIndex	int
fieldFlags	ExprFieldFieldFlags
field	ast::FieldDeclaration const? const
skipQQ	bool
derefFlags	ExprFieldDerefFlags
printFlags	ExprPrintFlags
name	builtin::das_string
atField	rtti::LineInfo
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Safe field lookup (foo?.bar)

ExprIsVariant

ExprIsVariant fields are

annotation	smart_ptr< rtti::TypeAnnotation >
value	smart_ptr< ast::Expression >
at	rtti::LineInfo
fieldIndex	int
fieldFlags	ExprFieldFieldFlags
field	ast::FieldDeclaration const? const
derefFlags	ExprFieldDerefFlags
printFlags	ExprPrintFlags
name	builtin::das_string
atField	rtti::LineInfo
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Is expression (foo is bar)

ExprAsVariant

ExprAsVariant fields are

annotation	smart_ptr< rtti::TypeAnnotation >
value	smart_ptr< ast::Expression >
at	rtti::LineInfo
fieldIndex	int
fieldFlags	ExprFieldFieldFlags
field	ast::FieldDeclaration const? const
derefFlags	ExprFieldDerefFlags
printFlags	ExprPrintFlags
name	builtin::das_string
atField	rtti::LineInfo
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

As expression (foo as bar)

ExprSafeAsVariant

ExprSafeAsVariant fields are

annotation	smart_ptr< rtti::TypeAnnotation >
value	smart_ptr< ast::Expression >
at	rtti::LineInfo
fieldIndex	int
fieldFlags	ExprFieldFieldFlags
field	ast::FieldDeclaration const? const
skipQQ	bool
derefFlags	ExprFieldDerefFlags
printFlags	ExprPrintFlags
name	builtin::das_string
atField	rtti::LineInfo
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Safe as expression (foo? as bar)

ExprOp1

ExprOp1 fields are

atEnclosure	rtti::LineInfo
func	ast::Function ?
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
op	builtin::das_string
printFlags	ExprPrintFlags
stackTop	uint
name	builtin::das_string
subexpr	smart_ptr< ast::Expression >
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Single operator expression (+a or -a or !a or ~a)

ExprReturn

ExprReturn fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
stackTop	uint
subexpr	smart_ptr< ast::Expression >
block	ast::ExprBlock ?
genFlags	ExprGenFlags
refStackTop	uint
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
returnFlags	ExprReturnFlags
__rtti	string const

Return expression (return or return foo, or return <- foo)

ExprYield

ExprYield fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
subexpr	smart_ptr< ast::Expression >
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags
returnFlags	ExprYieldFlags

Yield expression (yield foo or yeild <- bar)

ExprBreak

ExprBreak fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Break expression (break)

ExprContinue

ExprContinue fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Continue expression (continue)

ExprConst

ExprConst fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Compilation time constant expression base class

ExprFakeContext

ExprFakeContext fields are

at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Compilation time only fake context expression. Will simulate as current evaluation Context.

ExprFakeLineInfo

ExprFakeLineInfo fields are

value	void?
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Compilation time only fake lineinfo expression. Will simulate as current file and line LineInfo.

ExprConstPtr

ExprConstPtr fields are

value	void?
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Null (null). Technically can be any other pointer, but it is used for nullptr.

ExprConstInt8

ExprConstInt8 fields are

value	int8
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds int8 constant.

ExprConstInt16

ExprConstInt16 fields are

value	int16
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds int16 constant.

ExprConstInt64

ExprConstInt64 fields are

value	int64
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds int64 constant.

ExprConstInt

ExprConstInt fields are

value	int
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds int constant.

ExprConstInt2

ExprConstInt2 fields are

value	int2
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds int2 constant.

ExprConstInt3

ExprConstInt3 fields are

value	int3
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds int3 constant.

ExprConstInt4

ExprConstInt4 fields are

value	int4
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds int4 constant.

ExprConstUInt8

ExprConstUInt8 fields are

value	uint8
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds uint8 constant.

ExprConstUInt16

ExprConstUInt16 fields are

value	uint16
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds uint16 constant.

ExprConstUInt64

ExprConstUInt64 fields are

value	uint64
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds uint64 constant.

ExprConstUInt

ExprConstUInt fields are

value	uint
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds uint constant.

ExprConstUInt2

ExprConstUInt2 fields are

value	uint2
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds uint2 constant.

ExprConstUInt3

ExprConstUInt3 fields are

value	uint3
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds uint3 constant.

ExprConstUInt4

ExprConstUInt4 fields are

value	uint4
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds uint4 constant.

ExprConstRange

ExprConstRange fields are

value	range
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds range constant.

ExprConstURange

ExprConstURange fields are

value	urange
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds urange constant.

ExprConstRange64

ExprConstRange64 fields are

value	range64
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds range64 constant.

ExprConstURange64

ExprConstURange64 fields are

value	urange64
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds urange64 constant.

ExprConstFloat

ExprConstFloat fields are

value	float
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds float constant.

ExprConstFloat2

ExprConstFloat2 fields are

value	float2
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds float2 constant.

ExprConstFloat3

ExprConstFloat3 fields are

value	float3
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds float3 constant.

ExprConstFloat4

ExprConstFloat4 fields are

value	float4
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds float4 constant.

ExprConstDouble

ExprConstDouble fields are

value	double
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds double constant.

ExprConstBool

ExprConstBool fields are

value	bool
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds bool constant.

CaptureEntry

CaptureEntry fields are

name	builtin::das_string
mode	ast::CaptureMode

Single entry in lambda capture.

ExprMakeBlock

ExprMakeBlock fields are

mmFlags	ExprMakeBlockFlags
at	rtti::LineInfo
capture	vector<CaptureEntry>
printFlags	ExprPrintFlags
stackTop	uint
genFlags	ExprGenFlags
_block	smart_ptr< ast::Expression >
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Any closure. Holds block as well as capture information in CaptureEntry.

ExprMakeGenerator

ExprMakeGenerator fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
capture	vector<CaptureEntry>
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
iterType	smart_ptr< ast::TypeDecl >
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Generator closure (generator<int> or generator<Foo&>)

ExprMemZero

ExprMemZero fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Memzero (memzero(expr))

ExprConstEnumeration

ExprConstEnumeration fields are

value	builtin::das_string
at	rtti::LineInfo
printFlags	ExprPrintFlags
enumType	smart_ptr< ast::Enumeration >
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Holds enumeration constant, both type and entry (Foo bar).

ExprConstBitfield

ExprConstBitfield fields are

value	bitfield<>
at	rtti::LineInfo
bitfieldType	smart_ptr< ast::TypeDecl >
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Holds bitfield constant (Foo bar).

ExprConstString

ExprConstString fields are

value	builtin::das_string
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
baseType	rtti::Type
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Holds string constant.

ExprUnsafe

ExprUnsafe fields are

at	rtti::LineInfo
body	smart_ptr< ast::Expression >
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Unsafe expression (unsafe(addr(x)))

VisitorAdapter

Adapter for the AstVisitor interface.

FunctionAnnotation

Adapter for the AstFunctionAnnotation.

StructureAnnotation

Adapter for the AstStructureAnnotation.

EnumerationAnnotation

Adapater for the AstEnumearationAnnotation.

PassMacro

PassMacro fields are

name	builtin::das_string

Adapter for the AstPassMacro.

ReaderMacro

ReaderMacro fields are

_module	rtti::Module ?
name	builtin::das_string

Adapter for the AstReaderMacro.

CommentReader

Adapter for the AstCommentReader.

CallMacro

CallMacro fields are

_module	rtti::Module ?
name	builtin::das_string

Adapter for the AstCallMacro.

VariantMacro

VariantMacro fields are

name	builtin::das_string

Adapter for the AstVariantMacro.

ForLoopMacro

ForLoopMacro fields are

name	builtin::das_string

Adapter for the ‘AstForLoopMacro’.

CaptureMacro

CaptureMacro fields are

name	builtin::das_string

Adapter for the AstCaptureMacro.

TypeMacro

TypeMacro fields are

name	builtin::das_string

Compilation time only structure which holds live information about type macro.

SimulateMacro

SimulateMacro fields are

name	builtin::das_string

Adapter for the AstSimulateMacro.

ExprReader

ExprReader fields are

macro	smart_ptr< ast::ReaderMacro >
sequence	builtin::das_string
at	rtti::LineInfo
printFlags	ExprPrintFlags
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
__rtti	string const
flags	ExprFlags

Compilation time only expression which holds temporary information for the AstReaderMacro.

ExprCallMacro

ExprCallMacro fields are

atEnclosure	rtti::LineInfo
arguments	vector<smart_ptr<Expression>>
macro	ast::CallMacro ?
at	rtti::LineInfo
printFlags	ExprPrintFlags
name	builtin::das_string
argumentsFailedToInfer	bool
genFlags	ExprGenFlags
_type	smart_ptr< ast::TypeDecl >
flags	ExprFlags
__rtti	string const

Compilation time only expression which holds temporary infromation for the AstCallMacro.

12.4. Call macros

quote

Returns ast expression tree of the input, without evaluating or infering it. This is useful for macros which generate code as a shortcut for generating boilerplate code.

12.5. Typeinfo macros

ast_typedecl

Returns TypeDeclPtr of the type specified via type<> or subexpression type, for example typeinfo(ast_typedecl type<int?>)

ast_function

Returns FunctionPtr to the function specified by subexrepssion, for example typeinfo(ast_function @@foo)

12.6. Handled types

MakeStruct

Part of ExprMakeStruct, happens to be vector of MakeFieldDecl.

12.7. Classes

AstFunctionAnnotation

Annotation macro which is attached to the Function.

it defines as follows

AstFunctionAnnotation.transform(self: AstFunctionAnnotation; call: smart_ptr<ExprCallFunc>; errors: das_string)

transform returns ExpressionPtr

argument	argument type
self	ast::AstFunctionAnnotation
call	smart_ptr< ast::ExprCallFunc >
errors	builtin::das_string

This callback occurs during the infer pass of the compilation. If no transformation is needed, the callback should return null. errors is filled with the transformation errors should they occur. Returned value replaces function call in the ast.

AstFunctionAnnotation.verifyCall(self: AstFunctionAnnotation; call: smart_ptr<ExprCallFunc>; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

verifyCall returns bool

argument	argument type
self	ast::AstFunctionAnnotation
call	smart_ptr< ast::ExprCallFunc >
args	rtti::AnnotationArgumentList const
progArgs	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the lint pass of the compilation. If call has lint errors it should return false and errors is filled with the lint errors.

AstFunctionAnnotation.apply(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

apply returns bool

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the parse pass of the compilation on the function itself. If function has application errors it should return false and errors field.

AstFunctionAnnotation.generic_apply(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

generic_apply returns bool

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
errors	builtin::das_string

This call occurs during the infer pass of the compilation, when generic function is instanced on the instance of the function. If function has application errors it should return false and errors field.

AstFunctionAnnotation.finish(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

finish returns bool

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
progArgs	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the finalize allocations pass of the compilation, after the stack is allocated, on the function itself. If function has finalization errors it should return false and errors field.

AstFunctionAnnotation.patch(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string; astChanged: bool&)

patch returns bool

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
progArgs	rtti::AnnotationArgumentList const
errors	builtin::das_string
astChanged	bool&

This callback occurs right after the infer pass of the compilation on the function itself. If function has patching errors it should return false and errors field. If the astChanged flag is set, infer pass will be repeated. This allows to fix up the function after the infer pass with all the type information fully available.

AstFunctionAnnotation.fixup(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

fixup returns bool

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
progArgs	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the finalize allocations pass of the compilation, before the stack is allocated, on the function itself. If function has fixup errors it should return false and errors field.

AstFunctionAnnotation.lint(self: AstFunctionAnnotation; func: FunctionPtr; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

lint returns bool

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
progArgs	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the lint pass of the compilation on the function itself. If function has lint errors it should return false and errors field.

AstFunctionAnnotation.complete(self: AstFunctionAnnotation; func: FunctionPtr; ctx: smart_ptr<Context>)

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
ctx	smart_ptr< rtti::Context >

This callback occurs as the final stage of Context simulation.

AstFunctionAnnotation.isCompatible(self: AstFunctionAnnotation; func: FunctionPtr; types: VectorTypeDeclPtr; decl: AnnotationDeclaration const; errors: das_string)

isCompatible returns bool

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
types	VectorTypeDeclPtr
decl	rtti::AnnotationDeclaration const
errors	builtin::das_string

This callback occurs during function type matching for both generic and regular functions. If function can accept given argument types it should return true, otherwise errors is filled with the matching problems.

AstFunctionAnnotation.isSpecialized(self: AstFunctionAnnotation)

isSpecialized returns bool

This callback occurs during function type matching. If function requires special type matching (i.e. isCompatible` is implemented) it should return true.

AstFunctionAnnotation.appendToMangledName(self: AstFunctionAnnotation; func: FunctionPtr; decl: AnnotationDeclaration const; mangledName: das_string)

argument	argument type
self	ast::AstFunctionAnnotation
func	FunctionPtr
decl	rtti::AnnotationDeclaration const
mangledName	builtin::das_string

This call occurs when the function mangled name is requested. This is the way for the macro to ensure function is unique, even though type signature may be identical.

AstBlockAnnotation

Annotation macro which is attached to the ExprBlock.

it defines as follows

AstBlockAnnotation.apply(self: AstBlockAnnotation; blk: smart_ptr<ExprBlock>; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

apply returns bool

argument	argument type
self	ast::AstBlockAnnotation
blk	smart_ptr< ast::ExprBlock >
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the parse pass of the compilation. If block has application errors it should return false and errors field.

AstBlockAnnotation.finish(self: AstBlockAnnotation; blk: smart_ptr<ExprBlock>; group: ModuleGroup; args: AnnotationArgumentList const; progArgs: AnnotationArgumentList const; errors: das_string)

finish returns bool

argument	argument type
self	ast::AstBlockAnnotation
blk	smart_ptr< ast::ExprBlock >
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
progArgs	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the finalize allocations pass of the compilation, after the stack is allocated. If block has finalization errors it should return false and errors field.

AstStructureAnnotation

Annotation macro which is attached to the Structure.

it defines as follows

AstStructureAnnotation.apply(self: AstStructureAnnotation; st: StructurePtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

apply returns bool

argument	argument type
self	ast::AstStructureAnnotation
st	StructurePtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the parse pass of the compilation. If structure has application errors it should return false and errors field.

AstStructureAnnotation.finish(self: AstStructureAnnotation; st: StructurePtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

finish returns bool

argument	argument type
self	ast::AstStructureAnnotation
st	StructurePtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the finalize allocations pass of the compilation, after the stack is allocated. If structure has finalization errors it should return false and errors field.

AstStructureAnnotation.patch(self: AstStructureAnnotation; st: StructurePtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string; astChanged: bool&)

patch returns bool

argument	argument type
self	ast::AstStructureAnnotation
st	StructurePtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
errors	builtin::das_string
astChanged	bool&

This callback occurs right after the infer pass of the compilation on the structure itself. If structure has patching errors it should return false and errors field. If the astChanged flag is set, infer pass will be repeated. This allows to fix up the function after the infer pass with all the type information fully available.

AstStructureAnnotation.complete(self: AstStructureAnnotation; st: StructurePtr; ctx: smart_ptr<Context>)

argument	argument type
self	ast::AstStructureAnnotation
st	StructurePtr
ctx	smart_ptr< rtti::Context >

This callback occurs as the final stage of Context simulation.

AstStructureAnnotation.aotPrefix(self: AstStructureAnnotation; st: StructurePtr; args: AnnotationArgumentList const; writer: StringBuilderWriter)

argument	argument type
self	ast::AstStructureAnnotation
st	StructurePtr
args	rtti::AnnotationArgumentList const
writer	strings::StringBuilderWriter

This callback occurs during the AOT. It is used to generate CPP code before the structure declaration.

AstStructureAnnotation.aotBody(self: AstStructureAnnotation; st: StructurePtr; args: AnnotationArgumentList const; writer: StringBuilderWriter)

argument	argument type
self	ast::AstStructureAnnotation
st	StructurePtr
args	rtti::AnnotationArgumentList const
writer	strings::StringBuilderWriter

This callback occurs during the AOT. It is used to generate CPP code in the body of the structure.

AstStructureAnnotation.aotSuffix(self: AstStructureAnnotation; st: StructurePtr; args: AnnotationArgumentList const; writer: StringBuilderWriter)

argument	argument type
self	ast::AstStructureAnnotation
st	StructurePtr
args	rtti::AnnotationArgumentList const
writer	strings::StringBuilderWriter

This callback occurs during the AOT. It is used to generate CPP code after the structure declaration.

AstPassMacro

This macro is used to implement custom infer passes.

it defines as follows

AstPassMacro.apply(self: AstPassMacro; prog: ProgramPtr; mod: Module? const)

apply returns bool

argument	argument type
self	ast::AstPassMacro
prog	ProgramPtr
mod	rtti::Module ? const

This callback is called after infer pass. If macro did any work it returns true; infer pass is restarted a the memoent when first macro which did any work.

AstVariantMacro

This macro is used to implement custom is, as and ?as expressions.

it defines as follows

AstVariantMacro.visitExprIsVariant(self: AstVariantMacro; prog: ProgramPtr; mod: Module? const; expr: smart_ptr<ExprIsVariant> const)

visitExprIsVariant returns ExpressionPtr

argument	argument type
self	ast::AstVariantMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	smart_ptr< ast::ExprIsVariant > const

This callback occurs during the infer pass for every ExprIsVariant (a is b). If no work is necessary it should return null, otherwise expression will be replaced by the result.

AstVariantMacro.visitExprAsVariant(self: AstVariantMacro; prog: ProgramPtr; mod: Module? const; expr: smart_ptr<ExprAsVariant> const)

visitExprAsVariant returns ExpressionPtr

argument	argument type
self	ast::AstVariantMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	smart_ptr< ast::ExprAsVariant > const

This callback occurs during the infer pass for every ExprAsVariant (a as b). If no work is necessary it should return null, otherwise expression will be replaced by the result.

AstVariantMacro.visitExprSafeAsVariant(self: AstVariantMacro; prog: ProgramPtr; mod: Module? const; expr: smart_ptr<ExprSafeAsVariant> const)

visitExprSafeAsVariant returns ExpressionPtr

argument	argument type
self	ast::AstVariantMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	smart_ptr< ast::ExprSafeAsVariant > const

This callback occurs during the infer pass for every ExprSafeIsVariant (a ?as b). If no work is necessary it should return null, otherwise expression will be replaced by the result.

AstForLoopMacro

This macro is used to implement custom for-loop handlers. It is similar to visitExprFor callback of the AstVisitor.

it defines as follows

AstForLoopMacro.visitExprFor(self: AstForLoopMacro; prog: ProgramPtr; mod: Module? const; expr: smart_ptr<ExprFor> const)

visitExprFor returns ExpressionPtr

argument	argument type
self	ast::AstForLoopMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	smart_ptr< ast::ExprFor > const

This callback occurs during the infer pass for every ExprFor. If no work is necessary it should return null, otherwise expression will be replaced by the result.

AstCaptureMacro

This macro is used to implement custom lambda capturing functionality.

it defines as follows

AstCaptureMacro.captureExpression(self: AstCaptureMacro; prog: Program? const; mod: Module? const; expr: ExpressionPtr; etype: TypeDeclPtr)

captureExpression returns ExpressionPtr

argument	argument type
self	ast::AstCaptureMacro
prog	rtti::Program ? const
mod	rtti::Module ? const
expr	ExpressionPtr
etype	TypeDeclPtr

This callback occurs during the ‘infer’ pass for every time a lambda expression (or generator) is captured for every captured expression.

AstCaptureMacro.captureFunction(self: AstCaptureMacro; prog: Program? const; mod: Module? const; lcs: Structure?; fun: FunctionPtr)

argument	argument type
self	ast::AstCaptureMacro
prog	rtti::Program ? const
mod	rtti::Module ? const
lcs	ast::Structure ?
fun	FunctionPtr

This callback occurs during the ‘infer’ pass for every time a lambda expression (or generator) is captured, for every generated lambda (or generator) function.

AstTypeMacro

Macro which is part of the type declaration, for example $type_macro_name<type_macro_type_args…>(type_macro_args).

it defines as follows

AstTypeMacro.visit(self: AstTypeMacro; prog: ProgramPtr; mod: Module? const; td: TypeDeclPtr; passT: TypeDeclPtr)

visit returns TypeDeclPtr

argument	argument type
self	ast::AstTypeMacro
prog	ProgramPtr
mod	rtti::Module ? const
td	TypeDeclPtr
passT	TypeDeclPtr

This callback occurs after the type macro is visited.

AstSimulateMacro

Macro which is attached to the context simulation.

it defines as follows

AstSimulateMacro.preSimulate(self: AstSimulateMacro; prog: Program? const; ctx: Context? const)

preSimulate returns bool

argument	argument type
self	ast::AstSimulateMacro
prog	rtti::Program ? const
ctx	rtti::Context ? const

This callback occurs before the context simulation.

AstSimulateMacro.simulate(self: AstSimulateMacro; prog: Program? const; ctx: Context? const)

simulate returns bool

argument	argument type
self	ast::AstSimulateMacro
prog	rtti::Program ? const
ctx	rtti::Context ? const

This callback occurs after the context simulation.

AstReaderMacro

This macro is used to implement custom parsing functionality, i.e. anything starting with %NameOfTheMacro~ and ending when the macro says it ends.

it defines as follows

AstReaderMacro.accept(self: AstReaderMacro; prog: ProgramPtr; mod: Module? const; expr: ExprReader? const; ch: int const; info: LineInfo const)

accept returns bool

argument	argument type
self	ast::AstReaderMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	ast::ExprReader ? const
ch	int const
info	rtti::LineInfo const

This callback occurs during the parse pass for every character. When the macro is done with the input (i.e. recognizeable input ends) it should return false. Typically characters are appended to the expr.sequence inside the ExprReader.

AstReaderMacro.suffix(self: AstReaderMacro; prog: ProgramPtr; mod: Module? const; expr: ExprReader? const; info: LineInfo const; outLine: int&; outFile: FileInfo?&)

suffix returns string

argument	argument type
self	ast::AstReaderMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	ast::ExprReader ? const
info	rtti::LineInfo const
outLine	int&
outFile	rtti::FileInfo ?&

This callback occurs during the parse pass after the macro is done with the input. It returns text, which is to be parsed again by the parser.

AstReaderMacro.visit(self: AstReaderMacro; prog: ProgramPtr; mod: Module? const; expr: smart_ptr<ExprReader> const)

visit returns ExpressionPtr

argument	argument type
self	ast::AstReaderMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	smart_ptr< ast::ExprReader > const

This callback occurs during the infer pass for every instance of ExprReader for that specific macro. Macro needs to convert ExprReader to some meaningful expression.

AstCommentReader

This macro is used to implement custom comment parsing function (such as doxygen-style documentation etc).

it defines as follows

AstCommentReader.open(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; cpp: bool const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
cpp	bool const
info	rtti::LineInfo const

This callback occurs during the parse pass for every // or /* sequence which indicated begining of the comment section.

AstCommentReader.accept(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; ch: int const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
ch	int const
info	rtti::LineInfo const

This callback occurs during the parse pass for every character in the comment section.

AstCommentReader.close(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass for every new line or */ sequence which indicates end of the comment section.

AstCommentReader.beforeStructure(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass before the structure body block.

AstCommentReader.afterStructure(self: AstCommentReader; st: StructurePtr; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
st	StructurePtr
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass after the structure body block.

AstCommentReader.beforeStructureFields(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass before the first structure field is declared.

AstCommentReader.afterStructureField(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass after the structure field is declared (after the following comment section, should it have one).

AstCommentReader.afterStructureFields(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass after the last structure field is declared.

AstCommentReader.beforeFunction(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass before the function body block.

AstCommentReader.afterFunction(self: AstCommentReader; fn: FunctionPtr; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
fn	FunctionPtr
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass after the function body block.

AstCommentReader.beforeGlobalVariables(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass before the first global variable declaration but after let or var keyword.

AstCommentReader.afterGlobalVariable(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass after global variable is declaraed (after the following comment section, should it have one).

AstCommentReader.afterGlobalVariables(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass after every global variable in the declaration is declared.

AstCommentReader.beforeVariant(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass before the variant alias declaration.

AstCommentReader.beforeVariantEntries(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse before the first variant entry is declared.

AstCommentReader.afterVariantEntry(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the variant entry is declared (after the following comment section, should it have one).

AstCommentReader.afterVariantEntries(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the last variant entry is declared.

AstCommentReader.afterVariant(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the variant alias declaration.

AstCommentReader.beforeTuple(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass before the tuple declaration.

AstCommentReader.beforeTupleEntries(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse before the first tuple entry is declared.

AstCommentReader.afterTupleEntry(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the tuple entry is declared (after the following comment section, should it have one).

AstCommentReader.afterTupleEntries(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the last tuple entry is declared.

AstCommentReader.afterTuple(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the tuple declaration.

AstCommentReader.beforeBitfield(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse before the bitfield declaration.

AstCommentReader.beforeBitfieldEntries(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse before the first bitfield entry is declared.

AstCommentReader.afterBitfieldEntry(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the bitfield entry is declared (after the following comment section, should it have one).

AstCommentReader.afterBitfieldEntries(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the last bitfield entry is declared.

AstCommentReader.afterBitfield(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the bitfield declaration.

AstCommentReader.beforeEnumeration(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse before the enumeration declaration.

AstCommentReader.beforeEnumerationEntries(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse before the first enumeration entry is declared.

AstCommentReader.afterEnumerationEntry(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the enumeration entry is declared (after the following comment section, should it have one).

AstCommentReader.afterEnumerationEntries(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the last enumeration entry is declared.

AstCommentReader.afterEnumeration(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse after the enumeration declaration.

AstCommentReader.beforeAlias(self: AstCommentReader; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass before the type alias declaration.

AstCommentReader.afterAlias(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: Module? const; info: LineInfo const)

argument	argument type
self	ast::AstCommentReader
name	string const
prog	ProgramPtr
mod	rtti::Module ? const
info	rtti::LineInfo const

This callback occurs during the parse pass after the type alias declaration.

AstCallMacro

This macro is used to implement custom call-like expressions ( like foo(bar,bar2,…) ).

it defines as follows

AstCallMacro.preVisit(self: AstCallMacro; prog: ProgramPtr; mod: Module? const; expr: smart_ptr<ExprCallMacro> const)

argument	argument type
self	ast::AstCallMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	smart_ptr< ast::ExprCallMacro > const

This callback occurs during the infer pass for every ExprCallMacro, before its arguments are inferred.

AstCallMacro.visit(self: AstCallMacro; prog: ProgramPtr; mod: Module? const; expr: smart_ptr<ExprCallMacro> const)

visit returns ExpressionPtr

argument	argument type
self	ast::AstCallMacro
prog	ProgramPtr
mod	rtti::Module ? const
expr	smart_ptr< ast::ExprCallMacro > const

This callback occurs during the infer pass for every ExprCallMacro, after its arguments are inferred. When fully inferred macro is expected to replace ExprCallMacro with meaningful expression.

AstCallMacro.canVisitArgument(self: AstCallMacro; expr: smart_ptr<ExprCallMacro> const; argIndex: int const)

canVisitArgument returns bool

argument	argument type
self	ast::AstCallMacro
expr	smart_ptr< ast::ExprCallMacro > const
argIndex	int const

This callback occurs during the infer pass before the arguments of the call macro are visited. If callback returns true, the argument of given index is visited, otherwise it acts like a query expression.

AstCallMacro.canFoldReturnResult(self: AstCallMacro; expr: smart_ptr<ExprCallMacro> const)

canFoldReturnResult returns bool

argument	argument type
self	ast::AstCallMacro
expr	smart_ptr< ast::ExprCallMacro > const

If true the enclosing function can infer return result as void when unspecified. If false function will have to wait for the macro to fold.

AstTypeInfoMacro

This macro is used to implement type info traits, i.e. typeinfo(YourTraitHere …) expressions.

it defines as follows

AstTypeInfoMacro.getAstChange(self: AstTypeInfoMacro; expr: smart_ptr<ExprTypeInfo> const; errors: das_string)

getAstChange returns ExpressionPtr

argument	argument type
self	ast::AstTypeInfoMacro
expr	smart_ptr< ast::ExprTypeInfo > const
errors	builtin::das_string

This callback occurs during the infer pass. If no changes are necessary it should return null, otherwise expression will be replaced by the result. errors should be filled if trait is malformed.

AstTypeInfoMacro.getAstType(self: AstTypeInfoMacro; lib: ModuleLibrary; expr: smart_ptr<ExprTypeInfo> const; errors: das_string)

getAstType returns TypeDeclPtr

argument	argument type
self	ast::AstTypeInfoMacro
lib	ast::ModuleLibrary
expr	smart_ptr< ast::ExprTypeInfo > const
errors	builtin::das_string

This callback occurs during the infer pass. It should return type of the typeinfo expression. That way trait can return Type, and not Expression.

AstEnumerationAnnotation

Annotation macro which is attached to Enumeration.

it defines as follows

AstEnumerationAnnotation.apply(self: AstEnumerationAnnotation; st: EnumerationPtr; group: ModuleGroup; args: AnnotationArgumentList const; errors: das_string)

apply returns bool

argument	argument type
self	ast::AstEnumerationAnnotation
st	EnumerationPtr
group	rtti::ModuleGroup
args	rtti::AnnotationArgumentList const
errors	builtin::das_string

This callback occurs during the parse pass. If any errors occur errors should be filled and false should be returned.

AstVisitor

This class implements Visitor interface for the ast tree. For typical expression two methods are provided: preVisitExpr and visitExpr. preVisitExpr occurs before the subexpressions are visited, and visitExpr occurs after the subexpressions are visited. visitExpr can return new expression which will replace the original one, or original expression - if no changes are necessary. There are other potential callbacks deppending of the nature of expression, which represent particular sections of the ast tree. Additionally ‘preVisitExpression’ and visitExpression are called before and after expression specific callbacks.

it defines as follows

AstVisitor.preVisitProgram(self: AstVisitor; prog: ProgramPtr)

argument	argument type
self	ast::AstVisitor
prog	ProgramPtr

before entire program, put your initialization there.

AstVisitor.visitProgram(self: AstVisitor; porg: ProgramPtr)

argument	argument type
self	ast::AstVisitor
porg	ProgramPtr

after entire program, put your finalizers there.

AstVisitor.preVisitProgramBody(self: AstVisitor; prog: ProgramPtr; mod: Module? const)

argument	argument type
self	ast::AstVisitor
prog	ProgramPtr
mod	rtti::Module ? const

after enumerations, structures, and aliases, but before global variables, generics and functions.

AstVisitor.preVisitModule(self: AstVisitor; mod: Module? const)

argument	argument type
self	ast::AstVisitor
mod	rtti::Module ? const

before each module

AstVisitor.visitModule(self: AstVisitor; mod: Module? const)

argument	argument type
self	ast::AstVisitor
mod	rtti::Module ? const

after each module

AstVisitor.preVisitExprTypeDecl(self: AstVisitor; expr: smart_ptr<ExprTypeDecl> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTypeDecl > const

before ExprTypeDecl

AstVisitor.visitExprTypeDecl(self: AstVisitor; expr: smart_ptr<ExprTypeDecl> const)

visitExprTypeDecl returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTypeDecl > const

after ExprTypeDecl

AstVisitor.preVisitTypeDecl(self: AstVisitor; typ: TypeDeclPtr)

argument	argument type
self	ast::AstVisitor
typ	TypeDeclPtr

before a type declaration anywhere. yor type validation code typically goes here

AstVisitor.visitTypeDecl(self: AstVisitor; typ: TypeDeclPtr)

visitTypeDecl returns TypeDeclPtr

argument	argument type
self	ast::AstVisitor
typ	TypeDeclPtr

after a type declaration

AstVisitor.preVisitAlias(self: AstVisitor; typ: TypeDeclPtr; name: das_string const)

argument	argument type
self	ast::AstVisitor
typ	TypeDeclPtr
name	builtin::das_string const

before TypeDecl

AstVisitor.visitAlias(self: AstVisitor; typ: TypeDeclPtr; name: das_string const)

visitAlias returns TypeDeclPtr

argument	argument type
self	ast::AstVisitor
typ	TypeDeclPtr
name	builtin::das_string const

after TypeDecl

AstVisitor.canVisitEnumeration(self: AstVisitor; arg: Enumeration? const)

canVisitEnumeration returns bool

argument	argument type
self	ast::AstVisitor
arg	ast::Enumeration ? const

if true Enumeration will be visited

AstVisitor.preVisitEnumeration(self: AstVisitor; enu: EnumerationPtr)

argument	argument type
self	ast::AstVisitor
enu	EnumerationPtr

before Enumeration

AstVisitor.preVisitEnumerationValue(self: AstVisitor; enu: EnumerationPtr; name: das_string const; value: ExpressionPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
enu	EnumerationPtr
name	builtin::das_string const
value	ExpressionPtr
last	bool const

before every enumeration entry

AstVisitor.visitEnumerationValue(self: AstVisitor; enu: EnumerationPtr; name: das_string const; value: ExpressionPtr; last: bool const)

visitEnumerationValue returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
enu	EnumerationPtr
name	builtin::das_string const
value	ExpressionPtr
last	bool const

after every enumeration entry

AstVisitor.visitEnumeration(self: AstVisitor; enu: EnumerationPtr)

visitEnumeration returns EnumerationPtr

argument	argument type
self	ast::AstVisitor
enu	EnumerationPtr

after Enumeration

AstVisitor.canVisitStructure(self: AstVisitor; arg: Structure? const)

canVisitStructure returns bool

argument	argument type
self	ast::AstVisitor
arg	ast::Structure ? const

if true Structure will be visited

AstVisitor.preVisitStructure(self: AstVisitor; str: StructurePtr)

argument	argument type
self	ast::AstVisitor
str	StructurePtr

before Structure

AstVisitor.preVisitStructureField(self: AstVisitor; str: StructurePtr; decl: FieldDeclaration const; last: bool const)

argument	argument type
self	ast::AstVisitor
str	StructurePtr
decl	ast::FieldDeclaration const
last	bool const

before every structure field

AstVisitor.visitStructureField(self: AstVisitor; str: StructurePtr; decl: FieldDeclaration const; last: bool const)

argument	argument type
self	ast::AstVisitor
str	StructurePtr
decl	ast::FieldDeclaration const
last	bool const

after every structure field

AstVisitor.visitStructure(self: AstVisitor; str: StructurePtr)

visitStructure returns StructurePtr

argument	argument type
self	ast::AstVisitor
str	StructurePtr

after Structure

AstVisitor.canVisitFunction(self: AstVisitor; fun: Function? const)

canVisitFunction returns bool

argument	argument type
self	ast::AstVisitor
fun	ast::Function ? const

if true Function will be visited

AstVisitor.canVisitFunctionArgumentInit(self: AstVisitor; fun: Function? const; arg: VariablePtr; value: ExpressionPtr)

canVisitFunctionArgumentInit returns bool

argument	argument type
self	ast::AstVisitor
fun	ast::Function ? const
arg	VariablePtr
value	ExpressionPtr

if true function argument initialization expressions will be visited

AstVisitor.preVisitFunction(self: AstVisitor; fun: FunctionPtr)

argument	argument type
self	ast::AstVisitor
fun	FunctionPtr

before Function

AstVisitor.visitFunction(self: AstVisitor; fun: FunctionPtr)

visitFunction returns FunctionPtr

argument	argument type
self	ast::AstVisitor
fun	FunctionPtr

after Function

AstVisitor.preVisitFunctionArgument(self: AstVisitor; fun: FunctionPtr; arg: VariablePtr; lastArg: bool const)

argument	argument type
self	ast::AstVisitor
fun	FunctionPtr
arg	VariablePtr
lastArg	bool const

before every argument

AstVisitor.visitFunctionArgument(self: AstVisitor; fun: FunctionPtr; arg: VariablePtr; lastArg: bool const)

visitFunctionArgument returns VariablePtr

argument	argument type
self	ast::AstVisitor
fun	FunctionPtr
arg	VariablePtr
lastArg	bool const

after every argument

AstVisitor.preVisitFunctionArgumentInit(self: AstVisitor; fun: FunctionPtr; arg: VariablePtr; value: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
fun	FunctionPtr
arg	VariablePtr
value	ExpressionPtr

before every argument initialization expression (should it have one), between ‘preVisitFunctionArgument’ and visitFunctionArgument

AstVisitor.visitFunctionArgumentInit(self: AstVisitor; fun: FunctionPtr; arg: VariablePtr; value: ExpressionPtr)

visitFunctionArgumentInit returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
fun	FunctionPtr
arg	VariablePtr
value	ExpressionPtr

after every argument initialization expression (should it have one), between ‘preVisitFunctionArgument’ and visitFunctionArgument

AstVisitor.preVisitFunctionBody(self: AstVisitor; fun: FunctionPtr; expr: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
fun	FunctionPtr
expr	ExpressionPtr

before the Function body block, between preVisitFunction and visitFunction (not for abstract functions)

AstVisitor.visitFunctionBody(self: AstVisitor; fun: FunctionPtr; expr: ExpressionPtr)

visitFunctionBody returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
fun	FunctionPtr
expr	ExpressionPtr

after the Function body block, between preVisitFunction and visitFunction (not for abstract functions)

AstVisitor.preVisitExpression(self: AstVisitor; expr: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	ExpressionPtr

before every Expression

AstVisitor.visitExpression(self: AstVisitor; expr: ExpressionPtr)

visitExpression returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	ExpressionPtr

after every Expression

AstVisitor.preVisitExprBlock(self: AstVisitor; blk: smart_ptr<ExprBlock> const)

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const

before ExprBlock

AstVisitor.visitExprBlock(self: AstVisitor; blk: smart_ptr<ExprBlock> const)

visitExprBlock returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const

after ExprBlock

AstVisitor.preVisitExprBlockArgument(self: AstVisitor; blk: smart_ptr<ExprBlock> const; arg: VariablePtr; lastArg: bool const)

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const
arg	VariablePtr
lastArg	bool const

before every block argument

AstVisitor.visitExprBlockArgument(self: AstVisitor; blk: smart_ptr<ExprBlock> const; arg: VariablePtr; lastArg: bool const)

visitExprBlockArgument returns VariablePtr

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const
arg	VariablePtr
lastArg	bool const

after every block argument

AstVisitor.preVisitExprBlockArgumentInit(self: AstVisitor; blk: smart_ptr<ExprBlock> const; arg: VariablePtr; expr: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const
arg	VariablePtr
expr	ExpressionPtr

before every block argument initialization expression (should it have one), between ‘preVisitExprBlockArgument’ and visitExprBlockArgument

AstVisitor.visitExprBlockArgumentInit(self: AstVisitor; blk: smart_ptr<ExprBlock> const; arg: VariablePtr; expr: ExpressionPtr)

visitExprBlockArgumentInit returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const
arg	VariablePtr
expr	ExpressionPtr

after every block argument initialization expression (should it have one), between ‘preVisitExprBlockArgument’ and visitExprBlockArgument

AstVisitor.preVisitExprBlockExpression(self: AstVisitor; blk: smart_ptr<ExprBlock> const; expr: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const
expr	ExpressionPtr

before every block expression

AstVisitor.visitExprBlockExpression(self: AstVisitor; blk: smart_ptr<ExprBlock> const; expr: ExpressionPtr)

visitExprBlockExpression returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const
expr	ExpressionPtr

after every block expression

AstVisitor.preVisitExprBlockFinal(self: AstVisitor; blk: smart_ptr<ExprBlock> const)

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const

before finally` section of the block

AstVisitor.visitExprBlockFinal(self: AstVisitor; blk: smart_ptr<ExprBlock> const)

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const

after finally` section of the block

AstVisitor.preVisitExprBlockFinalExpression(self: AstVisitor; blk: smart_ptr<ExprBlock> const; expr: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const
expr	ExpressionPtr

before every block expression in the finally section, between preVisitExprBlockFinal and visitExprBlockFinal

AstVisitor.visitExprBlockFinalExpression(self: AstVisitor; blk: smart_ptr<ExprBlock> const; expr: ExpressionPtr)

visitExprBlockFinalExpression returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprBlock > const
expr	ExpressionPtr

after every block expression in the finally` section, between preVisitExprBlockFinal and visitExprBlockFinal

AstVisitor.preVisitExprLet(self: AstVisitor; expr: smart_ptr<ExprLet> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLet > const

before ExprLet

AstVisitor.visitExprLet(self: AstVisitor; expr: smart_ptr<ExprLet> const)

visitExprLet returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLet > const

after ExprLet

AstVisitor.preVisitExprLetVariable(self: AstVisitor; expr: smart_ptr<ExprLet> const; arg: VariablePtr; lastArg: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLet > const
arg	VariablePtr
lastArg	bool const

before every variable

AstVisitor.visitExprLetVariable(self: AstVisitor; expr: smart_ptr<ExprLet> const; arg: VariablePtr; lastArg: bool const)

visitExprLetVariable returns VariablePtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLet > const
arg	VariablePtr
lastArg	bool const

after every variable

AstVisitor.preVisitExprLetVariableInit(self: AstVisitor; blk: smart_ptr<ExprLet> const; arg: VariablePtr; expr: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprLet > const
arg	VariablePtr
expr	ExpressionPtr

before variable initialization (should it have one), between preVisitExprLetVariable and visitExprLetVariable

AstVisitor.visitExprLetVariableInit(self: AstVisitor; blk: smart_ptr<ExprLet> const; arg: VariablePtr; expr: ExpressionPtr)

visitExprLetVariableInit returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
blk	smart_ptr< ast::ExprLet > const
arg	VariablePtr
expr	ExpressionPtr

after variable initialization (should it have one), between preVisitExprLetVariable and visitExprLetVariable

AstVisitor.canVisitGlobalVariable(self: AstVisitor; arg: Variable? const)

canVisitGlobalVariable returns bool

argument	argument type
self	ast::AstVisitor
arg	ast::Variable ? const

If true global variable declaration will be visited

AstVisitor.preVisitGlobalLet(self: AstVisitor; prog: ProgramPtr)

argument	argument type
self	ast::AstVisitor
prog	ProgramPtr

before global variable declaration

AstVisitor.visitGlobalLet(self: AstVisitor; prog: ProgramPtr)

argument	argument type
self	ast::AstVisitor
prog	ProgramPtr

after global variable declaration

AstVisitor.preVisitGlobalLetVariable(self: AstVisitor; arg: VariablePtr; lastArg: bool const)

argument	argument type
self	ast::AstVisitor
arg	VariablePtr
lastArg	bool const

before every global variable

AstVisitor.visitGlobalLetVariable(self: AstVisitor; arg: VariablePtr; lastArg: bool const)

visitGlobalLetVariable returns VariablePtr

argument	argument type
self	ast::AstVisitor
arg	VariablePtr
lastArg	bool const

after every global variable

AstVisitor.preVisitGlobalLetVariableInit(self: AstVisitor; arg: VariablePtr; expr: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
arg	VariablePtr
expr	ExpressionPtr

before global variable initialization (should it have one), between preVisitGlobalLetVariable and visitGlobalLetVariable

AstVisitor.visitGlobalLetVariableInit(self: AstVisitor; arg: VariablePtr; expr: ExpressionPtr)

visitGlobalLetVariableInit returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
arg	VariablePtr
expr	ExpressionPtr

after global variable initialization (should it have one), between preVisitGlobalLetVariable and visitGlobalLetVariable

AstVisitor.preVisitExprStringBuilder(self: AstVisitor; expr: smart_ptr<ExprStringBuilder> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprStringBuilder > const

before ExprStringBuilder

AstVisitor.visitExprStringBuilder(self: AstVisitor; expr: smart_ptr<ExprStringBuilder> const)

visitExprStringBuilder returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprStringBuilder > const

after ExprStringBuilder

AstVisitor.preVisitExprStringBuilderElement(self: AstVisitor; expr: smart_ptr<ExprStringBuilder> const; elem: ExpressionPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprStringBuilder > const
elem	ExpressionPtr
last	bool const

before any element of string builder (string or expression)

AstVisitor.visitExprStringBuilderElement(self: AstVisitor; expr: smart_ptr<ExprStringBuilder> const; elem: ExpressionPtr; last: bool const)

visitExprStringBuilderElement returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprStringBuilder > const
elem	ExpressionPtr
last	bool const

after any element of string builder

AstVisitor.preVisitExprNew(self: AstVisitor; expr: smart_ptr<ExprNew> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNew > const

before ExprNew

AstVisitor.visitExprNew(self: AstVisitor; expr: smart_ptr<ExprNew> const)

visitExprNew returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNew > const

after ExprNew

AstVisitor.preVisitExprNewArgument(self: AstVisitor; expr: smart_ptr<ExprNew> const; arg: ExpressionPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNew > const
arg	ExpressionPtr
last	bool const

before every argument

AstVisitor.visitExprNewArgument(self: AstVisitor; expr: smart_ptr<ExprNew> const; arg: ExpressionPtr; last: bool const)

visitExprNewArgument returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNew > const
arg	ExpressionPtr
last	bool const

after every argument

AstVisitor.preVisitExprNamedCall(self: AstVisitor; expr: smart_ptr<ExprNamedCall> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNamedCall > const

before ExprNamedCall

AstVisitor.visitExprNamedCall(self: AstVisitor; expr: smart_ptr<ExprNamedCall> const)

visitExprNamedCall returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNamedCall > const

after ExprNamedCall`

AstVisitor.preVisitExprNamedCallArgument(self: AstVisitor; expr: smart_ptr<ExprNamedCall> const; arg: MakeFieldDeclPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNamedCall > const
arg	MakeFieldDeclPtr
last	bool const

before every argument

AstVisitor.visitExprNamedCallArgument(self: AstVisitor; expr: smart_ptr<ExprNamedCall> const; arg: MakeFieldDeclPtr; last: bool const)

visitExprNamedCallArgument returns MakeFieldDeclPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNamedCall > const
arg	MakeFieldDeclPtr
last	bool const

after every argument

AstVisitor.preVisitExprLooksLikeCall(self: AstVisitor; expr: smart_ptr<ExprLooksLikeCall> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLooksLikeCall > const

before ExprLooksLikeCall

AstVisitor.visitExprLooksLikeCall(self: AstVisitor; expr: smart_ptr<ExprLooksLikeCall> const)

visitExprLooksLikeCall returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLooksLikeCall > const

after ExprLooksLikeCall

AstVisitor.canVisitLooksLikeCallArgument(self: AstVisitor; expr: smart_ptr<ExprLooksLikeCall> const; arg: ExpressionPtr; last: bool const)

canVisitLooksLikeCallArgument returns bool

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLooksLikeCall > const
arg	ExpressionPtr
last	bool const

If true ExprLooksLikeCall arguments will be visited

AstVisitor.preVisitExprLooksLikeCallArgument(self: AstVisitor; expr: smart_ptr<ExprLooksLikeCall> const; arg: ExpressionPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLooksLikeCall > const
arg	ExpressionPtr
last	bool const

before every argument

AstVisitor.visitExprLooksLikeCallArgument(self: AstVisitor; expr: smart_ptr<ExprLooksLikeCall> const; arg: ExpressionPtr; last: bool const)

visitExprLooksLikeCallArgument returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLooksLikeCall > const
arg	ExpressionPtr
last	bool const

after every argument

AstVisitor.canVisitCall(self: AstVisitor; expr: ExprCall? const)

canVisitCall returns bool

argument	argument type
self	ast::AstVisitor
expr	ast::ExprCall ? const

If false call will be completely skipped, otherwise it behaves normally.

AstVisitor.preVisitExprCall(self: AstVisitor; expr: smart_ptr<ExprCall> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCall > const

before ExprCall

AstVisitor.visitExprCall(self: AstVisitor; expr: smart_ptr<ExprCall> const)

visitExprCall returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCall > const

after ExprCall

AstVisitor.preVisitExprCallArgument(self: AstVisitor; expr: smart_ptr<ExprCall> const; arg: ExpressionPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCall > const
arg	ExpressionPtr
last	bool const

before every argument

AstVisitor.visitExprCallArgument(self: AstVisitor; expr: smart_ptr<ExprCall> const; arg: ExpressionPtr; last: bool const)

visitExprCallArgument returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCall > const
arg	ExpressionPtr
last	bool const

after every argument

AstVisitor.preVisitExprNullCoalescing(self: AstVisitor; expr: smart_ptr<ExprNullCoalescing> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNullCoalescing > const

before ExprNullCoalescing

AstVisitor.visitExprNullCoalescing(self: AstVisitor; expr: smart_ptr<ExprNullCoalescing> const)

visitExprNullCoalescing returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNullCoalescing > const

after ExprNullCoalescing

AstVisitor.preVisitExprNullCoalescingDefault(self: AstVisitor; expr: smart_ptr<ExprNullCoalescing> const; defval: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprNullCoalescing > const
defval	ExpressionPtr

before the default value

AstVisitor.preVisitExprAt(self: AstVisitor; expr: smart_ptr<ExprAt> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAt > const

before ExprAt

AstVisitor.visitExprAt(self: AstVisitor; expr: smart_ptr<ExprAt> const)

visitExprAt returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAt > const

after ExprAt

AstVisitor.preVisitExprAtIndex(self: AstVisitor; expr: smart_ptr<ExprAt> const; index: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAt > const
index	ExpressionPtr

before the index

AstVisitor.preVisitExprSafeAt(self: AstVisitor; expr: smart_ptr<ExprSafeAt> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSafeAt > const

before ExprSafeAt

AstVisitor.visitExprSafeAt(self: AstVisitor; expr: smart_ptr<ExprSafeAt> const)

visitExprSafeAt returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSafeAt > const

after ExprSafeAt

AstVisitor.preVisitExprSafeAtIndex(self: AstVisitor; expr: smart_ptr<ExprAt> const; index: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAt > const
index	ExpressionPtr

before the index

AstVisitor.preVisitExprIs(self: AstVisitor; expr: smart_ptr<ExprIs> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIs > const

before ExprIs

AstVisitor.visitExprIs(self: AstVisitor; expr: smart_ptr<ExprIs> const)

visitExprIs returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIs > const

after ExprIs

AstVisitor.preVisitExprIsType(self: AstVisitor; expr: smart_ptr<ExprIs> const; typeDecl: TypeDeclPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIs > const
typeDecl	TypeDeclPtr

before the type

AstVisitor.preVisitExprOp2(self: AstVisitor; expr: smart_ptr<ExprOp2> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp2 > const

before ExprOp2

AstVisitor.visitExprOp2(self: AstVisitor; expr: smart_ptr<ExprOp2> const)

visitExprOp2 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp2 > const

after ExprOp2

AstVisitor.preVisitExprOp2Right(self: AstVisitor; expr: smart_ptr<ExprOp2> const; right: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp2 > const
right	ExpressionPtr

before the right operand

AstVisitor.preVisitExprOp3(self: AstVisitor; expr: smart_ptr<ExprOp3> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp3 > const

before ExprOp3

AstVisitor.visitExprOp3(self: AstVisitor; expr: smart_ptr<ExprOp3> const)

visitExprOp3 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp3 > const

after ExprOp3

AstVisitor.preVisitExprOp3Left(self: AstVisitor; expr: smart_ptr<ExprOp3> const; left: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp3 > const
left	ExpressionPtr

before the left option

AstVisitor.preVisitExprOp3Right(self: AstVisitor; expr: smart_ptr<ExprOp3> const; right: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp3 > const
right	ExpressionPtr

before the right option

AstVisitor.preVisitExprCopy(self: AstVisitor; expr: smart_ptr<ExprCopy> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCopy > const

before ExprCopy

AstVisitor.visitExprCopy(self: AstVisitor; expr: smart_ptr<ExprCopy> const)

visitExprCopy returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCopy > const

after ExprCopy

AstVisitor.preVisitExprCopyRight(self: AstVisitor; expr: smart_ptr<ExprCopy> const; right: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCopy > const
right	ExpressionPtr

before the right operand

AstVisitor.preVisitExprMove(self: AstVisitor; expr: smart_ptr<ExprMove> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMove > const

before ExprMove

AstVisitor.visitExprMove(self: AstVisitor; expr: smart_ptr<ExprMove> const)

visitExprMove returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMove > const

after ExprMove

AstVisitor.preVisitExprMoveRight(self: AstVisitor; expr: smart_ptr<ExprMove> const; right: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMove > const
right	ExpressionPtr

before the right operand

AstVisitor.preVisitExprClone(self: AstVisitor; expr: smart_ptr<ExprClone> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprClone > const

before ExprClone

AstVisitor.visitExprClone(self: AstVisitor; expr: smart_ptr<ExprClone> const)

visitExprClone returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprClone > const

after ExprClone

AstVisitor.preVisitExprCloneRight(self: AstVisitor; expr: smart_ptr<ExprClone> const; right: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprClone > const
right	ExpressionPtr

before the right operand

AstVisitor.canVisitWithAliasSubexpression(self: AstVisitor; expr: smart_ptr<ExprAssume> const)

canVisitWithAliasSubexpression returns bool

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAssume > const

before the sub expression in the ExprAssume

AstVisitor.preVisitExprAssume(self: AstVisitor; expr: smart_ptr<ExprAssume> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAssume > const

before ExprAssume

AstVisitor.visitExprAssume(self: AstVisitor; expr: smart_ptr<ExprAssume> const)

visitExprAssume returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAssume > const

after ExprAssume

AstVisitor.preVisitExprWith(self: AstVisitor; expr: smart_ptr<ExprWith> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprWith > const

before ExprWith

AstVisitor.visitExprWith(self: AstVisitor; expr: smart_ptr<ExprWith> const)

visitExprWith returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprWith > const

after ExprWith

AstVisitor.preVisitExprWithBody(self: AstVisitor; expr: smart_ptr<ExprWith> const; right: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprWith > const
right	ExpressionPtr

before the body block

AstVisitor.preVisitExprWhile(self: AstVisitor; expr: smart_ptr<ExprWhile> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprWhile > const

before ExprWhile

AstVisitor.visitExprWhile(self: AstVisitor; expr: smart_ptr<ExprWhile> const)

visitExprWhile returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprWhile > const

after ExprWhile

AstVisitor.preVisitExprWhileBody(self: AstVisitor; expr: smart_ptr<ExprWhile> const; right: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprWhile > const
right	ExpressionPtr

before the body block

AstVisitor.preVisitExprTryCatch(self: AstVisitor; expr: smart_ptr<ExprTryCatch> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTryCatch > const

before ExprTryCatch

AstVisitor.visitExprTryCatch(self: AstVisitor; expr: smart_ptr<ExprTryCatch> const)

visitExprTryCatch returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTryCatch > const

after ExprTryCatch

AstVisitor.preVisitExprTryCatchCatch(self: AstVisitor; expr: smart_ptr<ExprTryCatch> const; right: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTryCatch > const
right	ExpressionPtr

before the catch (recover) section

AstVisitor.preVisitExprIfThenElse(self: AstVisitor; expr: smart_ptr<ExprIfThenElse> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIfThenElse > const

before ExprIfThenElse

AstVisitor.visitExprIfThenElse(self: AstVisitor; expr: smart_ptr<ExprIfThenElse> const)

visitExprIfThenElse returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIfThenElse > const

after ExprIfThenElse

AstVisitor.preVisitExprIfThenElseIfBlock(self: AstVisitor; expr: smart_ptr<ExprIfThenElse> const; ifBlock: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIfThenElse > const
ifBlock	ExpressionPtr

before the if block

AstVisitor.preVisitExprIfThenElseElseBlock(self: AstVisitor; expr: smart_ptr<ExprIfThenElse> const; elseBlock: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIfThenElse > const
elseBlock	ExpressionPtr

before the else block

AstVisitor.preVisitExprFor(self: AstVisitor; expr: smart_ptr<ExprFor> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFor > const

before the ExprFor

AstVisitor.visitExprFor(self: AstVisitor; expr: smart_ptr<ExprFor> const)

visitExprFor returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFor > const

after the ExprFor

AstVisitor.preVisitExprForVariable(self: AstVisitor; expr: smart_ptr<ExprFor> const; svar: VariablePtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFor > const
svar	VariablePtr
last	bool const

before each variable

AstVisitor.visitExprForVariable(self: AstVisitor; expr: smart_ptr<ExprFor> const; svar: VariablePtr; last: bool const)

visitExprForVariable returns VariablePtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFor > const
svar	VariablePtr
last	bool const

after each variable

AstVisitor.preVisitExprForSource(self: AstVisitor; expr: smart_ptr<ExprFor> const; source: ExpressionPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFor > const
source	ExpressionPtr
last	bool const

before each source

AstVisitor.visitExprForSource(self: AstVisitor; expr: smart_ptr<ExprFor> const; source: ExpressionPtr; last: bool const)

visitExprForSource returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFor > const
source	ExpressionPtr
last	bool const

after each source

AstVisitor.preVisitExprForStack(self: AstVisitor; expr: smart_ptr<ExprFor> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFor > const

before the stack is allocated before the body, regardless if it has one

AstVisitor.preVisitExprForBody(self: AstVisitor; expr: smart_ptr<ExprFor> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFor > const

before the body (should it have one)

AstVisitor.preVisitExprMakeVariant(self: AstVisitor; expr: smart_ptr<ExprMakeVariant> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeVariant > const

before ExprMakeVariant

AstVisitor.visitExprMakeVariant(self: AstVisitor; expr: smart_ptr<ExprMakeVariant> const)

visitExprMakeVariant returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeVariant > const

after ExprMakeVariant

AstVisitor.preVisitExprMakeVariantField(self: AstVisitor; expr: smart_ptr<ExprMakeVariant> const; index: int const; decl: MakeFieldDeclPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeVariant > const
index	int const
decl	MakeFieldDeclPtr
last	bool const

before every field

AstVisitor.visitExprMakeVariantField(self: AstVisitor; expr: smart_ptr<ExprMakeVariant> const; index: int const; decl: MakeFieldDeclPtr; last: bool const)

visitExprMakeVariantField returns MakeFieldDeclPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeVariant > const
index	int const
decl	MakeFieldDeclPtr
last	bool const

after every field

AstVisitor.canVisitMakeStructBody(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const)

canVisitMakeStructBody returns bool

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const

if true the visitor can visit the body of ExprMakeStruct

AstVisitor.canVisitMakeStructBlock(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const; blk: ExpressionPtr)

canVisitMakeStructBlock returns bool

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const
blk	ExpressionPtr

if true the visitor can visit the block behind ExprMakeStruct

AstVisitor.preVisitExprMakeStruct(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const

before ExprMakeStruct

AstVisitor.visitExprMakeStruct(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const)

visitExprMakeStruct returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const

after ExprMakeStruct

AstVisitor.preVisitExprMakeStructIndex(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const; index: int const; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const
index	int const
last	bool const

before each struct in the array of structures

AstVisitor.visitExprMakeStructIndex(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const; index: int const; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const
index	int const
last	bool const

after each struct in the array of structures

AstVisitor.preVisitExprMakeStructField(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const; index: int const; decl: MakeFieldDeclPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const
index	int const
decl	MakeFieldDeclPtr
last	bool const

before each field of the struct, between preVisitExprMakeStructIndex and visitExprMakeStructIndex

AstVisitor.visitExprMakeStructField(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const; index: int const; decl: MakeFieldDeclPtr; last: bool const)

visitExprMakeStructField returns MakeFieldDeclPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const
index	int const
decl	MakeFieldDeclPtr
last	bool const

after each field of the struct, between preVisitExprMakeStructIndex and visitExprMakeStructIndex

AstVisitor.preVisitMakeStructureBlock(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const; blk: smart_ptr<Expression> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const
blk	smart_ptr< ast::Expression > const

before the block behind ExprMakeStruct

AstVisitor.visitMakeStructureBlock(self: AstVisitor; expr: smart_ptr<ExprMakeStruct> const; blk: smart_ptr<Expression> const)

visitMakeStructureBlock returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeStruct > const
blk	smart_ptr< ast::Expression > const

after the block behind ExprMakeStruct

AstVisitor.preVisitExprMakeArray(self: AstVisitor; expr: smart_ptr<ExprMakeArray> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeArray > const

before ExprMakeArray

AstVisitor.visitExprMakeArray(self: AstVisitor; expr: smart_ptr<ExprMakeArray> const)

visitExprMakeArray returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeArray > const

after ExprMakeArray

AstVisitor.preVisitExprMakeArrayIndex(self: AstVisitor; expr: smart_ptr<ExprMakeArray> const; index: int const; init: ExpressionPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeArray > const
index	int const
init	ExpressionPtr
last	bool const

before each element of the array

AstVisitor.visitExprMakeArrayIndex(self: AstVisitor; expr: smart_ptr<ExprMakeArray> const; index: int const; init: ExpressionPtr; last: bool const)

visitExprMakeArrayIndex returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeArray > const
index	int const
init	ExpressionPtr
last	bool const

after each element of the array

AstVisitor.preVisitExprMakeTuple(self: AstVisitor; expr: smart_ptr<ExprMakeTuple> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeTuple > const

before ExprMakeTuple

AstVisitor.visitExprMakeTuple(self: AstVisitor; expr: smart_ptr<ExprMakeTuple> const)

visitExprMakeTuple returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeTuple > const

after ExprMakeTuple

AstVisitor.preVisitExprMakeTupleIndex(self: AstVisitor; expr: smart_ptr<ExprMakeTuple> const; index: int const; init: ExpressionPtr; last: bool const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeTuple > const
index	int const
init	ExpressionPtr
last	bool const

before each field of the tuple

AstVisitor.visitExprMakeTupleIndex(self: AstVisitor; expr: smart_ptr<ExprMakeTuple> const; index: int const; init: ExpressionPtr; last: bool const)

visitExprMakeTupleIndex returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeTuple > const
index	int const
init	ExpressionPtr
last	bool const

after each field of the tuple

AstVisitor.preVisitExprArrayComprehension(self: AstVisitor; expr: smart_ptr<ExprArrayComprehension> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprArrayComprehension > const

before ExprArrayComprehension

AstVisitor.visitExprArrayComprehension(self: AstVisitor; expr: smart_ptr<ExprArrayComprehension> const)

visitExprArrayComprehension returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprArrayComprehension > const

after ExprArrayComprehension

AstVisitor.preVisitExprArrayComprehensionSubexpr(self: AstVisitor; expr: smart_ptr<ExprArrayComprehension> const; subexrp: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprArrayComprehension > const
subexrp	ExpressionPtr

before the subexpression

AstVisitor.preVisitExprArrayComprehensionWhere(self: AstVisitor; expr: smart_ptr<ExprArrayComprehension> const; filter: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprArrayComprehension > const
filter	ExpressionPtr

before the where clause

AstVisitor.preVisitExprTypeInfo(self: AstVisitor; expr: smart_ptr<ExprTypeInfo> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTypeInfo > const

before ExprTypeInfo

AstVisitor.visitExprTypeInfo(self: AstVisitor; expr: smart_ptr<ExprTypeInfo> const)

visitExprTypeInfo returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTypeInfo > const

after ExprTypeInfo

AstVisitor.preVisitExprPtr2Ref(self: AstVisitor; expr: smart_ptr<ExprPtr2Ref> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprPtr2Ref > const

before ExprPtr2Ref

AstVisitor.visitExprPtr2Ref(self: AstVisitor; expr: smart_ptr<ExprPtr2Ref> const)

visitExprPtr2Ref returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprPtr2Ref > const

after ExprPtr2Ref

AstVisitor.preVisitExprLabel(self: AstVisitor; expr: smart_ptr<ExprLabel> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLabel > const

before ExprLabel

AstVisitor.visitExprLabel(self: AstVisitor; expr: smart_ptr<ExprLabel> const)

visitExprLabel returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprLabel > const

after ExprLabel

AstVisitor.preVisitExprGoto(self: AstVisitor; expr: smart_ptr<ExprGoto> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprGoto > const

before ExprGoto

AstVisitor.visitExprGoto(self: AstVisitor; expr: smart_ptr<ExprGoto> const)

visitExprGoto returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprGoto > const

after ExprGoto

AstVisitor.preVisitExprRef2Value(self: AstVisitor; expr: smart_ptr<ExprRef2Value> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprRef2Value > const

before ExprRef2Value

AstVisitor.visitExprRef2Value(self: AstVisitor; expr: smart_ptr<ExprRef2Value> const)

visitExprRef2Value returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprRef2Value > const

after ExprRef2Value

AstVisitor.preVisitExprRef2Ptr(self: AstVisitor; expr: smart_ptr<ExprRef2Ptr> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprRef2Ptr > const

before ExprRef2Ptr

AstVisitor.visitExprRef2Ptr(self: AstVisitor; expr: smart_ptr<ExprRef2Ptr> const)

visitExprRef2Ptr returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprRef2Ptr > const

after ExprRef2Ptr

AstVisitor.preVisitExprAddr(self: AstVisitor; expr: smart_ptr<ExprAddr> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAddr > const

before ExprAddr

AstVisitor.visitExprAddr(self: AstVisitor; expr: smart_ptr<ExprAddr> const)

visitExprAddr returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAddr > const

after ExprAddr

AstVisitor.preVisitExprAssert(self: AstVisitor; expr: smart_ptr<ExprAssert> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAssert > const

before ExprAssert

AstVisitor.visitExprAssert(self: AstVisitor; expr: smart_ptr<ExprAssert> const)

visitExprAssert returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAssert > const

after ExprAssert

AstVisitor.preVisitExprStaticAssert(self: AstVisitor; expr: smart_ptr<ExprStaticAssert> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprStaticAssert > const

before ExprStaticAssert

AstVisitor.visitExprStaticAssert(self: AstVisitor; expr: smart_ptr<ExprStaticAssert> const)

visitExprStaticAssert returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprStaticAssert > const

after ExprStaticAssert

AstVisitor.preVisitExprQuote(self: AstVisitor; expr: smart_ptr<ExprQuote> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprQuote > const

before ExprQuote

AstVisitor.visitExprQuote(self: AstVisitor; expr: smart_ptr<ExprQuote> const)

visitExprQuote returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprQuote > const

after ExprQuote

AstVisitor.preVisitExprDebug(self: AstVisitor; expr: smart_ptr<ExprDebug> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprDebug > const

before ExprDebug

AstVisitor.visitExprDebug(self: AstVisitor; expr: smart_ptr<ExprDebug> const)

visitExprDebug returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprDebug > const

after ExprDebug

AstVisitor.preVisitExprInvoke(self: AstVisitor; expr: smart_ptr<ExprInvoke> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprInvoke > const

before ExprInvoke

AstVisitor.visitExprInvoke(self: AstVisitor; expr: smart_ptr<ExprInvoke> const)

visitExprInvoke returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprInvoke > const

after ExprInvoke

AstVisitor.preVisitExprErase(self: AstVisitor; expr: smart_ptr<ExprErase> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprErase > const

before ExprErase

AstVisitor.visitExprErase(self: AstVisitor; expr: smart_ptr<ExprErase> const)

visitExprErase returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprErase > const

after ExprErase

AstVisitor.preVisitExprSetInsert(self: AstVisitor; expr: smart_ptr<ExprSetInsert> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSetInsert > const

before ExprSetInsert

AstVisitor.visitExprSetInsert(self: AstVisitor; expr: smart_ptr<ExprSetInsert> const)

visitExprSetInsert returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSetInsert > const

after ExprSetInsert

AstVisitor.preVisitExprFind(self: AstVisitor; expr: smart_ptr<ExprFind> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFind > const

before ExprFind

AstVisitor.visitExprFind(self: AstVisitor; expr: smart_ptr<ExprFind> const)

visitExprFind returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFind > const

after ExprFind

AstVisitor.preVisitExprKeyExists(self: AstVisitor; expr: smart_ptr<ExprKeyExists> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprKeyExists > const

before ExprKeyExists

AstVisitor.visitExprKeyExists(self: AstVisitor; expr: smart_ptr<ExprKeyExists> const)

visitExprKeyExists returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprKeyExists > const

after ExprKeyExists

AstVisitor.preVisitExprAscend(self: AstVisitor; expr: smart_ptr<ExprAscend> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAscend > const

before ExprAscend

AstVisitor.visitExprAscend(self: AstVisitor; expr: smart_ptr<ExprAscend> const)

visitExprAscend returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAscend > const

after ExprAscend

AstVisitor.preVisitExprCast(self: AstVisitor; expr: smart_ptr<ExprCast> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCast > const

before ExprCast

AstVisitor.visitExprCast(self: AstVisitor; expr: smart_ptr<ExprCast> const)

visitExprCast returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCast > const

after ExprCast

AstVisitor.preVisitExprDelete(self: AstVisitor; expr: smart_ptr<ExprDelete> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprDelete > const

before ExprDelete

AstVisitor.visitExprDelete(self: AstVisitor; expr: smart_ptr<ExprDelete> const)

visitExprDelete returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprDelete > const

after ExprDelete

AstVisitor.preVisitExprVar(self: AstVisitor; expr: smart_ptr<ExprVar> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprVar > const

before ExprVar

AstVisitor.visitExprVar(self: AstVisitor; expr: smart_ptr<ExprVar> const)

visitExprVar returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprVar > const

after ExprVar

AstVisitor.preVisitExprTag(self: AstVisitor; expr: smart_ptr<ExprTag> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTag > const

before ExprTag

AstVisitor.preVisitExprTagValue(self: AstVisitor; expr: smart_ptr<ExprTag> const; value: ExpressionPtr)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTag > const
value	ExpressionPtr

before the value portion of ExprTag

AstVisitor.visitExprTag(self: AstVisitor; expr: smart_ptr<ExprTag> const)

visitExprTag returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprTag > const

after ExprTag

AstVisitor.preVisitExprField(self: AstVisitor; expr: smart_ptr<ExprField> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprField > const

before ExprField

AstVisitor.visitExprField(self: AstVisitor; expr: smart_ptr<ExprField> const)

visitExprField returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprField > const

after ExprField

AstVisitor.preVisitExprSafeField(self: AstVisitor; expr: smart_ptr<ExprSafeField> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSafeField > const

before ExprSafeField

AstVisitor.visitExprSafeField(self: AstVisitor; expr: smart_ptr<ExprSafeField> const)

visitExprSafeField returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSafeField > const

after ExprSafeField

AstVisitor.preVisitExprSwizzle(self: AstVisitor; expr: smart_ptr<ExprSwizzle> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSwizzle > const

before ExprSwizzle

AstVisitor.visitExprSwizzle(self: AstVisitor; expr: smart_ptr<ExprSwizzle> const)

visitExprSwizzle returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSwizzle > const

after ExprSwizzle

AstVisitor.preVisitExprIsVariant(self: AstVisitor; expr: smart_ptr<ExprIsVariant> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIsVariant > const

before ExprIsVariant

AstVisitor.visitExprIsVariant(self: AstVisitor; expr: smart_ptr<ExprIsVariant> const)

visitExprIsVariant returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprIsVariant > const

after ExprIsVariant

AstVisitor.preVisitExprAsVariant(self: AstVisitor; expr: smart_ptr<ExprAsVariant> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAsVariant > const

before ExprAsVariant

AstVisitor.visitExprAsVariant(self: AstVisitor; expr: smart_ptr<ExprAsVariant> const)

visitExprAsVariant returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprAsVariant > const

after ExprAsVariant

AstVisitor.preVisitExprSafeAsVariant(self: AstVisitor; expr: smart_ptr<ExprSafeAsVariant> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSafeAsVariant > const

before ExprSafeAsVariant

AstVisitor.visitExprSafeAsVariant(self: AstVisitor; expr: smart_ptr<ExprSafeAsVariant> const)

visitExprSafeAsVariant returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprSafeAsVariant > const

after ExprSafeAsVariant

AstVisitor.preVisitExprOp1(self: AstVisitor; expr: smart_ptr<ExprOp1> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp1 > const

before ExprOp1

AstVisitor.visitExprOp1(self: AstVisitor; expr: smart_ptr<ExprOp1> const)

visitExprOp1 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprOp1 > const

after ExprOp1

AstVisitor.preVisitExprReturn(self: AstVisitor; expr: smart_ptr<ExprReturn> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprReturn > const

before ExprReturn

AstVisitor.visitExprReturn(self: AstVisitor; expr: smart_ptr<ExprReturn> const)

visitExprReturn returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprReturn > const

after ExprReturn

AstVisitor.preVisitExprYield(self: AstVisitor; expr: smart_ptr<ExprYield> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprYield > const

before ExprYield

AstVisitor.visitExprYield(self: AstVisitor; expr: smart_ptr<ExprYield> const)

visitExprYield returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprYield > const

after ‘ExprYield’

AstVisitor.preVisitExprBreak(self: AstVisitor; expr: smart_ptr<ExprBreak> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprBreak > const

before ExprBreak

AstVisitor.visitExprBreak(self: AstVisitor; expr: smart_ptr<ExprBreak> const)

visitExprBreak returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprBreak > const

after ExprBreak

AstVisitor.preVisitExprContinue(self: AstVisitor; expr: smart_ptr<ExprContinue> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprContinue > const

before ExprContinue

AstVisitor.visitExprContinue(self: AstVisitor; expr: smart_ptr<ExprContinue> const)

visitExprContinue returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprContinue > const

after ExprContinue

AstVisitor.canVisitMakeBlockBody(self: AstVisitor; expr: smart_ptr<ExprMakeBlock> const)

canVisitMakeBlockBody returns bool

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeBlock > const

before the body of the makeBlock expression is visited. If true body will be visited

AstVisitor.preVisitExprMakeBlock(self: AstVisitor; expr: smart_ptr<ExprMakeBlock> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeBlock > const

before ExprMakeBlock

AstVisitor.visitExprMakeBlock(self: AstVisitor; expr: smart_ptr<ExprMakeBlock> const)

visitExprMakeBlock returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeBlock > const

after ExprMakeBlock

AstVisitor.preVisitExprMakeGenerator(self: AstVisitor; expr: smart_ptr<ExprMakeGenerator> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeGenerator > const

before ExprMakeGenerator

AstVisitor.visitExprMakeGenerator(self: AstVisitor; expr: smart_ptr<ExprMakeGenerator> const)

visitExprMakeGenerator returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMakeGenerator > const

after ExprMakeGenerator

AstVisitor.preVisitExprMemZero(self: AstVisitor; expr: smart_ptr<ExprMemZero> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMemZero > const

before ExprMemZero

AstVisitor.visitExprMemZero(self: AstVisitor; expr: smart_ptr<ExprMemZero> const)

visitExprMemZero returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprMemZero > const

after ExprMemZero

AstVisitor.preVisitExprConst(self: AstVisitor; expr: smart_ptr<ExprConst> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConst > const

before ExprConst

AstVisitor.visitExprConst(self: AstVisitor; expr: smart_ptr<ExprConst> const)

visitExprConst returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConst > const

after ExprConst

AstVisitor.preVisitExprConstPtr(self: AstVisitor; expr: smart_ptr<ExprConstPtr> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstPtr > const

before ExprConstPtr

AstVisitor.visitExprConstPtr(self: AstVisitor; expr: smart_ptr<ExprConstPtr> const)

visitExprConstPtr returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstPtr > const

after ExprConstPtr

AstVisitor.preVisitExprConstEnumeration(self: AstVisitor; expr: smart_ptr<ExprConstEnumeration> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstEnumeration > const

before ExprConstEnumeration

AstVisitor.visitExprConstEnumeration(self: AstVisitor; expr: smart_ptr<ExprConstEnumeration> const)

visitExprConstEnumeration returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstEnumeration > const

after ExprConstEnumeration

AstVisitor.preVisitExprConstBitfield(self: AstVisitor; expr: smart_ptr<ExprConstBitfield> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstBitfield > const

before ExprConstBitfield

AstVisitor.visitExprConstBitfield(self: AstVisitor; expr: smart_ptr<ExprConstBitfield> const)

visitExprConstBitfield returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstBitfield > const

after ExprConstBitfield

AstVisitor.preVisitExprConstInt8(self: AstVisitor; expr: smart_ptr<ExprConstInt8> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt8 > const

before ExprConstInt8

AstVisitor.visitExprConstInt8(self: AstVisitor; expr: smart_ptr<ExprConstInt8> const)

visitExprConstInt8 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt8 > const

after ExprConstInt8

AstVisitor.preVisitExprConstInt16(self: AstVisitor; expr: smart_ptr<ExprConstInt16> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt16 > const

before ExprConstInt16

AstVisitor.visitExprConstInt16(self: AstVisitor; expr: smart_ptr<ExprConstInt16> const)

visitExprConstInt16 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt16 > const

after ExprConstInt16

AstVisitor.preVisitExprConstInt64(self: AstVisitor; expr: smart_ptr<ExprConstInt64> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt64 > const

before ExprConstInt64

AstVisitor.visitExprConstInt64(self: AstVisitor; expr: smart_ptr<ExprConstInt64> const)

visitExprConstInt64 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt64 > const

after ExprConstInt64

AstVisitor.preVisitExprConstInt(self: AstVisitor; expr: smart_ptr<ExprConstInt> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt > const

before ExprConstInt

AstVisitor.visitExprConstInt(self: AstVisitor; expr: smart_ptr<ExprConstInt> const)

visitExprConstInt returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt > const

after ExprConstInt

AstVisitor.preVisitExprConstInt2(self: AstVisitor; expr: smart_ptr<ExprConstInt2> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt2 > const

before ExprConstInt2

AstVisitor.visitExprConstInt2(self: AstVisitor; expr: smart_ptr<ExprConstInt2> const)

visitExprConstInt2 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt2 > const

after ExprConstInt2

AstVisitor.preVisitExprConstInt3(self: AstVisitor; expr: smart_ptr<ExprConstInt3> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt3 > const

before ExprConstInt3

AstVisitor.visitExprConstInt3(self: AstVisitor; expr: smart_ptr<ExprConstInt3> const)

visitExprConstInt3 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt3 > const

after ExprConstInt3

AstVisitor.preVisitExprConstInt4(self: AstVisitor; expr: smart_ptr<ExprConstInt4> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt4 > const

before ExprConstInt4

AstVisitor.visitExprConstInt4(self: AstVisitor; expr: smart_ptr<ExprConstInt4> const)

visitExprConstInt4 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstInt4 > const

after ExprConstInt4

AstVisitor.preVisitExprConstUInt8(self: AstVisitor; expr: smart_ptr<ExprConstUInt8> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt8 > const

before ExprConstUInt8

AstVisitor.visitExprConstUInt8(self: AstVisitor; expr: smart_ptr<ExprConstUInt8> const)

visitExprConstUInt8 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt8 > const

after ExprConstUInt8

AstVisitor.preVisitExprConstUInt16(self: AstVisitor; expr: smart_ptr<ExprConstUInt16> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt16 > const

before ExprConstUInt16

AstVisitor.visitExprConstUInt16(self: AstVisitor; expr: smart_ptr<ExprConstUInt16> const)

visitExprConstUInt16 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt16 > const

after ExprConstUInt16

AstVisitor.preVisitExprConstUInt64(self: AstVisitor; expr: smart_ptr<ExprConstUInt64> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt64 > const

before ExprConstUInt64

AstVisitor.visitExprConstUInt64(self: AstVisitor; expr: smart_ptr<ExprConstUInt64> const)

visitExprConstUInt64 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt64 > const

after ExprConstUInt64

AstVisitor.preVisitExprConstUInt(self: AstVisitor; expr: smart_ptr<ExprConstUInt> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt > const

before ExprConstUInt

AstVisitor.visitExprConstUInt(self: AstVisitor; expr: smart_ptr<ExprConstUInt> const)

visitExprConstUInt returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt > const

after ExprConstUInt

AstVisitor.preVisitExprConstUInt2(self: AstVisitor; expr: smart_ptr<ExprConstUInt2> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt2 > const

before ExprConstUInt2

AstVisitor.visitExprConstUInt2(self: AstVisitor; expr: smart_ptr<ExprConstUInt2> const)

visitExprConstUInt2 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt2 > const

after ExprConstUInt2

AstVisitor.preVisitExprConstUInt3(self: AstVisitor; expr: smart_ptr<ExprConstUInt3> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt3 > const

before ExprConstUInt3

AstVisitor.visitExprConstUInt3(self: AstVisitor; expr: smart_ptr<ExprConstUInt3> const)

visitExprConstUInt3 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt3 > const

after ExprConstUInt3

AstVisitor.preVisitExprConstUInt4(self: AstVisitor; expr: smart_ptr<ExprConstUInt4> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt4 > const

before ExprConstUInt4

AstVisitor.visitExprConstUInt4(self: AstVisitor; expr: smart_ptr<ExprConstUInt4> const)

visitExprConstUInt4 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstUInt4 > const

after ExprConstUInt4

AstVisitor.preVisitExprConstRange(self: AstVisitor; expr: smart_ptr<ExprConstRange> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstRange > const

before ExprConstRange

AstVisitor.visitExprConstRange(self: AstVisitor; expr: smart_ptr<ExprConstRange> const)

visitExprConstRange returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstRange > const

after ExprConstRange

AstVisitor.preVisitExprConstURange(self: AstVisitor; expr: smart_ptr<ExprConstURange> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstURange > const

before ExprConstURange

AstVisitor.visitExprConstURange(self: AstVisitor; expr: smart_ptr<ExprConstURange> const)

visitExprConstURange returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstURange > const

after ExprConstURange

AstVisitor.preVisitExprConstRange64(self: AstVisitor; expr: smart_ptr<ExprConstRange64> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstRange64 > const

before ExprConstRange64

AstVisitor.visitExprConstRange64(self: AstVisitor; expr: smart_ptr<ExprConstRange64> const)

visitExprConstRange64 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstRange64 > const

after ExprConstRange64

AstVisitor.preVisitExprConstURange64(self: AstVisitor; expr: smart_ptr<ExprConstURange64> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstURange64 > const

before ExprConstURange64

AstVisitor.visitExprConstURange64(self: AstVisitor; expr: smart_ptr<ExprConstURange64> const)

visitExprConstURange64 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstURange64 > const

after ExprConstURange64

AstVisitor.preVisitExprConstBool(self: AstVisitor; expr: smart_ptr<ExprConstBool> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstBool > const

before ExprConstBool

AstVisitor.visitExprConstBool(self: AstVisitor; expr: smart_ptr<ExprConstBool> const)

visitExprConstBool returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstBool > const

after ExprConstBool

AstVisitor.preVisitExprConstFloat(self: AstVisitor; expr: smart_ptr<ExprConstFloat> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstFloat > const

before ExprConstFloat

AstVisitor.visitExprConstFloat(self: AstVisitor; expr: smart_ptr<ExprConstFloat> const)

visitExprConstFloat returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstFloat > const

after ExprConstFloat

AstVisitor.preVisitExprConstFloat2(self: AstVisitor; expr: smart_ptr<ExprConstFloat2> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstFloat2 > const

before ExprConstFloat2

AstVisitor.visitExprConstFloat2(self: AstVisitor; expr: smart_ptr<ExprConstFloat2> const)

visitExprConstFloat2 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstFloat2 > const

after ExprConstFloat2

AstVisitor.preVisitExprConstFloat3(self: AstVisitor; expr: smart_ptr<ExprConstFloat3> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstFloat3 > const

before ExprConstFloat3

AstVisitor.visitExprConstFloat3(self: AstVisitor; expr: smart_ptr<ExprConstFloat3> const)

visitExprConstFloat3 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstFloat3 > const

after ExprConstFloat3

AstVisitor.preVisitExprConstFloat4(self: AstVisitor; expr: smart_ptr<ExprConstFloat4> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstFloat4 > const

before ExprConstFloat4

AstVisitor.visitExprConstFloat4(self: AstVisitor; expr: smart_ptr<ExprConstFloat4> const)

visitExprConstFloat4 returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstFloat4 > const

after ExprConstFloat4

AstVisitor.preVisitExprConstString(self: AstVisitor; expr: smart_ptr<ExprConstString> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstString > const

before ExprConstString

AstVisitor.visitExprConstString(self: AstVisitor; expr: smart_ptr<ExprConstString> const)

visitExprConstString returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstString > const

after ExprConstString

AstVisitor.preVisitExprConstDouble(self: AstVisitor; expr: smart_ptr<ExprConstDouble> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstDouble > const

before ExprConstDouble

AstVisitor.visitExprConstDouble(self: AstVisitor; expr: smart_ptr<ExprConstDouble> const)

visitExprConstDouble returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprConstDouble > const

after ExprConstDouble

AstVisitor.preVisitExprFakeContext(self: AstVisitor; expr: smart_ptr<ExprFakeContext> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFakeContext > const

before ExprConstFakeContext

AstVisitor.visitExprFakeContext(self: AstVisitor; expr: smart_ptr<ExprFakeContext> const)

visitExprFakeContext returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFakeContext > const

after ExprConstFakeContext

AstVisitor.preVisitExprFakeLineInfo(self: AstVisitor; expr: smart_ptr<ExprFakeLineInfo> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFakeLineInfo > const

before ExprConstFakeLineInfo

AstVisitor.visitExprFakeLineInfo(self: AstVisitor; expr: smart_ptr<ExprFakeLineInfo> const)

visitExprFakeLineInfo returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprFakeLineInfo > const

after ExprConstFakeLineInfo

AstVisitor.preVisitExprReader(self: AstVisitor; expr: smart_ptr<ExprReader> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprReader > const

before ExprReader

AstVisitor.visitExprReader(self: AstVisitor; expr: smart_ptr<ExprReader> const)

visitExprReader returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprReader > const

after ExprReader

AstVisitor.preVisitExprUnsafe(self: AstVisitor; expr: smart_ptr<ExprUnsafe> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprUnsafe > const

before ExprUnsafe

AstVisitor.visitExprUnsafe(self: AstVisitor; expr: smart_ptr<ExprUnsafe> const)

visitExprUnsafe returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprUnsafe > const

after ExprUnsafe

AstVisitor.preVisitExprCallMacro(self: AstVisitor; expr: smart_ptr<ExprCallMacro> const)

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCallMacro > const

before ExprCallMacro

AstVisitor.visitExprCallMacro(self: AstVisitor; expr: smart_ptr<ExprCallMacro> const)

visitExprCallMacro returns ExpressionPtr

argument	argument type
self	ast::AstVisitor
expr	smart_ptr< ast::ExprCallMacro > const

after ExprCallMacro

12.8. Call generation

• make_call (at:rtti::LineInfo const implicit;name:string const implicit) : smart_ptr<ast::Expression>

make_call(at: LineInfo const implicit; name: string const implicit)

make_call returns smart_ptr< ast::Expression >

argument	argument type
at	rtti::LineInfo const implicit
name	string const implicit

Creates appropriate call expression for the given call function name in the Program. ExprCallMacro will be created if appropriate macro is found. Otherwise ExprCall will be created.

12.9. Visitor pattern

• visit (program:smart_ptr<rtti::Program> const implicit;adapter:smart_ptr<ast::VisitorAdapter> const implicit;context:__context const;line:__lineInfo const) : void

• visit_modules (program:smart_ptr<rtti::Program> const implicit;adapter:smart_ptr<ast::VisitorAdapter> const implicit;context:__context const;line:__lineInfo const) : void

• visit (function:smart_ptr<ast::Function> const implicit;adapter:smart_ptr<ast::VisitorAdapter> const implicit;context:__context const;line:__lineInfo const) : void

• visit (expression:smart_ptr<ast::Expression> const implicit;adapter:smart_ptr<ast::VisitorAdapter> const implicit;context:__context const;line:__lineInfo const) : smart_ptr<ast::Expression>

• visit_finally (expression:smart_ptr<ast::ExprBlock> const implicit;adapter:smart_ptr<ast::VisitorAdapter> const implicit;context:__context const;line:__lineInfo const) : void

visit(program: smart_ptr<Program> const implicit; adapter: smart_ptr<VisitorAdapter> const implicit)

argument	argument type
program	smart_ptr< rtti::Program > const implicit
adapter	smart_ptr< ast::VisitorAdapter > const implicit

Invokes visitor for the given object.

visit_modules(program: smart_ptr<Program> const implicit; adapter: smart_ptr<VisitorAdapter> const implicit)

argument	argument type
program	smart_ptr< rtti::Program > const implicit
adapter	smart_ptr< ast::VisitorAdapter > const implicit

Invokes visitor for the given list of modules inside the Program.

visit(function: smart_ptr<Function> const implicit; adapter: smart_ptr<VisitorAdapter> const implicit)

argument	argument type
function	smart_ptr< ast::Function > const implicit
adapter	smart_ptr< ast::VisitorAdapter > const implicit

Invokes visitor for the given object.

visit(expression: smart_ptr<Expression> const implicit; adapter: smart_ptr<VisitorAdapter> const implicit)

visit returns smart_ptr< ast::Expression >

argument	argument type
expression	smart_ptr< ast::Expression > const implicit
adapter	smart_ptr< ast::VisitorAdapter > const implicit

Invokes visitor for the given object.

visit_finally(expression: smart_ptr<ExprBlock> const implicit; adapter: smart_ptr<VisitorAdapter> const implicit)

argument	argument type
expression	smart_ptr< ast::ExprBlock > const implicit
adapter	smart_ptr< ast::VisitorAdapter > const implicit

Calls visit on the finally section of the block.

12.10. Expression generation

• force_generated (expression:smart_ptr<ast::Expression> const& implicit;value:bool const) : void

• get_expression_annotation (expr:ast::Expression? const implicit;context:__context const;line:__lineInfo const) : rtti::Annotation?

• make_type_info_structure (ctx:rtti::Context implicit;type:smart_ptr<ast::TypeDecl> const implicit;context:__context const;at:__lineInfo const) : rtti::TypeInfo?

force_generated(expression: smart_ptr<Expression> const& implicit; value: bool const)

argument	argument type
expression	smart_ptr< ast::Expression > const& implicit
value	bool const

Forces generated flag on subexrepssion.

get_expression_annotation(expr: Expression? const implicit)

get_expression_annotation returns rtti::Annotation ?

argument	argument type
expr	ast::Expression ? const implicit

Get ‘Annotation’ for the ‘ast::Expression’ and its inherited types.

make_type_info_structure(ctx: Context implicit; type: smart_ptr<TypeDecl> const implicit)

make_type_info_structure returns rtti::TypeInfo ?

argument	argument type
ctx	rtti::Context implicit
type	smart_ptr< ast::TypeDecl > const implicit

Returns new TypeInfo corresponding to the specific type.

12.11. Adapter generation

• make_visitor (class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::VisitorAdapter>

• make_function_annotation (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::FunctionAnnotation>

• make_block_annotation (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::FunctionAnnotation>

• make_structure_annotation (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::StructureAnnotation>

• make_enumeration_annotation (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::EnumerationAnnotation>

• make_pass_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::PassMacro>

• make_reader_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::ReaderMacro>

• make_comment_reader (class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::CommentReader>

• make_call_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::CallMacro>

• make_typeinfo_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::TypeInfoMacro>

• make_variant_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::VariantMacro>

• make_for_loop_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::ForLoopMacro>

• make_capture_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::CaptureMacro>

• make_type_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::TypeMacro>

• make_simulate_macro (name:string const implicit;class:void? const implicit;info:rtti::StructInfo const? const implicit;context:__context const) : smart_ptr<ast::SimulateMacro>

• make_clone_structure (structure:ast::Structure? const implicit) : smart_ptr<ast::Function>

• make_function_annotation (name:string const;someClassPtr:auto const) : smart_ptr<ast::FunctionAnnotation>

• make_block_annotation (name:string const;someClassPtr:auto const) : smart_ptr<ast::FunctionAnnotation>

• make_structure_annotation (name:string const;someClassPtr:auto const) : smart_ptr<ast::StructureAnnotation>

• make_enumeration_annotation (name:string const;someClassPtr:auto const) : smart_ptr<ast::EnumerationAnnotation>

• make_visitor (someClass:auto const) : smart_ptr<ast::VisitorAdapter>

• make_reader_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::ReaderMacro>

• make_comment_reader (name:string const;someClassPtr:auto const) : smart_ptr<ast::CommentReader>

• make_call_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::CallMacro>

• make_typeinfo_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::TypeInfoMacro>

• make_pass_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::PassMacro>

• make_variant_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::VariantMacro>

• make_for_loop_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::ForLoopMacro>

• make_capture_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::CaptureMacro>

• make_type_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::TypeMacro>

• make_simulate_macro (name:string const;someClassPtr:auto const) : smart_ptr<ast::SimulateMacro>

make_visitor(class: void? const implicit; info: StructInfo const? const implicit)

make_visitor returns smart_ptr< ast::VisitorAdapter >

argument	argument type
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstVisitor interface.

make_function_annotation(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_function_annotation returns smart_ptr< ast::FunctionAnnotation >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstFunctionAnnotation.

make_block_annotation(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_block_annotation returns smart_ptr< ast::FunctionAnnotation >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstBlockAnnotation.

make_structure_annotation(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_structure_annotation returns smart_ptr< ast::StructureAnnotation >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstStructureAnnotation.

make_enumeration_annotation(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_enumeration_annotation returns smart_ptr< ast::EnumerationAnnotation >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstEnumearationAnnotation.

make_pass_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_pass_macro returns smart_ptr< ast::PassMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstPassMacro.

make_reader_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_reader_macro returns smart_ptr< ast::ReaderMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstReaderMacro.

make_comment_reader(class: void? const implicit; info: StructInfo const? const implicit)

make_comment_reader returns smart_ptr< ast::CommentReader >

argument	argument type
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstCommentReader.

make_call_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_call_macro returns smart_ptr< ast::CallMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstCallMacro.

make_typeinfo_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_typeinfo_macro returns smart_ptr< ast::TypeInfoMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstTypeInfo macro.

make_variant_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_variant_macro returns smart_ptr< ast::VariantMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstVariantMacro.

make_for_loop_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_for_loop_macro returns smart_ptr< ast::ForLoopMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstForLoopMacro.

make_capture_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_capture_macro returns smart_ptr< ast::CaptureMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the AstCaptureMacro.

make_type_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_type_macro returns smart_ptr< ast::TypeMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the ‘AstTypeMacro’ interface.

make_simulate_macro(name: string const implicit; class: void? const implicit; info: StructInfo const? const implicit)

make_simulate_macro returns smart_ptr< ast::SimulateMacro >

argument	argument type
name	string const implicit
class	void? const implicit
info	rtti::StructInfo const? const implicit

Creates adapter for the ‘AstSimulateMacro’ interface.

make_clone_structure(structure: Structure? const implicit)

make_clone_structure returns smart_ptr< ast::Function >

argument	argument type
structure	ast::Structure ? const implicit

Generates clone function for the given structure.

make_function_annotation(name: string const; someClassPtr: auto const)

make_function_annotation returns FunctionAnnotationPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstFunctionAnnotation.

make_block_annotation(name: string const; someClassPtr: auto const)

make_block_annotation returns FunctionAnnotationPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstBlockAnnotation.

make_structure_annotation(name: string const; someClassPtr: auto const)

make_structure_annotation returns StructureAnnotationPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstStructureAnnotation.

make_enumeration_annotation(name: string const; someClassPtr: auto const)

make_enumeration_annotation returns EnumerationAnnotationPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstEnumearationAnnotation.

make_visitor(someClass: auto const)

make_visitor returns smart_ptr< ast::VisitorAdapter >

argument	argument type
someClass	auto const

Creates adapter for the AstVisitor interface.

make_reader_macro(name: string const; someClassPtr: auto const)

make_reader_macro returns ReaderMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstReaderMacro.

make_comment_reader(name: string const; someClassPtr: auto const)

make_comment_reader returns CommentReaderPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstCommentReader.

make_call_macro(name: string const; someClassPtr: auto const)

make_call_macro returns CallMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstCallMacro.

make_typeinfo_macro(name: string const; someClassPtr: auto const)

make_typeinfo_macro returns TypeInfoMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstTypeInfo macro.

make_pass_macro(name: string const; someClassPtr: auto const)

make_pass_macro returns PassMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstPassMacro.

make_variant_macro(name: string const; someClassPtr: auto const)

make_variant_macro returns VariantMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstVariantMacro.

make_for_loop_macro(name: string const; someClassPtr: auto const)

make_for_loop_macro returns ForLoopMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstForLoopMacro.

make_capture_macro(name: string const; someClassPtr: auto const)

make_capture_macro returns CaptureMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the AstCaptureMacro.

make_type_macro(name: string const; someClassPtr: auto const)

make_type_macro returns TypeMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the ‘AstTypeMacro’ interface.

make_simulate_macro(name: string const; someClassPtr: auto const)

make_simulate_macro returns SimulateMacroPtr

argument	argument type
name	string const
someClassPtr	auto const

Creates adapter for the ‘AstSimulateMacro’ interface.

12.12. Adapter application

• add_function_annotation (module:rtti::Module? const implicit;annotation:smart_ptr<ast::FunctionAnnotation>& implicit;context:__context const;at:__lineInfo const) : void

• add_function_annotation (function:smart_ptr<ast::Function> const implicit;annotation:smart_ptr<ast::FunctionAnnotation>& implicit;context:__context const;at:__lineInfo const) : void

• add_function_annotation (function:smart_ptr<ast::Function> const implicit;annotation:smart_ptr<rtti::AnnotationDeclaration>& implicit;context:__context const;at:__lineInfo const) : void

• add_block_annotation (block:smart_ptr<ast::ExprBlock> const implicit;annotation:smart_ptr<ast::FunctionAnnotation>& implicit;context:__context const;at:__lineInfo const) : void

• add_block_annotation (block:smart_ptr<ast::ExprBlock> const implicit;annotation:smart_ptr<rtti::AnnotationDeclaration>& implicit;context:__context const;at:__lineInfo const) : void

• add_structure_annotation (module:rtti::Module? const implicit;annotation:smart_ptr<ast::StructureAnnotation>& implicit;context:__context const;at:__lineInfo const) : void

• add_structure_annotation (structure:smart_ptr<ast::Structure> const implicit;annotation:smart_ptr<ast::StructureAnnotation>& implicit;context:__context const;at:__lineInfo const) : void

• add_structure_annotation (structure:smart_ptr<ast::Structure> const implicit;annotation:smart_ptr<rtti::AnnotationDeclaration>& implicit;context:__context const;at:__lineInfo const) : void

• add_enumeration_annotation (module:rtti::Module? const implicit;annotation:smart_ptr<ast::EnumerationAnnotation>& implicit;context:__context const;at:__lineInfo const) : void

• add_infer_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::PassMacro>& implicit;context:__context const) : void

• add_dirty_infer_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::PassMacro>& implicit;context:__context const) : void

• add_lint_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::PassMacro>& implicit;context:__context const) : void

• add_global_lint_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::PassMacro>& implicit;context:__context const) : void

• add_optimization_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::PassMacro>& implicit;context:__context const) : void

• add_reader_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::ReaderMacro>& implicit;context:__context const;at:__lineInfo const) : void

• add_comment_reader (module:rtti::Module? const implicit;reader:smart_ptr<ast::CommentReader>& implicit;context:__context const;at:__lineInfo const) : void

• add_call_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::CallMacro>& implicit;context:__context const;at:__lineInfo const) : void

• add_typeinfo_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::TypeInfoMacro>& implicit;context:__context const;at:__lineInfo const) : void

• add_variant_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::VariantMacro>& implicit;context:__context const) : void

• add_for_loop_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::ForLoopMacro>& implicit;context:__context const) : void

• add_capture_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::CaptureMacro>& implicit;context:__context const) : void

• add_type_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::TypeMacro>& implicit;context:__context const;at:__lineInfo const) : void

• add_simulate_macro (module:rtti::Module? const implicit;annotation:smart_ptr<ast::SimulateMacro>& implicit;context:__context const) : void

• add_module_option (module:rtti::Module? const implicit;option:string const implicit;type:rtti::Type const;context:__context const;at:__lineInfo const) : void

• add_new_block_annotation (name:string const;someClassPtr:auto const) : auto

• add_new_function_annotation (name:string const;someClassPtr:auto const) : auto

• add_new_contract_annotation (name:string const;someClassPtr:auto const) : auto

• add_new_structure_annotation (name:string const;someClassPtr:auto const) : auto

• add_new_enumeration_annotation (name:string const;someClassPtr:auto const) : auto

• add_new_variant_macro (name:string const;someClassPtr:auto const) : auto

• add_new_for_loop_macro (name:string const;someClassPtr:auto const) : auto

• add_new_capture_macro (name:string const;someClassPtr:auto const) : auto

• add_new_type_macro (name:string const;someClassPtr:auto const) : auto

• add_new_simulate_macro (name:string const;someClassPtr:auto const) : auto

• add_new_reader_macro (name:string const;someClassPtr:auto const) : auto

• add_new_comment_reader (name:string const;someClassPtr:auto const) : auto

• add_new_call_macro (name:string const;someClassPtr:auto const) : auto

• add_new_typeinfo_macro (name:string const;someClassPtr:auto const) : auto

• add_new_infer_macro (name:string const;someClassPtr:auto const) : auto

• add_new_dirty_infer_macro (name:string const;someClassPtr:auto const) : auto

• add_new_lint_macro (name:string const;someClassPtr:auto const) : auto

• add_new_global_lint_macro (name:string const;someClassPtr:auto const) : auto

• add_new_optimization_macro (name:string const;someClassPtr:auto const) : auto

add_function_annotation(module: Module? const implicit; annotation: smart_ptr<FunctionAnnotation>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::FunctionAnnotation >& implicit

Adds function annotation to the given object. Calls apply if applicable.

add_function_annotation(function: smart_ptr<Function> const implicit; annotation: smart_ptr<FunctionAnnotation>& implicit)

argument	argument type
function	smart_ptr< ast::Function > const implicit
annotation	smart_ptr< ast::FunctionAnnotation >& implicit

Adds function annotation to the given object. Calls apply if applicable.

add_function_annotation(function: smart_ptr<Function> const implicit; annotation: smart_ptr<AnnotationDeclaration>& implicit)

argument	argument type
function	smart_ptr< ast::Function > const implicit
annotation	smart_ptr< rtti::AnnotationDeclaration >& implicit

Adds function annotation to the given object. Calls apply if applicable.

add_block_annotation(block: smart_ptr<ExprBlock> const implicit; annotation: smart_ptr<FunctionAnnotation>& implicit)

argument	argument type
block	smart_ptr< ast::ExprBlock > const implicit
annotation	smart_ptr< ast::FunctionAnnotation >& implicit

Adds annotation declaration to the block.

add_block_annotation(block: smart_ptr<ExprBlock> const implicit; annotation: smart_ptr<AnnotationDeclaration>& implicit)

argument	argument type
block	smart_ptr< ast::ExprBlock > const implicit
annotation	smart_ptr< rtti::AnnotationDeclaration >& implicit

Adds annotation declaration to the block.

add_structure_annotation(module: Module? const implicit; annotation: smart_ptr<StructureAnnotation>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::StructureAnnotation >& implicit

Adds structure annotation to the given object. Calls apply if applicable.

add_structure_annotation(structure: smart_ptr<Structure> const implicit; annotation: smart_ptr<StructureAnnotation>& implicit)

argument	argument type
structure	smart_ptr< ast::Structure > const implicit
annotation	smart_ptr< ast::StructureAnnotation >& implicit

Adds structure annotation to the given object. Calls apply if applicable.

add_structure_annotation(structure: smart_ptr<Structure> const implicit; annotation: smart_ptr<AnnotationDeclaration>& implicit)

argument	argument type
structure	smart_ptr< ast::Structure > const implicit
annotation	smart_ptr< rtti::AnnotationDeclaration >& implicit

Adds structure annotation to the given object. Calls apply if applicable.

add_enumeration_annotation(module: Module? const implicit; annotation: smart_ptr<EnumerationAnnotation>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::EnumerationAnnotation >& implicit

Adds enumeration annotation to the given object. Calls apply if applicable.

add_infer_macro(module: Module? const implicit; annotation: smart_ptr<PassMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the infer` pass.

add_dirty_infer_macro(module: Module? const implicit; annotation: smart_ptr<PassMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the dirty infer pass.

add_lint_macro(module: Module? const implicit; annotation: smart_ptr<PassMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the lint pass.

add_global_lint_macro(module: Module? const implicit; annotation: smart_ptr<PassMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the global lint pass.

add_optimization_macro(module: Module? const implicit; annotation: smart_ptr<PassMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::PassMacro >& implicit

Adds AstPassMacro adapter to the optimization pass.

add_reader_macro(module: Module? const implicit; annotation: smart_ptr<ReaderMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::ReaderMacro >& implicit

Adds AstReaderMacro adapter to the specific module.

add_comment_reader(module: Module? const implicit; reader: smart_ptr<CommentReader>& implicit)

argument	argument type
module	rtti::Module ? const implicit
reader	smart_ptr< ast::CommentReader >& implicit

Adds AstCommentReader adapter to the specific module.

add_call_macro(module: Module? const implicit; annotation: smart_ptr<CallMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::CallMacro >& implicit

Adds AstCallMacro adapter to the specific module.

add_typeinfo_macro(module: Module? const implicit; annotation: smart_ptr<TypeInfoMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::TypeInfoMacro >& implicit

Adds AstTypeInfo adapter to the specific module.

add_variant_macro(module: Module? const implicit; annotation: smart_ptr<VariantMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::VariantMacro >& implicit

Adds AstVariantMacro to the specific module.

add_for_loop_macro(module: Module? const implicit; annotation: smart_ptr<ForLoopMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::ForLoopMacro >& implicit

Adds AstForLoopMacro to the specific module.

add_capture_macro(module: Module? const implicit; annotation: smart_ptr<CaptureMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::CaptureMacro >& implicit

Adds AstCaptureMacro to the specific module.

add_type_macro(module: Module? const implicit; annotation: smart_ptr<TypeMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::TypeMacro >& implicit

Adds ‘AstTypeMacro’ to the specific module.

add_simulate_macro(module: Module? const implicit; annotation: smart_ptr<SimulateMacro>& implicit)

argument	argument type
module	rtti::Module ? const implicit
annotation	smart_ptr< ast::SimulateMacro >& implicit

Adds AstSimulateMacro to the specific module.

add_module_option(module: Module? const implicit; option: string const implicit; type: Type const)

argument	argument type
module	rtti::Module ? const implicit
option	string const implicit
type	rtti::Type const

Add module-specific option, which is accessible via “options” keyword.

add_new_block_annotation(name: string const; someClassPtr: auto const)

add_new_block_annotation returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstBlockAnnotation and adds it to the current module.

add_new_function_annotation(name: string const; someClassPtr: auto const)

add_new_function_annotation returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstFunctionAnnotation and adds it to the current module.

add_new_contract_annotation(name: string const; someClassPtr: auto const)

add_new_contract_annotation returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstContractAnnotation and adds it to the current module.

add_new_structure_annotation(name: string const; someClassPtr: auto const)

add_new_structure_annotation returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstStructureAnnotation and adds it to the current module.

add_new_enumeration_annotation(name: string const; someClassPtr: auto const)

add_new_enumeration_annotation returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstEnumerationAnnotation and adds it to the current module.

add_new_variant_macro(name: string const; someClassPtr: auto const)

add_new_variant_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstVariantMacro and adds it to the current module.

add_new_for_loop_macro(name: string const; someClassPtr: auto const)

add_new_for_loop_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstForLoopMacro and adds it to the current module.

add_new_capture_macro(name: string const; someClassPtr: auto const)

add_new_capture_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstCaptureMacro and adds it to the current module.

add_new_type_macro(name: string const; someClassPtr: auto const)

add_new_type_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the ‘AstTypeMacro’ and adds it to the current module.

add_new_simulate_macro(name: string const; someClassPtr: auto const)

add_new_simulate_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstSimulateMacro and adds it to the current module.

add_new_reader_macro(name: string const; someClassPtr: auto const)

add_new_reader_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstReaderMacro and adds it to the current module.

add_new_comment_reader(name: string const; someClassPtr: auto const)

add_new_comment_reader returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstCommentReader and adds it to the current module.

add_new_call_macro(name: string const; someClassPtr: auto const)

add_new_call_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstCallMacro and adds it to the current module.

add_new_typeinfo_macro(name: string const; someClassPtr: auto const)

add_new_typeinfo_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstTypeInfoMacro and adds it to the current module.

add_new_infer_macro(name: string const; someClassPtr: auto const)

add_new_infer_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstPassMacro and adds it to the current module infer pass.

add_new_dirty_infer_macro(name: string const; someClassPtr: auto const)

add_new_dirty_infer_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstPassMacro and adds it to the current module dirty infer pass.

add_new_lint_macro(name: string const; someClassPtr: auto const)

add_new_lint_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstPassMacro and adds it to the current module lint pass.

add_new_global_lint_macro(name: string const; someClassPtr: auto const)

add_new_global_lint_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstPassMacro and adds it to the current module global lint pass.

add_new_optimization_macro(name: string const; someClassPtr: auto const)

add_new_optimization_macro returns auto

argument	argument type
name	string const
someClassPtr	auto const

Makes adapter to the AstPassMacro and adds it to the current module optimization pass.

12.13. Adding objects to objects

• add_enumeration_entry (enum:smart_ptr<ast::Enumeration> const implicit;name:string const implicit) : int

• add_function (module:rtti::Module? const implicit;function:smart_ptr<ast::Function>& implicit;context:__context const;line:__lineInfo const) : bool

• add_generic (module:rtti::Module? const implicit;function:smart_ptr<ast::Function>& implicit;context:__context const;line:__lineInfo const) : bool

• add_variable (module:rtti::Module? const implicit;variable:smart_ptr<ast::Variable>& implicit;context:__context const;line:__lineInfo const) : bool

• add_keyword (module:rtti::Module? const implicit;keyword:string const implicit;needOxfordComma:bool const;context:__context const;line:__lineInfo const) : bool

• add_type_function (module:rtti::Module? const implicit;keyword:string const implicit;context:__context const;line:__lineInfo const) : bool

• add_structure (module:rtti::Module? const implicit;structure:smart_ptr<ast::Structure>& implicit) : bool

• add_alias (module:rtti::Module? const implicit;structure:smart_ptr<ast::TypeDecl>& implicit) : bool

• add_module_require (module:rtti::Module? const implicit;publicModule:rtti::Module? const implicit;pub:bool const) : bool

add_enumeration_entry(enum: smart_ptr<Enumeration> const implicit; name: string const implicit)

add_enumeration_entry returns int

argument	argument type
enum	smart_ptr< ast::Enumeration > const implicit
name	string const implicit

Adds entry to enumeration annotation.

add_function(module: Module? const implicit; function: smart_ptr<Function>& implicit)

add_function returns bool

argument	argument type
module	rtti::Module ? const implicit
function	smart_ptr< ast::Function >& implicit

Adds function to a Module. Will return false on duplicates.

add_generic(module: Module? const implicit; function: smart_ptr<Function>& implicit)

add_generic returns bool

argument	argument type
module	rtti::Module ? const implicit
function	smart_ptr< ast::Function >& implicit

Adds generic function to a Module. Will return false on duplicates.

add_variable(module: Module? const implicit; variable: smart_ptr<Variable>& implicit)

add_variable returns bool

argument	argument type
module	rtti::Module ? const implicit
variable	smart_ptr< ast::Variable >& implicit

Adds variable to a Module. Will return false on duplicates.

add_keyword(module: Module? const implicit; keyword: string const implicit; needOxfordComma: bool const)

add_keyword returns bool

argument	argument type
module	rtti::Module ? const implicit
keyword	string const implicit
needOxfordComma	bool const

Adds new keyword. It can appear in the keyword <type> expr or keyword expr block syntax. See daslib/match as implementation example.

add_type_function(module: Module? const implicit; keyword: string const implicit)

add_type_function returns bool

argument	argument type
module	rtti::Module ? const implicit
keyword	string const implicit

Adds type function keyword, i.e allow function call to have several type arguments first via the following syntax some_call<type_args>(regular_args).

add_structure(module: Module? const implicit; structure: smart_ptr<Structure>& implicit)

add_structure returns bool

argument	argument type
module	rtti::Module ? const implicit
structure	smart_ptr< ast::Structure >& implicit

Adds structure to a Module. Will return false on duplicates.

add_alias(module: Module? const implicit; structure: smart_ptr<TypeDecl>& implicit)

add_alias returns bool

argument	argument type
module	rtti::Module ? const implicit
structure	smart_ptr< ast::TypeDecl >& implicit

Adds type alias to the specified module.

add_module_require(module: Module? const implicit; publicModule: Module? const implicit; pub: bool const)

add_module_require returns bool

argument	argument type
module	rtti::Module ? const implicit
publicModule	rtti::Module ? const implicit
pub	bool const

Add module dependencies similar to “require” keyword.

12.14. Program and module access

• this_program (context:__context const) : smart_ptr<rtti::Program>

• this_module (context:__context const;line:__lineInfo const) : rtti::Module?

• compiling_program (context:__context const;at:__lineInfo const) : smart_ptr<rtti::Program>

• compiling_module (context:__context const;at:__lineInfo const) : rtti::Module?

this_program()

this_program returns smart_ptr< rtti::Program >

Program attached to the current context (or null if RTTI is disabled).

this_module()

this_module returns rtti::Module ?

Main module attached to the current context (will through if RTTI is disabled).

compiling_program()

compiling_program returns smart_ptr< rtti::Program >

Currently compiling program.

compiling_module()

compiling_module returns rtti::Module ?

Currently compiling module.

12.15. Textual descriptions of the objects

• describe_typedecl (type:smart_ptr<ast::TypeDecl> const implicit;extra:bool const;contracts:bool const;module:bool const;context:__context const;lineinfo:__lineInfo const) : string

• describe_typedecl_cpp (type:smart_ptr<ast::TypeDecl> const implicit;substitueRef:bool const;skipRef:bool const;skipConst:bool const;redundantConst:bool const;context:__context const;lineinfo:__lineInfo const) : string

• describe_expression (expression:smart_ptr<ast::Expression> const implicit;context:__context const;lineinfo:__lineInfo const) : string

• describe_function (function:smart_ptr<ast::Function> const implicit;context:__context const;lineinfo:__lineInfo const) : string

• das_to_string (type:rtti::Type const;context:__context const;at:__lineInfo const) : string

• describe (decl:smart_ptr<ast::TypeDecl> const;extra:bool const;contracts:bool const;modules:bool const) : auto

• describe_cpp (decl:smart_ptr<ast::TypeDecl> const;substitureRef:bool const;skipRef:bool const;skipConst:bool const;redundantConst:bool const) : auto

• describe (expr:smart_ptr<ast::Expression> const) : auto

• describe (expr:smart_ptr<ast::Function> const) : auto

describe_typedecl(type: smart_ptr<TypeDecl> const implicit; extra: bool const; contracts: bool const; module: bool const)

describe_typedecl returns string

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit
extra	bool const
contracts	bool const
module	bool const

Returns description of the TypeDecl which should match corresponding Daslang type declaration.

describe_typedecl_cpp(type: smart_ptr<TypeDecl> const implicit; substitueRef: bool const; skipRef: bool const; skipConst: bool const; redundantConst: bool const)

describe_typedecl_cpp returns string

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit
substitueRef	bool const
skipRef	bool const
skipConst	bool const
redundantConst	bool const

Returns description of the TypeDecl which should match corresponding C++ type declaration.

describe_expression(expression: smart_ptr<Expression> const implicit)

describe_expression returns string

argument	argument type
expression	smart_ptr< ast::Expression > const implicit

Returns description of the Expression which should match corresponding Daslang code.

describe_function(function: smart_ptr<Function> const implicit)

describe_function returns string

argument	argument type
function	smart_ptr< ast::Function > const implicit

Returns description of the Function which should match corresponding Daslang function declaration.

das_to_string(type: Type const)

das_to_string returns string

argument	argument type
type	rtti::Type const

Returns description (name) of the corresponding Type.

describe(decl: smart_ptr<TypeDecl> const; extra: bool const; contracts: bool const; modules: bool const)

describe returns auto

argument	argument type
decl	smart_ptr< ast::TypeDecl > const
extra	bool const
contracts	bool const
modules	bool const

Describes object and produces corresponding Daslang code as string.

describe_cpp(decl: smart_ptr<TypeDecl> const; substitureRef: bool const; skipRef: bool const; skipConst: bool const; redundantConst: bool const)

describe_cpp returns auto

argument	argument type
decl	smart_ptr< ast::TypeDecl > const
substitureRef	bool const
skipRef	bool const
skipConst	bool const
redundantConst	bool const

Describes TypeDecl and produces corresponding C++ code as a string.

describe(expr: smart_ptr<Expression> const)

describe returns auto

argument	argument type
expr	smart_ptr< ast::Expression > const

Describes object and produces corresponding Daslang code as string.

describe(expr: smart_ptr<Function> const)

describe returns auto

argument	argument type
expr	smart_ptr< ast::Function > const

Describes object and produces corresponding Daslang code as string.

12.16. Searching

• find_module_via_rtti (program:smart_ptr<rtti::Program> const implicit;name:string const implicit;context:__context const;lineinfo:__lineInfo const) : rtti::Module?

• find_module_function_via_rtti (module:rtti::Module? const implicit;function:function<> const;context:__context const;lineinfo:__lineInfo const) : smart_ptr<ast::Function>

• find_variable (module:rtti::Module? const implicit;variable:string const implicit) : smart_ptr<ast::Variable>

• find_matching_variable (program:rtti::Program? const implicit;function:ast::Function? const implicit;name:string const implicit;seePrivate:bool const;block:block<(var arg0:array<smart_ptr<ast::Variable>>#):void> const implicit;context:__context const;line:__lineInfo const) : void

• find_bitfield_name (bit:smart_ptr<ast::TypeDecl> const implicit;value:bitfield const;context:__context const;lineinfo:__lineInfo const) : string

• find_enum_name (enum:ast::Enumeration? const implicit;value:int64 const;context:__context const;lineinfo:__lineInfo const) : string

• find_enum_value (enum:smart_ptr<ast::Enumeration> const implicit;value:string const implicit) : int64

• find_enum_value (enum:ast::Enumeration? const implicit;value:string const implicit) : int64

• find_structure_field (structPtr:ast::Structure? const implicit;field:string const implicit;context:__context const;lineinfo:__lineInfo const) : ast::FieldDeclaration?

• find_unique_structure (program:smart_ptr<rtti::Program> const implicit;name:string const implicit;context:__context const;at:__lineInfo const) : ast::Structure?

• find_module (prog:smart_ptr<rtti::Program> const;name:string const) : rtti::Module?

• find_module (name:string const) : rtti::Module?

• find_compiling_module (name:string const) : rtti::Module?

find_module_via_rtti(program: smart_ptr<Program> const implicit; name: string const implicit)

find_module_via_rtti returns rtti::Module ?

argument	argument type
program	smart_ptr< rtti::Program > const implicit
name	string const implicit

Find module by name in the Program.

find_module_function_via_rtti(module: Module? const implicit; function: function<> const)

find_module_function_via_rtti returns smart_ptr< ast::Function >

argument	argument type
module	rtti::Module ? const implicit
function	function<> const

Find function by name in the Module.

find_variable(module: Module? const implicit; variable: string const implicit)

find_variable returns smart_ptr< ast::Variable >

argument	argument type
module	rtti::Module ? const implicit
variable	string const implicit

Finds variable in the Module.

find_matching_variable(program: Program? const implicit; function: Function? const implicit; name: string const implicit; seePrivate: bool const; block: block<(var arg0:array<smart_ptr<Variable>>#):void> const implicit)

argument	argument type
program	rtti::Program ? const implicit
function	ast::Function ? const implicit
name	string const implicit
seePrivate	bool const
block	block<(array<smart_ptr< ast::Variable >>#):void> const implicit

Finds global or shared variable in the given function, according to visibility and privacy rules.

find_bitfield_name(bit: smart_ptr<TypeDecl> const implicit; value: bitfield const)

find_bitfield_name returns string

argument	argument type
bit	smart_ptr< ast::TypeDecl > const implicit
value	bitfield<> const

Finds name of the corresponding bitfield value in the specified type.

find_enum_name(enum: Enumeration? const implicit; value: int64 const)

find_enum_name returns string

argument	argument type
enum	ast::Enumeration ? const implicit
value	int64 const

Finds name of the corresponding enumeration value in the specified type.

find_enum_value(enum: smart_ptr<Enumeration> const implicit; value: string const implicit)

find_enum_value returns int64

argument	argument type
enum	smart_ptr< ast::Enumeration > const implicit
value	string const implicit

Finds name of the corresponding enumeration value in the specified type.

find_enum_value(enum: Enumeration? const implicit; value: string const implicit)

find_enum_value returns int64

argument	argument type
enum	ast::Enumeration ? const implicit
value	string const implicit

Finds name of the corresponding enumeration value in the specified type.

find_structure_field(structPtr: Structure? const implicit; field: string const implicit)

find_structure_field returns ast::FieldDeclaration ?

argument	argument type
structPtr	ast::Structure ? const implicit
field	string const implicit

Returns FieldDeclaration for the specific field of the structure type, or null if not found.

find_unique_structure(program: smart_ptr<Program> const implicit; name: string const implicit)

find_unique_structure returns ast::Structure ?

argument	argument type
program	smart_ptr< rtti::Program > const implicit
name	string const implicit

Find structure in the program with the specified name. If its unique - return it, otherwise null.

find_module(prog: smart_ptr<Program> const; name: string const)

find_module returns rtti::Module ?

argument	argument type
prog	smart_ptr< rtti::Program > const
name	string const

Finds Module in the Program.

find_module(name: string const)

find_module returns rtti::Module ?

argument	argument type
name	string const

Finds Module in the Program.

find_compiling_module(name: string const)

find_compiling_module returns rtti::Module ?

argument	argument type
name	string const

Finds Module in the currently compiling Program.

12.17. Iterating

• for_each_module (program:rtti::Program? const implicit;block:block<(var arg0:rtti::Module?):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_function (module:rtti::Module? const implicit;name:string const implicit;block:block<(var arg0:smart_ptr<ast::Function>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_generic (module:rtti::Module? const implicit;name:string const implicit;block:block<(var arg0:smart_ptr<ast::Function>):void> const implicit;context:__context const;line:__lineInfo const) : void

• any_table_foreach (table:void? const implicit;keyStride:int const;valueStride:int const;block:block<(var arg0:void?;var arg1:void?):void> const implicit;context:__context const;line:__lineInfo const) : void

• any_array_foreach (array:void? const implicit;stride:int const;block:block<(var arg0:void?):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_typedef (module:rtti::Module? const implicit;block:block<(var arg0:string#;var arg1:smart_ptr<ast::TypeDecl>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_enumeration (module:rtti::Module? const implicit;block:block<(var arg0:smart_ptr<ast::Enumeration>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_structure (module:rtti::Module? const implicit;block:block<(var arg0:smart_ptr<ast::Structure>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_generic (module:rtti::Module? const implicit;block:block<(var arg0:smart_ptr<ast::Function>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_global (module:rtti::Module? const implicit;block:block<(var arg0:smart_ptr<ast::Variable>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_call_macro (module:rtti::Module? const implicit;block:block<(var arg0:string#):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_reader_macro (module:rtti::Module? const implicit;block:block<(var arg0:string#):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_variant_macro (module:rtti::Module? const implicit;block:block<(var arg0:smart_ptr<ast::VariantMacro>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_for_loop_macro (module:rtti::Module? const implicit;block:block<(var arg0:smart_ptr<ast::ForLoopMacro>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_typeinfo_macro (module:rtti::Module? const implicit;block:block<(var arg0:smart_ptr<ast::TypeInfoMacro>):void> const implicit;context:__context const;line:__lineInfo const) : void

• for_each_field (annotation:rtti::BasicStructureAnnotation const implicit;block:block<(var arg0:string;var arg1:string;var arg2:smart_ptr<ast::TypeDecl>;var arg3:uint):void> const implicit;context:__context const;line:__lineInfo const) : void

for_each_module(program: Program? const implicit; block: block<(var arg0:Module?):void> const implicit)

argument	argument type
program	rtti::Program ? const implicit
block	block<( rtti::Module ?):void> const implicit

Iterates through each module in the program.

for_each_function(module: Module? const implicit; name: string const implicit; block: block<(var arg0:smart_ptr<Function>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
name	string const implicit
block	block<(smart_ptr< ast::Function >):void> const implicit

Iterates through each function in the given Module. If the name is empty matches all functions.

for_each_generic(module: Module? const implicit; name: string const implicit; block: block<(var arg0:smart_ptr<Function>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
name	string const implicit
block	block<(smart_ptr< ast::Function >):void> const implicit

Iterates through each generic function in the given Module.

any_table_foreach(table: void? const implicit; keyStride: int const; valueStride: int const; block: block<(var arg0:void?;var arg1:void?):void> const implicit)

argument	argument type
table	void? const implicit
keyStride	int const
valueStride	int const
block	block<(void?;void?):void> const implicit

Iterates through any table<> type in a typeless fasion (via void?)

any_array_foreach(array: void? const implicit; stride: int const; block: block<(var arg0:void?):void> const implicit)

argument	argument type
array	void? const implicit
stride	int const
block	block<(void?):void> const implicit

Iterates through any array<> type in a typeless fasion (via void?)

for_each_typedef(module: Module? const implicit; block: block<(var arg0:string#;var arg1:smart_ptr<TypeDecl>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(string#;smart_ptr< ast::TypeDecl >):void> const implicit

Iterates through every typedef in the Module.

for_each_enumeration(module: Module? const implicit; block: block<(var arg0:smart_ptr<Enumeration>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(smart_ptr< ast::Enumeration >):void> const implicit

Iterates through every enumeration in the Module.

for_each_structure(module: Module? const implicit; block: block<(var arg0:smart_ptr<Structure>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(smart_ptr< ast::Structure >):void> const implicit

Iterates through every structure in the Module.

for_each_generic(module: Module? const implicit; block: block<(var arg0:smart_ptr<Function>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(smart_ptr< ast::Function >):void> const implicit

Iterates through each generic function in the given Module.

for_each_global(module: Module? const implicit; block: block<(var arg0:smart_ptr<Variable>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(smart_ptr< ast::Variable >):void> const implicit

Iterates through every global variable in the Module.

for_each_call_macro(module: Module? const implicit; block: block<(var arg0:string#):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(string#):void> const implicit

Iterates through every CallMacro adapter in the Module.

for_each_reader_macro(module: Module? const implicit; block: block<(var arg0:string#):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(string#):void> const implicit

Iterates through each reader macro in the given Module.

for_each_variant_macro(module: Module? const implicit; block: block<(var arg0:smart_ptr<VariantMacro>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(smart_ptr< ast::VariantMacro >):void> const implicit

Iterates through each variant macro in the given Module.

for_each_for_loop_macro(module: Module? const implicit; block: block<(var arg0:smart_ptr<ForLoopMacro>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(smart_ptr< ast::ForLoopMacro >):void> const implicit

Iterates through each for loop macro in the given Module.

for_each_typeinfo_macro(module: Module? const implicit; block: block<(var arg0:smart_ptr<TypeInfoMacro>):void> const implicit)

argument	argument type
module	rtti::Module ? const implicit
block	block<(smart_ptr< ast::TypeInfoMacro >):void> const implicit

Iterates through each typeinfo macro in the given Module.

for_each_field(annotation: BasicStructureAnnotation const implicit; block: block<(var arg0:string;var arg1:string;var arg2:smart_ptr<TypeDecl>;var arg3:uint):void> const implicit)

argument	argument type
annotation	rtti::BasicStructureAnnotation const implicit
block	block<(string;string;smart_ptr< ast::TypeDecl >;uint):void> const implicit

Iterates through every field in the BuiltinStructure handled type.

12.18. Cloning

• clone_structure (structure:ast::Structure const? const implicit) : smart_ptr<ast::Structure>

• clone_expression (expression:smart_ptr<ast::Expression> const implicit) : smart_ptr<ast::Expression>

• clone_function (function:smart_ptr<ast::Function> const implicit) : smart_ptr<ast::Function>

• clone_variable (variable:smart_ptr<ast::Variable> const implicit) : smart_ptr<ast::Variable>

• clone_type (type:smart_ptr<ast::TypeDecl> const implicit) : smart_ptr<ast::TypeDecl>

• clone_function (fn:ast::Function? const) : smart_ptr<ast::Function>

clone_structure(structure: Structure const? const implicit)

clone_structure returns smart_ptr< ast::Structure >

argument	argument type
structure	ast::Structure const? const implicit

Returns clone of the Structure.

clone_expression(expression: smart_ptr<Expression> const implicit)

clone_expression returns smart_ptr< ast::Expression >

argument	argument type
expression	smart_ptr< ast::Expression > const implicit

Clones Expression with subexpressions, including corresponding type.

clone_function(function: smart_ptr<Function> const implicit)

clone_function returns smart_ptr< ast::Function >

argument	argument type
function	smart_ptr< ast::Function > const implicit

Clones Function and everything in it.

clone_variable(variable: smart_ptr<Variable> const implicit)

clone_variable returns smart_ptr< ast::Variable >

argument	argument type
variable	smart_ptr< ast::Variable > const implicit

Clones Variable and everything in it.

clone_type(type: smart_ptr<TypeDecl> const implicit)

clone_type returns smart_ptr< ast::TypeDecl >

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit

Clones TypeDecl with subtypes.

clone_function(fn: Function? const)

clone_function returns FunctionPtr

argument	argument type
fn	ast::Function ? const

Clones Function and everything in it.

12.19. Mangled name

• parse_mangled_name (txt:string const implicit;lib:rtti::ModuleGroup implicit;thisModule:rtti::Module? const implicit;context:__context const;line:__lineInfo const) : smart_ptr<ast::TypeDecl>

• get_mangled_name (function:smart_ptr<ast::Function> const implicit;context:__context const;line:__lineInfo const) : string

• get_mangled_name (type:smart_ptr<ast::TypeDecl> const implicit;context:__context const;line:__lineInfo const) : string

• get_mangled_name (variable:smart_ptr<ast::Variable> const implicit;context:__context const;line:__lineInfo const) : string

• get_mangled_name (variable:smart_ptr<ast::ExprBlock> const implicit;context:__context const;line:__lineInfo const) : string

• get_mangled_name (fn:ast::Function? const) : string

• get_mangled_name (decl:ast::TypeDecl? const) : string

• get_mangled_name (decl:ast::Variable? const) : string

• get_mangled_name (decl:ast::ExprBlock? const) : string

parse_mangled_name(txt: string const implicit; lib: ModuleGroup implicit; thisModule: Module? const implicit)

parse_mangled_name returns smart_ptr< ast::TypeDecl >

argument	argument type
txt	string const implicit
lib	rtti::ModuleGroup implicit
thisModule	rtti::Module ? const implicit

Parses mangled name and creates corresponding TypeDecl.

get_mangled_name(function: smart_ptr<Function> const implicit)

get_mangled_name returns string

argument	argument type
function	smart_ptr< ast::Function > const implicit

Returns mangled name of the object.

get_mangled_name(type: smart_ptr<TypeDecl> const implicit)

get_mangled_name returns string

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit

Returns mangled name of the object.

get_mangled_name(variable: smart_ptr<Variable> const implicit)

get_mangled_name returns string

argument	argument type
variable	smart_ptr< ast::Variable > const implicit

Returns mangled name of the object.

get_mangled_name(variable: smart_ptr<ExprBlock> const implicit)

get_mangled_name returns string

argument	argument type
variable	smart_ptr< ast::ExprBlock > const implicit

Returns mangled name of the object.

get_mangled_name(fn: Function? const)

get_mangled_name returns string

argument	argument type
fn	ast::Function ? const

Returns mangled name of the object.

get_mangled_name(decl: TypeDecl? const)

get_mangled_name returns string

argument	argument type
decl	ast::TypeDecl ? const

Returns mangled name of the object.

get_mangled_name(decl: Variable? const)

get_mangled_name returns string

argument	argument type
decl	ast::Variable ? const

Returns mangled name of the object.

get_mangled_name(decl: ExprBlock? const)

get_mangled_name returns string

argument	argument type
decl	ast::ExprBlock ? const

Returns mangled name of the object.

12.20. Size and offset

• get_variant_field_offset (variant:smart_ptr<ast::TypeDecl> const implicit;index:int const;context:__context const;at:__lineInfo const) : int

• get_tuple_field_offset (typle:smart_ptr<ast::TypeDecl> const implicit;index:int const;context:__context const;at:__lineInfo const) : int

• any_array_size (array:void? const implicit) : int

• any_table_size (table:void? const implicit) : int

• get_handled_type_field_offset (type:smart_ptr<rtti::TypeAnnotation> const implicit;field:string const implicit;context:__context const;line:__lineInfo const) : uint

get_variant_field_offset(variant: smart_ptr<TypeDecl> const implicit; index: int const)

get_variant_field_offset returns int

argument	argument type
variant	smart_ptr< ast::TypeDecl > const implicit
index	int const

Returns offset of the variant field in bytes.

get_tuple_field_offset(typle: smart_ptr<TypeDecl> const implicit; index: int const)

get_tuple_field_offset returns int

argument	argument type
typle	smart_ptr< ast::TypeDecl > const implicit
index	int const

Returns offset of the tuple field in bytes.

any_array_size(array: void? const implicit)

any_array_size returns int

argument	argument type
array	void? const implicit

Returns array size from pointer to array<> object.

any_table_size(table: void? const implicit)

any_table_size returns int

argument	argument type
table	void? const implicit

Returns table size from pointer to the table<> object.

get_handled_type_field_offset(type: smart_ptr<TypeAnnotation> const implicit; field: string const implicit)

get_handled_type_field_offset returns uint

argument	argument type
type	smart_ptr< rtti::TypeAnnotation > const implicit
field	string const implicit

Returns offset of the field in the ManagedStructure handled type.

12.21. Evaluations

• eval_single_expression (expr:smart_ptr<ast::Expression> const& implicit;ok:bool& implicit) : float4

eval_single_expression(expr: smart_ptr<Expression> const& implicit; ok: bool& implicit)

eval_single_expression returns float4

Warning

This is unsafe operation.

argument	argument type
expr	smart_ptr< ast::Expression > const& implicit
ok	bool& implicit

Simulates and evaluates single expression on the separate context. If expression has external references, simulation will likely fail. Global variable access or function calls will produce exceptions.

12.22. Error reporting

• macro_error (porogram:smart_ptr<rtti::Program> const implicit;at:rtti::LineInfo const implicit;message:string const implicit;context:__context const;line:__lineInfo const) : void

macro_error(porogram: smart_ptr<Program> const implicit; at: LineInfo const implicit; message: string const implicit)

argument	argument type
porogram	smart_ptr< rtti::Program > const implicit
at	rtti::LineInfo const implicit
message	string const implicit

Reports error to the currently compiling program to whatever current pass is. Usually called from inside the macro function.

12.23. Location and context

• force_at (expression:smart_ptr<ast::Expression> const& implicit;at:rtti::LineInfo const implicit) : void

• collect_dependencies (function:smart_ptr<ast::Function> const implicit;block:block<(var arg0:array<ast::Function?>;var arg1:array<ast::Variable?>):void> const implicit;context:__context const;line:__lineInfo const) : void

• get_ast_context (program:smart_ptr<rtti::Program> const implicit;expression:smart_ptr<ast::Expression> const implicit;block:block<(var arg0:bool;var arg1:ast::AstContext):void> const implicit;context:__context const;line:__lineInfo const) : void

force_at(expression: smart_ptr<Expression> const& implicit; at: LineInfo const implicit)

argument	argument type
expression	smart_ptr< ast::Expression > const& implicit
at	rtti::LineInfo const implicit

Replaces line info in the expression, its subexpressions, and its types.

collect_dependencies(function: smart_ptr<Function> const implicit; block: block<(var arg0:array<Function?>;var arg1:array<Variable?>):void> const implicit)

argument	argument type
function	smart_ptr< ast::Function > const implicit
block	block<(array< ast::Function ?>;array< ast::Variable ?>):void> const implicit

Collects dependencies of the given function (other functions it calls, global variables it accesses).

get_ast_context(program: smart_ptr<Program> const implicit; expression: smart_ptr<Expression> const implicit; block: block<(var arg0:bool;var arg1:AstContext):void> const implicit)

argument	argument type
program	smart_ptr< rtti::Program > const implicit
expression	smart_ptr< ast::Expression > const implicit
block	block<(bool; ast::AstContext ):void> const implicit

Returns AstContext for the given expression. It includes current function (if applicable), loops, blocks, scopes, and with sections.

12.24. Use queries

• get_use_global_variables (func:smart_ptr<ast::Function> const implicit;block:block<(var arg0:smart_ptr<ast::Variable>):void> const implicit;context:__context const;at:__lineInfo const) : void

• get_use_functions (func:smart_ptr<ast::Function> const implicit;block:block<(var arg0:smart_ptr<ast::Function>):void> const implicit;context:__context const;at:__lineInfo const) : void

get_use_global_variables(func: smart_ptr<Function> const implicit; block: block<(var arg0:smart_ptr<Variable>):void> const implicit)

argument	argument type
func	smart_ptr< ast::Function > const implicit
block	block<(smart_ptr< ast::Variable >):void> const implicit

Provides invoked block with the list of all global variables, used by a function.

get_use_functions(func: smart_ptr<Function> const implicit; block: block<(var arg0:smart_ptr<Function>):void> const implicit)

argument	argument type
func	smart_ptr< ast::Function > const implicit
block	block<(smart_ptr< ast::Function >):void> const implicit

Provides invoked block with the list of all functions, used by a function.

12.25. Log

• to_compilation_log (text:string const implicit;context:__context const;at:__lineInfo const) : void

to_compilation_log(text: string const implicit)

argument	argument type
text	string const implicit

Writes to compilation log from macro during compilation.

12.26. Removal

• remove_structure (module:rtti::Module? const implicit;structure:smart_ptr<ast::Structure>& implicit) : bool

remove_structure(module: Module? const implicit; structure: smart_ptr<Structure>& implicit)

remove_structure returns bool

argument	argument type
module	rtti::Module ? const implicit
structure	smart_ptr< ast::Structure >& implicit

Removes structure declaration from the specified module.

12.27. Properties

• get_current_search_module (program:rtti::Program? const implicit;function:ast::Function? const implicit;moduleName:string const implicit) : rtti::Module?

• can_access_global_variable (variable:smart_ptr<ast::Variable> const& implicit;module:rtti::Module? const implicit;thisModule:rtti::Module? const implicit) : bool

• is_temp_type (type:smart_ptr<ast::TypeDecl> const implicit;refMatters:bool const) : bool

• is_same_type (leftType:smart_ptr<ast::TypeDecl> const implicit;rightType:smart_ptr<ast::TypeDecl> const implicit;refMatters:rtti::RefMatters const;constMatters:rtti::ConstMatters const;tempMatters:rtti::TemporaryMatters const;context:__context const;at:__lineInfo const) : bool

• get_underlying_value_type (type:smart_ptr<ast::TypeDecl> const implicit;context:__context const;line:__lineInfo const) : smart_ptr<ast::TypeDecl>

• get_handled_type_field_type (type:smart_ptr<rtti::TypeAnnotation> const implicit;field:string const implicit;context:__context const;line:__lineInfo const) : rtti::TypeInfo?

• get_handled_type_field_type_declaration (type:smart_ptr<rtti::TypeAnnotation> const implicit;field:string const implicit;isConst:bool const;context:__context const;line:__lineInfo const) : smart_ptr<ast::TypeDecl>

• has_field (type:smart_ptr<ast::TypeDecl> const implicit;fieldName:string const implicit;constant:bool const) : bool

• get_field_type (type:smart_ptr<ast::TypeDecl> const implicit;fieldName:string const implicit;constant:bool const) : smart_ptr<ast::TypeDecl>

• is_visible_directly (from_module:rtti::Module? const implicit;which_module:rtti::Module? const implicit) : bool

• is_expr_like_call (expression:smart_ptr<ast::Expression> const& implicit) : bool

• is_expr_const (expression:smart_ptr<ast::Expression> const& implicit) : bool

• get_function_aot_hash (fun:ast::Function const? const implicit) : uint64

get_current_search_module(program: Program? const implicit; function: Function? const implicit; moduleName: string const implicit)

get_current_search_module returns rtti::Module ?

argument	argument type
program	rtti::Program ? const implicit
function	ast::Function ? const implicit
moduleName	string const implicit

Returns the module which is currently being searched for the function, given module name. Resolves “”, “_”, “*”, and “__” correctly.

can_access_global_variable(variable: smart_ptr<Variable> const& implicit; module: Module? const implicit; thisModule: Module? const implicit)

can_access_global_variable returns bool

argument	argument type
variable	smart_ptr< ast::Variable > const& implicit
module	rtti::Module ? const implicit
thisModule	rtti::Module ? const implicit

Returns true if global variable is accessible from the specified module.

is_temp_type(type: smart_ptr<TypeDecl> const implicit; refMatters: bool const)

is_temp_type returns bool

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit
refMatters	bool const

Returns true if type can be temporary.

is_same_type(leftType: smart_ptr<TypeDecl> const implicit; rightType: smart_ptr<TypeDecl> const implicit; refMatters: RefMatters const; constMatters: ConstMatters const; tempMatters: TemporaryMatters const)

is_same_type returns bool

argument	argument type
leftType	smart_ptr< ast::TypeDecl > const implicit
rightType	smart_ptr< ast::TypeDecl > const implicit
refMatters	rtti::RefMatters const
constMatters	rtti::ConstMatters const
tempMatters	rtti::TemporaryMatters const

Compares two types given comparison parameters and returns true if they match.

get_underlying_value_type(type: smart_ptr<TypeDecl> const implicit)

get_underlying_value_type returns smart_ptr< ast::TypeDecl >

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit

Returns Daslang type which is aliased with ManagedValue handled type.

get_handled_type_field_type(type: smart_ptr<TypeAnnotation> const implicit; field: string const implicit)

get_handled_type_field_type returns rtti::TypeInfo ?

argument	argument type
type	smart_ptr< rtti::TypeAnnotation > const implicit
field	string const implicit

Returns type of the field in the ManagedStructure handled type.

get_handled_type_field_type_declaration(type: smart_ptr<TypeAnnotation> const implicit; field: string const implicit; isConst: bool const)

get_handled_type_field_type_declaration returns smart_ptr< ast::TypeDecl >

argument	argument type
type	smart_ptr< rtti::TypeAnnotation > const implicit
field	string const implicit
isConst	bool const

Returns type declaration of the field in the ManagedStructure handled type.

has_field(type: smart_ptr<TypeDecl> const implicit; fieldName: string const implicit; constant: bool const)

has_field returns bool

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit
fieldName	string const implicit
constant	bool const

Returns if structure, variant, tuple, or handled type or pointer to either of those has specific field.

get_field_type(type: smart_ptr<TypeDecl> const implicit; fieldName: string const implicit; constant: bool const)

get_field_type returns smart_ptr< ast::TypeDecl >

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit
fieldName	string const implicit
constant	bool const

Returns type of the field if structure, variant, tuple, or handled type or pointer to either of those has it. It’s null otherwise.

is_visible_directly(from_module: Module? const implicit; which_module: Module? const implicit)

is_visible_directly returns bool

argument	argument type
from_module	rtti::Module ? const implicit
which_module	rtti::Module ? const implicit

Returns true if module is visible directly from the other module.

is_expr_like_call(expression: smart_ptr<Expression> const& implicit)

is_expr_like_call returns bool

argument	argument type
expression	smart_ptr< ast::Expression > const& implicit

Returns true if expression is or inherited from ExprLooksLikeCall

is_expr_const(expression: smart_ptr<Expression> const& implicit)

is_expr_const returns bool

argument	argument type
expression	smart_ptr< ast::Expression > const& implicit

Returns true if expression is or inherited from ExprConst

get_function_aot_hash(fun: Function const? const implicit)

get_function_aot_hash returns uint64

argument	argument type
fun	ast::Function const? const implicit

Returns hash of the function for the AOT matching.

12.28. Infer

• infer_generic_type (type:smart_ptr<ast::TypeDecl> const implicit;passType:smart_ptr<ast::TypeDecl> const implicit;topLevel:bool const;isPassType:bool const) : smart_ptr<ast::TypeDecl>

• update_alias_map (program:smart_ptr<rtti::Program> const implicit;argType:smart_ptr<ast::TypeDecl> const implicit;passType:smart_ptr<ast::TypeDecl> const implicit;context:__context const;at:__lineInfo const) : void

infer_generic_type(type: smart_ptr<TypeDecl> const implicit; passType: smart_ptr<TypeDecl> const implicit; topLevel: bool const; isPassType: bool const)

infer_generic_type returns smart_ptr< ast::TypeDecl >

argument	argument type
type	smart_ptr< ast::TypeDecl > const implicit
passType	smart_ptr< ast::TypeDecl > const implicit
topLevel	bool const
isPassType	bool const

Infers generic type for the specified type and pass type.

update_alias_map(program: smart_ptr<Program> const implicit; argType: smart_ptr<TypeDecl> const implicit; passType: smart_ptr<TypeDecl> const implicit)

argument	argument type
program	smart_ptr< rtti::Program > const implicit
argType	smart_ptr< ast::TypeDecl > const implicit
passType	smart_ptr< ast::TypeDecl > const implicit

Updates alias map for the specified infer.