Code Map

module volta.visitor.visitor;


alias VisitorStop = Visitor.Status.Stop;
alias VisitorContinue = Visitor.Status.Continue;
alias VisitorContinueParent = Visitor.Status.ContinueParent;

class Visitor
{
public:
	enum Status
	{
		Stop,
		Continue,
		ContinueParent,
	}


public:
	alias Stop = Status.Stop;
	alias Continue = Status.Continue;
	alias ContinueParent = Status.ContinueParent;


public:
	this() { }
	fn visitingError(n: ir.Node, msg: string) Status;
	fn enter(m: ir.Module) Status;
	fn leave(m: ir.Module) Status;
	fn enter(tlb: ir.TopLevelBlock) Status;
	fn leave(tlb: ir.TopLevelBlock) Status;
	fn enter(i: ir.Import) Status;
	fn leave(i: ir.Import) Status;
	fn enter(u: ir.Unittest) Status;
	fn leave(u: ir.Unittest) Status;
	fn enter(c: ir.Class) Status;
	fn leave(c: ir.Class) Status;
	fn enter(i: ir._Interface) Status;
	fn leave(i: ir._Interface) Status;
	fn enter(s: ir.Struct) Status;
	fn leave(s: ir.Struct) Status;
	fn enter(c: ir.Union) Status;
	fn leave(c: ir.Union) Status;
	fn enter(d: ir.Variable) Status;
	fn leave(d: ir.Variable) Status;
	fn enter(fp: ir.FunctionParam) Status;
	fn leave(fp: ir.FunctionParam) Status;
	fn enter(e: ir.Enum) Status;
	fn leave(e: ir.Enum) Status;
	fn enter(c: ir.Condition) Status;
	fn leave(c: ir.Condition) Status;
	fn enter(ctl: ir.ConditionTopLevel) Status;
	fn leave(ctl: ir.ConditionTopLevel) Status;
	fn enter(mf: ir.MixinFunction) Status;
	fn leave(mf: ir.MixinFunction) Status;
	fn enter(mt: ir.MixinTemplate) Status;
	fn leave(mt: ir.MixinTemplate) Status;
	fn visit(qname: ir.QualifiedName) Status;
	fn visit(name: ir.Identifier) Status;
	fn enter(e: ir.ExpStatement) Status;
	fn leave(e: ir.ExpStatement) Status;
	fn enter(ret: ir.ReturnStatement) Status;
	fn leave(ret: ir.ReturnStatement) Status;
	fn enter(b: ir.BlockStatement) Status;
	fn leave(b: ir.BlockStatement) Status;
	fn enter(a: ir.AsmStatement) Status;
	fn leave(a: ir.AsmStatement) Status;
	fn enter(i: ir.IfStatement) Status;
	fn leave(i: ir.IfStatement) Status;
	fn enter(w: ir.WhileStatement) Status;
	fn leave(w: ir.WhileStatement) Status;
	fn enter(d: ir.DoStatement) Status;
	fn leave(d: ir.DoStatement) Status;
	fn enter(f: ir.ForStatement) Status;
	fn leave(f: ir.ForStatement) Status;
	fn enter(fes: ir.ForeachStatement) Status;
	fn leave(fes: ir.ForeachStatement) Status;
	fn enter(ls: ir.LabelStatement) Status;
	fn leave(ls: ir.LabelStatement) Status;
	fn enter(ss: ir.SwitchStatement) Status;
	fn leave(ss: ir.SwitchStatement) Status;
	fn enter(c: ir.SwitchCase) Status;
	fn leave(c: ir.SwitchCase) Status;
	fn enter(gs: ir.GotoStatement) Status;
	fn leave(gs: ir.GotoStatement) Status;
	fn enter(ws: ir.WithStatement) Status;
	fn leave(ws: ir.WithStatement) Status;
	fn enter(ss: ir.SynchronizedStatement) Status;
	fn leave(ss: ir.SynchronizedStatement) Status;
	fn enter(ts: ir.TryStatement) Status;
	fn leave(ts: ir.TryStatement) Status;
	fn enter(ts: ir.ThrowStatement) Status;
	fn leave(ts: ir.ThrowStatement) Status;
	fn enter(ss: ir.ScopeStatement) Status;
	fn leave(ss: ir.ScopeStatement) Status;
	fn enter(ps: ir.PragmaStatement) Status;
	fn leave(ps: ir.PragmaStatement) Status;
	fn enter(cs: ir.ConditionStatement) Status;
	fn leave(cs: ir.ConditionStatement) Status;
	fn enter(ms: ir.MixinStatement) Status;
	fn leave(ms: ir.MixinStatement) Status;
	fn enter(as: ir.AssertStatement) Status;
	fn leave(as: ir.AssertStatement) Status;
	fn visit(bs: ir.BreakStatement) Status;
	fn visit(cs: ir.ContinueStatement) Status;
	fn enter(pointer: ir.PointerType) Status;
	fn leave(pointer: ir.PointerType) Status;
	fn enter(array: ir.ArrayType) Status;
	fn leave(array: ir.ArrayType) Status;
	fn enter(array: ir.StaticArrayType) Status;
	fn leave(array: ir.StaticArrayType) Status;
	fn enter(array: ir.AAType) Status;
	fn leave(array: ir.AAType) Status;
	fn enter(array: ir.AmbiguousArrayType) Status;
	fn leave(array: ir.AmbiguousArrayType) Status;
	fn enter(func: ir.FunctionType) Status;
	fn leave(func: ir.FunctionType) Status;
	fn enter(func: ir.DelegateType) Status;
	fn leave(func: ir.DelegateType) Status;
	fn enter(func: ir.Function) Status;
	fn leave(func: ir.Function) Status;
	fn enter(type: ir.StorageType) Status;
	fn leave(type: ir.StorageType) Status;
	fn enter(attr: ir.Attribute) Status;
	fn leave(attr: ir.Attribute) Status;
	fn enter(a: ir.Alias) Status;
	fn leave(a: ir.Alias) Status;
	fn enter(typeOf: ir.TypeOf) Status;
	fn leave(typeOf: ir.TypeOf) Status;
	fn enter(ir.EnumDeclaration) Status;
	fn leave(ir.EnumDeclaration) Status;
	fn enter(ir.AliasStaticIf) Status;
	fn leave(ir.AliasStaticIf) Status;
	fn visit(it: ir.PrimitiveType) Status;
	fn visit(tr: ir.TypeReference) Status;
	fn visit(nt: ir.NullType) Status;
	fn visit(at: ir.AutoType) Status;
	fn visit(at: ir.NoType) Status;
	fn enter(ti: ir.TemplateInstance) Status;
	fn leave(ti: ir.TemplateInstance) Status;
	fn visit(td: ir.TemplateDefinition) Status;
	fn enter(ir.Exp, ir.Postfix) Visitor.Status;
	fn leave(ir.Exp, ir.Postfix) Visitor.Status;
	fn enter(ir.Exp, ir.Unary) Visitor.Status;
	fn leave(ir.Exp, ir.Unary) Visitor.Status;
	fn enter(ir.Exp, ir.BinOp) Visitor.Status;
	fn leave(ir.Exp, ir.BinOp) Visitor.Status;
	fn enter(ir.Exp, ir.Ternary) Visitor.Status;
	fn leave(ir.Exp, ir.Ternary) Visitor.Status;
	fn enter(ir.Exp, ir.ArrayLiteral) Visitor.Status;
	fn leave(ir.Exp, ir.ArrayLiteral) Visitor.Status;
	fn enter(ir.Exp, ir.AssocArray) Visitor.Status;
	fn leave(ir.Exp, ir.AssocArray) Visitor.Status;
	fn enter(ir.Exp, ir.Assert) Visitor.Status;
	fn leave(ir.Exp, ir.Assert) Visitor.Status;
	fn enter(ir.Exp, ir.StringImport) Visitor.Status;
	fn leave(ir.Exp, ir.StringImport) Visitor.Status;
	fn enter(ir.Exp, ir.Typeid) Visitor.Status;
	fn leave(ir.Exp, ir.Typeid) Visitor.Status;
	fn enter(ir.Exp, ir.IsExp) Visitor.Status;
	fn leave(ir.Exp, ir.IsExp) Visitor.Status;
	fn enter(ir.Exp, ir.FunctionLiteral) Visitor.Status;
	fn leave(ir.Exp, ir.FunctionLiteral) Visitor.Status;
	fn enter(ir.Exp, ir.StructLiteral) Visitor.Status;
	fn leave(ir.Exp, ir.StructLiteral) Visitor.Status;
	fn enter(ir.Exp, ir.UnionLiteral) Visitor.Status;
	fn leave(ir.Exp, ir.UnionLiteral) Visitor.Status;
	fn enter(ir.Exp, ir.ClassLiteral) Visitor.Status;
	fn leave(ir.Exp, ir.ClassLiteral) Visitor.Status;
	fn enter(ir.Exp, ir.Constant) Visitor.Status;
	fn leave(ir.Exp, ir.Constant) Visitor.Status;
	fn enter(ir.Exp, ir.TypeExp) Visitor.Status;
	fn leave(ir.Exp, ir.TypeExp) Visitor.Status;
	fn enter(ir.Exp, ir.StatementExp) Visitor.Status;
	fn leave(ir.Exp, ir.StatementExp) Visitor.Status;
	fn enter(ir.Exp, ir.VaArgExp) Visitor.Status;
	fn leave(ir.Exp, ir.VaArgExp) Visitor.Status;
	fn enter(ir.Exp, ir.PropertyExp) Visitor.Status;
	fn leave(ir.Exp, ir.PropertyExp) Visitor.Status;
	fn enter(ir.Exp, ir.BuiltinExp) Visitor.Status;
	fn leave(ir.Exp, ir.BuiltinExp) Visitor.Status;
	fn enter(ir.Exp, ir.AccessExp) Visitor.Status;
	fn leave(ir.Exp, ir.AccessExp) Visitor.Status;
	fn enter(ir.Exp, ir.RunExp) Visitor.Status;
	fn leave(ir.Exp, ir.RunExp) Visitor.Status;
	fn enter(ir.Exp, ir.ComposableString) Visitor.Status;
	fn leave(ir.Exp, ir.ComposableString) Visitor.Status;
	fn visit(ir.Exp, ir.IdentifierExp) Visitor.Status;
	fn visit(ir.Exp, ir.ExpReference) Visitor.Status;
	fn visit(ir.Exp, ir.TokenExp) Visitor.Status;
	fn visit(ir.Exp, ir.StoreExp) Visitor.Status;
}

//! A visitor that does nothing.
class NullVisitor : Visitor
{
public:
	this() { }
	fn visitingError(n: ir.Node, msg: string) Status { }
	fn enter(m: ir.Module) Status { }
	fn leave(m: ir.Module) Status { }
	fn enter(tlb: ir.TopLevelBlock) Status { }
	fn leave(tlb: ir.TopLevelBlock) Status { }
	fn enter(i: ir.Import) Status { }
	fn leave(i: ir.Import) Status { }
	fn enter(u: ir.Unittest) Status { }
	fn leave(u: ir.Unittest) Status { }
	fn enter(c: ir.Class) Status { }
	fn leave(c: ir.Class) Status { }
	fn enter(i: ir._Interface) Status { }
	fn leave(i: ir._Interface) Status { }
	fn enter(u: ir.Union) Status { }
	fn leave(u: ir.Union) Status { }
	fn enter(s: ir.Struct) Status { }
	fn leave(s: ir.Struct) Status { }
	fn enter(d: ir.Variable) Status { }
	fn leave(d: ir.Variable) Status { }
	fn enter(fp: ir.FunctionParam) Status { }
	fn leave(fp: ir.FunctionParam) Status { }
	fn enter(e: ir.Enum) Status { }
	fn leave(e: ir.Enum) Status { }
	fn enter(c: ir.Condition) Status { }
	fn leave(c: ir.Condition) Status { }
	fn enter(ctl: ir.ConditionTopLevel) Status { }
	fn leave(ctl: ir.ConditionTopLevel) Status { }
	fn enter(mf: ir.MixinFunction) Status { }
	fn leave(mf: ir.MixinFunction) Status { }
	fn enter(mt: ir.MixinTemplate) Status { }
	fn leave(mt: ir.MixinTemplate) Status { }
	fn visit(qname: ir.QualifiedName) Status { }
	fn visit(name: ir.Identifier) Status { }
	fn enter(e: ir.ExpStatement) Status { }
	fn leave(e: ir.ExpStatement) Status { }
	fn enter(ret: ir.ReturnStatement) Status { }
	fn leave(ret: ir.ReturnStatement) Status { }
	fn enter(b: ir.BlockStatement) Status { }
	fn leave(b: ir.BlockStatement) Status { }
	fn enter(a: ir.AsmStatement) Status { }
	fn leave(a: ir.AsmStatement) Status { }
	fn enter(i: ir.IfStatement) Status { }
	fn leave(i: ir.IfStatement) Status { }
	fn enter(w: ir.WhileStatement) Status { }
	fn leave(w: ir.WhileStatement) Status { }
	fn enter(d: ir.DoStatement) Status { }
	fn leave(d: ir.DoStatement) Status { }
	fn enter(f: ir.ForStatement) Status { }
	fn leave(f: ir.ForStatement) Status { }
	fn enter(fes: ir.ForeachStatement) Status { }
	fn leave(fes: ir.ForeachStatement) Status { }
	fn enter(ls: ir.LabelStatement) Status { }
	fn leave(ls: ir.LabelStatement) Status { }
	fn enter(ss: ir.SwitchStatement) Status { }
	fn leave(ss: ir.SwitchStatement) Status { }
	fn enter(c: ir.SwitchCase) Status { }
	fn leave(c: ir.SwitchCase) Status { }
	fn enter(gs: ir.GotoStatement) Status { }
	fn leave(gs: ir.GotoStatement) Status { }
	fn enter(ws: ir.WithStatement) Status { }
	fn leave(ws: ir.WithStatement) Status { }
	fn enter(ss: ir.SynchronizedStatement) Status { }
	fn leave(ss: ir.SynchronizedStatement) Status { }
	fn enter(ts: ir.TryStatement) Status { }
	fn leave(ts: ir.TryStatement) Status { }
	fn enter(ts: ir.ThrowStatement) Status { }
	fn leave(ts: ir.ThrowStatement) Status { }
	fn enter(ss: ir.ScopeStatement) Status { }
	fn leave(ss: ir.ScopeStatement) Status { }
	fn enter(ps: ir.PragmaStatement) Status { }
	fn leave(ps: ir.PragmaStatement) Status { }
	fn enter(cs: ir.ConditionStatement) Status { }
	fn leave(cs: ir.ConditionStatement) Status { }
	fn enter(ms: ir.MixinStatement) Status { }
	fn leave(ms: ir.MixinStatement) Status { }
	fn enter(as: ir.AssertStatement) Status { }
	fn leave(as: ir.AssertStatement) Status { }
	fn visit(cs: ir.ContinueStatement) Status { }
	fn visit(bs: ir.BreakStatement) Status { }
	fn enter(pointer: ir.PointerType) Status { }
	fn leave(pointer: ir.PointerType) Status { }
	fn enter(array: ir.ArrayType) Status { }
	fn leave(array: ir.ArrayType) Status { }
	fn enter(array: ir.StaticArrayType) Status { }
	fn leave(array: ir.StaticArrayType) Status { }
	fn enter(array: ir.AAType) Status { }
	fn leave(array: ir.AAType) Status { }
	fn enter(array: ir.AmbiguousArrayType) Status { }
	fn leave(array: ir.AmbiguousArrayType) Status { }
	fn enter(func: ir.FunctionType) Status { }
	fn leave(func: ir.FunctionType) Status { }
	fn enter(func: ir.DelegateType) Status { }
	fn leave(func: ir.DelegateType) Status { }
	fn enter(func: ir.Function) Status { }
	fn leave(func: ir.Function) Status { }
	fn enter(type: ir.StorageType) Status { }
	fn leave(type: ir.StorageType) Status { }
	fn enter(attr: ir.Attribute) Status { }
	fn leave(attr: ir.Attribute) Status { }
	fn enter(a: ir.Alias) Status { }
	fn leave(a: ir.Alias) Status { }
	fn enter(to: ir.TypeOf) Status { }
	fn leave(to: ir.TypeOf) Status { }
	fn enter(ed: ir.EnumDeclaration) Status { }
	fn leave(ed: ir.EnumDeclaration) Status { }
	fn enter(asi: ir.AliasStaticIf) Status { }
	fn leave(asi: ir.AliasStaticIf) Status { }
	fn enter(ti: ir.TemplateInstance) Status { }
	fn leave(ti: ir.TemplateInstance) Status { }
	fn visit(td: ir.TemplateDefinition) Status { }
	fn visit(it: ir.PrimitiveType) Status { }
	fn visit(tr: ir.TypeReference) Status { }
	fn visit(nt: ir.NullType) Status { }
	fn visit(at: ir.AutoType) Status { }
	fn visit(at: ir.NoType) Status { }
	fn enter(ir.Exp, ir.Postfix) Status { }
	fn leave(ir.Exp, ir.Postfix) Status { }
	fn enter(ir.Exp, ir.Unary) Status { }
	fn leave(ir.Exp, ir.Unary) Status { }
	fn enter(ir.Exp, ir.BinOp) Status { }
	fn leave(ir.Exp, ir.BinOp) Status { }
	fn enter(ir.Exp, ir.Ternary) Status { }
	fn leave(ir.Exp, ir.Ternary) Status { }
	fn enter(ir.Exp, ir.ArrayLiteral) Status { }
	fn leave(ir.Exp, ir.ArrayLiteral) Status { }
	fn enter(ir.Exp, ir.AssocArray) Status { }
	fn leave(ir.Exp, ir.AssocArray) Status { }
	fn enter(ir.Exp, ir.Assert) Status { }
	fn leave(ir.Exp, ir.Assert) Status { }
	fn enter(ir.Exp, ir.StringImport) Status { }
	fn leave(ir.Exp, ir.StringImport) Status { }
	fn enter(ir.Exp, ir.Typeid) Status { }
	fn leave(ir.Exp, ir.Typeid) Status { }
	fn enter(ir.Exp, ir.IsExp) Status { }
	fn leave(ir.Exp, ir.IsExp) Status { }
	fn enter(ir.Exp, ir.FunctionLiteral) Status { }
	fn leave(ir.Exp, ir.FunctionLiteral) Status { }
	fn enter(ir.Exp, ir.StructLiteral) Status { }
	fn leave(ir.Exp, ir.StructLiteral) Status { }
	fn enter(ir.Exp, ir.UnionLiteral) Status { }
	fn leave(ir.Exp, ir.UnionLiteral) Status { }
	fn enter(ir.Exp, ir.ClassLiteral) Status { }
	fn leave(ir.Exp, ir.ClassLiteral) Status { }
	fn enter(ir.Exp, ir.Constant) Status { }
	fn leave(ir.Exp, ir.Constant) Status { }
	fn enter(ir.Exp, ir.TypeExp) Status { }
	fn leave(ir.Exp, ir.TypeExp) Status { }
	fn enter(ir.Exp, ir.StatementExp) Status { }
	fn leave(ir.Exp, ir.StatementExp) Status { }
	fn enter(ir.Exp, ir.VaArgExp) Status { }
	fn leave(ir.Exp, ir.VaArgExp) Status { }
	fn enter(ir.Exp, ir.PropertyExp) Status { }
	fn leave(ir.Exp, ir.PropertyExp) Status { }
	fn enter(ir.Exp, ir.BuiltinExp) Status { }
	fn leave(ir.Exp, ir.BuiltinExp) Status { }
	fn enter(ir.Exp, ir.AccessExp) Status { }
	fn leave(ir.Exp, ir.AccessExp) Status { }
	fn enter(ir.Exp, ir.RunExp) Status { }
	fn leave(ir.Exp, ir.RunExp) Status { }
	fn enter(ir.Exp, ir.ComposableString) Status { }
	fn leave(ir.Exp, ir.ComposableString) Status { }
	fn visit(ir.Exp, ir.ExpReference) Status { }
	fn visit(ir.Exp, ir.IdentifierExp) Status { }
	fn visit(ir.Exp, ir.TokenExp) Status { }
	fn visit(ir.Exp, ir.StoreExp) Status { }
}

//! Helper function that returns VistorContinue if @s is
//! VisitorContinueParent, used to abort a leaf node, but not the whole
//! tree.
fn parentContinue(s: Visitor.Status) Visitor.Status { }
fn accept(n: ir.Node, av: Visitor) Visitor.Status { }
fn acceptExp(exp: ir.Exp, av: Visitor) Visitor.Status { }
fn acceptModule(m: ir.Module, av: Visitor) Visitor.Status { }
fn acceptTopLevelBlock(tlb: ir.TopLevelBlock, av: Visitor) Visitor.Status { }
fn acceptImport(i: ir.Import, av: Visitor) Visitor.Status { }
fn acceptVariable(d: ir.Variable, av: Visitor) Visitor.Status { }
fn acceptFunctionParam(fp: ir.FunctionParam, av: Visitor) Visitor.Status { }
fn acceptUnittest(u: ir.Unittest, av: Visitor) Visitor.Status { }
fn acceptClass(c: ir.Class, av: Visitor) Visitor.Status { }
fn acceptInterface(i: ir._Interface, av: Visitor) Visitor.Status { }
fn acceptStruct(s: ir.Struct, av: Visitor) Visitor.Status { }
fn acceptUnion(u: ir.Union, av: Visitor) Visitor.Status { }
fn acceptEnum(e: ir.Enum, av: Visitor) Visitor.Status { }
fn acceptCondition(c: ir.Condition, av: Visitor) Visitor.Status { }
fn acceptConditionTopLevel(ctl: ir.ConditionTopLevel, av: Visitor) Visitor.Status { }
fn acceptMixinFunction(mf: ir.MixinFunction, av: Visitor) Visitor.Status { }
fn acceptMixinTemplate(mt: ir.MixinTemplate, av: Visitor) Visitor.Status { }
fn acceptAttribute(attr: ir.Attribute, av: Visitor) Visitor.Status { }
fn acceptAlias(a: ir.Alias, av: Visitor) Visitor.Status { }
fn acceptTypeOf(typeOf: ir.TypeOf, av: Visitor) Visitor.Status { }
fn acceptStorageType(type: ir.StorageType, av: Visitor) Visitor.Status { }
fn acceptPointerType(pointer: ir.PointerType, av: Visitor) Visitor.Status { }
fn acceptArrayType(array: ir.ArrayType, av: Visitor) Visitor.Status { }
fn acceptAmbiguousArrayType(array: ir.AmbiguousArrayType, av: Visitor) Visitor.Status { }
fn acceptStaticArrayType(array: ir.StaticArrayType, av: Visitor) Visitor.Status { }
fn acceptAAType(array: ir.AAType, av: Visitor) Visitor.Status { }
fn acceptFunctionType(func: ir.FunctionType, av: Visitor) Visitor.Status { }
fn acceptDelegateType(func: ir.DelegateType, av: Visitor) Visitor.Status { }
fn acceptFunction(func: ir.Function, av: Visitor) Visitor.Status { }
fn acceptEnumDeclaration(ed: ir.EnumDeclaration, av: Visitor) Visitor.Status { }
fn acceptAliasStaticIf(asi: ir.AliasStaticIf, av: Visitor) Visitor.Status { }
fn acceptExpStatement(e: ir.ExpStatement, av: Visitor) Visitor.Status { }
fn acceptReturnStatement(ret: ir.ReturnStatement, av: Visitor) Visitor.Status { }
fn acceptBlockStatement(b: ir.BlockStatement, av: Visitor) Visitor.Status { }
fn acceptAsmStatement(a: ir.AsmStatement, av: Visitor) Visitor.Status { }
fn acceptIfStatement(i: ir.IfStatement, av: Visitor) Visitor.Status { }
fn acceptWhileStatement(w: ir.WhileStatement, av: Visitor) Visitor.Status { }
fn acceptDoStatement(d: ir.DoStatement, av: Visitor) Visitor.Status { }
fn acceptForStatement(f: ir.ForStatement, av: Visitor) Visitor.Status { }
fn acceptForeachStatement(fes: ir.ForeachStatement, av: Visitor) Visitor.Status { }
fn acceptLabelStatement(ls: ir.LabelStatement, av: Visitor) Visitor.Status { }
fn acceptSwitchStatement(ss: ir.SwitchStatement, av: Visitor) Visitor.Status { }
fn acceptSwitchCase(sc: ir.SwitchCase, av: Visitor) Visitor.Status { }
fn acceptGotoStatement(gs: ir.GotoStatement, av: Visitor) Visitor.Status { }
fn acceptWithStatement(ws: ir.WithStatement, av: Visitor) Visitor.Status { }
fn acceptSynchronizedStatement(ss: ir.SynchronizedStatement, av: Visitor) Visitor.Status { }
fn acceptTryStatement(ts: ir.TryStatement, av: Visitor) Visitor.Status { }
fn acceptThrowStatement(ts: ir.ThrowStatement, av: Visitor) Visitor.Status { }
fn acceptScopeStatement(ss: ir.ScopeStatement, av: Visitor) Visitor.Status { }
fn acceptPragmaStatement(ps: ir.PragmaStatement, av: Visitor) Visitor.Status { }
fn acceptConditionStatement(cs: ir.ConditionStatement, av: Visitor) Visitor.Status { }
fn acceptAssertStatement(as: ir.AssertStatement, av: Visitor) Visitor.Status { }
fn acceptMixinStatement(ms: ir.MixinStatement, av: Visitor) Visitor.Status { }
fn acceptPostfix(exp: ir.Exp, postfix: ir.Postfix, av: Visitor) Visitor.Status { }
fn acceptUnary(exp: ir.Exp, unary: ir.Unary, av: Visitor) Visitor.Status { }
fn acceptBinOp(exp: ir.Exp, binop: ir.BinOp, av: Visitor) Visitor.Status { }
fn acceptTernary(exp: ir.Exp, ternary: ir.Ternary, av: Visitor) Visitor.Status { }
fn acceptArrayLiteral(exp: ir.Exp, array: ir.ArrayLiteral, av: Visitor) Visitor.Status { }
fn acceptAssocArray(exp: ir.Exp, array: ir.AssocArray, av: Visitor) Visitor.Status { }
fn acceptAssert(exp: ir.Exp, _assert: ir.Assert, av: Visitor) Visitor.Status { }
fn acceptStringImport(exp: ir.Exp, strimport: ir.StringImport, av: Visitor) Visitor.Status { }
fn acceptTypeid(exp: ir.Exp, ti: ir.Typeid, av: Visitor) Visitor.Status { }
fn acceptIsExp(exp: ir.Exp, isExp: ir.IsExp, av: Visitor) Visitor.Status { }
fn acceptFunctionLiteral(exp: ir.Exp, functionLiteral: ir.FunctionLiteral, av: Visitor) Visitor.Status { }
fn acceptStructLiteral(exp: ir.Exp, sliteral: ir.StructLiteral, av: Visitor) Visitor.Status { }
fn acceptUnionLiteral(exp: ir.Exp, uliteral: ir.UnionLiteral, av: Visitor) Visitor.Status { }
fn acceptClassLiteral(exp: ir.Exp, cliteral: ir.ClassLiteral, av: Visitor) Visitor.Status { }
fn acceptTypeExp(exp: ir.Exp, texp: ir.TypeExp, av: Visitor) Visitor.Status { }
fn acceptStoreExp(exp: ir.Exp, sexp: ir.StoreExp, av: Visitor) Visitor.Status { }
fn acceptStatementExp(exp: ir.Exp, state: ir.StatementExp, av: Visitor) Visitor.Status { }
fn acceptTokenExp(exp: ir.Exp, fexp: ir.TokenExp, av: Visitor) Visitor.Status { }
fn acceptVaArgExp(exp: ir.Exp, vaexp: ir.VaArgExp, av: Visitor) Visitor.Status { }
fn acceptPropertyExp(exp: ir.Exp, prop: ir.PropertyExp, av: Visitor) Visitor.Status { }
fn acceptBuiltinExp(exp: ir.Exp, inbuilt: ir.BuiltinExp, av: Visitor) Visitor.Status { }
fn acceptAccessExp(exp: ir.Exp, ae: ir.AccessExp, av: Visitor) Visitor.Status { }
fn acceptRunExp(exp: ir.Exp, runexp: ir.RunExp, av: Visitor) Visitor.Status { }
fn acceptComposableString(exp: ir.Exp, cs: ir.ComposableString, av: Visitor) Visitor.Status { }
fn acceptExpReference(exp: ir.Exp, expref: ir.ExpReference, av: Visitor) Visitor.Status { }
fn acceptConstant(exp: ir.Exp, constant: ir.Constant, av: Visitor) Visitor.Status { }
fn acceptIdentifierExp(exp: ir.Exp, identifier: ir.IdentifierExp, av: Visitor) Visitor.Status { }
fn acceptTemplateInstance(ti: ir.TemplateInstance, av: Visitor) Visitor.Status { }
fn acceptTemplateDefinition(td: ir.TemplateDefinition, av: Visitor) Visitor.Status { }