DEM NODES BRUH

// ReSharper disable All
using System;
using System.Collections.Generic;
using System.Linq;
using GSSharp.Syntax.Ast;


namespace GSSharp.Syntax.Ast
{
    public partial class CompilationUnitNode : AbstractNode
    {



        public IList<IncludeNode> Includes {
            get { return includes.GetList(); }
            set { this.includes.SetList(value); }
        }
        private readonly NodeList<IncludeNode> includes;


        public IList<ClassNode> Classes {
            get { return classes.GetList(); }
            set { this.classes.SetList(value); }
        }
        private readonly NodeList<ClassNode> classes;


        public CompilationUnitNode(IEnumerable<IncludeNode> includes = default(IEnumerable<IncludeNode>), IEnumerable<ClassNode> classes = default(IEnumerable<ClassNode>))
            : base()
        {



            this.includes = new NodeList<IncludeNode>(this);
            this.includes.SetList(includes);

            this.classes = new NodeList<ClassNode>(this);
            this.classes.SetList(classes);

        }

        public CompilationUnitNode(CompilationUnitNode other)
            : base(other)
        {

            this.includes = new NodeList<IncludeNode>(this, other.includes);

            this.classes = new NodeList<ClassNode>(this, other.classes);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            includes.Accept(action);

            classes.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(CompilationUnitNode node)
        {
            return Visit((AbstractNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(CompilationUnitNode node)
        {
            Visit((AbstractNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class IncludeNode : AbstractNode
    {

        public string File { get; set; }



        public IncludeNode(string file = default(string))
            : base()
        {

            this.File = file;



        }

        public IncludeNode(IncludeNode other)
            : base(other)
        {

            this.File = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.File);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(IncludeNode node)
        {
            return Visit((AbstractNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(IncludeNode node)
        {
            Visit((AbstractNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public abstract partial class DeclNode : AbstractNode
    {



        public DeclNode()
            : base()
        {



        }

        public DeclNode(DeclNode other)
            : base(other)
        {

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(DeclNode node)
        {
            return Visit((AbstractNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(DeclNode node)
        {
            Visit((AbstractNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ClassNode : DeclNode
    {

        public string Name { get; set; }

        public List<string> BaseClasses { get; set; }



        public IList<FieldNode> Fields {
            get { return fields.GetList(); }
            set { this.fields.SetList(value); }
        }
        private readonly NodeList<FieldNode> fields;


        public IList<MethodNode> Methods {
            get { return methods.GetList(); }
            set { this.methods.SetList(value); }
        }
        private readonly NodeList<MethodNode> methods;


        public ClassNode(string name = default(string), List<string> baseClasses = default(List<string>), IEnumerable<FieldNode> fields = default(IEnumerable<FieldNode>), IEnumerable<MethodNode> methods = default(IEnumerable<MethodNode>))
            : base()
        {

            this.Name = name;

            this.BaseClasses = baseClasses;



            this.fields = new NodeList<FieldNode>(this);
            this.fields.SetList(fields);

            this.methods = new NodeList<MethodNode>(this);
            this.methods.SetList(methods);

        }

        public ClassNode(ClassNode other)
            : base(other)
        {

            this.Name = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Name);

            this.BaseClasses = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.BaseClasses);

            this.fields = new NodeList<FieldNode>(this, other.fields);

            this.methods = new NodeList<MethodNode>(this, other.methods);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            fields.Accept(action);

            methods.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ClassNode node)
        {
            return Visit((DeclNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ClassNode node)
        {
            Visit((DeclNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class FieldNode : DeclNode
    {


        public VariableNode Variable {
            get { return variable.Get(); }
            set { this.variable.Set(value); }
        }
        private readonly NodeCell<VariableNode> variable;



        public FieldNode(VariableNode variable = default(VariableNode))
            : base()
        {


            this.variable = new NodeCell<VariableNode>(this);
            this.variable.Set(variable);


        }

        public FieldNode(FieldNode other)
            : base(other)
        {

            this.variable = new NodeCell<VariableNode>(this, other.variable);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            variable.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(FieldNode node)
        {
            return Visit((DeclNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(FieldNode node)
        {
            Visit((DeclNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class MethodNode : DeclNode
    {

        public string Name { get; set; }


        public TypeNode ReturnType {
            get { return returnType.Get(); }
            set { this.returnType.Set(value); }
        }
        private readonly NodeCell<TypeNode> returnType;


        public BlockStmtNode Body {
            get { return body.Get(); }
            set { this.body.Set(value); }
        }
        private readonly NodeCell<BlockStmtNode> body;



        public IList<ParameterNode> Parameters {
            get { return parameters.GetList(); }
            set { this.parameters.SetList(value); }
        }
        private readonly NodeList<ParameterNode> parameters;


        public MethodNode(string name = default(string), TypeNode returnType = default(TypeNode), IEnumerable<ParameterNode> parameters = default(IEnumerable<ParameterNode>), BlockStmtNode body = default(BlockStmtNode))
            : base()
        {

            this.Name = name;


            this.returnType = new NodeCell<TypeNode>(this);
            this.returnType.Set(returnType);

            this.body = new NodeCell<BlockStmtNode>(this);
            this.body.Set(body);


            this.parameters = new NodeList<ParameterNode>(this);
            this.parameters.SetList(parameters);

        }

        public MethodNode(MethodNode other)
            : base(other)
        {

            this.Name = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Name);

            this.returnType = new NodeCell<TypeNode>(this, other.returnType);

            this.parameters = new NodeList<ParameterNode>(this, other.parameters);

            this.body = new NodeCell<BlockStmtNode>(this, other.body);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            returnType.Accept(action);

            parameters.Accept(action);

            body.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(MethodNode node)
        {
            return Visit((DeclNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(MethodNode node)
        {
            Visit((DeclNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ParameterNode : DeclNode
    {


        public VariableNode Variable {
            get { return variable.Get(); }
            set { this.variable.Set(value); }
        }
        private readonly NodeCell<VariableNode> variable;



        public ParameterNode(VariableNode variable = default(VariableNode))
            : base()
        {


            this.variable = new NodeCell<VariableNode>(this);
            this.variable.Set(variable);


        }

        public ParameterNode(ParameterNode other)
            : base(other)
        {

            this.variable = new NodeCell<VariableNode>(this, other.variable);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            variable.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ParameterNode node)
        {
            return Visit((DeclNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ParameterNode node)
        {
            Visit((DeclNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public abstract partial class StmtNode : AbstractNode
    {



        public StmtNode()
            : base()
        {



        }

        public StmtNode(StmtNode other)
            : base(other)
        {

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(StmtNode node)
        {
            return Visit((AbstractNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(StmtNode node)
        {
            Visit((AbstractNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class BlockStmtNode : StmtNode
    {



        public IList<StmtNode> Stmts {
            get { return stmts.GetList(); }
            set { this.stmts.SetList(value); }
        }
        private readonly NodeList<StmtNode> stmts;


        public BlockStmtNode(IEnumerable<StmtNode> stmts = default(IEnumerable<StmtNode>))
            : base()
        {



            this.stmts = new NodeList<StmtNode>(this);
            this.stmts.SetList(stmts);

        }

        public BlockStmtNode(BlockStmtNode other)
            : base(other)
        {

            this.stmts = new NodeList<StmtNode>(this, other.stmts);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            stmts.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(BlockStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(BlockStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public abstract partial class LabeledStmtNode : StmtNode
    {


        public StmtNode Stmt {
            get { return stmt.Get(); }
            set { this.stmt.Set(value); }
        }
        private readonly NodeCell<StmtNode> stmt;



        public LabeledStmtNode(StmtNode stmt = default(StmtNode))
            : base()
        {


            this.stmt = new NodeCell<StmtNode>(this);
            this.stmt.Set(stmt);


        }

        public LabeledStmtNode(LabeledStmtNode other)
            : base(other)
        {

            this.stmt = new NodeCell<StmtNode>(this, other.stmt);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            stmt.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(LabeledStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(LabeledStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class LabelStmtNode : LabeledStmtNode
    {

        public string Label { get; set; }



        public LabelStmtNode(StmtNode stmt = default(StmtNode), string label = default(string))
            : base(stmt: stmt)
        {

            this.Label = label;



        }

        public LabelStmtNode(LabelStmtNode other)
            : base(other)
        {

            this.Label = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Label);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(LabelStmtNode node)
        {
            return Visit((LabeledStmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(LabelStmtNode node)
        {
            Visit((LabeledStmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class DefaultStmtNode : LabeledStmtNode
    {



        public DefaultStmtNode(StmtNode stmt = default(StmtNode))
            : base(stmt: stmt)
        {



        }

        public DefaultStmtNode(DefaultStmtNode other)
            : base(other)
        {

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(DefaultStmtNode node)
        {
            return Visit((LabeledStmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(DefaultStmtNode node)
        {
            Visit((LabeledStmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class CaseStmtNode : LabeledStmtNode
    {


        public ExprNode Label {
            get { return label.Get(); }
            set { this.label.Set(value); }
        }
        private readonly NodeCell<ExprNode> label;



        public CaseStmtNode(StmtNode stmt = default(StmtNode), ExprNode label = default(ExprNode))
            : base(stmt: stmt)
        {


            this.label = new NodeCell<ExprNode>(this);
            this.label.Set(label);


        }

        public CaseStmtNode(CaseStmtNode other)
            : base(other)
        {

            this.label = new NodeCell<ExprNode>(this, other.label);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            label.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(CaseStmtNode node)
        {
            return Visit((LabeledStmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(CaseStmtNode node)
        {
            Visit((LabeledStmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class OnStmtNode : LabeledStmtNode
    {


        public ExprNode Major {
            get { return major.Get(); }
            set { this.major.Set(value); }
        }
        private readonly NodeCell<ExprNode> major;


        public ExprNode Minor {
            get { return minor.Get(); }
            set { this.minor.Set(value); }
        }
        private readonly NodeCell<ExprNode> minor;


        public ExprNode Reciever {
            get { return reciever.Get(); }
            set { this.reciever.Set(value); }
        }
        private readonly NodeCell<ExprNode> reciever;



        public OnStmtNode(StmtNode stmt = default(StmtNode), ExprNode major = default(ExprNode), ExprNode minor = default(ExprNode), ExprNode reciever = default(ExprNode))
            : base(stmt: stmt)
        {


            this.major = new NodeCell<ExprNode>(this);
            this.major.Set(major);

            this.minor = new NodeCell<ExprNode>(this);
            this.minor.Set(minor);

            this.reciever = new NodeCell<ExprNode>(this);
            this.reciever.Set(reciever);


        }

        public OnStmtNode(OnStmtNode other)
            : base(other)
        {

            this.major = new NodeCell<ExprNode>(this, other.major);

            this.minor = new NodeCell<ExprNode>(this, other.minor);

            this.reciever = new NodeCell<ExprNode>(this, other.reciever);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            major.Accept(action);

            minor.Accept(action);

            reciever.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(OnStmtNode node)
        {
            return Visit((LabeledStmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(OnStmtNode node)
        {
            Visit((LabeledStmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ReturnStmtNode : StmtNode
    {


        public ExprNode Expr {
            get { return expr.Get(); }
            set { this.expr.Set(value); }
        }
        private readonly NodeCell<ExprNode> expr;



        public ReturnStmtNode(ExprNode expr = default(ExprNode))
            : base()
        {


            this.expr = new NodeCell<ExprNode>(this);
            this.expr.Set(expr);


        }

        public ReturnStmtNode(ReturnStmtNode other)
            : base(other)
        {

            this.expr = new NodeCell<ExprNode>(this, other.expr);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            expr.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ReturnStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ReturnStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ConditionalStmtNode : StmtNode
    {


        public ExprNode Condition {
            get { return condition.Get(); }
            set { this.condition.Set(value); }
        }
        private readonly NodeCell<ExprNode> condition;


        public StmtNode ThenClause {
            get { return thenClause.Get(); }
            set { this.thenClause.Set(value); }
        }
        private readonly NodeCell<StmtNode> thenClause;


        public StmtNode ElseClause {
            get { return elseClause.Get(); }
            set { this.elseClause.Set(value); }
        }
        private readonly NodeCell<StmtNode> elseClause;



        public ConditionalStmtNode(ExprNode condition = default(ExprNode), StmtNode thenClause = default(StmtNode), StmtNode elseClause = default(StmtNode))
            : base()
        {


            this.condition = new NodeCell<ExprNode>(this);
            this.condition.Set(condition);

            this.thenClause = new NodeCell<StmtNode>(this);
            this.thenClause.Set(thenClause);

            this.elseClause = new NodeCell<StmtNode>(this);
            this.elseClause.Set(elseClause);


        }

        public ConditionalStmtNode(ConditionalStmtNode other)
            : base(other)
        {

            this.condition = new NodeCell<ExprNode>(this, other.condition);

            this.thenClause = new NodeCell<StmtNode>(this, other.thenClause);

            this.elseClause = new NodeCell<StmtNode>(this, other.elseClause);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            condition.Accept(action);

            thenClause.Accept(action);

            elseClause.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ConditionalStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ConditionalStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class SwitchStmtNode : StmtNode
    {


        public ExprNode Selector {
            get { return selector.Get(); }
            set { this.selector.Set(value); }
        }
        private readonly NodeCell<ExprNode> selector;


        public BlockStmtNode Body {
            get { return body.Get(); }
            set { this.body.Set(value); }
        }
        private readonly NodeCell<BlockStmtNode> body;



        public SwitchStmtNode(ExprNode selector = default(ExprNode), BlockStmtNode body = default(BlockStmtNode))
            : base()
        {


            this.selector = new NodeCell<ExprNode>(this);
            this.selector.Set(selector);

            this.body = new NodeCell<BlockStmtNode>(this);
            this.body.Set(body);


        }

        public SwitchStmtNode(SwitchStmtNode other)
            : base(other)
        {

            this.selector = new NodeCell<ExprNode>(this, other.selector);

            this.body = new NodeCell<BlockStmtNode>(this, other.body);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            selector.Accept(action);

            body.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(SwitchStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(SwitchStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class WaitStmtNode : StmtNode
    {


        public BlockStmtNode Body {
            get { return body.Get(); }
            set { this.body.Set(value); }
        }
        private readonly NodeCell<BlockStmtNode> body;



        public WaitStmtNode(BlockStmtNode body = default(BlockStmtNode))
            : base()
        {


            this.body = new NodeCell<BlockStmtNode>(this);
            this.body.Set(body);


        }

        public WaitStmtNode(WaitStmtNode other)
            : base(other)
        {

            this.body = new NodeCell<BlockStmtNode>(this, other.body);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            body.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(WaitStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(WaitStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class WhileStmtNode : StmtNode
    {


        public ExprNode Condition {
            get { return condition.Get(); }
            set { this.condition.Set(value); }
        }
        private readonly NodeCell<ExprNode> condition;


        public StmtNode Body {
            get { return body.Get(); }
            set { this.body.Set(value); }
        }
        private readonly NodeCell<StmtNode> body;



        public WhileStmtNode(ExprNode condition = default(ExprNode), StmtNode body = default(StmtNode))
            : base()
        {


            this.condition = new NodeCell<ExprNode>(this);
            this.condition.Set(condition);

            this.body = new NodeCell<StmtNode>(this);
            this.body.Set(body);


        }

        public WhileStmtNode(WhileStmtNode other)
            : base(other)
        {

            this.condition = new NodeCell<ExprNode>(this, other.condition);

            this.body = new NodeCell<StmtNode>(this, other.body);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            condition.Accept(action);

            body.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(WhileStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(WhileStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ForStmtNode : StmtNode
    {


        public ExprNode Initialization {
            get { return initialization.Get(); }
            set { this.initialization.Set(value); }
        }
        private readonly NodeCell<ExprNode> initialization;


        public ExprNode Condition {
            get { return condition.Get(); }
            set { this.condition.Set(value); }
        }
        private readonly NodeCell<ExprNode> condition;


        public ExprNode Iteration {
            get { return iteration.Get(); }
            set { this.iteration.Set(value); }
        }
        private readonly NodeCell<ExprNode> iteration;


        public StmtNode Body {
            get { return body.Get(); }
            set { this.body.Set(value); }
        }
        private readonly NodeCell<StmtNode> body;



        public ForStmtNode(ExprNode initialization = default(ExprNode), ExprNode condition = default(ExprNode), ExprNode iteration = default(ExprNode), StmtNode body = default(StmtNode))
            : base()
        {


            this.initialization = new NodeCell<ExprNode>(this);
            this.initialization.Set(initialization);

            this.condition = new NodeCell<ExprNode>(this);
            this.condition.Set(condition);

            this.iteration = new NodeCell<ExprNode>(this);
            this.iteration.Set(iteration);

            this.body = new NodeCell<StmtNode>(this);
            this.body.Set(body);


        }

        public ForStmtNode(ForStmtNode other)
            : base(other)
        {

            this.initialization = new NodeCell<ExprNode>(this, other.initialization);

            this.condition = new NodeCell<ExprNode>(this, other.condition);

            this.iteration = new NodeCell<ExprNode>(this, other.iteration);

            this.body = new NodeCell<StmtNode>(this, other.body);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            initialization.Accept(action);

            condition.Accept(action);

            iteration.Accept(action);

            body.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ForStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ForStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class GotoStmtNode : StmtNode
    {

        public string Label { get; set; }



        public GotoStmtNode(string label = default(string))
            : base()
        {

            this.Label = label;



        }

        public GotoStmtNode(GotoStmtNode other)
            : base(other)
        {

            this.Label = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Label);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(GotoStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(GotoStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class BreakStmtNode : StmtNode
    {



        public BreakStmtNode()
            : base()
        {



        }

        public BreakStmtNode(BreakStmtNode other)
            : base(other)
        {

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(BreakStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(BreakStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ContinueStmtNode : StmtNode
    {



        public ContinueStmtNode()
            : base()
        {



        }

        public ContinueStmtNode(ContinueStmtNode other)
            : base(other)
        {

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ContinueStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ContinueStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class VariableStmtNode : StmtNode
    {



        public IList<VariableNode> Variables {
            get { return variables.GetList(); }
            set { this.variables.SetList(value); }
        }
        private readonly NodeList<VariableNode> variables;


        public VariableStmtNode(IEnumerable<VariableNode> variables = default(IEnumerable<VariableNode>))
            : base()
        {



            this.variables = new NodeList<VariableNode>(this);
            this.variables.SetList(variables);

        }

        public VariableStmtNode(VariableStmtNode other)
            : base(other)
        {

            this.variables = new NodeList<VariableNode>(this, other.variables);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            variables.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(VariableStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(VariableStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ExprStmtNode : StmtNode
    {


        public ExprNode Expr {
            get { return expr.Get(); }
            set { this.expr.Set(value); }
        }
        private readonly NodeCell<ExprNode> expr;



        public ExprStmtNode(ExprNode expr = default(ExprNode))
            : base()
        {


            this.expr = new NodeCell<ExprNode>(this);
            this.expr.Set(expr);


        }

        public ExprStmtNode(ExprStmtNode other)
            : base(other)
        {

            this.expr = new NodeCell<ExprNode>(this, other.expr);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            expr.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ExprStmtNode node)
        {
            return Visit((StmtNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ExprStmtNode node)
        {
            Visit((StmtNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public abstract partial class ExprNode : AbstractNode
    {



        public ExprNode()
            : base()
        {



        }

        public ExprNode(ExprNode other)
            : base(other)
        {

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ExprNode node)
        {
            return Visit((AbstractNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ExprNode node)
        {
            Visit((AbstractNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class AssignmentExprNode : ExprNode
    {


        public ExprNode Target {
            get { return target.Get(); }
            set { this.target.Set(value); }
        }
        private readonly NodeCell<ExprNode> target;


        public ExprNode Source {
            get { return source.Get(); }
            set { this.source.Set(value); }
        }
        private readonly NodeCell<ExprNode> source;



        public AssignmentExprNode(ExprNode target = default(ExprNode), ExprNode source = default(ExprNode))
            : base()
        {


            this.target = new NodeCell<ExprNode>(this);
            this.target.Set(target);

            this.source = new NodeCell<ExprNode>(this);
            this.source.Set(source);


        }

        public AssignmentExprNode(AssignmentExprNode other)
            : base(other)
        {

            this.target = new NodeCell<ExprNode>(this, other.target);

            this.source = new NodeCell<ExprNode>(this, other.source);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            target.Accept(action);

            source.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(AssignmentExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(AssignmentExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class BinaryExprNode : ExprNode
    {


        public ExprNode Left {
            get { return left.Get(); }
            set { this.left.Set(value); }
        }
        private readonly NodeCell<ExprNode> left;


        public ExprNode Right {
            get { return right.Get(); }
            set { this.right.Set(value); }
        }
        private readonly NodeCell<ExprNode> right;



        public BinaryExprNode(ExprNode left = default(ExprNode), ExprNode right = default(ExprNode))
            : base()
        {


            this.left = new NodeCell<ExprNode>(this);
            this.left.Set(left);

            this.right = new NodeCell<ExprNode>(this);
            this.right.Set(right);


        }

        public BinaryExprNode(BinaryExprNode other)
            : base(other)
        {

            this.left = new NodeCell<ExprNode>(this, other.left);

            this.right = new NodeCell<ExprNode>(this, other.right);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            left.Accept(action);

            right.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(BinaryExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(BinaryExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class UnaryExprNode : ExprNode
    {


        public ExprNode Inner {
            get { return inner.Get(); }
            set { this.inner.Set(value); }
        }
        private readonly NodeCell<ExprNode> inner;



        public UnaryExprNode(ExprNode inner = default(ExprNode))
            : base()
        {


            this.inner = new NodeCell<ExprNode>(this);
            this.inner.Set(inner);


        }

        public UnaryExprNode(UnaryExprNode other)
            : base(other)
        {

            this.inner = new NodeCell<ExprNode>(this, other.inner);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            inner.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(UnaryExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(UnaryExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ConstantExprNode : ExprNode
    {

        public string Value { get; set; }



        public ConstantExprNode(string value = default(string))
            : base()
        {

            this.Value = value;



        }

        public ConstantExprNode(ConstantExprNode other)
            : base(other)
        {

            this.Value = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Value);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ConstantExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ConstantExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class NameExprNode : ExprNode
    {

        public string Name { get; set; }



        public NameExprNode(string name = default(string))
            : base()
        {

            this.Name = name;



        }

        public NameExprNode(NameExprNode other)
            : base(other)
        {

            this.Name = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Name);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(NameExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(NameExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class IndexExprNode : ExprNode
    {


        public ExprNode Array {
            get { return array.Get(); }
            set { this.array.Set(value); }
        }
        private readonly NodeCell<ExprNode> array;


        public ExprNode Index {
            get { return index.Get(); }
            set { this.index.Set(value); }
        }
        private readonly NodeCell<ExprNode> index;



        public IndexExprNode(ExprNode array = default(ExprNode), ExprNode index = default(ExprNode))
            : base()
        {


            this.array = new NodeCell<ExprNode>(this);
            this.array.Set(array);

            this.index = new NodeCell<ExprNode>(this);
            this.index.Set(index);


        }

        public IndexExprNode(IndexExprNode other)
            : base(other)
        {

            this.array = new NodeCell<ExprNode>(this, other.array);

            this.index = new NodeCell<ExprNode>(this, other.index);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            array.Accept(action);

            index.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(IndexExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(IndexExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class IndexRangeExprNode : ExprNode
    {


        public ExprNode Array {
            get { return array.Get(); }
            set { this.array.Set(value); }
        }
        private readonly NodeCell<ExprNode> array;


        public ExprNode Start {
            get { return start.Get(); }
            set { this.start.Set(value); }
        }
        private readonly NodeCell<ExprNode> start;


        public ExprNode End {
            get { return end.Get(); }
            set { this.end.Set(value); }
        }
        private readonly NodeCell<ExprNode> end;



        public IndexRangeExprNode(ExprNode array = default(ExprNode), ExprNode start = default(ExprNode), ExprNode end = default(ExprNode))
            : base()
        {


            this.array = new NodeCell<ExprNode>(this);
            this.array.Set(array);

            this.start = new NodeCell<ExprNode>(this);
            this.start.Set(start);

            this.end = new NodeCell<ExprNode>(this);
            this.end.Set(end);


        }

        public IndexRangeExprNode(IndexRangeExprNode other)
            : base(other)
        {

            this.array = new NodeCell<ExprNode>(this, other.array);

            this.start = new NodeCell<ExprNode>(this, other.start);

            this.end = new NodeCell<ExprNode>(this, other.end);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            array.Accept(action);

            start.Accept(action);

            end.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(IndexRangeExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(IndexRangeExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class CastExprNode : ExprNode
    {


        public ExprNode Source {
            get { return source.Get(); }
            set { this.source.Set(value); }
        }
        private readonly NodeCell<ExprNode> source;


        public TypeNode Type {
            get { return type.Get(); }
            set { this.type.Set(value); }
        }
        private readonly NodeCell<TypeNode> type;



        public CastExprNode(ExprNode source = default(ExprNode), TypeNode type = default(TypeNode))
            : base()
        {


            this.source = new NodeCell<ExprNode>(this);
            this.source.Set(source);

            this.type = new NodeCell<TypeNode>(this);
            this.type.Set(type);


        }

        public CastExprNode(CastExprNode other)
            : base(other)
        {

            this.source = new NodeCell<ExprNode>(this, other.source);

            this.type = new NodeCell<TypeNode>(this, other.type);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            source.Accept(action);

            type.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(CastExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(CastExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class IsClassExprNode : ExprNode
    {


        public ExprNode Source {
            get { return source.Get(); }
            set { this.source.Set(value); }
        }
        private readonly NodeCell<ExprNode> source;


        public TypeNode Type {
            get { return type.Get(); }
            set { this.type.Set(value); }
        }
        private readonly NodeCell<TypeNode> type;



        public IsClassExprNode(ExprNode source = default(ExprNode), TypeNode type = default(TypeNode))
            : base()
        {


            this.source = new NodeCell<ExprNode>(this);
            this.source.Set(source);

            this.type = new NodeCell<TypeNode>(this);
            this.type.Set(type);


        }

        public IsClassExprNode(IsClassExprNode other)
            : base(other)
        {

            this.source = new NodeCell<ExprNode>(this, other.source);

            this.type = new NodeCell<TypeNode>(this, other.type);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            source.Accept(action);

            type.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(IsClassExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(IsClassExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class CopyExprNode : ExprNode
    {


        public ExprNode Target {
            get { return target.Get(); }
            set { this.target.Set(value); }
        }
        private readonly NodeCell<ExprNode> target;


        public ExprNode Source {
            get { return source.Get(); }
            set { this.source.Set(value); }
        }
        private readonly NodeCell<ExprNode> source;



        public CopyExprNode(ExprNode target = default(ExprNode), ExprNode source = default(ExprNode))
            : base()
        {


            this.target = new NodeCell<ExprNode>(this);
            this.target.Set(target);

            this.source = new NodeCell<ExprNode>(this);
            this.source.Set(source);


        }

        public CopyExprNode(CopyExprNode other)
            : base(other)
        {

            this.target = new NodeCell<ExprNode>(this, other.target);

            this.source = new NodeCell<ExprNode>(this, other.source);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            target.Accept(action);

            source.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(CopyExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(CopyExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class SizeExprNode : ExprNode
    {


        public ExprNode Target {
            get { return target.Get(); }
            set { this.target.Set(value); }
        }
        private readonly NodeCell<ExprNode> target;



        public SizeExprNode(ExprNode target = default(ExprNode))
            : base()
        {


            this.target = new NodeCell<ExprNode>(this);
            this.target.Set(target);


        }

        public SizeExprNode(SizeExprNode other)
            : base(other)
        {

            this.target = new NodeCell<ExprNode>(this, other.target);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            target.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(SizeExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(SizeExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class NewExprNode : ExprNode
    {


        public TypeNode Type {
            get { return type.Get(); }
            set { this.type.Set(value); }
        }
        private readonly NodeCell<TypeNode> type;



        public IList<ExprNode> Arguments {
            get { return arguments.GetList(); }
            set { this.arguments.SetList(value); }
        }
        private readonly NodeList<ExprNode> arguments;


        public NewExprNode(TypeNode type = default(TypeNode), IEnumerable<ExprNode> arguments = default(IEnumerable<ExprNode>))
            : base()
        {


            this.type = new NodeCell<TypeNode>(this);
            this.type.Set(type);


            this.arguments = new NodeList<ExprNode>(this);
            this.arguments.SetList(arguments);

        }

        public NewExprNode(NewExprNode other)
            : base(other)
        {

            this.type = new NodeCell<TypeNode>(this, other.type);

            this.arguments = new NodeList<ExprNode>(this, other.arguments);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            type.Accept(action);

            arguments.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(NewExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(NewExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class NewArrayExprNode : ExprNode
    {


        public TypeNode Type {
            get { return type.Get(); }
            set { this.type.Set(value); }
        }
        private readonly NodeCell<TypeNode> type;



        public IList<ExprNode> Length {
            get { return length.GetList(); }
            set { this.length.SetList(value); }
        }
        private readonly NodeList<ExprNode> length;


        public NewArrayExprNode(TypeNode type = default(TypeNode), IEnumerable<ExprNode> length = default(IEnumerable<ExprNode>))
            : base()
        {


            this.type = new NodeCell<TypeNode>(this);
            this.type.Set(type);


            this.length = new NodeList<ExprNode>(this);
            this.length.SetList(length);

        }

        public NewArrayExprNode(NewArrayExprNode other)
            : base(other)
        {

            this.type = new NodeCell<TypeNode>(this, other.type);

            this.length = new NodeList<ExprNode>(this, other.length);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            type.Accept(action);

            length.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(NewArrayExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(NewArrayExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class MemberAccessExprNode : ExprNode
    {

        public string Member { get; set; }


        public ExprNode Target {
            get { return target.Get(); }
            set { this.target.Set(value); }
        }
        private readonly NodeCell<ExprNode> target;



        public MemberAccessExprNode(ExprNode target = default(ExprNode), string member = default(string))
            : base()
        {

            this.Member = member;


            this.target = new NodeCell<ExprNode>(this);
            this.target.Set(target);


        }

        public MemberAccessExprNode(MemberAccessExprNode other)
            : base(other)
        {

            this.target = new NodeCell<ExprNode>(this, other.target);

            this.Member = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Member);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            target.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(MemberAccessExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(MemberAccessExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class MethodCallExprNode : ExprNode
    {


        public ExprNode Target {
            get { return target.Get(); }
            set { this.target.Set(value); }
        }
        private readonly NodeCell<ExprNode> target;



        public IList<ExprNode> Arguments {
            get { return arguments.GetList(); }
            set { this.arguments.SetList(value); }
        }
        private readonly NodeList<ExprNode> arguments;


        public MethodCallExprNode(ExprNode target = default(ExprNode), IEnumerable<ExprNode> arguments = default(IEnumerable<ExprNode>))
            : base()
        {


            this.target = new NodeCell<ExprNode>(this);
            this.target.Set(target);


            this.arguments = new NodeList<ExprNode>(this);
            this.arguments.SetList(arguments);

        }

        public MethodCallExprNode(MethodCallExprNode other)
            : base(other)
        {

            this.target = new NodeCell<ExprNode>(this, other.target);

            this.arguments = new NodeList<ExprNode>(this, other.arguments);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            target.Accept(action);

            arguments.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(MethodCallExprNode node)
        {
            return Visit((ExprNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(MethodCallExprNode node)
        {
            Visit((ExprNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class VariableNode : AbstractNode
    {

        public string Name { get; set; }


        public TypeNode Type {
            get { return type.Get(); }
            set { this.type.Set(value); }
        }
        private readonly NodeCell<TypeNode> type;


        public ExprNode Initializer {
            get { return initializer.Get(); }
            set { this.initializer.Set(value); }
        }
        private readonly NodeCell<ExprNode> initializer;



        public VariableNode(TypeNode type = default(TypeNode), string name = default(string), ExprNode initializer = default(ExprNode))
            : base()
        {

            this.Name = name;


            this.type = new NodeCell<TypeNode>(this);
            this.type.Set(type);

            this.initializer = new NodeCell<ExprNode>(this);
            this.initializer.Set(initializer);


        }

        public VariableNode(VariableNode other)
            : base(other)
        {

            this.type = new NodeCell<TypeNode>(this, other.type);

            this.Name = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Name);

            this.initializer = new NodeCell<ExprNode>(this, other.initializer);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            type.Accept(action);

            initializer.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(VariableNode node)
        {
            return Visit((AbstractNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(VariableNode node)
        {
            Visit((AbstractNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public abstract partial class TypeNode : AbstractNode
    {



        public TypeNode()
            : base()
        {



        }

        public TypeNode(TypeNode other)
            : base(other)
        {

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(TypeNode node)
        {
            return Visit((AbstractNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(TypeNode node)
        {
            Visit((AbstractNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class PrimitiveTypeNode : TypeNode
    {

        public string Name { get; set; }



        public PrimitiveTypeNode(string name = default(string))
            : base()
        {

            this.Name = name;



        }

        public PrimitiveTypeNode(PrimitiveTypeNode other)
            : base(other)
        {

            this.Name = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Name);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(PrimitiveTypeNode node)
        {
            return Visit((TypeNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(PrimitiveTypeNode node)
        {
            Visit((TypeNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ObjectTypeNode : TypeNode
    {

        public string Name { get; set; }



        public ObjectTypeNode(string name = default(string))
            : base()
        {

            this.Name = name;



        }

        public ObjectTypeNode(ObjectTypeNode other)
            : base(other)
        {

            this.Name = global::GSSharp.Syntax.Ast.Helper.CloneProp(other.Name);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ObjectTypeNode node)
        {
            return Visit((TypeNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ObjectTypeNode node)
        {
            Visit((TypeNode) node);
        }
    }
}



namespace GSSharp.Syntax.Ast
{
    public partial class ArrayTypeNode : TypeNode
    {


        public TypeNode Item {
            get { return item.Get(); }
            set { this.item.Set(value); }
        }
        private readonly NodeCell<TypeNode> item;



        public ArrayTypeNode(TypeNode item = default(TypeNode))
            : base()
        {


            this.item = new NodeCell<TypeNode>(this);
            this.item.Set(item);


        }

        public ArrayTypeNode(ArrayTypeNode other)
            : base(other)
        {

            this.item = new NodeCell<TypeNode>(this, other.item);

        }

        public override void VisitChildren(Action<AbstractNode> action)
        {
            base.VisitChildren(action);

            item.Accept(action);

        }

        public override T Accept<T>(AbstractVisitor<T> visitor)
        {
            return visitor.Visit(this);
        }

        public override void Accept(AbstractVisitor visitor)
        {
            visitor.Visit(this);
        }
    }


    public abstract partial class AbstractVisitor<T>
    {
        public virtual T Visit(ArrayTypeNode node)
        {
            return Visit((TypeNode) node);
        }
    }


    public abstract partial class AbstractVisitor
    {
        public virtual void Visit(ArrayTypeNode node)
        {
            Visit((TypeNode) node);
        }
    }
}