Untangling patches to classes that only exist in eclipse, not ecj

Specifically, Rawi01's patches to make javadoc behaviour in eclipse better,
which cannot be applied to ecj as you get load errors (javadoc not a thing there).

As part of this commit, tests can be limited to ecj or eclipse, and I made cut-down
versions of a few tests (to run on ecj, as the main one cannot be, due to javadoc issues).

The tests now marked as eclipse only don't fail on ecj, but they don't generate the same
result. Alternatively, we could go with a separated out after-ecj and after-eclipse dir
instead, but that's perhaps going overboard.

4 files changed, 84 insertions, 33 deletions

diff --git a/src/core/lombok/eclipse/EclipseAugments.java b/src/core/lombok/eclipse/EcjAugments.java
index 783e25c9..965c4fb6 100644
--- a/src/core/lombok/eclipse/EclipseAugments.java
+++ b/src/core/lombok/eclipse/EcjAugments.java
@@ -33,8 +33,8 @@ import org.eclipse.jdt.internal.core.SourceMethod;
 
 import lombok.core.FieldAugment;
 
-public final class EclipseAugments {
-	private EclipseAugments() {
+public final class EcjAugments {
+	private EcjAugments() {
 		// Prevent instantiation
 	}
 	
@@ -42,6 +42,13 @@ public final class EclipseAugments {
 	public static final FieldAugment<ASTNode, Boolean> ASTNode_handled = FieldAugment.augment(ASTNode.class, boolean.class, "lombok$handled");
 	public static final FieldAugment<ASTNode, ASTNode> ASTNode_generatedBy = FieldAugment.augment(ASTNode.class, ASTNode.class, "$generatedBy");
 	public static final FieldAugment<Annotation, Boolean> Annotation_applied = FieldAugment.augment(Annotation.class, boolean.class, "lombok$applied");
-	public static final FieldAugment<CompilationUnit, Map<String, String>> CompilationUnit_javadoc = FieldAugment.augment(CompilationUnit.class, Map.class, "$javadoc");
-	public static final FieldAugment<CompilationUnit, ConcurrentMap<String, List<SourceMethod>>> CompilationUnit_delegateMethods = FieldAugment.augment(CompilationUnit.class, ConcurrentMap.class, "$delegateMethods");
+	
+	public static final class EclipseAugments {
+		private EclipseAugments() {
+			// Prevent instantiation
+		}
+		
+		public static final FieldAugment<CompilationUnit, Map<String, String>> CompilationUnit_javadoc = FieldAugment.augment(CompilationUnit.class, Map.class, "$javadoc");
+		public static final FieldAugment<CompilationUnit, ConcurrentMap<String, List<SourceMethod>>> CompilationUnit_delegateMethods = FieldAugment.augment(CompilationUnit.class, ConcurrentMap.class, "$delegateMethods");
+	}
 }
diff --git a/src/core/lombok/eclipse/HandlerLibrary.java b/src/core/lombok/eclipse/HandlerLibrary.java
index 0e72fb38..8d69325e 100644
--- a/src/core/lombok/eclipse/HandlerLibrary.java
+++ b/src/core/lombok/eclipse/HandlerLibrary.java
@@ -23,7 +23,7 @@ package lombok.eclipse;
 
 import static lombok.eclipse.Eclipse.*;
 import static lombok.eclipse.handlers.EclipseHandlerUtil.*;
-import static lombok.eclipse.EclipseAugments.ASTNode_handled;
+import static lombok.eclipse.EcjAugments.ASTNode_handled;
 
 import java.io.IOException;
 import java.lang.annotation.Annotation;
diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
index d85c2ee8..03f26341 100644
--- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
+++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
@@ -23,7 +23,7 @@ package lombok.eclipse.handlers;
 
 import static lombok.core.handlers.HandlerUtil.*;
 import static lombok.eclipse.Eclipse.*;
-import static lombok.eclipse.EclipseAugments.*;
+import static lombok.eclipse.EcjAugments.*;
 import static lombok.eclipse.handlers.EclipseHandlerUtil.EclipseReflectiveMembers.*;
 
 import java.lang.reflect.Array;
@@ -2649,22 +2649,42 @@ public class EclipseHandlerUtil {
 		return null;
 	}
 	
+	private static class EclipseOnlyUtil {
+		public static void setDocComment(CompilationUnitDeclaration cud, TypeDeclaration type, ASTNode node, String doc) {
+			if (cud.compilationResult.compilationUnit instanceof CompilationUnit) {
+				CompilationUnit compilationUnit = (CompilationUnit) cud.compilationResult.compilationUnit;
+				Map<String, String> docs = EclipseAugments.CompilationUnit_javadoc.setIfAbsent(compilationUnit, new HashMap<String, String>());
+				
+				if (node instanceof AbstractMethodDeclaration) {
+					AbstractMethodDeclaration methodDeclaration = (AbstractMethodDeclaration) node;
+					String signature = getSignature(type, methodDeclaration);
+					/* Add javadoc start marker, add leading asterisks to each line, add javadoc end marker */
+					docs.put(signature, String.format("/**%n%s%n */", doc.replaceAll("(?m)^", " * ")));
+				}
+			}
+		}
+	}
+	
+	private static Boolean eclipseMode;
+	private static boolean eclipseMode() {
+		if (eclipseMode != null) return eclipseMode.booleanValue();
+		try {
+			Class.forName("org.eclipse.jdt.internal.core.CompilationUnit");
+			eclipseMode = true;
+		} catch (Exception e) {
+			eclipseMode = false;
+		}
+		return eclipseMode;
+	}
+	
 	public static void setDocComment(CompilationUnitDeclaration cud, EclipseNode eclipseNode, String doc) {
+		if (!eclipseMode()) return;
 		setDocComment(cud, (TypeDeclaration) upToTypeNode(eclipseNode).get(), eclipseNode.get(), doc);
 	}
-	
+	 
 	public static void setDocComment(CompilationUnitDeclaration cud, TypeDeclaration type, ASTNode node, String doc) {
-		if (cud.compilationResult.compilationUnit instanceof CompilationUnit) {
-			CompilationUnit compilationUnit = (CompilationUnit) cud.compilationResult.compilationUnit;
-			Map<String, String> docs = CompilationUnit_javadoc.setIfAbsent(compilationUnit, new HashMap<String, String>());
-			
-			if (node instanceof AbstractMethodDeclaration) {
-				AbstractMethodDeclaration methodDeclaration = (AbstractMethodDeclaration) node;
-				String signature = getSignature(type, methodDeclaration);
-				/* Add javadoc start marker, add leading asterisks to each line, add javadoc end marker */
-				docs.put(signature, String.format("/**%n%s%n */", doc.replaceAll("(?m)^", " * ")));
-			}
-		}
+		if (!eclipseMode()) return;
+		EclipseOnlyUtil.setDocComment(cud, type, node, doc);
 	}
 	
 	public static String getSignature(TypeDeclaration type, AbstractMethodDeclaration methodDeclaration) {
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index 2379d0a0..5ff29758 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -144,12 +144,12 @@ public class JavacHandlerUtil {
 		Options options = Options.instance(context);
 		return (options.keySet().contains("ide") && !options.keySet().contains("backgroundCompilation"));
 	}
-
+	
 	public static boolean inNetbeansCompileOnSave(Context context) {
 		Options options = Options.instance(context);
 		return (options.keySet().contains("ide") && options.keySet().contains("backgroundCompilation"));
 	}
-
+	
 	public static JCTree getGeneratedBy(JCTree node) {
 		return JCTree_generatedNode.get(node);
 	}
@@ -1026,7 +1026,7 @@ public class JavacHandlerUtil {
 	public static JavacNode injectField(JavacNode typeNode, JCVariableDecl field) {
 		return injectField(typeNode, field, false);
 	}
-
+	
 	public static JavacNode injectField(JavacNode typeNode, JCVariableDecl field, boolean addGenerated) {
 		return injectField(typeNode, field, addGenerated, false);
 	}
@@ -1076,6 +1076,17 @@ public class JavacHandlerUtil {
 		private static Constructor<?> CONSTRUCTOR;
 		private static Field ANNOTATIONS, UNDERLYING_TYPE;
 		
+		private static void initByLoader(ClassLoader classLoader) {
+			if (TYPE != null) return;
+			Class<?> c;
+			try {
+				c = classLoader.loadClass("com.sun.tools.javac.tree.JCTree$JCAnnotatedType");
+			} catch (Exception e) {
+				return;
+			}
+			init(c);
+		}
+		
 		private static void init(Class<?> in) {
 			if (TYPE != null) return;
 			if (!in.getName().equals("com.sun.tools.javac.tree.JCTree$JCAnnotatedType")) return;
@@ -1120,17 +1131,18 @@ public class JavacHandlerUtil {
 		}
 		
 		static JCExpression create(List<JCAnnotation> annotations, JCExpression underlyingType) {
+			initByLoader(underlyingType.getClass().getClassLoader());
 			try {
 				return (JCExpression) CONSTRUCTOR.newInstance(annotations, underlyingType);
 			} catch (Exception e) {
-				return null;
+				return underlyingType;
 			}
 		}
 	}
-
+	
 	static class JCAnnotationReflect {
 		private static Field ATTRIBUTE;
-
+		
 		static {
 			try {
 				ATTRIBUTE = Permit.getField(JCAnnotation.class, "attribute");
@@ -1199,7 +1211,7 @@ public class JavacHandlerUtil {
 		Context context = typeNode.getContext();
 		Symtab symtab = Symtab.instance(context);
 		JCClassDecl type = (JCClassDecl) typeNode.get();
-
+		
 		if (method.getName().contentEquals("<init>")) {
 			//Scan for default constructor, and remove it.
 			int idx = 0;
@@ -1216,11 +1228,11 @@ public class JavacHandlerUtil {
 				idx++;
 			}
 		}
-
+		
 		addSuppressWarningsAll(method.mods, typeNode, method.pos, getGeneratedBy(method), typeNode.getContext());
 		addGenerated(method.mods, typeNode, method.pos, getGeneratedBy(method), typeNode.getContext());
 		type.defs = type.defs.append(method);
-
+		
 		List<Symbol.VarSymbol> params = null;
 		if (method.getParameters() != null && !method.getParameters().isEmpty()) {
 			ListBuffer<Symbol.VarSymbol> newParams = new ListBuffer<Symbol.VarSymbol>();
@@ -1250,12 +1262,12 @@ public class JavacHandlerUtil {
 			params = newParams.toList();
 			if (params.length() != method.getParameters().length()) params = null;
 		}
-
+		
 		fixMethodMirror(typeNode.getContext(), typeNode.getElement(), method.getModifiers().flags, method.getName(), paramTypes, params, returnType);
-
+		
 		typeNode.add(method, Kind.METHOD);
 	}
-
+	
 	private static void fixMethodMirror(Context context, Element typeMirror, long access, Name methodName, List<Type> paramTypes, List<Symbol.VarSymbol> params, Type returnType) {
 		if (typeMirror == null || paramTypes == null || returnType == null) return;
 		ClassSymbol cs = (ClassSymbol) typeMirror;
@@ -1428,6 +1440,7 @@ public class JavacHandlerUtil {
 		}
 		return e;
 	}
+	
 	/**
 	 * In javac, dotted access of any kind, from {@code java.lang.String} to {@code var.methodName}
 	 * is represented by a fold-left of {@code Select} nodes with the leftmost string represented by
@@ -1831,20 +1844,30 @@ public class JavacHandlerUtil {
 	public static JCExpression namePlusTypeParamsToTypeReference(JavacTreeMaker maker, JavacNode type, List<JCTypeParameter> params) {
 		JCClassDecl td = (JCClassDecl) type.get();
 		boolean instance = (td.mods.flags & Flags.STATIC) == 0;
-		return namePlusTypeParamsToTypeReference(maker, type.up(), td.name, instance, params);
+		return namePlusTypeParamsToTypeReference(maker, type.up(), td.name, instance, params, List.<JCAnnotation>nil());
+	}
+	
+	public static JCExpression namePlusTypeParamsToTypeReference(JavacTreeMaker maker, JavacNode type, List<JCTypeParameter> params, List<JCAnnotation> annotations) {
+		JCClassDecl td = (JCClassDecl) type.get();
+		boolean instance = (td.mods.flags & Flags.STATIC) == 0;
+		return namePlusTypeParamsToTypeReference(maker, type.up(), td.name, instance, params, annotations);
 	}
 	
 	public static JCExpression namePlusTypeParamsToTypeReference(JavacTreeMaker maker, JavacNode parentType, Name typeName, boolean instance, List<JCTypeParameter> params) {
+		return namePlusTypeParamsToTypeReference(maker, parentType, typeName, instance, params, List.<JCAnnotation>nil());
+	}
+	
+	public static JCExpression namePlusTypeParamsToTypeReference(JavacTreeMaker maker, JavacNode parentType, Name typeName, boolean instance, List<JCTypeParameter> params, List<JCAnnotation> annotations) {
 		JCExpression r = null;
-		
 		if (parentType != null && parentType.getKind() == Kind.TYPE) {
 			JCClassDecl td = (JCClassDecl) parentType.get();
 			boolean outerInstance = instance && ((td.mods.flags & Flags.STATIC) == 0);
 			List<JCTypeParameter> outerParams = instance ? td.typarams : List.<JCTypeParameter>nil();
-			r = namePlusTypeParamsToTypeReference(maker, parentType.up(), td.name, outerInstance, outerParams);
+			r = namePlusTypeParamsToTypeReference(maker, parentType.up(), td.name, outerInstance, outerParams, List.<JCAnnotation>nil());
 		}
 		
 		r = r == null ? maker.Ident(typeName) : maker.Select(r, typeName);
+		if (!annotations.isEmpty()) r = JCAnnotatedTypeReflect.create(annotations, r);
 		if (!params.isEmpty()) r = maker.TypeApply(r, typeParameterNames(maker, params));
 		return r;
 	}
@@ -2078,6 +2101,7 @@ public class JavacHandlerUtil {
 	public static void copyJavadoc(JavacNode from, JCTree to, CopyJavadoc copyMode) {
 		copyJavadoc(from, to, copyMode, false);
 	}
+	
 	/**
 	 * Copies javadoc on one node to the other.
 	 *