The bulk of the effort for a new pretty printer.

37 files changed, 1557 insertions, 109 deletions

diff --git a/src/delombok/lombok/delombok/DelombokResult.java b/src/delombok/lombok/delombok/DelombokResult.java
index 84aeb68b..8985b257 100644
--- a/src/delombok/lombok/delombok/DelombokResult.java
+++ b/src/delombok/lombok/delombok/DelombokResult.java
@@ -65,7 +65,8 @@ public class DelombokResult {
 		else comments_ = com.sun.tools.javac.util.List.from(comments.toArray(new CommentInfo[0]));
 		
 		FormatPreferences preferences = new FormatPreferenceScanner().scan(formatPreferences, getContent());
-		compilationUnit.accept(new PrettyCommentsPrinter(out, compilationUnit, comments_, preferences));
+		//compilationUnit.accept(new PrettyCommentsPrinter(out, compilationUnit, comments_, preferences));
+		compilationUnit.accept(new PrettyPrinter(out, compilationUnit, comments_, preferences));
 	}
 
 	private CharSequence getContent() throws IOException {
diff --git a/src/delombok/lombok/delombok/PrettyPrinter.java b/src/delombok/lombok/delombok/PrettyPrinter.java
new file mode 100644
index 00000000..0b248c52
--- /dev/null
+++ b/src/delombok/lombok/delombok/PrettyPrinter.java
@@ -0,0 +1,1458 @@
+package lombok.delombok;
+
+import static com.sun.tools.javac.code.Flags.*;
+import static lombok.javac.Javac.*;
+import static lombok.javac.JavacTreeMaker.TreeTag.treeTag;
+import static lombok.javac.JavacTreeMaker.TypeTag.typeTag;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+import com.sun.tools.javac.tree.DocCommentTable;
+import com.sun.tools.javac.tree.JCTree;
+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.JCExpression;
+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.JCStatement;
+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.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.util.JCDiagnostic.DiagnosticPosition;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.Position;
+
+import lombok.javac.CommentInfo;
+import lombok.javac.CommentInfo.EndConnection;
+import lombok.javac.CommentInfo.StartConnection;
+import lombok.javac.JavacTreeMaker.TreeTag;
+import lombok.javac.JavacTreeMaker.TypeTag;
+
+public class PrettyPrinter extends JCTree.Visitor {
+	private static final String LINE_SEP = System.getProperty("line.separator");
+	private static final Map<TreeTag, String> OPERATORS;
+	
+	static {
+		Map<TreeTag, String> map = new HashMap<TreeTag, String>();
+		
+		map.put(treeTag("POS"), "+");
+		map.put(treeTag("NEG"), "-");
+		map.put(treeTag("NOT"), "!");
+		map.put(treeTag("COMPL"), "~");
+		map.put(treeTag("PREINC"), "++");
+		map.put(treeTag("PREDEC"), "--");
+		map.put(treeTag("POSTINC"), "++");
+		map.put(treeTag("POSTDEC"), "--");
+		map.put(treeTag("NULLCHK"), "<*nullchk*>");
+		map.put(treeTag("OR"), "||");
+		map.put(treeTag("AND"), "&&");
+		map.put(treeTag("EQ"), "==");
+		map.put(treeTag("NE"), "!=");
+		map.put(treeTag("LT"), "<");
+		map.put(treeTag("GT"), ">");
+		map.put(treeTag("LE"), "<=");
+		map.put(treeTag("GE"), ">=");
+		map.put(treeTag("BITOR"), "|");
+		map.put(treeTag("BITXOR"), "^");
+		map.put(treeTag("BITAND"), "&");
+		map.put(treeTag("SL"), "<<");
+		map.put(treeTag("SR"), ">>");
+		map.put(treeTag("USR"), ">>>");
+		map.put(treeTag("PLUS"), "+");
+		map.put(treeTag("MINUS"), "-");
+		map.put(treeTag("MUL"), "*");
+		map.put(treeTag("DIV"), "/");
+		map.put(treeTag("MOD"), "%");
+		
+		map.put(treeTag("BITOR_ASG"), "|=");
+		map.put(treeTag("BITXOR_ASG"), "^=");
+		map.put(treeTag("BITAND_ASG"), "&=");
+		map.put(treeTag("SL_ASG"), "<<=");
+		map.put(treeTag("SR_ASG"), ">>=");
+		map.put(treeTag("USR_ASG"), ">>>=");
+		map.put(treeTag("PLUS_ASG"), "+=");
+		map.put(treeTag("MINUS_ASG"), "-=");
+		map.put(treeTag("MUL_ASG"), "*=");
+		map.put(treeTag("DIV_ASG"), "/=");
+		map.put(treeTag("MOD_ASG"), "%=");
+		
+		OPERATORS = map;
+	}
+	
+	private final Writer out;
+	private final JCCompilationUnit compilationUnit;
+	private List<CommentInfo> comments;
+	private final FormatPreferences formatPreferences;
+	
+	private final Map<JCTree, String> docComments;
+	private final DocCommentTable docTable;
+	private int indent = 0;
+	
+	@SuppressWarnings({"unchecked", "rawtypes"})
+	public PrettyPrinter(Writer out, JCCompilationUnit cu, List<CommentInfo> comments, FormatPreferences preferences) {
+		this.out = out;
+		this.comments = comments;
+		this.compilationUnit = cu;
+		this.formatPreferences = preferences;
+		
+		/* load doc comments */ {
+			Object dc = getDocComments(compilationUnit);
+			if (dc instanceof Map<?, ?>) {
+				this.docComments = (Map) dc;
+				this.docTable = null;
+			} else if (dc instanceof DocCommentTable) {
+				this.docComments = null;
+				this.docTable = (DocCommentTable) dc;
+			} else {
+				this.docComments = null;
+				this.docTable = null;
+			}
+		}
+	}
+	
+	private int endPos(JCTree tree) {
+		return getEndPosition(tree, compilationUnit);
+	}
+	
+	private static int lineEndPos(String s, int start) {
+		int pos = s.indexOf('\n', start);
+		if (pos < 0) pos = s.length();
+		return pos;
+	}
+	
+	private boolean needsAlign, needsNewLine, onNewLine = true, needsSpace, aligned;
+	
+	public static final class UncheckedIOException extends RuntimeException {
+		UncheckedIOException(IOException source) {
+			super(toMsg(source));
+			setStackTrace(source.getStackTrace());
+		}
+		
+		private static String toMsg(Throwable t) {
+			String msg = t.getMessage();
+			String n = t.getClass().getSimpleName();
+			if (msg == null || msg.isEmpty()) return n;
+			return n + ": " + msg;
+		}
+	}
+	
+	private void align() {
+		if (!onNewLine) return;
+		try {
+			for (int i = 0; i < indent; i++) out.write(formatPreferences.indent());
+		} catch (IOException e) {
+			throw new UncheckedIOException(e);
+		}
+		
+		onNewLine = false;
+		aligned = true;
+		needsAlign = false;
+	}
+	
+	private void print(JCTree tree) {
+		if (tree == null) {
+			print("/*missing*/");
+			return;
+		}
+		
+		consumeComments(tree);
+		tree.accept(this);
+		consumeTrailingComments(endPos(tree));
+	}
+	
+	private void print(List<? extends JCTree> trees, String infix) {
+		boolean first = true;
+		JCTree prev = null;
+		for (JCTree tree : trees) {
+			if (suppress(tree)) continue;
+			if (!first && infix != null && !infix.isEmpty()) {
+				if ("\n".equals(infix)) println(prev);
+				else print(infix);
+			}
+			first = false;
+			print(tree);
+			prev = tree;
+		}
+	}
+	
+	private boolean suppress(JCTree tree) {
+		if (tree instanceof JCBlock) {
+			JCBlock block = (JCBlock) tree;
+			return (Position.NOPOS == block.pos) && block.stats.isEmpty();
+		}
+		
+		if (tree instanceof JCExpressionStatement) {
+			JCExpression expr = ((JCExpressionStatement)tree).expr;
+			if (expr instanceof JCMethodInvocation) {
+				JCMethodInvocation inv = (JCMethodInvocation) expr;
+				if (!inv.typeargs.isEmpty() || !inv.args.isEmpty()) return false;
+				if (!(inv.meth instanceof JCIdent)) return false;
+				return ((JCIdent) inv.meth).name.toString().equals("super");
+			}
+		}
+		
+		return false;
+	}
+	
+	private void print(CharSequence s) {
+		boolean align = needsAlign;
+		if (needsNewLine && !onNewLine) println();
+		if (align && !aligned) align();
+		try {
+			if (needsSpace && !onNewLine && !aligned) out.write(' ');
+			out.write(s.toString());
+		} catch (IOException e) {
+			throw new UncheckedIOException(e);
+		}
+		
+		needsSpace = false;
+		onNewLine = false;
+		aligned = false;
+	}
+	
+	
+	private void println() {
+		try {
+			out.write(LINE_SEP);
+		} catch (IOException e) {
+			throw new UncheckedIOException(e);
+		}
+		
+		onNewLine = true;
+		aligned = false;
+		needsNewLine = false;
+	}
+	
+	private void println(JCTree completed) {
+		if (completed != null) {
+			int endPos = endPos(completed);
+			consumeTrailingComments(endPos);
+		}
+		try {
+			out.write(LINE_SEP);
+		} catch (IOException e) {
+			throw new UncheckedIOException(e);
+		}
+		
+		onNewLine = true;
+		aligned = false;
+		needsNewLine = false;
+	}
+	
+	private void println(CharSequence s) {
+		print(s);
+		println();
+	}
+	
+	private void println(CharSequence s, JCTree completed) {
+		print(s);
+		println(completed);
+	}
+	
+	private void aPrint(CharSequence s) {
+		align();
+		print(s);
+	}
+	
+	private void aPrintln(CharSequence s) {
+		align();
+		print(s);
+		println();
+	}
+	
+	private void aPrintln(CharSequence s, JCTree completed) {
+		align();
+		print(s);
+		println(completed);
+	}
+	
+	private void consumeComments(int until) {
+		CommentInfo head = comments.head;
+		while (comments.nonEmpty() && head.pos < until) {
+			printComment(head);
+			comments = comments.tail;
+			head = comments.head;
+		}
+	}
+	
+	private void consumeComments(JCTree tree) {
+		consumeComments(tree.pos);
+	}
+	
+	private void consumeTrailingComments(int from) {
+		boolean prevNewLine = onNewLine;
+		CommentInfo head = comments.head;
+		boolean stop = false;
+		
+		while (comments.nonEmpty() && head.prevEndPos == from && !stop && !(head.start == StartConnection.ON_NEXT_LINE || head.start == StartConnection.START_OF_LINE)) {
+			from = head.endPos;
+			printComment(head);
+			stop = (head.end == EndConnection.ON_NEXT_LINE);
+			comments = comments.tail;
+			head = comments.head;
+		}
+		
+		if (!onNewLine && prevNewLine) {
+			println();
+		}
+	}
+	
+	private String getJavadocFor(JCTree node) {
+		if (docComments != null) return docComments.get(node);
+		if (docTable != null) return docTable.getCommentText(node);
+		return null;
+	}
+	
+	private void printComment(CommentInfo comment) {
+		switch (comment.start) {
+		case DIRECT_AFTER_PREVIOUS:
+			needsSpace = false;
+			break;
+		case AFTER_PREVIOUS:
+			needsSpace = true;
+			break;
+		case START_OF_LINE:
+			needsNewLine = true;
+			needsAlign = false;
+			break;
+		case ON_NEXT_LINE:
+			if (!onNewLine) {
+				needsNewLine = true;
+				needsAlign = true;
+			} else if (!aligned) {
+				needsAlign = true;
+			}
+			break;
+		}
+		
+		print(comment.content);
+		
+		switch (comment.end) {
+		case ON_NEXT_LINE:
+			if (!aligned) {
+				needsNewLine = true;
+				needsAlign = true;
+			}
+			break;
+		case AFTER_COMMENT:
+			needsSpace = true;
+			break;
+		case DIRECT_AFTER_COMMENT:
+			// do nothing
+			break;
+		}
+	}
+	
+	private void printDocComment(JCTree tree) {
+		String dc = getJavadocFor(tree);
+		if (dc == null) return;
+		aPrintln("/**");
+		int pos = 0;
+		int endpos = lineEndPos(dc, pos);
+		boolean atStart = true;
+		while (pos < dc.length()) {
+			String line = dc.substring(pos, endpos);
+			if (line.trim().isEmpty() && atStart) {
+				atStart = false;
+				continue;
+			}
+			atStart = false;
+			aPrint(" *");
+			if (pos < dc.length() && dc.charAt(pos) > ' ') print(" ");
+			println(dc.substring(pos, endpos));
+			pos = endpos + 1;
+			endpos = lineEndPos(dc, pos);
+		}
+		aPrintln(" */");
+	}
+	
+	private Name __INIT__, __VALUE__;
+	private Name name_init(Name someName) {
+		if (__INIT__ == null) __INIT__ = someName.table.fromChars("<init>".toCharArray(), 0, 6);
+		return __INIT__;
+	}
+	private Name name_value(Name someName) {
+		if (__VALUE__ == null) __VALUE__ = someName.table.fromChars("value".toCharArray(), 0, 5);
+		return __VALUE__;
+	}
+	
+	@Override public void visitTopLevel(JCCompilationUnit tree) {
+		printDocComment(tree);
+		if (tree.pid != null) {
+			consumeComments(tree);
+			aPrint("package ");
+			print(tree.pid);
+			println(";", tree.pid);
+		}
+		
+		boolean first = true;
+		
+		for (JCTree child : tree.defs) {
+			if (!(child instanceof JCImport)) continue;
+			if (first) println();
+			first = false;
+			print(child);
+		}
+		
+		for (JCTree child : tree.defs) {
+			if (child instanceof JCImport) continue;
+			print(child);
+		}
+		consumeComments(Integer.MAX_VALUE);
+	}
+	
+	@Override public void visitImport(JCImport tree) {
+		aPrint("import ");
+		if (tree.staticImport) print("static ");
+		print(tree.qualid);
+		println(";", tree);
+	}
+	
+	private Name currentTypeName;
+	@Override public void visitClassDef(JCClassDecl tree) {
+		println();
+		printDocComment(tree);
+		align();
+		print(tree.mods);
+		
+		boolean isInterface = (tree.mods.flags & INTERFACE) != 0;
+		boolean isAnnotationInterface = isInterface && (tree.mods.flags & ANNOTATION) != 0;
+		boolean isEnum = (tree.mods.flags & ENUM) != 0;
+		
+		if (isAnnotationInterface) print("@interface ");
+		else if (isInterface) print("interface ");
+		else if (isEnum) print("enum ");
+		else print("class ");
+		
+		print(tree.name);
+		Name prevTypeName = currentTypeName;
+		currentTypeName = tree.name;
+		
+		if (tree.typarams.nonEmpty()) {
+			print("<");
+			print(tree.typarams, ", ");
+			print(">");
+		}
+		JCTree extendsClause = getExtendsClause(tree);
+		if (extendsClause != null) {
+			print(" extends ");
+			print(extendsClause);
+		}
+		
+		if (tree.implementing.nonEmpty()) {
+			print(isInterface ? " extends " : " implements ");
+			print(tree.implementing, ", ");
+		}
+		
+		println(" {");
+		indent++;
+		printClassMembers(tree.defs, isEnum, isInterface);
+		consumeComments(endPos(tree));
+		indent--;
+		aPrintln("}", tree);
+		currentTypeName = prevTypeName;
+	}
+	
+	private void printClassMembers(List<JCTree> members, boolean isEnum, boolean isInterface) {
+		Class<?> prefType = null;
+		int typeOfPrevEnumMember = isEnum ? 3 : 0; // 1 = normal, 2 = with body, 3 = no enum field yet.
+		boolean prevWasEnumMember = isEnum;
+		
+		for (JCTree member : members) {
+			if (typeOfPrevEnumMember == 3 && member instanceof JCMethodDecl && (((JCMethodDecl) member).mods.flags & GENERATEDCONSTR) != 0) continue;
+			boolean isEnumVar = isEnum && member instanceof JCVariableDecl && (((JCVariableDecl) member).mods.flags & ENUM) != 0;
+			if (!isEnumVar && prevWasEnumMember) {
+				prevWasEnumMember = false;
+				if (typeOfPrevEnumMember == 3) align();
+				println(";");
+			}
+			
+			if (isEnumVar) {
+				if (prefType != null && prefType != JCVariableDecl.class) println();
+				switch (typeOfPrevEnumMember) {
+				case 1:
+					print(", ");
+					break;
+				case 2:
+					println(",");
+					align();
+					break;
+				}
+				print(member);
+				JCTree init = ((JCVariableDecl) member).init;
+				typeOfPrevEnumMember = init instanceof JCNewClass && ((JCNewClass) init).def != null ? 2 : 1;
+			} else if (member instanceof JCVariableDecl) {
+				if (prefType != null && prefType != JCVariableDecl.class) println();
+				if (isInterface) flagMod = -1L & ~(PUBLIC | STATIC | FINAL);
+				print(member);
+			} else if (member instanceof JCMethodDecl) {
+				if ((((JCMethodDecl) member).mods.flags & GENERATEDCONSTR) != 0) continue;
+				if (prefType != null) println();
+				if (isInterface) flagMod = -1L & ~(PUBLIC | ABSTRACT);
+				print(member);
+			} else if (member instanceof JCClassDecl) {
+				if (prefType != null) println();
+				if (isInterface) flagMod = -1L & ~(PUBLIC | STATIC);
+				print(member);
+			} else {
+				if (prefType != null) println();
+				print(member);
+			}
+			
+			prefType = member.getClass();
+		}
+		
+		if (prevWasEnumMember) {
+			prevWasEnumMember = false;
+			if (typeOfPrevEnumMember == 3) align();
+			println(";");
+		}
+	}
+	
+	@Override public void visitTypeParameter(JCTypeParameter tree) {
+		List<JCExpression> annotations = readObject(tree, "annotations", List.<JCExpression>nil());
+		if (!annotations.isEmpty()) {
+			print(annotations, " ");
+			print(" ");
+		}
+		print(tree.name);
+		if (tree.bounds.nonEmpty()) {
+			print(" extends ");
+			print(tree.bounds, " & ");
+		}
+		consumeComments(tree);
+	}
+	
+	@Override public void visitVarDef(JCVariableDecl tree) {
+		printDocComment(tree);
+		align();
+		if ((tree.mods.flags & ENUM) != 0) {
+			printEnumMember(tree);
+			return;
+		}
+		printAnnotations(tree.mods.annotations, true);
+		printModifierKeywords(tree.mods);
+		printVarDef0(tree);
+		println(";", tree);
+	}
+	
+	private void printVarDefInline(JCVariableDecl tree) {
+		printAnnotations(tree.mods.annotations, false);
+		printModifierKeywords(tree.mods);
+		printVarDef0(tree);
+	}
+	
+	private void printVarDef0(JCVariableDecl tree) {
+		boolean varargs = (tree.mods.flags & VARARGS) != 0;
+		if (varargs && tree.vartype instanceof JCArrayTypeTree) {
+			print(((JCArrayTypeTree) tree.vartype).elemtype);
+			print("...");
+		} else {
+			print(tree.vartype);
+		}
+		print(" ");
+		print(tree.name);
+		if (tree.init != null) {
+			print(" = ");
+			print(tree.init);
+		}
+	}
+	
+	private void printEnumMember(JCVariableDecl tree) {
+		printAnnotations(tree.mods.annotations, true);
+		print(tree.name);
+		if (tree.init instanceof JCNewClass) {
+			JCNewClass constructor = (JCNewClass) tree.init;
+			if (constructor.args != null && constructor.args.nonEmpty()) {
+				print("(");
+				print(constructor.args, ", ");
+				print(")");
+			}
+			
+			if (constructor.def != null && constructor.def.defs != null) {
+				println(" {");
+				indent++;
+				printClassMembers(constructor.def.defs, false, false);
+				consumeComments(endPos(tree));
+				indent--;
+				aPrint("}");
+			}
+		}
+	}
+	
+	// TODO: Test postfix syntax for methods (?), for decls. Multiline vardefs, possibly with comments. enums with bodies. constructor-local generics, method-local generics, also do/while, finally, try-with-resources, lambdas, annotations in java8 places...
+	// TODO: Whatever is JCAnnotatedType? We handle it in the 7+ bucket in the old one...
+	
+	@Override public void visitTypeApply(JCTypeApply tree) {
+		print(tree.clazz);
+		print("<");
+		print(tree.arguments, ", ");
+		print(">");
+	}
+	
+	@Override public void visitWildcard(JCWildcard tree) {
+		switch (tree.getKind()) {
+		default:
+		case UNBOUNDED_WILDCARD:
+			print("?");
+			return;
+		case EXTENDS_WILDCARD:
+			print("? extends ");
+			print(tree.inner);
+			return;
+		case SUPER_WILDCARD:
+			print("? super ");
+			print(tree.inner);
+			return;
+		}
+	}
+	
+	@Override public void visitLiteral(JCLiteral tree) {
+		TypeTag typeTag = typeTag(tree);
+		if (CTC_INT.equals(typeTag)) print("" + tree.value);
+		else if (CTC_LONG.equals(typeTag)) print(tree.value + "L");
+		else if (CTC_FLOAT.equals(typeTag)) print(tree.value + "F");
+		else if (CTC_DOUBLE.equals(typeTag)) print("" + tree.value);
+		else if (CTC_CHAR.equals(typeTag)) {
+			print("\'" + quoteChar((char)((Number)tree.value).intValue()) + "\'");
+		}
+		else if (CTC_BOOLEAN.equals(typeTag)) print(((Number)tree.value).intValue() == 1 ? "true" : "false");
+		else if (CTC_BOT.equals(typeTag)) print("null");
+		else print("\"" + quoteChars(tree.value.toString()) + "\"");
+	}
+	
+	@Override public void visitMethodDef(JCMethodDecl tree) {
+		boolean isConstructor = tree.name == name_init(tree.name);
+		if (isConstructor && (tree.mods.flags & GENERATEDCONSTR) != 0) return;
+		printDocComment(tree);
+		align();
+		print(tree.mods);
+		if (tree.typarams != null && tree.typarams.nonEmpty()) {
+			print("<");
+			print(tree.typarams, ", ");
+			print("> ");
+		}
+		
+		if (isConstructor) {
+			print(currentTypeName == null ? "<init>" : currentTypeName);
+		} else {
+			print(tree.restype);
+			print(" ");
+			print(tree.name);
+		}
+		
+		print("(");
+		boolean first = true;
+		for (JCVariableDecl param : tree.params) {
+			if (!first) print(", ");
+			first = false;
+			printVarDefInline(param);
+		}
+		print(")");
+		
+		if (tree.thrown.nonEmpty()) {
+			print(" throws ");
+			print(tree.thrown, ", ");
+		}
+		
+		if (tree.defaultValue != null) {
+			print(" default ");
+			print(tree.defaultValue);
+		}
+		
+		if (tree.body != null) {
+			print(" ");
+			print(tree.body);
+		} else println(";", tree);
+	}
+	
+	@Override public void visitSkip(JCSkip that) {
+		print(";");
+	}
+	
+	@Override public void visitAnnotation(JCAnnotation tree) {
+		print("@");
+		print(tree.annotationType);
+		if (tree.args.isEmpty()) return;
+		print("(");
+		boolean done = false;
+		if (tree.args.length() == 1 && tree.args.get(0) instanceof JCAssign) {
+			JCAssign arg1 = (JCAssign) tree.args.get(0);
+			JCIdent arg1Name = arg1.lhs instanceof JCIdent ? ((JCIdent) arg1.lhs) : null;
+			if (arg1Name != null && arg1Name.name == name_value(arg1Name.name)) {
+				print(arg1.rhs);
+				done = true;
+			}
+		}
+		if (!done) print(tree.args, ", ");
+		print(")");
+	}
+	
+	@Override public void visitTypeArray(JCArrayTypeTree tree) {
+		JCTree elem = tree.elemtype;
+		while (elem instanceof JCWildcard) elem = ((JCWildcard) elem).inner;
+		print(elem);
+		print("[]");
+	}
+	
+	@Override public void visitNewArray(JCNewArray tree)