public class AJCAnnotation extends JCAnnotation implements JavaParserComments {

    public String comment;

    public AJCAnnotation(Tag tag, JCTree annotationType, List<JCExpression> args) {
        super(tag, annotationType, args);
    }

    public AJCAnnotation(JCAnnotation ltree) {
        super(ltree.getTag(), ltree.annotationType, ltree.args);
    }

    public AJCAnnotation(JCAnnotation 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 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 AJCErroneous extends JCErroneous implements JavaParserComments {

    public String comment;

    public AJCErroneous(List<? extends JCTree> errs) {
        super(errs);
    }

    public AJCErroneous(JCErroneous ltree) {
        super(ltree.errs);
    }

    public AJCErroneous(JCErroneous 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 AJCSkip extends JCSkip implements JavaParserComments {

    public String comment;

    public AJCSkip() {
        super();
    }

    public AJCSkip(String lcomment) {
        this();
        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 ALetExpr extends LetExpr implements JavaParserComments {

    public String comment;

    public ALetExpr(List<JCVariableDecl> defs, JCTree expr) {
        super(defs, expr);
    }

    public ALetExpr(LetExpr ltree) {
        super(ltree.defs, ltree.expr);
    }

    public ALetExpr(LetExpr 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 com.sun.tools.javac.tree.JCTree.JCAnnotation;
import com.sun.tools.javac.tree.JCTree.JCArrayAccess;
import com.sun.tools.javac.tree.JCTree.JCArrayTypeTree;
import com.sun.tools.javac.tree.JCTree.JCAssert;
import com.sun.tools.javac.tree.JCTree.JCAssign;
import com.sun.tools.javac.tree.JCTree.JCAssignOp;
import com.sun.tools.javac.tree.JCTree.JCBinary;
import com.sun.tools.javac.tree.JCTree.JCBlock;
import com.sun.tools.javac.tree.JCTree.JCBreak;
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.JCCompilationUnit;
import com.sun.tools.javac.tree.JCTree.JCConditional;
import com.sun.tools.javac.tree.JCTree.JCContinue;
import com.sun.tools.javac.tree.JCTree.JCDoWhileLoop;
import com.sun.tools.javac.tree.JCTree.JCEnhancedForLoop;
import com.sun.tools.javac.tree.JCTree.JCErroneous;
import com.sun.tools.javac.tree.JCTree.JCExpressionStatement;
import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
import com.sun.tools.javac.tree.JCTree.JCForLoop;
import com.sun.tools.javac.tree.JCTree.JCIdent;
import com.sun.tools.javac.tree.JCTree.JCIf;
import com.sun.tools.javac.tree.JCTree.JCImport;
import com.sun.tools.javac.tree.JCTree.JCInstanceOf;
import com.sun.tools.javac.tree.JCTree.JCLabeledStatement;
import com.sun.tools.javac.tree.JCTree.JCLiteral;
import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
import com.sun.tools.javac.tree.JCTree.JCModifiers;
import com.sun.tools.javac.tree.JCTree.JCNewArray;
import com.sun.tools.javac.tree.JCTree.JCNewClass;
import com.sun.tools.javac.tree.JCTree.JCParens;
import com.sun.tools.javac.tree.JCTree.JCPrimitiveTypeTree;
import com.sun.tools.javac.tree.JCTree.JCReturn;
import com.sun.tools.javac.tree.JCTree.JCSkip;
import com.sun.tools.javac.tree.JCTree.JCSwitch;
import com.sun.tools.javac.tree.JCTree.JCSynchronized;
import com.sun.tools.javac.tree.JCTree.JCThrow;
import com.sun.tools.javac.tree.JCTree.JCTry;
import com.sun.tools.javac.tree.JCTree.JCTypeApply;
import com.sun.tools.javac.tree.JCTree.JCTypeCast;
import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
import com.sun.tools.javac.tree.JCTree.JCTypeUnion;
import com.sun.tools.javac.tree.JCTree.JCUnary;
import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
import com.sun.tools.javac.tree.JCTree.JCWhileLoop;
import com.sun.tools.javac.tree.JCTree.JCWildcard;
import com.sun.tools.javac.tree.JCTree.LetExpr;
import com.sun.tools.javac.tree.JCTree.TypeBoundKind;
import com.sun.tools.javac.tree.Pretty;
import java.io.IOException;
import java.io.Writer;
import stave.java.ast.AJCAnnotation;
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.AJCErroneous;
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.AJCSkip;
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.ALetExpr;
import stave.java.ast.ATypeBoundKind;
    }

    public void visitExec(JCExpressionStatement that) {
        if (that instanceof AJCExpressionStatement) {
            if (((AJCExpressionStatement) that).hasComment()) {
                try {
                    println();
                    print("/*" + ((AJCExpressionStatement) that).getComment() + "*/");
                } catch (IOException e) {
                    System.err.println("Exception at line " +
                            Thread.currentThread().getStackTrace()[1].getLineNumber() +
                            ":" +
                            e.getMessage());
                }
            }

            try {
                super.visitExec(that);
            } catch (Exception e) {
                System.err.println("Exception at line " +
                        Thread.currentThread().getStackTrace()[1].getLineNumber() +
                        ":" +
                        e.getMessage() + ". Proceeding still...");
            }
        }
    }

    public void visitBreak(JCBreak that) {
        if (((AJCBreak) that).hasComment()) {
            try {
                println();
                print("/*" + ((AJCBreak) that).getComment() + "*/");
            } catch (IOException e) {
                System.err.println("Exception at line " +
                        Thread.currentThread().getStackTrace()[1].getLineNumber() +
                        ":" +
                        e.getMessage());
            }
        }

        try {
            super.visitBreak(that);
        } catch (Exception e) {
            System.err.println("Exception at line " +
                    Thread.currentThread().getStackTrace()[1].getLineNumber() +
                    ":" +
                    e.getMessage() + ". Proceeding still...");
        }
    }

    public void visitContinue(JCContinue that) {
        if (((AJCContinue) that).hasComment()) {
            try {
                println();
                print("/*" + ((AJCContinue) that).getComment() + "*/");
            } catch (IOException e) {
                System.err.println("Exception at line " +
                        Thread.currentThread().getStackTrace()[1].getLineNumber() +
                        ":" +
                        e.getMessage());
            }
        }

        try {
            super.visitContinue(that);
        } catch (Exception e) {
            System.err.println("Exception at line " +
                    Thread.currentThread().getStackTrace()[1].getLineNumber() +
                    ":" +
                    e.getMessage() + ". Proceeding still...");
        }
    }

    public void visitReturn(JCReturn that) {
        if (((AJCReturn) that).hasComment()) {
            try {
                println();
                print("/*" + ((AJCReturn) that).getComment() + "*/");
            } catch (IOException e) {
                System.err.println("Exception at line " +
                        Thread.currentThread().getStackTrace()[1].getLineNumber() +
                        ":" +
                        e.getMessage());
            }
        }

        try {
            super.visitReturn(that);
        } catch (Exception e) {
            System.err.println("Exception at line " +
                    Thread.currentThread().getStackTrace()[1].getLineNumber() +
                    ":" +
                    e.getMessage() + ". Proceeding still...");
        }
    }

    public void visitThrow(JCThrow that) {
        if (((AJCThrow) that).hasComment()) {
            try {
                println();
                print("/*" + ((AJCThrow) that).getComment() + "*/");
            } catch (IOException e) {
                System.err.println("Exception at line " +
                        Thread.currentThread().getStackTrace()[1].getLineNumber() +
                        ":" +
                        e.getMessage());
            }
        }

        try {
            super.visitThrow(that);
        } catch (Exception e) {
            System.err.println("Exception at line " +
                    Thread.currentThread().getStackTrace()[1].getLineNumber() +
                    ":" +
                    e.getMessage() + ". Proceeding still...");
        }
    }

    public void visitAssert(JCAssert that) {
        if (((AJCAssert) that).hasComment()) {