Merge branch 'master' of github.com:rzwitserloot/lombok

Conflicts:
	src/delombok/lombok/delombok/DelombokApp.java

1 files changed, 217 insertions, 94 deletions

diff --git a/src/utils/lombok/javac/Javac.java b/src/utils/lombok/javac/Javac.java
index 4f316d9f..bdf5e7a0 100644
--- a/src/utils/lombok/javac/Javac.java
+++ b/src/utils/lombok/javac/Javac.java
@@ -21,57 +21,105 @@
  */
 package lombok.javac;
 
+import static lombok.javac.JavacTreeMaker.TreeTag.treeTag;
+import static lombok.javac.JavacTreeMaker.TypeTag.typeTag;
+
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import com.sun.tools.javac.code.TypeTags;
+import javax.lang.model.type.NoType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeVisitor;
+
+import lombok.javac.JavacTreeMaker.TreeTag;
+import lombok.javac.JavacTreeMaker.TypeTag;
+
+import com.sun.tools.javac.code.Source;
+import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
 import com.sun.tools.javac.tree.JCTree.JCExpression;
 import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
 import com.sun.tools.javac.tree.JCTree.JCIdent;
 import com.sun.tools.javac.tree.JCTree.JCLiteral;
-import com.sun.tools.javac.tree.JCTree.JCModifiers;
-import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
-import com.sun.tools.javac.tree.TreeMaker;
-import com.sun.tools.javac.util.List;
-import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 
 /**
  * Container for static utility methods relevant to lombok's operation on javac.
  */
 public class Javac {
 	private Javac() {
-		//prevent instantiation
+		// prevent instantiation
 	}
 	
 	/** Matches any of the 8 primitive names, such as {@code boolean}. */
-	private static final Pattern PRIMITIVE_TYPE_NAME_PATTERN = Pattern.compile(
-			"^(boolean|byte|short|int|long|float|double|char)$");
+	private static final Pattern PRIMITIVE_TYPE_NAME_PATTERN = Pattern.compile("^(boolean|byte|short|int|long|float|double|char)$");
 	
 	private static final Pattern VERSION_PARSER = Pattern.compile("^(\\d{1,6})\\.(\\d{1,6}).*$");
+	private static final Pattern SOURCE_PARSER = Pattern.compile("^JDK(\\d{1,6})_(\\d{1,6}).*$");
+	
+	private static final AtomicInteger compilerVersion = new AtomicInteger(-1);
 	
 	/**
 	 * Returns the version of this java compiler, i.e. the JDK that it shipped in. For example, for javac v1.7, this returns {@code 7}.
 	 */
 	public static int getJavaCompilerVersion() {
-		Matcher m = VERSION_PARSER.matcher(JavaCompiler.version());
-		if (m.matches()) {
-			int major = Integer.parseInt(m.group(1));
-			int minor = Integer.parseInt(m.group(2));
-			if (major == 1) return minor;
+		int cv = compilerVersion.get();
+		if (cv != -1) return cv;
+		
+		/* Main algorithm: Use JavaCompiler's intended method to do this */ {
+			Matcher m = VERSION_PARSER.matcher(JavaCompiler.version());
+			if (m.matches()) {
+				int major = Integer.parseInt(m.group(1));
+				int minor = Integer.parseInt(m.group(2));
+				if (major == 1) {
+					compilerVersion.set(minor);
+					return minor;
+				}
+			}
 		}
 		
+		/* Fallback algorithm one: Check Source's values. Lets hope oracle never releases a javac that recognizes future versions for -source */ {
+			String name = Source.values()[Source.values().length - 1].name();
+			Matcher m = SOURCE_PARSER.matcher(name);
+			if (m.matches()) {
+				int major = Integer.parseInt(m.group(1));
+				int minor = Integer.parseInt(m.group(2));
+				if (major == 1) {
+					compilerVersion.set(minor);
+					return minor;
+				}
+			}
+		}
+		
+		compilerVersion.set(6);
 		return 6;
 	}
 	
+	private static final Class<?> DOCCOMMENTTABLE_CLASS;
+	
+	static {
+		Class<?> c = null;
+		try {
+			c = Class.forName("com.sun.tools.javac.tree.DocCommentTable");
+		} catch (Throwable ignore) {}
+		DOCCOMMENTTABLE_CLASS = c;
+	}
+	
+	public static boolean instanceOfDocCommentTable(Object o) {
+		return DOCCOMMENTTABLE_CLASS != null && DOCCOMMENTTABLE_CLASS.isInstance(o);
+	}
+	
 	/**
-	 * Checks if the given expression (that really ought to refer to a type expression) represents a primitive type.
+	 * Checks if the given expression (that really ought to refer to a type
+	 * expression) represents a primitive type.
 	 */
 	public static boolean isPrimitive(JCExpression ref) {
 		String typeName = ref.toString();
@@ -79,15 +127,16 @@ public class Javac {
 	}
 	
 	/**
-	 * Turns an expression into a guessed intended literal. Only works for literals, as you can imagine.
+	 * Turns an expression into a guessed intended literal. Only works for
+	 * literals, as you can imagine.
 	 * 
 	 * Will for example turn a TrueLiteral into 'Boolean.valueOf(true)'.
 	 */
 	public static Object calculateGuess(JCExpression expr) {
 		if (expr instanceof JCLiteral) {
-			JCLiteral lit = (JCLiteral)expr;
+			JCLiteral lit = (JCLiteral) expr;
 			if (lit.getKind() == com.sun.source.tree.Tree.Kind.BOOLEAN_LITERAL) {
-				return ((Number)lit.value).intValue() == 0 ? false : true;
+				return ((Number) lit.value).intValue() == 0 ? false : true;
 			}
 			return lit.value;
 		} else if (expr instanceof JCIdent || expr instanceof JCFieldAccess) {
@@ -98,102 +147,176 @@ public class Javac {
 				if (idx > -1) x = x.substring(idx + 1);
 			}
 			return x;
-		} else return null;
-	}
-	
-	public static final int CTC_BOOLEAN = getCtcInt(TypeTags.class, "BOOLEAN");
-	public static final int CTC_INT = getCtcInt(TypeTags.class, "INT");
-	public static final int CTC_DOUBLE = getCtcInt(TypeTags.class, "DOUBLE");
-	public static final int CTC_FLOAT = getCtcInt(TypeTags.class, "FLOAT");
-	public static final int CTC_SHORT = getCtcInt(TypeTags.class, "SHORT");
-	public static final int CTC_BYTE = getCtcInt(TypeTags.class, "BYTE");
-	public static final int CTC_LONG = getCtcInt(TypeTags.class, "LONG");
-	public static final int CTC_CHAR = getCtcInt(TypeTags.class, "CHAR");
-	public static final int CTC_VOID = getCtcInt(TypeTags.class, "VOID");
-	public static final int CTC_NONE = getCtcInt(TypeTags.class, "NONE");
-	
-	public static final int CTC_NOT_EQUAL = getCtcInt(JCTree.class, "NE");
-	public static final int CTC_NOT = getCtcInt(JCTree.class, "NOT");
-	public static final int CTC_BITXOR = getCtcInt(JCTree.class, "BITXOR");
-	public static final int CTC_UNSIGNED_SHIFT_RIGHT = getCtcInt(JCTree.class, "USR");
-	public static final int CTC_MUL = getCtcInt(JCTree.class, "MUL");
-	public static final int CTC_PLUS = getCtcInt(JCTree.class, "PLUS");
-	public static final int CTC_BOT = getCtcInt(TypeTags.class, "BOT");
-	public static final int CTC_EQUAL = getCtcInt(JCTree.class, "EQ");
+		} else
+			return null;
+	}
 	
-	/**
-	 * Retrieves a compile time constant of type int from the specified class location.
-	 * 
-	 * Solves the problem of compile time constant inlining, resulting in lombok having the wrong value 
-	 * (javac compiler changes private api constants from time to time)
-	 * 
-	 * @param ctcLocation location of the compile time constant
-	 * @param identifier the name of the field of the compile time constant.
-	 */
-	public static int getCtcInt(Class<?> ctcLocation, String identifier) {
+	public static final TypeTag CTC_BOOLEAN = typeTag("BOOLEAN");
+	public static final TypeTag CTC_INT = typeTag("INT");
+	public static final TypeTag CTC_DOUBLE = typeTag("DOUBLE");
+	public static final TypeTag CTC_FLOAT = typeTag("FLOAT");
+	public static final TypeTag CTC_SHORT = typeTag("SHORT");
+	public static final TypeTag CTC_BYTE = typeTag("BYTE");
+	public static final TypeTag CTC_LONG = typeTag("LONG");
+	public static final TypeTag CTC_CHAR = typeTag("CHAR");
+	public static final TypeTag CTC_VOID = typeTag("VOID");
+	public static final TypeTag CTC_NONE = typeTag("NONE");
+	public static final TypeTag CTC_BOT = typeTag("BOT");
+	public static final TypeTag CTC_CLASS = typeTag("CLASS");
+	
+	public static final TreeTag CTC_NOT_EQUAL = treeTag("NE");
+	public static final TreeTag CTC_POS = treeTag("POS");
+	public static final TreeTag CTC_NEG = treeTag("NEG");
+	public static final TreeTag CTC_NOT = treeTag("NOT");
+	public static final TreeTag CTC_COMPL = treeTag("COMPL");
+	public static final TreeTag CTC_BITXOR = treeTag("BITXOR");
+	public static final TreeTag CTC_UNSIGNED_SHIFT_RIGHT = treeTag("USR");
+	public static final TreeTag CTC_MUL = treeTag("MUL");
+	public static final TreeTag CTC_PLUS = treeTag("PLUS");
+	public static final TreeTag CTC_EQUAL = treeTag("EQ");
+	public static final TreeTag CTC_PREINC = treeTag("PREINC");
+	public static final TreeTag CTC_PREDEC = treeTag("PREDEC");
+	
+	private static final Method getExtendsClause, getEndPosition;
+	
+	static {
+		getExtendsClause = getMethod(JCClassDecl.class, "getExtendsClause", new Class<?>[0]);
+		getExtendsClause.setAccessible(true);
+		
+		if (getJavaCompilerVersion() < 8) {
+			getEndPosition = getMethod(DiagnosticPosition.class, "getEndPosition", java.util.Map.class);
+		} else {
+			getEndPosition = getMethod(DiagnosticPosition.class, "getEndPosition", "com.sun.tools.javac.tree.EndPosTable");
+		}
+		getEndPosition.setAccessible(true);
+	}
+	
+	private static Method getMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
 		try {
-			return (Integer)ctcLocation.getField(identifier).get(null);
-		} catch (NoSuchFieldException e) {
-			throw new RuntimeException(e);
-		} catch (IllegalAccessException e) {
-			throw new RuntimeException(e);
+			return clazz.getMethod(name, paramTypes);
+		} catch (NoSuchMethodException e) {
+			throw sneakyThrow(e);
 		}
 	}
 	
-	private static final Field JCTREE_TAG;
-	private static final Method JCTREE_GETTAG;
-	static {
-		Field f = null;
+	private static Method getMethod(Class<?> clazz, String name, String... paramTypes) {
 		try {
-			f = JCTree.class.getDeclaredField("tag");
-		} catch (NoSuchFieldException e) {}
-		JCTREE_TAG = f;
-		
-		Method m = null;
+			Class<?>[] c = new Class[paramTypes.length];
+			for (int i = 0; i < paramTypes.length; i++) c[i] = Class.forName(paramTypes[i]);
+			return clazz.getMethod(name, c);
+		} catch (NoSuchMethodException e) {
+			throw sneakyThrow(e);
+		} catch (ClassNotFoundException e) {
+			throw sneakyThrow(e);
+		}
+	}
+	
+	public static JCTree getExtendsClause(JCClassDecl decl) {
 		try {
-			m = JCTree.class.getDeclaredMethod("getTag");
-		} catch (NoSuchMethodException e) {}
-		JCTREE_GETTAG = m;
+			return (JCTree) getExtendsClause.invoke(decl);
+		} catch (IllegalAccessException e) {
+			throw sneakyThrow(e);
+		} catch (InvocationTargetException e) {
+			throw sneakyThrow(e.getCause());
+		}
 	}
 	
-	public static int getTag(JCTree node) {
-		if (JCTREE_GETTAG != null) {
-			try {
-				return (Integer) JCTREE_GETTAG.invoke(node);
-			} catch (Exception e) {}
+	public static Object getDocComments(JCCompilationUnit cu) {
+		try {
+			return JCCOMPILATIONUNIT_DOCCOMMENTS.get(cu);
+		} catch (IllegalAccessException e) {
+			throw sneakyThrow(e);
+		}
+	}
+	
+	public static void initDocComments(JCCompilationUnit cu) {
+		try {
+			JCCOMPILATIONUNIT_DOCCOMMENTS.set(cu, new HashMap<Object, String>());
+		} catch (IllegalArgumentException e) {
+			// That's fine - we're on JDK8, we'll fix that later.
+		} catch (IllegalAccessException e) {
+			throw sneakyThrow(e);
 		}
+	}
+	
+	public static int getEndPosition(DiagnosticPosition pos, JCCompilationUnit top) {
 		try {
-			return (Integer) JCTREE_TAG.get(node);
-		} catch (Exception e) {
-			throw new IllegalStateException("Can't get node tag");
+			Object endPositions = JCCOMPILATIONUNIT_ENDPOSITIONS.get(top);
+			return (Integer) getEndPosition.invoke(pos, endPositions);
+		} catch (IllegalAccessException e) {
+			throw sneakyThrow(e);
+		} catch (InvocationTargetException e) {
+			throw sneakyThrow(e.getCause());
 		}
 	}
 	
-	private static Method method;
+	private static final Class<?> JC_VOID_TYPE, JC_NO_TYPE;
+	
+	static {
+		Class<?> c = null;
+		try {
+			c = Class.forName("com.sun.tools.javac.code.Type$JCVoidType");
+		} catch (Throwable ignore) {}
+		JC_VOID_TYPE = c;
+		c = null;
+		try {
+			c = Class.forName("com.sun.tools.javac.code.Type$JCNoType");
+		} catch (Throwable ignore) {}
+		JC_NO_TYPE = c;
+	}
 	
-	public static JCClassDecl ClassDef(TreeMaker maker, JCModifiers mods, Name name, List<JCTypeParameter> typarams, JCExpression extending, List<JCExpression> implementing, List<JCTree> defs) {
-		if (method == null) try {
-			method = TreeMaker.class.getDeclaredMethod("ClassDef", JCModifiers.class, Name.class, List.class, JCExpression.class, List.class, List.class);
-		} catch (NoSuchMethodException ignore) {}
-		if (method == null) try {
-			method = TreeMaker.class.getDeclaredMethod("ClassDef", JCModifiers.class, Name.class, List.class, JCTree.class, List.class, List.class);
-		} catch (NoSuchMethodException ignore) {}
+	public static Type createVoidType(JavacTreeMaker maker, TypeTag tag) {
+		if (Javac.getJavaCompilerVersion() < 8) {
+			return new JCNoType(((Integer) tag.value).intValue());
+		} else {
+			try {
+				if (CTC_VOID.equals(tag)) {
+					return (Type) JC_VOID_TYPE.newInstance();
+				} else {
+					return (Type) JC_NO_TYPE.newInstance();
+				}
+			} catch (IllegalAccessException e) {
+				throw sneakyThrow(e);
+			} catch (InstantiationException e) {
+				throw sneakyThrow(e);
+			}
+		}
+	}
+	
+	private static class JCNoType extends Type implements NoType {
+		public JCNoType(int tag) {
+			super(tag, null);
+		}
 		
-		if (method == null) throw new IllegalStateException("Lombok bug #20130617-1310: ClassDef doesn't look like anything we thought it would look like.");
-		if (!Modifier.isPublic(method.getModifiers()) && !method.isAccessible()) {
-			method.setAccessible(true);
+		@Override
+		public TypeKind getKind() {
+			if (tag == ((Integer) CTC_VOID.value).intValue()) return TypeKind.VOID;
+			if (tag == ((Integer) CTC_NONE.value).intValue()) return TypeKind.NONE;
+			throw new AssertionError("Unexpected tag: " + tag);
 		}
 		
-		try {
-			return (JCClassDecl) method.invoke(maker, mods, name, typarams, extending, implementing, defs);
-		} catch (InvocationTargetException e) {
-			throw sneakyThrow(e.getCause());
-		} catch (IllegalAccessException e) {
-			throw sneakyThrow(e.getCause());
+		@Override
+		public <R, P> R accept(TypeVisitor<R, P> v, P p) {
+			return v.visitNoType(this, p);
 		}
 	}
 	
-	private static RuntimeException sneakyThrow(Throwable t) {
+	private static final Field JCCOMPILATIONUNIT_ENDPOSITIONS, JCCOMPILATIONUNIT_DOCCOMMENTS;
+	static {
+		Field f = null;
+		try {
+			f = JCCompilationUnit.class.getDeclaredField("endPositions");
+		} catch (NoSuchFieldException e) {}
+		JCCOMPILATIONUNIT_ENDPOSITIONS = f;
+		
+		f = null;
+		try {
+			f = JCCompilationUnit.class.getDeclaredField("docComments");
+		} catch (NoSuchFieldException e) {}
+		JCCOMPILATIONUNIT_DOCCOMMENTS = f;
+	}
+	
+	static RuntimeException sneakyThrow(Throwable t) {
 		if (t == null) throw new NullPointerException("t");
 		Javac.<RuntimeException>sneakyThrow0(t);
 		return null;