public abstract class Node {

	/**
	 * The JSDoc comment.
	 */
	protected JSDocComment jsDocComment = null;

	/**
	 * The position begin.
	 */
	protected int posBegin = 0;

	/**
	 * The position end.
	 */
	protected int posEnd = 0;

	public JSDocComment getJsDocComment() {
		return jsDocComment;
	}

	public void setJsDocComment(JSDocComment jsDocComment) {
		this.jsDocComment = jsDocComment;
	}

	public int getPosBegin() {
		return posBegin;
	}

	public void setPosBegin(int posBegin) {
		this.posBegin = posBegin;
	}

	public int getPosEnd() {
		return posEnd;
	}

	public void setPosEnd(int posEnd) {
		this.posEnd = posEnd;
	}

	Node() {
		super();
	}

	Node(JSDocComment jsDocComment, int posBegin, int posEnd) {
		super();
		this.jsDocComment = jsDocComment;
		this.posBegin = posBegin;
		this.posEnd = posEnd;
	}

	public abstract <C> void accept(VoidVisitor<C> v, C ctx) throws Exception;

	public abstract <R, C> R accept(GenericVisitor<R, C> v, C ctx)
			throws Exception;

	private static final CloneVisitor<Void> CLONE = new CloneVisitor<Void>();

	@Override
	public final Node clone() throws CloneNotSupportedException {
		try {
			return accept(CLONE, null);
		} catch (final Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public final boolean equals(Object obj) {
		try {
			return EqualsVisitor.equals(this, (Node) obj);
		} catch (Exception e) {
			return false;
		}
	}

	private static final String ENCODING = "UTF-8";

	private static final PrinterVisitor PRINTER = new PrinterVisitor();

	@Override
	public final String toString() {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		String result = null;
		try {
			accept(PRINTER, new SourcePrinter(out, ENCODING));
			result = out.toString(ENCODING);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	private static final TracePrinter TRACE_PRINTER = new TracePrinter();

	@Override
	public final int hashCode() {
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		String result = null;
		try {
			accept(TRACE_PRINTER, new SourcePrinter(out, ENCODING));
			result = out.toString(ENCODING);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result.hashCode();
	}

	private static final String CRYPTO = "SHA-256";

	public final String trace() {
		try {
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			accept(TRACE_PRINTER, new SourcePrinter(out, ENCODING));
			MessageDigest md = java.security.MessageDigest.getInstance(CRYPTO);
			md.update(out.toByteArray());
			byte byteData[] = md.digest();
			StringBuffer sb = new StringBuffer();
			for (int i = 0; i < byteData.length; i++) {
				sb.append(java.lang.Integer.toString(
						(byteData[i] & 0xff) + 0x100, 16).substring(1));
			}
			return sb.toString();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

}
 public interface GenericVisitor<R, C> {

    public R visit(AllocationExpression n, C ctx) throws Exception;

    public R visit(ArrayAccessExpression n, C ctx) throws Exception;

    public R visit(ArrayLiteral n, C ctx) throws Exception;

    public R visit(AssignmentExpression n, C ctx) throws Exception;

    public R visit(AssignOperator n, C ctx) throws Exception;

    public R visit(BinaryExpression n, C ctx) throws Exception;

    public R visit(BinaryOperator n, C ctx) throws Exception;

    public R visit(Block n, C ctx) throws Exception;

    public R visit(BlockComment n, C ctx) throws Exception;

    public R visit(BooleanLiteral n, C ctx) throws Exception;

    public R visit(BreakStatement n, C ctx) throws Exception;

    public R visit(CallExpression n, C ctx) throws Exception;

    public R visit(CaseBlock n, C ctx) throws Exception;

    public R visit(CaseClause n, C ctx) throws Exception;

    public R visit(CatchClause n, C ctx) throws Exception;

    public R visit(CompilationUnit n, C ctx) throws Exception;

    public R visit(ConditionalExpression n, C ctx) throws Exception;

    public R visit(ConstantStatement n, C ctx) throws Exception;

    public R visit(ContinueStatement n, C ctx) throws Exception;

    public R visit(DebuggerStatement n, C ctx) throws Exception;

    public R visit(DecimalLiteral n, C ctx) throws Exception;

    public R visit(DefaultClause n, C ctx) throws Exception;

    public R visit(DoWhileStatement n, C ctx) throws Exception;

    public R visit(EmptyLiteral n, C ctx) throws Exception;

    public R visit(EmptyStatement n, C ctx) throws Exception;

    public R visit(EnclosedExpression n, C ctx) throws Exception;

    public R visit(ExpressionStatement n, C ctx) throws Exception;

    public R visit(FieldAccessExpression n, C ctx) throws Exception;

    public R visit(FloatLiteral n, C ctx) throws Exception;

    public R visit(ForeachStatement n, C ctx) throws Exception;

    public R visit(ForStatement n, C ctx) throws Exception;

    public R visit(FunctionDeclaration n, C ctx) throws Exception;

    public R visit(FunctionExpression n, C ctx) throws Exception;

    public R visit(GetAssignment n, C ctx) throws Exception;

    public R visit(HexIntegerLiteral n, C ctx) throws Exception;

    public R visit(IdentifierName n, C ctx) throws Exception;

    public R visit(IfStatement n, C ctx) throws Exception;

    public R visit(ImportStatement n, C ctx) throws Exception;

    public R visit(JSDocComment n, C ctx) throws Exception;

    public R visit(LabelledStatement n, C ctx) throws Exception;

    public R visit(LetDefinition n, C ctx) throws Exception;

    public R visit(LetExpression n, C ctx) throws Exception;

    public R visit(LetStatement n, C ctx) throws Exception;

    public R visit(LineComment n, C ctx) throws Exception;

    public R visit(NewExpression n, C ctx) throws Exception;

    public <E extends Node> R visit(NodeList<E> n, C ctx) throws Exception;

    public R visit(NullLiteral n, C ctx) throws Exception;

    public R visit(ObjectLiteral n, C ctx) throws Exception;

    public R visit(OctalLiteral n, C ctx) throws Exception;

    public R visit(Parameter n, C ctx) throws Exception;

    public R visit(Project n, C ctx) throws Exception;

    public R visit(PutAssignment n, C ctx) throws Exception;

    public R visit(RegexpLiteral n, C ctx) throws Exception;

    public R visit(ReturnStatement n, C ctx) throws Exception;

    public R visit(SequenceExpression n, C ctx) throws Exception;

    public R visit(SetAssignment n, C ctx) throws Exception;

    public R visit(StringLiteralDouble n, C ctx) throws Exception;

    public R visit(StringLiteralSingle n, C ctx) throws Exception;

    public R visit(SuperExpression n, C ctx) throws Exception;

    public R visit(SwitchStatement n, C ctx) throws Exception;

    public R visit(ThisExpression n, C ctx) throws Exception;

    public R visit(ThrowStatement n, C ctx) throws Exception;

    public R visit(TryStatement n, C ctx) throws Exception;

    public R visit(UnaryExpression n, C ctx) throws Exception;

    public R visit(UnaryOperator n, C ctx) throws Exception;

    public R visit(VariableDeclaration n, C ctx) throws Exception;

    public R visit(VariableExpression n, C ctx) throws Exception;

    public R visit(VariableStatement n, C ctx) throws Exception;

    public R visit(WhileStatement n, C ctx) throws Exception;

    public R visit(WithStatement n, C ctx) throws Exception;

}
 public class AllocationExpression extends Expression {

    /** 
     * The body.
     */
    private Expression body;

    public Expression getBody() {
        return body;
    }

    public void setBody(Expression body) {
        this.body = body;
    }

    AllocationExpression() {
        super();
    }

    AllocationExpression(Expression body, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.body = body;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class NodeFacade extends NodeFactory {

	/**
	 * JS doc comment.
	 * 
	 * @param content
	 *            the content
	 * @return the JS doc comment
	 */
	public static JSDocComment JSDocComment(String content) {
		return JSDocComment(content, null, 0, 0);
	}

	/**
	 * Line comment.
	 * 
	 * @param content
	 *            the content
	 * @return the line comment
	 */
	public static LineComment LineComment(String content) {
		return LineComment(content, null, 0, 0);
	}

	/**
	 * Block comment.
	 * 
	 * @param content
	 *            the content
	 * @return the block comment
	 */
	public static BlockComment BlockComment(String content) {
		return BlockComment(content, null, 0, 0);
	}

	/**
	 * Decimal literal.
	 * 
	 * @param value
	 *            the value
	 * @return the decimal literal
	 */
	public static DecimalLiteral DecimalLiteral(String value) {
		return DecimalLiteral(value, null, 0, 0);
	}

	/**
	 * Octal literal.
	 * 
	 * @param value
	 *            the value
	 * @return the octal literal
	 */
	public static OctalLiteral OctalLiteral(String value) {
		return OctalLiteral(value, null, 0, 0);
	}

	/**
	 * Hex integer literal.
	 * 
	 * @param value
	 *            the value
	 * @return the hex integer literal
	 */
	public static HexIntegerLiteral HexIntegerLiteral(String value) {
		return HexIntegerLiteral(value, null, 0, 0);
	}

	/**
	 * Float literal.
	 * 
	 * @param value
	 *            the value
	 * @return the float literal
	 */
	public static FloatLiteral FloatLiteral(String value) {
		return FloatLiteral(value, null, 0, 0);
	}

	/**
	 * Boolean literal.
	 * 
	 * @param value
	 *            the value
	 * @return the boolean literal
	 */
	public static BooleanLiteral BooleanLiteral(boolean value) {
		return BooleanLiteral(value, null, 0, 0);
	}

	/**
	 * Regexp literal.
	 * 
	 * @param value
	 *            the value
	 * @return the regexp literal
	 */
	public static RegexpLiteral RegexpLiteral(String value) {
		return RegexpLiteral(value, null, 0, 0);
	}

	/**
	 * String literal single.
	 * 
	 * @param value
	 *            the value
	 * @return the string literal single
	 */
	public static StringLiteralSingle StringLiteralSingle(String value) {
		return StringLiteralSingle(value, null, 0, 0);
	}

	/**
	 * String literal double.
	 * 
	 * @param value
	 *            the value
	 * @return the string literal double
	 */
	public static StringLiteralDouble StringLiteralDouble(String value) {
		return StringLiteralDouble(value, null, 0, 0);
	}

	/**
	 * Identifier name.
	 * 
	 * @param value
	 *            the value
	 * @return the identifier name
	 */
	public static IdentifierName IdentifierName(String value) {
		return IdentifierName(value, null, 0, 0);
	}

	/**
	 * Enclosed expression.
	 * 
	 * @param inner
	 *            the inner
	 * @return the enclosed expression
	 */
	public static EnclosedExpression EnclosedExpression(Expression inner) {
		return EnclosedExpression(inner, null, 0, 0);
	}

	/**
	 * Function expression.
	 * 
	 * @param name
	 *            the name
	 * @param parameters
	 *            the parameters
	 * @param body
	 *            the body
	 * @return the function expression
	 */
	public static FunctionExpression FunctionExpression(String name,
			List<Parameter> parameters, Block body) {
		return FunctionExpression(name, NodeList(parameters), body, null, 0, 0);
	}

	/**
	 * Call expression.
	 * 
	 * @param scope
	 *            the scope
	 * @param args
	 *            the args
	 * @return the call expression
	 */
	public static CallExpression CallExpression(Expression scope,
			List<Expression> args) {
		return CallExpression(scope, NodeList(args), null, 0, 0);
	}

	/**
	 * Array access expression.
	 * 
	 * @param name
	 *            the name
	 * @param index
	 *            the index
	 * @return the array access expression
	 */
	public static ArrayAccessExpression ArrayAccessExpression(Expression name,
			Expression index) {
		return ArrayAccessExpression(name, index, null, 0, 0);
	}

	/**
	 * Field access expression.
	 * 
	 * @param scope
	 *            the scope
	 * @param field
	 *            the field
	 * @return the field access expression
	 */
	public static FieldAccessExpression FieldAccessExpression(Expression scope,
			IdentifierName field) {
		return FieldAccessExpression(scope, field, null, 0, 0);
	}

	/**
	 * New expression.
	 * 
	 * @param expression
	 *            the expression
	 * @return the new expression
	 */
	public static NewExpression NewExpression(Expression expression) {
		return NewExpression(expression, null, null, 0, 0);
	}

	/**
	 * Array literal.
	 * 
	 * @param expressions
	 *            the expressions
	 * @return the array literal
	 */
	public static ArrayLiteral ArrayLiteral(List<Expression> expressions) {
		return ArrayLiteral(NodeList(expressions), null, 0, 0);
	}

	/**
	 * Object literal.
	 * 
	 * @param propertyAssignments
	 *            the property assignments
	 * @return the object literal
	 */
	public static ObjectLiteral ObjectLiteral(
			List<PropertyAssignment> propertyAssignments) {
		return ObjectLiteral(NodeList(propertyAssignments), null, 0, 0);
	}

	/**
	 * Gets the assignment.
	 * 
	 * @param propertyName
	 *            the property name
	 * @param block
	 *            the block
	 * @return the gets the assignment
	 */
	public static GetAssignment GetAssignment(PropertyName propertyName,
			Block block) {
		return GetAssignment(block, propertyName, null, null, 0, 0);
	}

	/**
	 * Sets the assignment.
	 * 
	 * @param propertyName
	 *            the property name
	 * @param identifier
	 *            the identifier
	 * @param block
	 *            the block
	 * @return the sets the assignment
	 */
	public static SetAssignment SetAssignment(PropertyName propertyName,
			String identifier, Block block) {
		return SetAssignment(identifier, block, propertyName, null, null, 0, 0);
	}

	/**
	 * Put assignment.
	 * 
	 * @param propertyName
	 *            the property name
	 * @param propertyValue
	 *            the property value
	 * @return the put assignment
	 */
	public static PutAssignment PutAssignment(PropertyName propertyName,
			Expression propertyValue) {
		return PutAssignment(propertyValue, propertyName, null, null, 0, 0);
	}

	/**
	 * Unary expression.
	 * 
	 * @param expression
	 *            the expression
	 * @param operator
	 *            the operator
	 * @return the unary expression
	 */
	public static UnaryExpression UnaryExpression(Expression expression,
			UnaryOperator operator) {
		return UnaryExpression(expression, operator, null, 0, 0);
	}

	/**
	 * Binary expression.
	 * 
	 * @param left
	 *            the left
	 * @param right
	 *            the right
	 * @param operator
	 *            the operator
	 * @return the binary expression
	 */
	public static BinaryExpression BinaryExpression(Expression left,
			Expression right, BinaryOperator operator) {
		return BinaryExpression(left, right, operator, null, 0, 0);
	}

	/**
	 * Conditional expression.
	 * 
	 * @param condition
	 *            the condition
	 * @param thenExpr
	 *            the then expr
	 * @param elseExpr
	 *            the else expr
	 * @return the conditional expression
	 */
	public static ConditionalExpression ConditionalExpression(
			Expression condition, Expression thenExpr, Expression elseExpr) {
		return ConditionalExpression(condition, thenExpr, elseExpr, null, 0, 0);
	}

	/**
	 * Assignment expression.
	 * 
	 * @param target
	 *            the target
	 * @param value
	 *            the value
	 * @param operator
	 *            the operator
	 * @return the assignment expression
	 */
	public static AssignmentExpression AssignmentExpression(Expression target,
			Expression value, AssignOperator operator) {
		return AssignmentExpression(target, value, operator, null, 0, 0);
	}

	/**
	 * Sequence expression.
	 * 
	 * @param expressions
	 *            the expressions
	 * @return the sequence expression
	 */
	public static SequenceExpression SequenceExpression(
			List<Expression> expressions) {
		return SequenceExpression(NodeList(expressions), null, 0, 0);
	}

	/**
	 * Block.
	 * 
	 * @param statements
	 *            the statements
	 * @return the block
	 */
	public static Block Block(List<Statement> statements) {
		return Block(NodeList(statements), null, 0, 0);
	}

	/**
	 * Let definition.
	 * 
	 * @param comment
	 *            the comment
	 * @param declarations
	 *            the declarations
	 * @return the let definition
	 */
	public static LetDefinition LetDefinition(JSDocComment comment,
			List<VariableDeclaration> declarations) {
		return LetDefinition(NodeList(declarations), comment, 0, 0);
	}

	/**
	 * Let statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param declarations
	 *            the declarations
	 * @param statement
	 *            the statement
	 * @return the let statement
	 */
	public static LetStatement LetStatement(JSDocComment comment,
			List<VariableDeclaration> declarations, Statement statement) {
		return LetStatement(NodeList(declarations), statement, null, 0, 0);
	}

	/**
	 * Debugger statement.
	 * 
	 * @param comment
	 *            the comment
	 * @return the debugger statement
	 */
	public static DebuggerStatement DebuggerStatement(JSDocComment comment) {
		return DebuggerStatement(comment, 0, 0);
	}

	/**
	 * Constant statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param declarations
	 *            the declarations
	 * @return the constant statement
	 */
	public static ConstantStatement ConstantStatement(JSDocComment comment,
			List<VariableDeclaration> declarations) {
		return ConstantStatement(NodeList(declarations), comment, 0, 0);
	}

	/**
	 * Variable statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param declarations
	 *            the declarations
	 * @return the variable statement
	 */
	public static VariableStatement VariableStatement(JSDocComment comment,
			List<VariableDeclaration> declarations) {
		return VariableStatement(NodeList(declarations), comment, 0, 0);
	}

	/**
	 * Variable declaration.
	 * 
	 * @param name
	 *            the name
	 * @param expression
	 *            the expression
	 * @return the variable declaration
	 */
	public static VariableDeclaration VariableDeclaration(String name,
			Expression expression) {
		return VariableDeclaration(name, expression, null, 0, 0);
	}

	/**
	 * Empty statement.
	 * 
	 * @param comment
	 *            the comment
	 * @return the empty statement
	 */
	public static EmptyStatement EmptyStatement(JSDocComment comment) {
		return EmptyStatement(comment, 0, 0);
	}

	/**
	 * If statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param condition
	 *            the condition
	 * @param thenStatement
	 *            the then statement
	 * @param elseStatement
	 *            the else statement
	 * @return the if statement
	 */
	public static IfStatement IfStatement(JSDocComment comment,
			Expression condition, Statement thenStatement,
			Statement elseStatement) {
		return IfStatement(condition, thenStatement, elseStatement, comment, 0,
				0);
	}

	/**
	 * Labelled statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param label
	 *            the label
	 * @param statement
	 *            the statement
	 * @return the labelled statement
	 */
	public static LabelledStatement LabelledStatement(JSDocComment comment,
			String label, Statement statement) {
		return LabelledStatement(label, statement, comment, 0, 0);
	}

	/**
	 * Expression statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param expression
	 *            the expression
	 * @return the expression statement
	 */
	public static ExpressionStatement ExpressionStatement(JSDocComment comment,
			Expression expression) {
		return ExpressionStatement(expression, comment, 0, 0);
	}

	/**
	 * While statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param condition
	 *            the condition
	 * @param statement
	 *            the statement
	 * @return the while statement
	 */
	public static WhileStatement WhileStatement(JSDocComment comment,
			Expression condition, Statement statement) {
		return WhileStatement(condition, statement, comment, 0, 0);
	}

	/**
	 * Do while statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param condition
	 *            the condition
	 * @param statement
	 *            the statement
	 * @return the do while statement
	 */
	public static DoWhileStatement DoWhileStatement(JSDocComment comment,
			Expression condition, Statement statement) {
		return DoWhileStatement(condition, statement, comment, 0, 0);
	}

	/**
	 * For statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param variable
	 *            the variable
	 * @param condition
	 *            the condition
	 * @param expr
	 *            the expr
	 * @param body
	 *            the body
	 * @return the for statement
	 */
	public static ForStatement ForStatement(JSDocComment comment,
			Expression variable, Expression condition, Expression expr,
			Statement body) {
		return ForStatement(variable, condition, expr, body, comment, 0, 0);
	}

	/**
	 * Variable expression.
	 * 
	 * @param declarations
	 *            the declarations
	 * @return the variable expression
	 */
	public static VariableExpression VariableExpression(
			List<VariableDeclaration> declarations) {
		return VariableExpression(NodeList(declarations), null, 0, 0);
	}

	/**
	 * Let expression.
	 * 
	 * @param declarations
	 *            the declarations
	 * @param expression
	 *            the expression
	 * @return the let expression
	 */
	public static LetExpression LetExpression(
			List<VariableDeclaration> declarations, Expression expression) {
		return LetExpression(NodeList(declarations), expression, null, 0, 0);
	}

	/**
	 * Foreach statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param variable
	 *            the variable
	 * @param expression
	 *            the expression
	 * @param body
	 *            the body
	 * @return the foreach statement
	 */
	public static ForeachStatement ForeachStatement(JSDocComment comment,
			Expression variable, Expression expression, Statement body) {
		return ForeachStatement(variable, expression, body, comment, 0, 0);
	}

	/**
	 * Break statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param identifier
	 *            the identifier
	 * @return the break statement
	 */
	public static BreakStatement BreakStatement(JSDocComment comment,
			String identifier) {
		return BreakStatement(identifier, comment, 0, 0);
	}

	/**
	 * Continue statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param identifier
	 *            the identifier
	 * @return the continue statement
	 */
	public static ContinueStatement ContinueStatement(JSDocComment comment,
			String identifier) {
		return ContinueStatement(identifier, comment, 0, 0);
	}

	/**
	 * With statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param expression
	 *            the expression
	 * @param statement
	 *            the statement
	 * @return the with statement
	 */
	public static WithStatement WithStatement(JSDocComment comment,
			Expression expression, Statement statement) {
		return WithStatement(expression, statement, comment, 0, 0);
	}

	/**
	 * Try statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param tryBlock
	 *            the try block
	 * @param catchClause
	 *            the catch clause
	 * @param finallyBlock
	 *            the finally block
	 * @return the try statement
	 */
	public static TryStatement TryStatement(JSDocComment comment,
			Block tryBlock, CatchClause catchClause, Block finallyBlock) {
		return TryStatement(tryBlock, catchClause, finallyBlock, comment, 0, 0);
	}

	/**
	 * Throw statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param expression
	 *            the expression
	 * @return the throw statement
	 */
	public static ThrowStatement ThrowStatement(JSDocComment comment,
			Expression expression) {
		return ThrowStatement(expression, comment, 0, 0);
	}

	/**
	 * Case block.
	 * 
	 * @param comment
	 *            the comment
	 * @param defaultClause
	 *            the default clause
	 * @param caseClauses
	 *            the case clauses
	 * @return the case block
	 */
	public static CaseBlock CaseBlock(JSDocComment comment,
			DefaultClause defaultClause, List<CaseClause> caseClauses) {
		return CaseBlock(defaultClause, NodeList(caseClauses), comment, 0, 0);
	}

	/**
	 * Switch statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param expression
	 *            the expression
	 * @param block
	 *            the block
	 * @return the switch statement
	 */
	public static SwitchStatement SwitchStatement(JSDocComment comment,
			Expression expression, CaseBlock block) {
		return SwitchStatement(expression, block, comment, 0, 0);
	}

	/**
	 * Catch clause.
	 * 
	 * @param identifier
	 *            the identifier
	 * @param block
	 *            the block
	 * @return the catch clause
	 */
	public static CatchClause CatchClause(String identifier, Block block) {
		return CatchClause(identifier, block, null, 0, 0);
	}

	/**
	 * Return statement.
	 * 
	 * @param comment
	 *            the comment
	 * @param expression
	 *            the expression
	 * @return the return statement
	 */
	public static ReturnStatement ReturnStatement(JSDocComment comment,
			Expression expression) {
		return ReturnStatement(expression, comment, 0, 0);
	}

	/**
	 * Case clause.
	 * 
	 * @param expression
	 *            the expression
	 * @param statements
	 *            the statements
	 * @return the case clause
	 */
	public static CaseClause CaseClause(Expression expression,
			List<Statement> statements) {
		return CaseClause(expression, NodeList(statements), null, 0, 0);
	}

	/**
	 * Function declaration.
	 * 
	 * @param comment
	 *            the comment
	 * @param name
	 *            the name
	 * @param parameters
	 *            the parameters
	 * @param body
	 *            the body
	 * @return the function declaration
	 */
	public static FunctionDeclaration FunctionDeclaration(JSDocComment comment,
			String name, List<Parameter> parameters, Block body) {
		return FunctionDeclaration(name, NodeList(parameters), body, comment,
				0, 0);
	}

	/**
	 * Parameter.
	 * 
	 * @param name
	 *            the name
	 * @return the parameter
	 */
	public static Parameter Parameter(String name) {
		return Parameter(name, null, 0, 0);
	}

	/**
	 * Default clause.
	 * 
	 * @param statements
	 *            the statements
	 * @return the default clause
	 */
	public static DefaultClause DefaultClause(List<Statement> statements) {
		return DefaultClause(NodeList(statements), null, 0, 0);
	}

	/**
	 * Compilation unit.
	 * 
	 * @param comments
	 *            the comments
	 * @param elements
	 *            the elements
	 * @param name
	 *            the name
	 * @return the compilation unit
	 */
	public static CompilationUnit CompilationUnit(List<Comment> comments,
			List<Statement> elements, String name) {
		return CompilationUnit(NodeList(elements), NodeList(comments), name,
				null, 0, 0);
	}

	/**
	 * This method return null when nodes equals null.
	 * 
	 * @param <E>
	 *            the element type
	 * @param nodes
	 *            the nodes
	 * @return the node list
	 */
	public static <E extends Node> NodeList<E> NodeList(List<E> nodes) {
		if (nodes != null) {
			return NodeList(nodes, null, 0, 0);
		}
		return null;
	}

	/**
	 * This method return null when node equals null.
	 * 
	 * @param <E>
	 *            the element type
	 * @param node
	 *            the node
	 * @return the node list
	 */
	public static <E extends Node> NodeList<E> NodeList(E node) {
		if (node != null) {
			return NodeList(Arrays.asList(node));
		}
		return null;
	}

	/**
	 * This method return null when node equals null.
	 * 
	 * @param <E>
	 *            the element type
	 * @param node
	 *            the node
	 * @return the node list
	 */
	public static <E extends Node> NodeList<E> NodeList(E[] node) {
		if (node != null) {
			return NodeList(Arrays.asList(node));
		}
		return null;
	}

	/**
	 * New expression.
	 * 
	 * @param expression
	 *            the expression
	 * @param initializer
	 *            the initializer
	 * @return the new expression
	 */
	public static NewExpression NewExpression(Expression expression,
			ObjectLiteral initializer) {
		return NewExpression(expression, initializer, null, 0, 0);
	}

	/**
	 * Expression statement.
	 * 
	 * @param expression
	 *            the expression
	 * @return the expression statement
	 */
	public static ExpressionStatement ExpressionStatement(Expression expression) {
		return ExpressionStatement(null, expression);
	}

	/**
	 * Allocation expression.
	 * 
	 * @param expression
	 *            the expression
	 * @return the allocation expression
	 */
	public static AllocationExpression AllocationExpression(
			Expression expression) {
		return AllocationExpression(expression, null, 0, 0);
	}

}
 public abstract class Expression extends Node {

    Expression() {
        super();
    }

    Expression(JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
    }

}
 public final class JSDocComment extends Comment {

    JSDocComment() {
        super();
    }

    JSDocComment(String content, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(content, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ArrayAccessExpression extends Expression {

    /** 
     * The name.
     */
    private Expression name;

    /** 
     * The index.
     */
    private Expression index;

    public Expression getName() {
        return name;
    }

    public void setName(Expression name) {
        this.name = name;
    }

    public Expression getIndex() {
        return index;
    }

    public void setIndex(Expression index) {
        this.index = index;
    }

    ArrayAccessExpression() {
        super();
    }

    ArrayAccessExpression(Expression name, Expression index, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.name = name;
        this.index = index;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ArrayLiteral extends Literal {

    /** 
     * The expressions.
     */
    private NodeList<Expression> expressions = null;

    public NodeList<Expression> getExpressions() {
        return expressions;
    }

    public void setExpressions(NodeList<Expression> expressions) {
        this.expressions = expressions;
    }

    ArrayLiteral() {
        super();
    }

    ArrayLiteral(NodeList<Expression> expressions, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expressions = expressions;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class NodeList<E extends Node> extends Node implements List<E> {

    /** 
     * The nodes.
     */
    private List<E> nodes = null;

    public Iterator<E> iterator() {
        if (nodes != null) {
            return nodes.iterator();
        }
        return null;
    }

    public int size() {
        return nodes.size();
    }

    public boolean isEmpty() {
        return nodes.isEmpty();
    }

    public boolean contains(Object o) {
        return nodes.contains(o);
    }

    public Object[] toArray() {
        return nodes.toArray();
    }

    public <T> T[] toArray(T[] a) {
        return nodes.toArray(a);
    }

    public boolean add(E e) {
        return nodes.add(e);
    }

    public boolean remove(Object o) {
        return nodes.remove(o);
    }

    public boolean containsAll(Collection<?> c) {
        return nodes.containsAll(c);
    }

    public boolean addAll(Collection<? extends E> c) {
        return nodes.addAll(c);
    }

    public boolean addAll(int index, Collection<? extends E> c) {
        return nodes.addAll(index, c);
    }

    public boolean removeAll(Collection<?> c) {
        return nodes.removeAll(c);
    }

    public boolean retainAll(Collection<?> c) {
        return nodes.retainAll(c);
    }

    public void clear() {
        nodes.clear();
    }

    public E get(int index) {
        return nodes.get(index);
    }

    public E set(int index, E element) {
        return nodes.set(index, element);
    }

    public void add(int index, E element) {
        nodes.add(index, element);
    }

    public E remove(int index) {
        return nodes.remove(index);
    }

    public int indexOf(Object o) {
        return nodes.indexOf(o);
    }

    public int lastIndexOf(Object o) {
        return nodes.lastIndexOf(o);
    }

    public ListIterator<E> listIterator() {
        return nodes.listIterator();
    }

    public ListIterator<E> listIterator(int index) {
        return nodes.listIterator(index);
    }

    public List<E> subList(int fromIndex, int toIndex) {
        return nodes.subList(fromIndex, toIndex);
    }

    public boolean addNodes(E nodes) {
        boolean res = getNodes().add(nodes);
        if (res) {
        }
        return res;
    }

    public boolean removeNodes(E nodes) {
        boolean res = getNodes().remove(nodes);
        if (res) {
        }
        return res;
    }

    public List<E> getNodes() {
        return nodes;
    }

    public void setNodes(List<E> nodes) {
        this.nodes = nodes;
    }

    NodeList() {
        super();
    }

    NodeList(List<E> nodes, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.nodes = nodes;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class AssignmentExpression extends Expression {

    /** 
     * The Enum AssignOperator.
     */
    public static enum AssignOperator {

        /** 
         * The assign.
         */
        assign, 
        /** 
         * The plus.
         */
        plus, 
        /** 
         * The minus.
         */
        minus, 
        /** 
         * The star.
         */
        star, 
        /** 
         * The slash.
         */
        slash, 
        /** 
         * The and.
         */
        and, 
        /** 
         * The or.
         */
        or, 
        /** 
         * The xor.
         */
        xor, 
        /** 
         * The rem.
         */
        rem, 
        /** 
         * The l shift.
         */
        lShift, 
        /** 
         * The r signed shift.
         */
        rSignedShift, 
        /** 
         * The r unsigned shift.
         */
        rUnsignedShift;

        public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
            v.visit(this, ctx);
        }

        public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
            return v.visit(this, ctx);
        }

    }

    /** 
     * The target.
     */
    private Expression target;

    /** 
     * The value.
     */
    private Expression value;

    /** 
     * The assign operator.
     */
    private AssignmentExpression.AssignOperator assignOperator;

    public Expression getTarget() {
        return target;
    }

    public void setTarget(Expression target) {
        this.target = target;
    }

    public Expression getValue() {
        return value;
    }

    public void setValue(Expression value) {
        this.value = value;
    }

    public AssignmentExpression.AssignOperator getAssignOperator() {
        return assignOperator;
    }

    public void setAssignOperator(AssignmentExpression.AssignOperator assignOperator) {
        this.assignOperator = assignOperator;
    }

    AssignmentExpression() {
        super();
    }

    AssignmentExpression(Expression target, Expression value, AssignmentExpression.AssignOperator assignOperator, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.target = target;
        this.value = value;
        this.assignOperator = assignOperator;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public static enum AssignOperator {

    /** 
     * The assign.
     */
    assign, 
    /** 
     * The plus.
     */
    plus, 
    /** 
     * The minus.
     */
    minus, 
    /** 
     * The star.
     */
    star, 
    /** 
     * The slash.
     */
    slash, 
    /** 
     * The and.
     */
    and, 
    /** 
     * The or.
     */
    or, 
    /** 
     * The xor.
     */
    xor, 
    /** 
     * The rem.
     */
    rem, 
    /** 
     * The l shift.
     */
    lShift, 
    /** 
     * The r signed shift.
     */
    rSignedShift, 
    /** 
     * The r unsigned shift.
     */
    rUnsignedShift;

    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class BinaryExpression extends Expression {

    /** 
     * The Enum BinaryOperator.
     */
    public static enum BinaryOperator {

        /** 
         * The or.
         */
        or, 
        /** 
         * The and.
         */
        and, 
        /** 
         * The bin or.
         */
        binOr, 
        /** 
         * The bin and.
         */
        binAnd, 
        /** 
         * The xor.
         */
        xor, 
        /** 
         * The equals.
         */
        equals, 
        /** 
         * The not equals.
         */
        notEquals, 
        /** 
         * The identity.
         */
        identity, 
        /** 
         * The not identity.
         */
        notIdentity, 
        /** 
         * The less.
         */
        less, 
        /** 
         * The greater.
         */
        greater, 
        /** 
         * The less equals.
         */
        lessEquals, 
        /** 
         * The greater equals.
         */
        greaterEquals, 
        /** 
         * The l shift.
         */
        lShift, 
        /** 
         * The r signed shift.
         */
        rSignedShift, 
        /** 
         * The r unsigned shift.
         */
        rUnsignedShift, 
        /** 
         * The plus.
         */
        plus, 
        /** 
         * The minus.
         */
        minus, 
        /** 
         * The times.
         */
        times, 
        /** 
         * The divide.
         */
        divide, 
        /** 
         * The remainder.
         */
        remainder, 
        /** 
         * The op instanceof.
         */
        opInstanceof, 
        /** 
         * The in.
         */
        in;

        public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
            v.visit(this, ctx);
        }

        public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
            return v.visit(this, ctx);
        }

    }

    /** 
     * The left.
     */
    private Expression left;

    /** 
     * The right.
     */
    private Expression right;

    /** 
     * The binary operator.
     */
    private BinaryExpression.BinaryOperator binaryOperator;

    public Expression getLeft() {
        return left;
    }

    public void setLeft(Expression left) {
        this.left = left;
    }

    public Expression getRight() {
        return right;
    }

    public void setRight(Expression right) {
        this.right = right;
    }

    public BinaryExpression.BinaryOperator getBinaryOperator() {
        return binaryOperator;
    }

    public void setBinaryOperator(BinaryExpression.BinaryOperator binaryOperator) {
        this.binaryOperator = binaryOperator;
    }

    BinaryExpression() {
        super();
    }

    BinaryExpression(Expression left, Expression right, BinaryExpression.BinaryOperator binaryOperator, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.left = left;
        this.right = right;
        this.binaryOperator = binaryOperator;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public static enum BinaryOperator {

    /** 
     * The or.
     */
    or, 
    /** 
     * The and.
     */
    and, 
    /** 
     * The bin or.
     */
    binOr, 
    /** 
     * The bin and.
     */
    binAnd, 
    /** 
     * The xor.
     */
    xor, 
    /** 
     * The equals.
     */
    equals, 
    /** 
     * The not equals.
     */
    notEquals, 
    /** 
     * The identity.
     */
    identity, 
    /** 
     * The not identity.
     */
    notIdentity, 
    /** 
     * The less.
     */
    less, 
    /** 
     * The greater.
     */
    greater, 
    /** 
     * The less equals.
     */
    lessEquals, 
    /** 
     * The greater equals.
     */
    greaterEquals, 
    /** 
     * The l shift.
     */
    lShift, 
    /** 
     * The r signed shift.
     */
    rSignedShift, 
    /** 
     * The r unsigned shift.
     */
    rUnsignedShift, 
    /** 
     * The plus.
     */
    plus, 
    /** 
     * The minus.
     */
    minus, 
    /** 
     * The times.
     */
    times, 
    /** 
     * The divide.
     */
    divide, 
    /** 
     * The remainder.
     */
    remainder, 
    /** 
     * The op instanceof.
     */
    opInstanceof, 
    /** 
     * The in.
     */
    in;

    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public final class Block extends Statement {

    /** 
     * The statements.
     */
    private NodeList<Statement> statements;

    public NodeList<Statement> getStatements() {
        return statements;
    }

    public void setStatements(NodeList<Statement> statements) {
        this.statements = statements;
    }

    Block() {
        super();
    }

    Block(NodeList<Statement> statements, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.statements = statements;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public abstract class Statement extends Node {

    Statement() {
        super();
    }

    Statement(JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
    }

}
 public final class BlockComment extends Comment {

    BlockComment() {
        super();
    }

    BlockComment(String content, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(content, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class BooleanLiteral extends Literal {

    /** 
     * The value.
     */
    private boolean value;

    public boolean isValue() {
        return value;
    }

    public void setValue(boolean value) {
        this.value = value;
    }

    BooleanLiteral() {
        super();
    }

    BooleanLiteral(boolean value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.value = value;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class BreakStatement extends Statement {

    /** 
     * The identifier.
     */
    private String identifier;

    public String getIdentifier() {
        return identifier;
    }

    public void setIdentifier(String identifier) {
        this.identifier = identifier;
    }

    BreakStatement() {
        super();
    }

    BreakStatement(String identifier, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.identifier = identifier;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class CallExpression extends Expression {

    /** 
     * The scope.
     */
    private Expression scope;

    /** 
     * The args.
     */
    private NodeList<Expression> args;

    public Expression getScope() {
        return scope;
    }

    public void setScope(Expression scope) {
        this.scope = scope;
    }

    public NodeList<Expression> getArgs() {
        return args;
    }

    public void setArgs(NodeList<Expression> args) {
        this.args = args;
    }

    CallExpression() {
        super();
    }

    CallExpression(Expression scope, NodeList<Expression> args, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.scope = scope;
        this.args = args;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class CaseBlock extends Statement {

    /** 
     * The default clause.
     */
    private DefaultClause defaultClause;

    /** 
     * The case clauses.
     */
    private NodeList<CaseClause> caseClauses;

    public DefaultClause getDefaultClause() {
        return defaultClause;
    }

    public void setDefaultClause(DefaultClause defaultClause) {
        this.defaultClause = defaultClause;
    }

    public NodeList<CaseClause> getCaseClauses() {
        return caseClauses;
    }

    public void setCaseClauses(NodeList<CaseClause> caseClauses) {
        this.caseClauses = caseClauses;
    }

    CaseBlock() {
        super();
    }

    CaseBlock(DefaultClause defaultClause, NodeList<CaseClause> caseClauses, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.defaultClause = defaultClause;
        this.caseClauses = caseClauses;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class DefaultClause extends Node {

    /** 
     * The statements.
     */
    private NodeList<Statement> statements;

    public NodeList<Statement> getStatements() {
        return statements;
    }

    public void setStatements(NodeList<Statement> statements) {
        this.statements = statements;
    }

    DefaultClause() {
        super();
    }

    DefaultClause(NodeList<Statement> statements, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.statements = statements;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class CaseClause extends Node {

    /** 
     * The expression.
     */
    private Expression expression;

    /** 
     * The statements.
     */
    private NodeList<Statement> statements;

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    public NodeList<Statement> getStatements() {
        return statements;
    }

    public void setStatements(NodeList<Statement> statements) {
        this.statements = statements;
    }

    CaseClause() {
        super();
    }

    CaseClause(Expression expression, NodeList<Statement> statements, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expression = expression;
        this.statements = statements;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class CatchClause extends Node {

    /** 
     * The string.
     */
    private String string;

    /** 
     * The block.
     */
    private Block block;

    public String getString() {
        return string;
    }

    public void setString(String string) {
        this.string = string;
    }

    public Block getBlock() {
        return block;
    }

    public void setBlock(Block block) {
        this.block = block;
    }

    CatchClause() {
        super();
    }

    CatchClause(String string, Block block, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.string = string;
        this.block = block;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class CompilationUnit extends Node {

    /** 
     * The elements.
     */
    private NodeList<Statement> elements;

    /** 
     * The comments.
     */
    private NodeList<Comment> comments;

    /** 
     * The name.
     */
    private String name;

    public NodeList<Statement> getElements() {
        return elements;
    }

    public void setElements(NodeList<Statement> elements) {
        this.elements = elements;
    }

    public NodeList<Comment> getComments() {
        return comments;
    }

    public void setComments(NodeList<Comment> comments) {
        this.comments = comments;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    CompilationUnit() {
        super();
    }

    CompilationUnit(NodeList<Statement> elements, NodeList<Comment> comments, String name, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.elements = elements;
        this.comments = comments;
        this.name = name;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public abstract class Comment extends Node {

    /** The content.
     */
    private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    Comment() {
        super();
    }

    Comment(String content, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.content = content;
    }

}
 public class ConditionalExpression extends Expression {

    /** 
     * The condition.
     */
    private Expression condition;

    /** 
     * The then expr.
     */
    private Expression thenExpr;

    /** 
     * The else expr.
     */
    private Expression elseExpr;

    public Expression getCondition() {
        return condition;
    }

    public void setCondition(Expression condition) {
        this.condition = condition;
    }

    public Expression getThenExpr() {
        return thenExpr;
    }

    public void setThenExpr(Expression thenExpr) {
        this.thenExpr = thenExpr;
    }

    public Expression getElseExpr() {
        return elseExpr;
    }

    public void setElseExpr(Expression elseExpr) {
        this.elseExpr = elseExpr;
    }

    ConditionalExpression() {
        super();
    }

    ConditionalExpression(Expression condition, Expression thenExpr, Expression elseExpr, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.condition = condition;
        this.thenExpr = thenExpr;
        this.elseExpr = elseExpr;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ConstantStatement extends Statement {

    /** 
     * The variable declarations.
     */
    private NodeList<VariableDeclaration> variableDeclarations;

    public NodeList<VariableDeclaration> getVariableDeclarations() {
        return variableDeclarations;
    }

    public void setVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
        this.variableDeclarations = variableDeclarations;
    }

    ConstantStatement() {
        super();
    }

    ConstantStatement(NodeList<VariableDeclaration> variableDeclarations, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.variableDeclarations = variableDeclarations;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class VariableDeclaration extends Node {

    /** 
     * The name.
     */
    private String name;

    /** 
     * The expression.
     */
    private Expression expression;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    VariableDeclaration() {
        super();
    }

    VariableDeclaration(String name, Expression expression, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.name = name;
        this.expression = expression;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ContinueStatement extends Statement {

    /** 
     * The identifier.
     */
    private String identifier;

    public String getIdentifier() {
        return identifier;
    }

    public void setIdentifier(String identifier) {
        this.identifier = identifier;
    }

    ContinueStatement() {
        super();
    }

    ContinueStatement(String identifier, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.identifier = identifier;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class DebuggerStatement extends Statement {

    DebuggerStatement() {
        super();
    }

    DebuggerStatement(JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class DecimalLiteral extends NumericLiteral {

    DecimalLiteral() {
        super();
    }

    DecimalLiteral(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class DoWhileStatement extends WhileStatement {

    DoWhileStatement() {
        super();
    }

    DoWhileStatement(Expression condition, Statement body, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(condition, body, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class EmptyLiteral extends Literal {

    EmptyLiteral() {
        super();
    }

    EmptyLiteral(JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class EmptyStatement extends Statement {

    EmptyStatement() {
        super();
    }

    EmptyStatement(JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class EnclosedExpression extends Expression {

    /** 
     * The inner.
     */
    private Expression inner;

    public Expression getInner() {
        return inner;
    }

    public void setInner(Expression inner) {
        this.inner = inner;
    }

    EnclosedExpression() {
        super();
    }

    EnclosedExpression(Expression inner, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.inner = inner;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ExpressionStatement extends Statement {

    /** 
     * The expression.
     */
    private Expression expression;

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    ExpressionStatement() {
        super();
    }

    ExpressionStatement(Expression expression, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expression = expression;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class FieldAccessExpression extends Expression {

    /** 
     * The scope.
     */
    private Expression scope;

    /** 
     * The field.
     */
    private IdentifierName field;

    public Expression getScope() {
        return scope;
    }

    public void setScope(Expression scope) {
        this.scope = scope;
    }

    public IdentifierName getField() {
        return field;
    }

    public void setField(IdentifierName field) {
        this.field = field;
    }

    FieldAccessExpression() {
        super();
    }

    FieldAccessExpression(Expression scope, IdentifierName field, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.scope = scope;
        this.field = field;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class IdentifierName extends PropertyName {

    IdentifierName() {
        super();
    }

    IdentifierName(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class FloatLiteral extends NumericLiteral {

    FloatLiteral() {
        super();
    }

    FloatLiteral(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ForeachStatement extends Statement {

    /** 
     * The variable.
     */
    private Expression variable;

    /** 
     * The expression.
     */
    private Expression expression;

    /** 
     * The body.
     */
    private Statement body;

    public Expression getVariable() {
        return variable;
    }

    public void setVariable(Expression variable) {
        this.variable = variable;
    }

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    public Statement getBody() {
        return body;
    }

    public void setBody(Statement body) {
        this.body = body;
    }

    ForeachStatement() {
        super();
    }

    ForeachStatement(Expression variable, Expression expression, Statement body, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.variable = variable;
        this.expression = expression;
        this.body = body;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ForStatement extends Statement {

    /** 
     * The variable.
     */
    private Expression variable;

    /** 
     * The condition.
     */
    private Expression condition;

    /** 
     * The expr.
     */
    private Expression expr;

    /** 
     * The body.
     */
    private Statement body;

    public Expression getVariable() {
        return variable;
    }

    public void setVariable(Expression variable) {
        this.variable = variable;
    }

    public Expression getCondition() {
        return condition;
    }

    public void setCondition(Expression condition) {
        this.condition = condition;
    }

    public Expression getExpr() {
        return expr;
    }

    public void setExpr(Expression expr) {
        this.expr = expr;
    }

    public Statement getBody() {
        return body;
    }

    public void setBody(Statement body) {
        this.body = body;
    }

    ForStatement() {
        super();
    }

    ForStatement(Expression variable, Expression condition, Expression expr, Statement body, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.variable = variable;
        this.condition = condition;
        this.expr = expr;
        this.body = body;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class FunctionDeclaration extends Statement {

    /** 
     * The name.
     */
    private String name;

    /** 
     * The parameters.
     */
    private NodeList<Parameter> parameters;

    /** 
     * The body.
     */
    private Block body;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public NodeList<Parameter> getParameters() {
        return parameters;
    }

    public void setParameters(NodeList<Parameter> parameters) {
        this.parameters = parameters;
    }

    public Block getBody() {
        return body;
    }

    public void setBody(Block body) {
        this.body = body;
    }

    FunctionDeclaration() {
        super();
    }

    FunctionDeclaration(String name, NodeList<Parameter> parameters, Block body, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.name = name;
        this.parameters = parameters;
        this.body = body;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class Parameter extends Expression {

    /** 
     * The name.
     */
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    Parameter() {
        super();
    }

    Parameter(String name, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.name = name;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class FunctionExpression extends Expression {

    /** 
     * The name.
     */
    private String name;

    /** 
     * The parameters.
     */
    private NodeList<Parameter> parameters;

    /** 
     * The body.
     */
    private Block body;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public NodeList<Parameter> getParameters() {
        return parameters;
    }

    public void setParameters(NodeList<Parameter> parameters) {
        this.parameters = parameters;
    }

    public Block getBody() {
        return body;
    }

    public void setBody(Block body) {
        this.body = body;
    }

    FunctionExpression() {
        super();
    }

    FunctionExpression(String name, NodeList<Parameter> parameters, Block body, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.name = name;
        this.parameters = parameters;
        this.body = body;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class GetAssignment extends PropertyAssignment {

    /** 
     * The block.
     */
    private Block block;

    public Block getBlock() {
        return block;
    }

    public void setBlock(Block block) {
        this.block = block;
    }

    GetAssignment() {
        super();
    }

    GetAssignment(Block block, PropertyName propertyName, Comment comment, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(propertyName, comment, jsDocComment, posBegin, posEnd);
        this.block = block;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public abstract class PropertyName extends StringBasedLiteral {

    PropertyName() {
        super();
    }

    PropertyName(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

}
 public class HexIntegerLiteral extends NumericLiteral {

    HexIntegerLiteral() {
        super();
    }

    HexIntegerLiteral(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class IfStatement extends Statement {

    /** 
     * The condition.
     */
    private Expression condition;

    /** 
     * The then statement.
     */
    private Statement thenStatement;

    /** 
     * The else statement.
     */
    private Statement elseStatement;

    public Expression getCondition() {
        return condition;
    }

    public void setCondition(Expression condition) {
        this.condition = condition;
    }

    public Statement getThenStatement() {
        return thenStatement;
    }

    public void setThenStatement(Statement thenStatement) {
        this.thenStatement = thenStatement;
    }

    public Statement getElseStatement() {
        return elseStatement;
    }

    public void setElseStatement(Statement elseStatement) {
        this.elseStatement = elseStatement;
    }

    IfStatement() {
        super();
    }

    IfStatement(Expression condition, Statement thenStatement, Statement elseStatement, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.condition = condition;
        this.thenStatement = thenStatement;
        this.elseStatement = elseStatement;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ImportStatement extends Statement {

    /** 
     * The name.
     */
    private IdentifierName name;

    public IdentifierName getName() {
        return name;
    }

    public void setName(IdentifierName name) {
        this.name = name;
    }

    ImportStatement() {
        super();
    }

    ImportStatement(IdentifierName name, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.name = name;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class LabelledStatement extends Statement {

    /** 
     * The label.
     */
    private String label;

    /** 
     * The statement.
     */
    private Statement statement;

    public String getLabel() {
        return label;
    }

    public void setLabel(String label) {
        this.label = label;
    }

    public Statement getStatement() {
        return statement;
    }

    public void setStatement(Statement statement) {
        this.statement = statement;
    }

    LabelledStatement() {
        super();
    }

    LabelledStatement(String label, Statement statement, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.label = label;
        this.statement = statement;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class LetDefinition extends Statement {

    /** 
     * The variable declarations.
     */
    private NodeList<VariableDeclaration> variableDeclarations = null;

    public NodeList<VariableDeclaration> getVariableDeclarations() {
        return variableDeclarations;
    }

    public void setVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
        this.variableDeclarations = variableDeclarations;
    }

    LetDefinition() {
        super();
    }

    LetDefinition(NodeList<VariableDeclaration> variableDeclarations, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.variableDeclarations = variableDeclarations;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class LetExpression extends Expression {

    /** 
     * The variable declarations.
     */
    private NodeList<VariableDeclaration> variableDeclarations = null;

    /** 
     * The expression.
     */
    private Expression expression = null;

    public NodeList<VariableDeclaration> getVariableDeclarations() {
        return variableDeclarations;
    }

    public void setVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
        this.variableDeclarations = variableDeclarations;
    }

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    LetExpression() {
        super();
    }

    LetExpression(NodeList<VariableDeclaration> variableDeclarations, Expression expression, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.variableDeclarations = variableDeclarations;
        this.expression = expression;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class LetStatement extends Statement {

    /** 
     * The variable declarations.
     */
    private NodeList<VariableDeclaration> variableDeclarations = null;

    /** 
     * The statement.
     */
    private Statement statement = null;

    public NodeList<VariableDeclaration> getVariableDeclarations() {
        return variableDeclarations;
    }

    public void setVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
        this.variableDeclarations = variableDeclarations;
    }

    public Statement getStatement() {
        return statement;
    }

    public void setStatement(Statement statement) {
        this.statement = statement;
    }

    LetStatement() {
        super();
    }

    LetStatement(NodeList<VariableDeclaration> variableDeclarations, Statement statement, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.variableDeclarations = variableDeclarations;
        this.statement = statement;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public final class LineComment extends Comment {

    LineComment() {
        super();
    }

    LineComment(String content, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(content, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class NewExpression extends Expression {

    /** 
     * The expression.
     */
    private Expression expression = null;

    /** 
     * The initializer.
     */
    private ObjectLiteral initializer = null;

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    public ObjectLiteral getInitializer() {
        return initializer;
    }

    public void setInitializer(ObjectLiteral initializer) {
        this.initializer = initializer;
    }

    NewExpression() {
        super();
    }

    NewExpression(Expression expression, ObjectLiteral initializer, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expression = expression;
        this.initializer = initializer;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ObjectLiteral extends Literal {

    /** 
     * The property assignments.
     */
    private NodeList<PropertyAssignment> propertyAssignments;

    public NodeList<PropertyAssignment> getPropertyAssignments() {
        return propertyAssignments;
    }

    public void setPropertyAssignments(NodeList<PropertyAssignment> propertyAssignments) {
        this.propertyAssignments = propertyAssignments;
    }

    ObjectLiteral() {
        super();
    }

    ObjectLiteral(NodeList<PropertyAssignment> propertyAssignments, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.propertyAssignments = propertyAssignments;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class NullLiteral extends Literal {

    NullLiteral() {
        super();
    }

    NullLiteral(JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public abstract class PropertyAssignment extends Expression {

    /** 
     * The property name.
     */
    private PropertyName propertyName;

    /** 
     * The comment.
     */
    private Comment comment = null;

    public PropertyName getPropertyName() {
        return propertyName;
    }

    public void setPropertyName(PropertyName propertyName) {
        this.propertyName = propertyName;
    }

    public Comment getComment() {
        return comment;
    }

    public void setComment(Comment comment) {
        this.comment = comment;
    }

    PropertyAssignment() {
        super();
    }

    PropertyAssignment(PropertyName propertyName, Comment comment, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.propertyName = propertyName;
        this.comment = comment;
    }

}
 public class OctalLiteral extends NumericLiteral {

    OctalLiteral() {
        super();
    }

    OctalLiteral(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class Project extends Node {

    /** 
     * The compilation units.
     */
    private NodeList<CompilationUnit> compilationUnits = null;

    public NodeList<CompilationUnit> getCompilationUnits() {
        return compilationUnits;
    }

    public void setCompilationUnits(NodeList<CompilationUnit> compilationUnits) {
        this.compilationUnits = compilationUnits;
    }

    Project() {
        super();
    }

    Project(NodeList<CompilationUnit> compilationUnits, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.compilationUnits = compilationUnits;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class PutAssignment extends PropertyAssignment {

    /** 
     * The property value.
     */
    private Expression propertyValue;

    public Expression getPropertyValue() {
        return propertyValue;
    }

    public void setPropertyValue(Expression propertyValue) {
        this.propertyValue = propertyValue;
    }

    PutAssignment() {
        super();
    }

    PutAssignment(Expression propertyValue, PropertyName propertyName, Comment comment, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(propertyName, comment, jsDocComment, posBegin, posEnd);
        this.propertyValue = propertyValue;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class RegexpLiteral extends StringBasedLiteral {

    RegexpLiteral() {
        super();
    }

    RegexpLiteral(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ReturnStatement extends Statement {

    /** 
     * The expression.
     */
    private Expression expression;

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    ReturnStatement() {
        super();
    }

    ReturnStatement(Expression expression, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expression = expression;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class SequenceExpression extends Expression {

    /** 
     * The expressions.
     */
    private NodeList<Expression> expressions;

    public NodeList<Expression> getExpressions() {
        return expressions;
    }

    public void setExpressions(NodeList<Expression> expressions) {
        this.expressions = expressions;
    }

    SequenceExpression() {
        super();
    }

    SequenceExpression(NodeList<Expression> expressions, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expressions = expressions;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class SetAssignment extends GetAssignment {

    /** 
     * The identifier.
     */
    private String identifier;

    public String getIdentifier() {
        return identifier;
    }

    public void setIdentifier(String identifier) {
        this.identifier = identifier;
    }

    SetAssignment() {
        super();
    }

    SetAssignment(String identifier, Block block, PropertyName propertyName, Comment comment, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(block, propertyName, comment, jsDocComment, posBegin, posEnd);
        this.identifier = identifier;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class StringLiteralDouble extends StringLiteral {

    StringLiteralDouble() {
        super();
    }

    StringLiteralDouble(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class StringLiteralSingle extends StringLiteral {

    StringLiteralSingle() {
        super();
    }

    StringLiteralSingle(String value, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(value, jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class SuperExpression extends Expression {

    SuperExpression() {
        super();
    }

    SuperExpression(JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class SwitchStatement extends Statement {

    /** 
     * The expression.
     */
    private Expression expression;

    /** 
     * The block.
     */
    private CaseBlock block;

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    public CaseBlock getBlock() {
        return block;
    }

    public void setBlock(CaseBlock block) {
        this.block = block;
    }

    SwitchStatement() {
        super();
    }

    SwitchStatement(Expression expression, CaseBlock block, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expression = expression;
        this.block = block;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ThisExpression extends Expression {

    ThisExpression() {
        super();
    }

    ThisExpression(JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class ThrowStatement extends Statement {

    /** 
     * The expression.
     */
    private Expression expression;

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    ThrowStatement() {
        super();
    }

    ThrowStatement(Expression expression, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expression = expression;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class TryStatement extends Statement {

    /** 
     * The try block.
     */
    private Block tryBlock;

    /** 
     * The catch clause.
     */
    private CatchClause catchClause;

    /** 
     * The finally block.
     */
    private Block finallyBlock;

    public Block getTryBlock() {
        return tryBlock;
    }

    public void setTryBlock(Block tryBlock) {
        this.tryBlock = tryBlock;
    }

    public CatchClause getCatchClause() {
        return catchClause;
    }

    public void setCatchClause(CatchClause catchClause) {
        this.catchClause = catchClause;
    }

    public Block getFinallyBlock() {
        return finallyBlock;
    }

    public void setFinallyBlock(Block finallyBlock) {
        this.finallyBlock = finallyBlock;
    }

    TryStatement() {
        super();
    }

    TryStatement(Block tryBlock, CatchClause catchClause, Block finallyBlock, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.tryBlock = tryBlock;
        this.catchClause = catchClause;
        this.finallyBlock = finallyBlock;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public final class UnaryExpression extends Expression {

    /** 
     * The Enum UnaryOperator.
     */
    public static enum UnaryOperator {

        /** 
         * The positive.
         */
        positive, 
        /** 
         * The negative.
         */
        negative, 
        /** 
         * The pre increment.
         */
        preIncrement, 
        /** 
         * The pre decrement.
         */
        preDecrement, 
        /** 
         * The not.
         */
        not, 
        /** 
         * The rem.
         */
        rem, 
        /** 
         * The inverse.
         */
        inverse, 
        /** 
         * The pos increment.
         */
        posIncrement, 
        /** 
         * The pos decrement.
         */
        posDecrement, 
        /** 
         * The delete.
         */
        delete, 
        /** 
         * The op void.
         */
        opVoid, 
        /** 
         * The typeof.
         */
        typeof;

        public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
            v.visit(this, ctx);
        }

        public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
            return v.visit(this, ctx);
        }

    }

    /** 
     * The expression.
     */
    private Expression expression;

    /** 
     * The unary operator.
     */
    private UnaryExpression.UnaryOperator unaryOperator;

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    public UnaryExpression.UnaryOperator getUnaryOperator() {
        return unaryOperator;
    }

    public void setUnaryOperator(UnaryExpression.UnaryOperator unaryOperator) {
        this.unaryOperator = unaryOperator;
    }

    UnaryExpression() {
        super();
    }

    UnaryExpression(Expression expression, UnaryExpression.UnaryOperator unaryOperator, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expression = expression;
        this.unaryOperator = unaryOperator;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public static enum UnaryOperator {

    /** 
     * The positive.
     */
    positive, 
    /** 
     * The negative.
     */
    negative, 
    /** 
     * The pre increment.
     */
    preIncrement, 
    /** 
     * The pre decrement.
     */
    preDecrement, 
    /** 
     * The not.
     */
    not, 
    /** 
     * The rem.
     */
    rem, 
    /** 
     * The inverse.
     */
    inverse, 
    /** 
     * The pos increment.
     */
    posIncrement, 
    /** 
     * The pos decrement.
     */
    posDecrement, 
    /** 
     * The delete.
     */
    delete, 
    /** 
     * The op void.
     */
    opVoid, 
    /** 
     * The typeof.
     */
    typeof;

    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class VariableExpression extends Expression {

    /** 
     * The variable declarations.
     */
    private NodeList<VariableDeclaration> variableDeclarations;

    public NodeList<VariableDeclaration> getVariableDeclarations() {
        return variableDeclarations;
    }

    public void setVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
        this.variableDeclarations = variableDeclarations;
    }

    VariableExpression() {
        super();
    }

    VariableExpression(NodeList<VariableDeclaration> variableDeclarations, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.variableDeclarations = variableDeclarations;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class VariableStatement extends Statement {

    /** 
     * The variable declarations.
     */
    private NodeList<VariableDeclaration> variableDeclarations;

    public NodeList<VariableDeclaration> getVariableDeclarations() {
        return variableDeclarations;
    }

    public void setVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
        this.variableDeclarations = variableDeclarations;
    }

    VariableStatement() {
        super();
    }

    VariableStatement(NodeList<VariableDeclaration> variableDeclarations, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.variableDeclarations = variableDeclarations;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class WhileStatement extends Statement {

    /** 
     * The condition.
     */
    private Expression condition;

    /** 
     * The body.
     */
    private Statement body;

    public Expression getCondition() {
        return condition;
    }

    public void setCondition(Expression condition) {
        this.condition = condition;
    }

    public Statement getBody() {
        return body;
    }

    public void setBody(Statement body) {
        this.body = body;
    }

    WhileStatement() {
        super();
    }

    WhileStatement(Expression condition, Statement body, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.condition = condition;
        this.body = body;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}
 public class WithStatement extends Statement {

    /** 
     * The expression.
     */
    private Expression expression;

    /** 
     * The statement.
     */
    private Statement statement;

    public Expression getExpression() {
        return expression;
    }

    public void setExpression(Expression expression) {
        this.expression = expression;
    }

    public Statement getStatement() {
        return statement;
    }

    public void setStatement(Statement statement) {
        this.statement = statement;
    }

    WithStatement() {
        super();
    }

    WithStatement(Expression expression, Statement statement, JSDocComment jsDocComment, int posBegin, int posEnd) {
        super(jsDocComment, posBegin, posEnd);
        this.expression = expression;
        this.statement = statement;
    }

    @Override
    public <C> void accept(VoidVisitor<C> v, C ctx) throws Exception {
        v.visit(this, ctx);
    }

    @Override
    public <R, C> R accept(GenericVisitor<R, C> v, C ctx) throws Exception {
        return v.visit(this, ctx);
    }

}

import com.digiarea.es5.Node;
import com.digiarea.es5.visitor.GenericVisitor;
import com.digiarea.es5.AllocationExpression;
import com.digiarea.es5.NodeFacade;
import com.digiarea.es5.Expression;
import com.digiarea.es5.JSDocComment;
import com.digiarea.es5.ArrayAccessExpression;
import com.digiarea.es5.ArrayLiteral;
import com.digiarea.es5.NodeList;
import com.digiarea.es5.AssignmentExpression;
import com.digiarea.es5.AssignmentExpression.AssignOperator;
import com.digiarea.es5.BinaryExpression;
import com.digiarea.es5.BinaryExpression.BinaryOperator;
import com.digiarea.es5.Block;
import com.digiarea.es5.Statement;
import com.digiarea.es5.BlockComment;
import com.digiarea.es5.BooleanLiteral;
import com.digiarea.es5.BreakStatement;
import com.digiarea.es5.CallExpression;
import com.digiarea.es5.CaseBlock;
import com.digiarea.es5.DefaultClause;
import com.digiarea.es5.CaseClause;
import com.digiarea.es5.CatchClause;
import com.digiarea.es5.CompilationUnit;
import com.digiarea.es5.Comment;
import com.digiarea.es5.ConditionalExpression;
import com.digiarea.es5.ConstantStatement;
import com.digiarea.es5.VariableDeclaration;
import com.digiarea.es5.ContinueStatement;
import com.digiarea.es5.DebuggerStatement;
import com.digiarea.es5.DecimalLiteral;
import com.digiarea.es5.DoWhileStatement;
import com.digiarea.es5.EmptyLiteral;
import com.digiarea.es5.EmptyStatement;
import com.digiarea.es5.EnclosedExpression;
import com.digiarea.es5.ExpressionStatement;
import com.digiarea.es5.FieldAccessExpression;
import com.digiarea.es5.IdentifierName;
import com.digiarea.es5.FloatLiteral;
import com.digiarea.es5.ForeachStatement;
import com.digiarea.es5.ForStatement;
import com.digiarea.es5.FunctionDeclaration;
import com.digiarea.es5.Parameter;
import com.digiarea.es5.FunctionExpression;
import com.digiarea.es5.GetAssignment;
import com.digiarea.es5.PropertyName;
import com.digiarea.es5.HexIntegerLiteral;
import com.digiarea.es5.IfStatement;
import com.digiarea.es5.ImportStatement;
import com.digiarea.es5.LabelledStatement;
import com.digiarea.es5.LetDefinition;
import com.digiarea.es5.LetExpression;
import com.digiarea.es5.LetStatement;
import com.digiarea.es5.LineComment;
import com.digiarea.es5.NewExpression;
import com.digiarea.es5.ObjectLiteral;
import java.util.List;
import java.util.ArrayList;
import com.digiarea.es5.NullLiteral;
import com.digiarea.es5.PropertyAssignment;
import com.digiarea.es5.OctalLiteral;
import com.digiarea.es5.Project;
import com.digiarea.es5.PutAssignment;
import com.digiarea.es5.RegexpLiteral;
import com.digiarea.es5.ReturnStatement;
import com.digiarea.es5.SequenceExpression;
import com.digiarea.es5.SetAssignment;
import com.digiarea.es5.StringLiteralDouble;
import com.digiarea.es5.StringLiteralSingle;
import com.digiarea.es5.SuperExpression;
import com.digiarea.es5.SwitchStatement;
import com.digiarea.es5.ThisExpression;
import com.digiarea.es5.ThrowStatement;
import com.digiarea.es5.TryStatement;
import com.digiarea.es5.UnaryExpression;
import com.digiarea.es5.UnaryExpression.UnaryOperator;
import com.digiarea.es5.VariableExpression;
import com.digiarea.es5.VariableStatement;
import com.digiarea.es5.WhileStatement;
import com.digiarea.es5.WithStatement;

        return img;
    }

    @Override
    public Node visit(ConstantStatement n, C ctx) throws Exception {
        ConstantStatement img = NodeFacade.ConstantStatement();
        if (n.getVariableDeclarations() != null) {
            img.setVariableDeclarations((NodeList<VariableDeclaration>) n.getVariableDeclarations().accept(this, ctx));
        }
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override
    public Node visit(ContinueStatement n, C ctx) throws Exception {
        ContinueStatement img = NodeFacade.ContinueStatement();
        img.setIdentifier(n.getIdentifier());
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override
    public Node visit(DebuggerStatement n, C ctx) throws Exception {
        DebuggerStatement img = NodeFacade.DebuggerStatement();
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override
    public Node visit(DecimalLiteral n, C ctx) throws Exception {
        DecimalLiteral img = NodeFacade.DecimalLiteral();
        img.setValue(n.getValue());
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override
    public Node visit(DefaultClause n, C ctx) throws Exception {
        DefaultClause img = NodeFacade.DefaultClause();
        if (n.getStatements() != null) {
            img.setStatements((NodeList<Statement>) n.getStatements().accept(this, ctx));
        }
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override
    public Node visit(DoWhileStatement n, C ctx) throws Exception {
        DoWhileStatement img = NodeFacade.DoWhileStatement();
        if (n.getCondition() != null) {
            img.setCondition((Expression) n.getCondition().accept(this, ctx));
        }
        if (n.getBody() != null) {
            img.setBody((Statement) n.getBody().accept(this, ctx));
        }
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override
    public Node visit(EmptyLiteral n, C ctx) throws Exception {
        EmptyLiteral img = NodeFacade.EmptyLiteral();
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override
    public Node visit(EmptyStatement n, C ctx) throws Exception {
        EmptyStatement img = NodeFacade.EmptyStatement();
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override
    public Node visit(EnclosedExpression n, C ctx) throws Exception {
        EnclosedExpression img = NodeFacade.EnclosedExpression();
        if (n.getInner() != null) {
            img.setInner((Expression) n.getInner().accept(this, ctx));
        }
        if (n.getJsDocComment() != null) {
            img.setJsDocComment((JSDocComment) n.getJsDocComment().accept(this, ctx));
        }
        img.setPosBegin(n.getPosBegin());
        img.setPosEnd(n.getPosEnd());
        return img;
    }

    @Override

    public Node visit(ExpressionStatement n, C ctx) throws Exception {
