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

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

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

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

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

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

properties of the ExprVar object.

ExprMakeStructFlags is a bitfield

field

bit

value

useInitializer

0

1

isNewHandle

1

2

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

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

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<ast::Expression>

Smart pointer to Expression object.

ProgramPtr = smart_ptr<rtti::Program>

Smart pointer to Program object.

TypeDeclPtr = smart_ptr<ast::TypeDecl>

Smart pointer to TypeDecl object.

VectorTypeDeclPtr = dasvector`smart_ptr`TypeDecl

Smart pointer to das::vector<ExpressionPtr>.

EnumerationPtr = smart_ptr<ast::Enumeration>

Smart pointer to Enumeration object.

StructurePtr = smart_ptr<ast::Structure>

Smart pointer to Structure object.

FunctionPtr = smart_ptr<ast::Function>

Smart pointer to Function object.

VariablePtr = smart_ptr<ast::Variable>

Smart pointer to Variable object.

MakeFieldDeclPtr = smart_ptr<ast::MakeFieldDecl>

Smart pointer to MakeFieldDecl object.

FunctionAnnotationPtr = smart_ptr<ast::FunctionAnnotation>

Smart pointer to FunctionAnnotation object.

StructureAnnotationPtr = smart_ptr<ast::StructureAnnotation>

Smart pointer to StructureAnnotation object.

EnumerationAnnotationPtr = smart_ptr<ast::EnumerationAnnotation>

Smart pointer to EnumerationAnnotation object.

PassMacroPtr = smart_ptr<ast::PassMacro>

Smart pointer to PassMacro object.

VariantMacroPtr = smart_ptr<ast::VariantMacro>

Smart pointer to VariantMacro object.

ReaderMacroPtr = smart_ptr<ast::ReaderMacro>

Smart pointer to ReaderMacro object.

CommentReaderPtr = smart_ptr<ast::CommentReader>

Smart pointer to CommentReader object.

CallMacroPtr = smart_ptr<ast::CallMacro>

Smart pointer to CallMacro object.

TypeInfoMacroPtr = smart_ptr<ast::TypeInfoMacro>

Smart pointer to TypeInfoMacro object.

ForLoopMacroPtr = smart_ptr<ast::ForLoopMacro>

Smart pointer to ‘ForLoopMacro’.

CaptureMacroPtr = smart_ptr<ast::CaptureMacro>

Smart pointer to ‘CaptureMacro’.

SimulateMacroPtr = smart_ptr<ast::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

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

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

smart_ptr< 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

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>>

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

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

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

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

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 >

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

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

native

bool

printFlags

ExprPrintFlags

subexpr

smart_ptr< ast::Expression >

genFlags

ExprGenFlags

_type

smart_ptr< ast::TypeDecl >

__rtti

string const

flags

ExprFlags

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

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.

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<ast::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<ast::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<rtti::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<ast::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<ast::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<rtti::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: rtti::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: rtti::Module? const; expr: smart_ptr<ast::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: rtti::Module? const; expr: smart_ptr<ast::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: rtti::Module? const; expr: smart_ptr<ast::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: rtti::Module? const; expr: smart_ptr<ast::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: rtti::Program? const; mod: rtti::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: rtti::Program? const; mod: rtti::Module? const; lcs: ast::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.

AstSimulateMacro

Macro which is attached to the context simulation.

it defines as follows

AstSimulateMacro.preSimulate(self: AstSimulateMacro; prog: rtti::Program? const; ctx: rtti::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: rtti::Program? const; ctx: rtti::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: rtti::Module? const; expr: ast::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.visit(self: AstReaderMacro; prog: ProgramPtr; mod: rtti::Module? const; expr: smart_ptr<ast::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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.afterVariant(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: rtti::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.beforeEnumeration(self: AstCommentReader; prog: ProgramPtr; mod: rtti::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.afterEnumeration(self: AstCommentReader; name: string const; prog: ProgramPtr; mod: rtti::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: rtti::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: rtti::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: rtti::Module? const; expr: smart_ptr<ast::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: rtti::Module? const; expr: smart_ptr<ast::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<ast::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<ast::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<ast::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<ast::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: rtti::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: rtti::Module? const)

argument

argument type

self

ast::AstVisitor

mod

rtti::Module ? const

before each module

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

argument

argument type

self

ast::AstVisitor

mod

rtti::Module ? const

after each module

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

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTypeDecl > const

before ExprTypeDecl

AstVisitor.visitExprTypeDecl(self: AstVisitor; expr: smart_ptr<ast::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: ast::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: ast::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: ast::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: ast::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<ast::ExprBlock> const)

argument

argument type

self

ast::AstVisitor

blk

smart_ptr< ast::ExprBlock > const

before ExprBlock

AstVisitor.visitExprBlock(self: AstVisitor; blk: smart_ptr<ast::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<ast::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<ast::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<ast::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<ast::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<ast::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<ast::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<ast::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<ast::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<ast::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<ast::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<ast::ExprLet> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLet > const

before ExprLet

AstVisitor.visitExprLet(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::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<ast::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: ast::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<ast::ExprStringBuilder> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprStringBuilder > const

before ExprStringBuilder

AstVisitor.visitExprStringBuilder(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprNew> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNew > const

before ExprNew

AstVisitor.visitExprNew(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprNamedCall> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNamedCall > const

before ExprNamedCall

AstVisitor.visitExprNamedCall(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprLooksLikeCall> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLooksLikeCall > const

before ExprLooksLikeCall

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

visitExprLooksLikeCall returns ExpressionPtr

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLooksLikeCall > const

after ExprLooksLikeCall

AstVisitor.preVisitExprLooksLikeCallArgument(self: AstVisitor; expr: smart_ptr<ast::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<ast::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: ast::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<ast::ExprCall> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCall > const

before ExprCall

AstVisitor.visitExprCall(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprNullCoalescing> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprNullCoalescing > const

before ExprNullCoalescing

AstVisitor.visitExprNullCoalescing(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprAt> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAt > const

before ExprAt

AstVisitor.visitExprAt(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprSafeAt> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeAt > const

before ExprSafeAt

AstVisitor.visitExprSafeAt(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprIs> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIs > const

before ExprIs

AstVisitor.visitExprIs(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprOp2> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp2 > const

before ExprOp2

AstVisitor.visitExprOp2(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprOp3> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp3 > const

before ExprOp3

AstVisitor.visitExprOp3(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprCopy> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCopy > const

before ExprCopy

AstVisitor.visitExprCopy(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprMove> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMove > const

before ExprMove

AstVisitor.visitExprMove(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprClone> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprClone > const

before ExprClone

AstVisitor.visitExprClone(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprAssume> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAssume > const

before ExprAssume

AstVisitor.visitExprAssume(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprWith> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprWith > const

before ExprWith

AstVisitor.visitExprWith(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprWhile> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprWhile > const

before ExprWhile

AstVisitor.visitExprWhile(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprTryCatch> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTryCatch > const

before ExprTryCatch

AstVisitor.visitExprTryCatch(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprIfThenElse> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIfThenElse > const

before ExprIfThenElse

AstVisitor.visitExprIfThenElse(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprFor> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFor > const

before the ExprFor

AstVisitor.visitExprFor(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::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<ast::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<ast::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<ast::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<ast::ExprMakeVariant> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeVariant > const

before ExprMakeVariant

AstVisitor.visitExprMakeVariant(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::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<ast::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<ast::ExprMakeStruct> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeStruct > const

before ExprMakeStruct

AstVisitor.visitExprMakeStruct(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::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<ast::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.preVisitExprMakeArray(self: AstVisitor; expr: smart_ptr<ast::ExprMakeArray> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeArray > const

before ExprMakeArray

AstVisitor.visitExprMakeArray(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprMakeTuple> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeTuple > const

before ExprMakeTuple

AstVisitor.visitExprMakeTuple(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprArrayComprehension> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprArrayComprehension > const

before ExprArrayComprehension

AstVisitor.visitExprArrayComprehension(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::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<ast::ExprTypeInfo> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTypeInfo > const

before ExprTypeInfo

AstVisitor.visitExprTypeInfo(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprPtr2Ref> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprPtr2Ref > const

before ExprPtr2Ref

AstVisitor.visitExprPtr2Ref(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprLabel> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprLabel > const

before ExprLabel

AstVisitor.visitExprLabel(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprGoto> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprGoto > const

before ExprGoto

AstVisitor.visitExprGoto(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprRef2Value> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprRef2Value > const

before ExprRef2Value

AstVisitor.visitExprRef2Value(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprRef2Ptr> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprRef2Ptr > const

before ExprRef2Ptr

AstVisitor.visitExprRef2Ptr(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprAddr> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAddr > const

before ExprAddr

AstVisitor.visitExprAddr(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprAssert> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAssert > const

before ExprAssert

AstVisitor.visitExprAssert(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprStaticAssert> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprStaticAssert > const

before ExprStaticAssert

AstVisitor.visitExprStaticAssert(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprQuote> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprQuote > const

before ExprQuote

AstVisitor.visitExprQuote(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprDebug> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprDebug > const

before ExprDebug

AstVisitor.visitExprDebug(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprInvoke> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprInvoke > const

before ExprInvoke

AstVisitor.visitExprInvoke(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprErase> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprErase > const

before ExprErase

AstVisitor.visitExprErase(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprSetInsert> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSetInsert > const

before ExprSetInsert

AstVisitor.visitExprSetInsert(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprFind> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFind > const

before ExprFind

AstVisitor.visitExprFind(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprKeyExists> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprKeyExists > const

before ExprKeyExists

AstVisitor.visitExprKeyExists(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprAscend> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAscend > const

before ExprAscend

AstVisitor.visitExprAscend(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprCast> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCast > const

before ExprCast

AstVisitor.visitExprCast(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprDelete> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprDelete > const

before ExprDelete

AstVisitor.visitExprDelete(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprVar> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprVar > const

before ExprVar

AstVisitor.visitExprVar(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprTag> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprTag > const

before ExprTag

AstVisitor.preVisitExprTagValue(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprField> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprField > const

before ExprField

AstVisitor.visitExprField(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprSafeField> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeField > const

before ExprSafeField

AstVisitor.visitExprSafeField(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprSwizzle> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSwizzle > const

before ExprSwizzle

AstVisitor.visitExprSwizzle(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprIsVariant> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprIsVariant > const

before ExprIsVariant

AstVisitor.visitExprIsVariant(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprAsVariant> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprAsVariant > const

before ExprAsVariant

AstVisitor.visitExprAsVariant(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprSafeAsVariant> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprSafeAsVariant > const

before ExprSafeAsVariant

AstVisitor.visitExprSafeAsVariant(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprOp1> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprOp1 > const

before ExprOp1

AstVisitor.visitExprOp1(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprReturn> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprReturn > const

before ExprReturn

AstVisitor.visitExprReturn(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprYield> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprYield > const

before ExprYield

AstVisitor.visitExprYield(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprBreak> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprBreak > const

before ExprBreak

AstVisitor.visitExprBreak(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprContinue> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprContinue > const

before ExprContinue

AstVisitor.visitExprContinue(self: AstVisitor; expr: smart_ptr<ast::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<ast::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<ast::ExprMakeBlock> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeBlock > const

before ExprMakeBlock

AstVisitor.visitExprMakeBlock(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprMakeGenerator> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMakeGenerator > const

before ExprMakeGenerator

AstVisitor.visitExprMakeGenerator(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprMemZero> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprMemZero > const

before ExprMemZero

AstVisitor.visitExprMemZero(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConst> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConst > const

before ExprConst

AstVisitor.visitExprConst(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstPtr> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstPtr > const

before ExprConstPtr

AstVisitor.visitExprConstPtr(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstEnumeration> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstEnumeration > const

before ExprConstEnumeration

AstVisitor.visitExprConstEnumeration(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstBitfield> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstBitfield > const

before ExprConstBitfield

AstVisitor.visitExprConstBitfield(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstInt8> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt8 > const

before ExprConstInt8

AstVisitor.visitExprConstInt8(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstInt16> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt16 > const

before ExprConstInt16

AstVisitor.visitExprConstInt16(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstInt64> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt64 > const

before ExprConstInt64

AstVisitor.visitExprConstInt64(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstInt> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt > const

before ExprConstInt

AstVisitor.visitExprConstInt(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstInt2> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt2 > const

before ExprConstInt2

AstVisitor.visitExprConstInt2(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstInt3> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt3 > const

before ExprConstInt3

AstVisitor.visitExprConstInt3(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstInt4> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstInt4 > const

before ExprConstInt4

AstVisitor.visitExprConstInt4(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstUInt8> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt8 > const

before ExprConstUInt8

AstVisitor.visitExprConstUInt8(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstUInt16> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt16 > const

before ExprConstUInt16

AstVisitor.visitExprConstUInt16(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstUInt64> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt64 > const

before ExprConstUInt64

AstVisitor.visitExprConstUInt64(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstUInt> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt > const

before ExprConstUInt

AstVisitor.visitExprConstUInt(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstUInt2> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt2 > const

before ExprConstUInt2

AstVisitor.visitExprConstUInt2(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstUInt3> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt3 > const

before ExprConstUInt3

AstVisitor.visitExprConstUInt3(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstUInt4> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstUInt4 > const

before ExprConstUInt4

AstVisitor.visitExprConstUInt4(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstRange> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstRange > const

before ExprConstRange

AstVisitor.visitExprConstRange(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstURange> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstURange > const

before ExprConstURange

AstVisitor.visitExprConstURange(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstRange64> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstRange64 > const

before ExprConstRange64

AstVisitor.visitExprConstRange64(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstURange64> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstURange64 > const

before ExprConstURange64

AstVisitor.visitExprConstURange64(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstBool> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstBool > const

before ExprConstBool

AstVisitor.visitExprConstBool(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstFloat> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat > const

before ExprConstFloat

AstVisitor.visitExprConstFloat(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstFloat2> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat2 > const

before ExprConstFloat2

AstVisitor.visitExprConstFloat2(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstFloat3> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat3 > const

before ExprConstFloat3

AstVisitor.visitExprConstFloat3(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstFloat4> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstFloat4 > const

before ExprConstFloat4

AstVisitor.visitExprConstFloat4(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstString> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstString > const

before ExprConstString

AstVisitor.visitExprConstString(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprConstDouble> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprConstDouble > const

before ExprConstDouble

AstVisitor.visitExprConstDouble(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprFakeContext> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFakeContext > const

before ExprConstFakeContext

AstVisitor.visitExprFakeContext(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprFakeLineInfo> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprFakeLineInfo > const

before ExprConstFakeLineInfo

AstVisitor.visitExprFakeLineInfo(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprReader> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprReader > const

before ExprReader

AstVisitor.visitExprReader(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprUnsafe> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprUnsafe > const

before ExprUnsafe

AstVisitor.visitExprUnsafe(self: AstVisitor; expr: smart_ptr<ast::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<ast::ExprCallMacro> const)

argument

argument type

self

ast::AstVisitor

expr

smart_ptr< ast::ExprCallMacro > const

before ExprCallMacro

AstVisitor.visitExprCallMacro(self: AstVisitor; expr: smart_ptr<ast::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: 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)

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<rtti::Program> const implicit; adapter: smart_ptr<ast::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<ast::Function> const implicit; adapter: smart_ptr<ast::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<ast::Expression> const implicit; adapter: smart_ptr<ast::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<ast::ExprBlock> const implicit; adapter: smart_ptr<ast::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)

argument

argument type

expression

smart_ptr< ast::Expression > const& implicit

value

bool const

Forces generated flag on subexrepssion.

get_expression_annotation(expr: ast::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<ast::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)

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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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: rtti::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_simulate_macro(name: string const implicit; class: void? const implicit; info: rtti::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: ast::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_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)

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<ast::Function> const implicit; annotation: smart_ptr<ast::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<ast::Function> const implicit; annotation: smart_ptr<rtti::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<ast::ExprBlock> const implicit; annotation: smart_ptr<ast::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<ast::ExprBlock> const implicit; annotation: smart_ptr<rtti::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: rtti::Module? const implicit; annotation: smart_ptr<ast::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<ast::Structure> const implicit; annotation: smart_ptr<ast::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<ast::Structure> const implicit; annotation: smart_ptr<rtti::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: rtti::Module? const implicit; annotation: smart_ptr<ast::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: rtti::Module? const implicit; annotation: smart_ptr<ast::PassMacro>& implicit)

argument

argument type

module

rtti::Module ? const implicit

annotation

smart_ptr<