public class AJCArrayAccess extends JCArrayAccess implements JavaParserComments {

    public String comment;

    public AJCArrayAccess(JCExpression indexed, JCExpression index) {
        super(indexed, index);
    }

    public AJCArrayAccess(JCArrayAccess ltree) {
        super(ltree.indexed, ltree.index);
    }

    public AJCArrayAccess(JCArrayAccess ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCArrayTypeTree extends JCArrayTypeTree implements JavaParserComments {

    public String comment;

    public AJCArrayTypeTree(JCExpression elemtype) {
        super(elemtype);
    }

    public AJCArrayTypeTree(JCArrayTypeTree ltree) {
        super(ltree.elemtype);
    }

    public AJCArrayTypeTree(JCArrayTypeTree ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCAssert extends JCAssert implements JavaParserComments {

    public String comment;

    public AJCAssert(JCExpression cond, JCExpression detail) {
        super(cond, detail);
    }

    public AJCAssert(JCAssert ltree) {
        super(ltree.cond, ltree.detail);
    }

    public AJCAssert(JCAssert ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCAssign extends JCAssign implements JavaParserComments {

    public String comment;

    public AJCAssign(JCExpression lhs, JCExpression rhs) {
        super(lhs, rhs);
    }

    public AJCAssign(JCAssign ltree) {
        super(ltree.lhs, ltree.rhs);
    }

    public AJCAssign(JCAssign ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCAssignOp extends JCAssignOp implements JavaParserComments {

    public String comment;

    public AJCAssignOp(Tag opcode, JCTree lhs, JCTree rhs, Symbol operator) {
        super(opcode, lhs, rhs, operator);
    }

    public AJCAssignOp(JCAssignOp ltree) {
        super(ltree.getTag(), ltree.lhs, ltree.rhs, ltree.operator);
    }

    public AJCAssignOp(JCAssignOp ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCBinary extends JCBinary implements JavaParserComments {

    public String comment;

    public AJCBinary(Tag opcode, JCExpression lhs, JCExpression rhs, Symbol operator) {
        super(opcode, lhs, rhs, operator);
    }

    public AJCBinary(JCBinary ltree) {
        super(ltree.getTag(), ltree.lhs, ltree.rhs, ltree.operator);
    }

    public AJCBinary(JCBinary ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCBlock extends JCBlock implements JavaParserComments {

    public String comment;

    public AJCBlock(long flags, List<JCStatement> stats) {
        super(flags, stats);
    }

    public AJCBlock(JCBlock ltree) {
        super(ltree.flags, ltree.stats);
    }

    public AJCBlock(JCBlock ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCBreak extends JCBreak implements JavaParserComments {

    public String comment;

    public AJCBreak(Name label, JCTree target) {
        super(label, target);
    }

    public AJCBreak(JCBreak ltree) {
        super(ltree.label, ltree.target);
    }

    public AJCBreak(JCBreak ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCCase extends JCCase implements JavaParserComments {

    public String comment;

    public AJCCase(JCExpression pat, List<JCStatement> stats) {
        super(pat, stats);
    }

    public AJCCase(JCCase ltree) {
        super(ltree.pat, ltree.stats);
    }

    public AJCCase(JCCase ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCCatch extends JCCatch implements JavaParserComments {

    public String comment;

    public AJCCatch(JCVariableDecl param, JCBlock body) {
        super(param, body);
    }

    public AJCCatch(JCCatch ltree) {
        super(ltree.param, ltree.body);
    }

    public AJCCatch(JCCatch ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCClassDecl extends JCClassDecl implements JavaParserComments {

    public String comment;

    public AJCClassDecl(JCModifiers mods,
                        Name name,
                        List<JCTypeParameter> typarams,
                        JCExpression extending,
                        List<JCExpression> implementing,
                        List<JCTree> defs,
                        ClassSymbol sym) {
        super(mods, name, typarams, extending, implementing, defs, sym);
    }

    public AJCClassDecl(JCClassDecl ltree) {
        super(ltree.mods, ltree.name, ltree.typarams, ltree.extending, ltree.implementing, ltree.defs, ltree.sym);
    }

    public AJCClassDecl(JCClassDecl ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCCompilationUnit extends JCCompilationUnit implements JavaParserComments {

    public String comment;

    public AJCCompilationUnit(List<JCAnnotation> packageAnnotations,
                              JCExpression pid,
                              List<JCTree> defs,
                              JavaFileObject sourcefile,
                              PackageSymbol packge,
                              ImportScope namedImportScope,
                              StarImportScope starImportScope) {
        super(packageAnnotations, pid, defs, sourcefile, packge, namedImportScope, starImportScope);
    }

    public AJCCompilationUnit(JCCompilationUnit ltree) {
        super(ltree.packageAnnotations, ltree.pid, ltree.defs, ltree.sourcefile, ltree.packge, ltree.namedImportScope, ltree.starImportScope);
    }

    public AJCCompilationUnit(JCCompilationUnit ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCConditional extends JCConditional implements JavaParserComments {

    public String comment;

    public AJCConditional(JCExpression cond, JCExpression truepart, JCExpression falsepart) {
        super(cond, truepart, falsepart);
    }

    public AJCConditional(JCConditional ltree) {
        super(ltree.cond, ltree.truepart, ltree.falsepart);
    }

    public AJCConditional(JCConditional ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCContinue extends JCContinue implements JavaParserComments {

    public String comment;

    public AJCContinue(Name label, JCTree target) {
        super(label, target);
    }

    public AJCContinue(JCContinue ltree) {
        super(ltree.label, ltree.target);
    }

    public AJCContinue(JCContinue ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCDoWhileLoop extends JCDoWhileLoop implements JavaParserComments {

    public String comment;

    public AJCDoWhileLoop(JCStatement body, JCExpression cond) {
        super(body, cond);
    }

    public AJCDoWhileLoop(JCDoWhileLoop ltree) {
        super(ltree.body, ltree.cond);
    }

    public AJCDoWhileLoop(JCDoWhileLoop ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCEnhancedForLoop extends JCEnhancedForLoop implements JavaParserComments {

    public String comment;

    public AJCEnhancedForLoop(JCVariableDecl var, JCExpression expr, JCStatement body) {
        super(var, expr, body);
    }

    public AJCEnhancedForLoop(JCEnhancedForLoop ltree) {
        super(ltree.var, ltree.expr, ltree.body);
    }

    public AJCEnhancedForLoop(JCEnhancedForLoop ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCExpressionStatement extends JCExpressionStatement implements JavaParserComments {

    public String comment;

    public AJCExpressionStatement(JCExpression expr) {
        super(expr);
    }

    public AJCExpressionStatement(JCExpressionStatement ltree) {
        super(ltree.expr);
    }

    public AJCExpressionStatement(JCExpressionStatement ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCFieldAccess extends JCFieldAccess implements JavaParserComments {

    public String comment;

    public AJCFieldAccess(JCExpression selected, Name name, Symbol sym) {
        super(selected, name, sym);
    }

    public AJCFieldAccess(JCFieldAccess ltree) {
        super(ltree.selected, ltree.name, ltree.sym);
    }

    public AJCFieldAccess(JCFieldAccess ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCForLoop extends JCForLoop implements JavaParserComments {

    public String comment;

    public AJCForLoop(List<JCStatement> init,
                      JCExpression cond,
                      List<JCExpressionStatement> update,
                      JCStatement body) {
        super(init, cond, update, body);
    }

    public AJCForLoop(JCForLoop ltree) {
        super(ltree.init, ltree.cond, ltree.step, ltree.body);
    }

    public AJCForLoop(JCForLoop ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCIdent extends JCIdent implements JavaParserComments {

    public String comment;

    public AJCIdent(Name name, Symbol sym) {
        super(name, sym);
    }

    public AJCIdent(JCIdent ltree) {
        super(ltree.name, ltree.sym);
    }

    public AJCIdent(JCIdent ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCIf extends JCIf implements JavaParserComments {

    public String comment;

    public AJCIf(JCExpression cond, JCStatement thenpart, JCStatement elsepart) {
        super(cond, thenpart, elsepart);
    }

    public AJCIf(JCIf ltree) {
        super(ltree.cond, ltree.thenpart, ltree.elsepart);
    }

    public AJCIf(JCIf ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCImport extends JCImport implements JavaParserComments {

    public String comment;

    public AJCImport(JCTree qualid, boolean importStatic) {
        super(qualid, importStatic);
    }

    public AJCImport(JCImport ltree) {
        super(ltree.qualid, ltree.isStatic());
    }

    public AJCImport(JCImport ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCInstanceOf extends JCInstanceOf implements JavaParserComments {

    public String comment;

    public AJCInstanceOf(JCExpression expr, JCTree clazz) {
        super(expr, clazz);
    }

    public AJCInstanceOf(JCInstanceOf ltree) {
        super(ltree.expr, ltree.clazz);
    }

    public AJCInstanceOf(JCInstanceOf ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCLabeledStatement extends JCLabeledStatement implements JavaParserComments {

    public String comment;

    public AJCLabeledStatement(Name label, JCStatement body) {
        super(label, body);
    }

    public AJCLabeledStatement(JCLabeledStatement ltree) {
        super(ltree.label, ltree.body);
    }

    public AJCLabeledStatement(JCLabeledStatement ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCLiteral extends JCLiteral implements JavaParserComments {

    public String comment;

    public AJCLiteral(TypeTag typetag, Object value) {
        super(typetag, value);
    }

    public AJCLiteral(JCLiteral ltree) {
        super(ltree.typetag, ltree.value);
    }

    public AJCLiteral(JCLiteral ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCMethodDecl extends JCMethodDecl implements JavaParserComments {

    public String comment;

    public AJCMethodDecl(JCModifiers mods,
                         Name name,
                         JCExpression restype,
                         List<JCTypeParameter> typarams,
                         JCVariableDecl recvparam,
                         List<JCVariableDecl> params,
                         List<JCExpression> thrown,
                         JCBlock body,
                         JCExpression defaultValue,
                         MethodSymbol sym) {
        super(mods, name, restype, typarams, recvparam, params, thrown, body, defaultValue, sym);
    }

    public AJCMethodDecl(JCMethodDecl ltree) {
        super(ltree.mods, ltree.name, ltree.restype, ltree.typarams, ltree.recvparam, ltree.params, ltree.thrown, ltree.body, ltree.defaultValue, ltree.sym);
    }

    public AJCMethodDecl(JCMethodDecl ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCMethodInvocation extends JCMethodInvocation implements JavaParserComments {

    public String comment;

    public AJCMethodInvocation(List<JCExpression> typeargs, JCExpression meth, List<JCExpression> args) {
        super(typeargs, meth, args);
    }

    public AJCMethodInvocation(JCMethodInvocation ltree) {
        super(ltree.typeargs, ltree.meth, ltree.args);
    }

    public AJCMethodInvocation(JCMethodInvocation ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCModifiers extends JCModifiers implements JavaParserComments {

    public String comment;

    public AJCModifiers(long flags, List<JCAnnotation> annotations) {
        super(flags, annotations);
    }

    public AJCModifiers(JCModifiers ltree) {
        super(ltree.flags, ltree.annotations);
    }

    public AJCModifiers(JCModifiers ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCNewArray extends JCNewArray implements JavaParserComments {

    public String comment;

    public AJCNewArray(JCExpression elemtype, List<JCExpression> dims, List<JCExpression> elems) {
        super(elemtype, dims, elems);
    }

    public AJCNewArray(JCNewArray ltree) {
        super(ltree.elemtype, ltree.dims, ltree.elems);
    }

    public AJCNewArray(JCNewArray ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCNewClass extends JCNewClass implements JavaParserComments {

    public String comment;

    public AJCNewClass(JCExpression encl, List<JCExpression> typeargs, JCExpression clazz, List<JCExpression> args, JCClassDecl def) {
        super(encl, typeargs, clazz, args, def);
    }

    public AJCNewClass(JCNewClass ltree) {
        super(ltree.encl, ltree.typeargs, ltree.clazz, ltree.args, ltree.def);
    }

    public AJCNewClass(JCNewClass ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCParens extends JCParens implements JavaParserComments {

    public String comment;

    public AJCParens(JCExpression expr) {
        super(expr);
    }

    public AJCParens(JCParens ltree) {
        super(ltree.expr);
    }

    public AJCParens(JCParens ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCPrimitiveTypeTree extends JCPrimitiveTypeTree implements JavaParserComments {

    public String comment;

    public AJCPrimitiveTypeTree(TypeTag typetag) {
        super(typetag);
    }

    public AJCPrimitiveTypeTree(JCPrimitiveTypeTree ltree) {
        super(ltree.typetag);
    }

    public AJCPrimitiveTypeTree(JCPrimitiveTypeTree ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCReturn extends JCReturn implements JavaParserComments {

    public String comment;

    public AJCReturn(JCExpression expr) {
        super(expr);
    }

    public AJCReturn(JCReturn ltree) {
        super(ltree.expr);
    }

    public AJCReturn(JCReturn ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCSwitch extends JCSwitch implements JavaParserComments {

    public String comment;

    public AJCSwitch(JCExpression selector, List<JCCase> cases) {
        super(selector, cases);
    }

    public AJCSwitch(JCSwitch ltree) {
        super(ltree.selector, ltree.cases);
    }

    public AJCSwitch(JCSwitch ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCSynchronized extends JCSynchronized implements JavaParserComments {

    public String comment;

    public AJCSynchronized(JCExpression lock, JCBlock body) {
        super(lock, body);
    }

    public AJCSynchronized(JCSynchronized ltree) {
        super(ltree.lock, ltree.body);
    }

    public AJCSynchronized(JCSynchronized ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCThrow extends JCThrow implements JavaParserComments {

    public String comment;

    public AJCThrow(JCExpression expr) {
        super(expr);
    }

    public AJCThrow(JCThrow ltree) {
        super(ltree.expr);
    }

    public AJCThrow(JCThrow ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCTry extends JCTry implements JavaParserComments {

    public String comment;

    public AJCTry(List<JCTree> resources,
                  JCBlock body,
                  List<JCCatch> catchers,
                  JCBlock finalizer) {
        super(resources, body, catchers, finalizer);
    }

    public AJCTry(JCTry ltree) {
        super(ltree.resources, ltree.body, ltree.catchers, ltree.finalizer);
    }

    public AJCTry(JCTry ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCTypeApply extends JCTypeApply implements JavaParserComments {

    public String comment;

    public AJCTypeApply(JCExpression clazz, List<JCExpression> arguments) {
        super(clazz, arguments);
    }

    public AJCTypeApply(JCTypeApply ltree) {
        super(ltree.clazz, ltree.arguments);
    }

    public AJCTypeApply(JCTypeApply ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCTypeCast extends JCTypeCast implements JavaParserComments {

    public String comment;

    public AJCTypeCast(JCTree clazz, JCExpression expr) {
        super(clazz, expr);
    }

    public AJCTypeCast(JCTypeCast ltree) {
        super(ltree.clazz, ltree.expr);
    }

    public AJCTypeCast(JCTypeCast ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCTypeParameter extends JCTypeParameter implements JavaParserComments {

    public String comment;

    public AJCTypeParameter(Name name, List<JCExpression> bounds) {
        super(name, bounds, List.<JCAnnotation>nil());
    }

    public AJCTypeParameter(JCTypeParameter ltree) {
        super(ltree.name, ltree.bounds, ltree.annotations);
    }

    public AJCTypeParameter(JCTypeParameter ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCTypeUnion extends JCTypeUnion implements JavaParserComments {

    public String comment;

    public AJCTypeUnion(List<JCExpression> components) {
        super(components);
    }

    public AJCTypeUnion(JCTypeUnion ltree) {
        super(ltree.getTypeAlternatives());
    }

    public AJCTypeUnion(JCTypeUnion ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCUnary extends JCUnary implements JavaParserComments {

    public String comment;

    public AJCUnary(Tag opcode, JCExpression arg) {
        super(opcode, arg);
    }

    public AJCUnary(JCUnary ltree) {
        super(ltree.getTag(), ltree.arg);
    }

    public AJCUnary(JCUnary ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCVariableDecl extends JCVariableDecl implements JavaParserComments {

    public String comment;

    public AJCVariableDecl(JCModifiers mods,
                           Name name,
                           JCExpression vartype,
                           JCExpression init,
                           VarSymbol sym) {
        super(mods, name, vartype, init, sym);
    }

    public AJCVariableDecl(JCVariableDecl ltree) {
        super(ltree.mods, ltree.name, ltree.vartype, ltree.init, ltree.sym);
    }

    public AJCVariableDecl(JCVariableDecl ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCWhileLoop extends JCWhileLoop implements JavaParserComments {

    public String comment;

    public AJCWhileLoop(JCExpression cond, JCStatement body) {
        super(cond, body);
    }

    public AJCWhileLoop(JCWhileLoop ltree) {
        super(ltree.cond, ltree.body);
    }

    public AJCWhileLoop(JCWhileLoop ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class AJCWildcard extends JCWildcard implements JavaParserComments {

    public String comment;

    public AJCWildcard(TypeBoundKind kind, JCTree inner) {
        super(kind, inner);
    }

    public AJCWildcard(JCWildcard ltree) {
        super(ltree.kind, ltree.inner);
    }

    public AJCWildcard(JCWildcard ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
} public class ATypeBoundKind extends TypeBoundKind implements JavaParserComments {

    public String comment;

    public ATypeBoundKind(BoundKind kind) {
        super(kind);
    }

    public ATypeBoundKind(TypeBoundKind ltree) {
        super(ltree.kind);
    }

    public ATypeBoundKind(TypeBoundKind ltree, String lcomment) {
        this(ltree);
        setComment(lcomment);
    }

    public boolean hasComment() {
        return comment != null;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String lcomment) {
        comment = lcomment;
    }
}
import static com.sun.tools.javac.code.BoundKind.EXTENDS;
import static com.sun.tools.javac.code.BoundKind.SUPER;
import static com.sun.tools.javac.code.BoundKind.UNBOUND;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.ImportDeclaration;
import com.github.javaparser.ast.PackageDeclaration;
import com.github.javaparser.ast.TypeParameter;
import com.github.javaparser.ast.body.AnnotationDeclaration;
import com.github.javaparser.ast.body.AnnotationMemberDeclaration;
import com.github.javaparser.ast.body.BodyDeclaration;
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
import com.github.javaparser.ast.body.ConstructorDeclaration;
import com.github.javaparser.ast.body.EmptyMemberDeclaration;
import com.github.javaparser.ast.body.EmptyTypeDeclaration;
import com.github.javaparser.ast.body.EnumConstantDeclaration;
import com.github.javaparser.ast.body.EnumDeclaration;
import com.github.javaparser.ast.body.FieldDeclaration;
import com.github.javaparser.ast.body.InitializerDeclaration;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.body.ModifierSet;
import com.github.javaparser.ast.body.MultiTypeParameter;
import com.github.javaparser.ast.body.Parameter;
import com.github.javaparser.ast.body.TypeDeclaration;
import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.body.VariableDeclaratorId;
import com.github.javaparser.ast.comments.BlockComment;
import com.github.javaparser.ast.comments.JavadocComment;
import com.github.javaparser.ast.comments.LineComment;
import com.github.javaparser.ast.expr.AnnotationExpr;
import com.github.javaparser.ast.expr.ArrayAccessExpr;
import com.github.javaparser.ast.expr.ArrayCreationExpr;
import com.github.javaparser.ast.expr.ArrayInitializerExpr;
import com.github.javaparser.ast.expr.AssignExpr;
import com.github.javaparser.ast.expr.BinaryExpr;
import com.github.javaparser.ast.expr.BooleanLiteralExpr;
import com.github.javaparser.ast.expr.CastExpr;
import com.github.javaparser.ast.expr.CharLiteralExpr;
import com.github.javaparser.ast.expr.ClassExpr;
import com.github.javaparser.ast.expr.ConditionalExpr;
import com.github.javaparser.ast.expr.DoubleLiteralExpr;
import com.github.javaparser.ast.expr.EnclosedExpr;
import com.github.javaparser.ast.expr.Expression;
import com.github.javaparser.ast.expr.FieldAccessExpr;
import com.github.javaparser.ast.expr.InstanceOfExpr;
import com.github.javaparser.ast.expr.IntegerLiteralExpr;
import com.github.javaparser.ast.expr.IntegerLiteralMinValueExpr;
import com.github.javaparser.ast.expr.LambdaExpr;
import com.github.javaparser.ast.expr.LongLiteralExpr;
import com.github.javaparser.ast.expr.LongLiteralMinValueExpr;
import com.github.javaparser.ast.expr.MarkerAnnotationExpr;
import com.github.javaparser.ast.expr.MemberValuePair;
import com.github.javaparser.ast.expr.MethodCallExpr;
import com.github.javaparser.ast.expr.MethodReferenceExpr;
import com.github.javaparser.ast.expr.NameExpr;
import com.github.javaparser.ast.expr.NormalAnnotationExpr;
import com.github.javaparser.ast.expr.NullLiteralExpr;
import com.github.javaparser.ast.expr.ObjectCreationExpr;
import com.github.javaparser.ast.expr.QualifiedNameExpr;
import com.github.javaparser.ast.expr.SingleMemberAnnotationExpr;
import com.github.javaparser.ast.expr.StringLiteralExpr;
import com.github.javaparser.ast.expr.SuperExpr;
import com.github.javaparser.ast.expr.ThisExpr;
import com.github.javaparser.ast.expr.TypeExpr;
import com.github.javaparser.ast.expr.UnaryExpr;
import com.github.javaparser.ast.expr.VariableDeclarationExpr;
import com.github.javaparser.ast.stmt.AssertStmt;
import com.github.javaparser.ast.stmt.BlockStmt;
import com.github.javaparser.ast.stmt.BreakStmt;
import com.github.javaparser.ast.stmt.CatchClause;
import com.github.javaparser.ast.stmt.ContinueStmt;
import com.github.javaparser.ast.stmt.DoStmt;
import com.github.javaparser.ast.stmt.EmptyStmt;
import com.github.javaparser.ast.stmt.ExplicitConstructorInvocationStmt;
import com.github.javaparser.ast.stmt.ExpressionStmt;
import com.github.javaparser.ast.stmt.ForStmt;
import com.github.javaparser.ast.stmt.ForeachStmt;
import com.github.javaparser.ast.stmt.IfStmt;
import com.github.javaparser.ast.stmt.LabeledStmt;
import com.github.javaparser.ast.stmt.ReturnStmt;
import com.github.javaparser.ast.stmt.Statement;
import com.github.javaparser.ast.stmt.SwitchEntryStmt;
import com.github.javaparser.ast.stmt.SwitchStmt;
import com.github.javaparser.ast.stmt.SynchronizedStmt;
import com.github.javaparser.ast.stmt.ThrowStmt;
import com.github.javaparser.ast.stmt.TryStmt;
import com.github.javaparser.ast.stmt.TypeDeclarationStmt;
import com.github.javaparser.ast.stmt.WhileStmt;
import com.github.javaparser.ast.type.ClassOrInterfaceType;
import com.github.javaparser.ast.type.PrimitiveType;
import com.github.javaparser.ast.type.ReferenceType;
import com.github.javaparser.ast.type.UnknownType;
import com.github.javaparser.ast.type.VoidType;
import com.github.javaparser.ast.type.WildcardType;
import com.github.javaparser.ast.visitor.GenericVisitor;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.TypeTag;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.JCTree.JCAnnotation;
import com.sun.tools.javac.tree.JCTree.JCBlock;
import com.sun.tools.javac.tree.JCTree.JCCase;
import com.sun.tools.javac.tree.JCTree.JCCatch;
import com.sun.tools.javac.tree.JCTree.JCClassDecl;
import com.sun.tools.javac.tree.JCTree.JCExpression;
import com.sun.tools.javac.tree.JCTree.JCExpressionStatement;
import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
import com.sun.tools.javac.tree.JCTree.JCIdent;
import com.sun.tools.javac.tree.JCTree.JCModifiers;
import com.sun.tools.javac.tree.JCTree.JCStatement;
import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
import com.sun.tools.javac.tree.JCTree.Tag;
import com.sun.tools.javac.tree.JCTree.TypeBoundKind;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.Name;
import com.sun.tools.javac.util.Names;
import stave.java.ast.AJCArrayAccess;
import stave.java.ast.AJCArrayTypeTree;
import stave.java.ast.AJCAssert;
import stave.java.ast.AJCAssign;
import stave.java.ast.AJCAssignOp;
import stave.java.ast.AJCBinary;
import stave.java.ast.AJCBlock;
import stave.java.ast.AJCBreak;
import stave.java.ast.AJCCase;
import stave.java.ast.AJCCatch;
import stave.java.ast.AJCClassDecl;
import stave.java.ast.AJCCompilationUnit;
import stave.java.ast.AJCConditional;
import stave.java.ast.AJCContinue;
import stave.java.ast.AJCDoWhileLoop;
import stave.java.ast.AJCEnhancedForLoop;
import stave.java.ast.AJCExpressionStatement;
import stave.java.ast.AJCFieldAccess;
import stave.java.ast.AJCForLoop;
import stave.java.ast.AJCIdent;
import stave.java.ast.AJCIf;
import stave.java.ast.AJCImport;
import stave.java.ast.AJCInstanceOf;
import stave.java.ast.AJCLabeledStatement;
import stave.java.ast.AJCLiteral;
import stave.java.ast.AJCMethodDecl;
import stave.java.ast.AJCMethodInvocation;
import stave.java.ast.AJCModifiers;
import stave.java.ast.AJCNewArray;
import stave.java.ast.AJCNewClass;
import stave.java.ast.AJCParens;
import stave.java.ast.AJCPrimitiveTypeTree;
import stave.java.ast.AJCReturn;
import stave.java.ast.AJCSwitch;
import stave.java.ast.AJCSynchronized;
import stave.java.ast.AJCThrow;
import stave.java.ast.AJCTry;
import stave.java.ast.AJCTypeApply;
import stave.java.ast.AJCTypeCast;
import stave.java.ast.AJCTypeParameter;
import stave.java.ast.AJCTypeUnion;
import stave.java.ast.AJCUnary;
import stave.java.ast.AJCVariableDecl;
import stave.java.ast.AJCWhileLoop;
import stave.java.ast.AJCWildcard;
import stave.java.ast.ATypeBoundKind;

        //ARG3: List<JCTypeParameter> typarams
        List<JCTypeParameter> arg3 = List.<JCTypeParameter>nil();
        if (n.getTypeParameters() != null) {
            for (final TypeParameter t : n.getTypeParameters()) {
                arg3 = arg3.append((JCTypeParameter) t.accept(this, arg));
            }
        }

        //ARG4: List<JCVariableDecl> params
        List<JCVariableDecl> arg4 = List.<JCVariableDecl>nil();
        if (n.getParameters() != null) {
            for (final Parameter p : n.getParameters()) {
                arg4 = arg4.append((JCVariableDecl) p.accept(this, arg));
            }
        }

        //ARG5: List<JCExpression> thrown
        List<JCExpression> arg5 = List.<JCExpression>nil();
        if (n.getThrows() != null) {
            for (final NameExpr name : n.getThrows()) {
                arg5 = arg5.append((JCExpression) name.accept(this, arg));
            }
        }

        //ARG6: JCBlock body
        JCBlock arg6 = null;
        if (n.getBody() != null) {
            arg6 = (JCBlock) n.getBody().accept(this, arg);
        }

        //ARG7: JCExpression defaultValue
        // TODO - Must check where to get this
        JCExpression arg7 = null;

        return new AJCMethodDecl(make.MethodDef(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7), ((n.getComment() != null) ? n.getComment().getContent() : null));
    }

    @Override
    public JCTree visit(final NameExpr n, final Object arg) {
        //ARG0: Name name
        Name arg0 = names.fromString(n.getName());

        return new AJCIdent(make.Ident(arg0), ((n.getComment() != null) ? n.getComment().getContent() : null));
    }

    @Override
    public JCTree visit(final NormalAnnotationExpr n, final Object arg) {
         /* TODO - Not supporting annotations
	 JCTree result = n.getName().accept(this, arg);
	 if (n.getPairs() != null) {
	    for (final MemberValuePair m : n.getPairs()) {
	       JCTree result = m.accept(this, arg);
	    }
	 }
	 return new AJCNormalAnnotation( make.NormalAnnotation( ), ( (n.getComment()!=null)?n.getComment().getContent():null ) );
         */
        System.err.println("Assigning null at:" + Thread.currentThread().getStackTrace()[1].getLineNumber());
        return null;
    }

    @Override
    public JCTree visit(final NullLiteralExpr n, final Object arg) {
        //ARG0: int tag
        TypeTag arg0 = TypeTag.BOT;

        //ARG1: Object value
        Object arg1 = null;

        return new AJCLiteral(make.Literal(arg0, arg1), ((n.getComment() != null) ? n.getComment().getContent() : null));
    }

    @Override
    public JCTree visit(final ObjectCreationExpr n, final Object arg) {
        //ARG0: JCExpression encl
        JCExpression arg0 = null;
        if (n.getScope() != null) {
            arg0 = (JCExpression) n.getScope().accept(this, arg);
        }

        //ARG1: List<JCExpression> typeargs
        List<JCExpression> arg1 = List.<JCExpression>nil();
        if (n.getTypeArgs() != null) {
            for (final com.github.javaparser.ast.type.Type t : n.getTypeArgs()) {
                arg1 = arg1.append((JCExpression) t.accept(this, arg));
            }
        }

        //ARG2: JCExpression clazz
        JCExpression arg2 = (JCExpression) n.getType().accept(this, arg);

        //ARG3: List<JCExpression> args
        List<JCExpression> arg3 = List.<JCExpression>nil();
        if (n.getArgs() != null) {
            for (final Expression e : n.getArgs()) {
                arg3 = arg3.append((JCExpression) e.accept(this, arg));
            }
        }

        //ARG4: JCClassDecl def
        JCClassDecl arg4 = null;

        // Must convert internal modifiers
        if (n.getAnonymousClassBody() != null) {
            long jcmodifier = 0;
            List<JCTree> defs = List.<JCTree>nil();

            for (final BodyDeclaration member : n.getAnonymousClassBody()) {
                defs = defs.append(member.accept(this, arg));
                // TODO - Currently the modifier flags are accumulating
                // Must figure out how to separe them per class body
                if (member instanceof TypeDeclaration) {
                    jcmodifier = setJCTreeModifiers(((TypeDeclaration) member).getModifiers(), jcmodifier);
                }
            }
            JCModifiers mods = new AJCModifiers(make.Modifiers(jcmodifier), null);
            arg4 = new AJCClassDecl(make.AnonymousClassDef(mods, defs), null);
        }


        return new AJCNewClass(make.NewClass(arg0, arg1, arg2, arg3, arg4), ((n.getComment() != null) ? n.getComment().getContent() : null));