Merge remote-tracking branch 'rzwitserloot/master'

1 files changed, 93 insertions, 48 deletions

diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index 949c9f5c..68d8061c 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -92,6 +92,7 @@ import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
 import com.sun.tools.javac.tree.JCTree.JCWildcard;
 import com.sun.tools.javac.tree.JCTree.TypeBoundKind;
+import com.sun.tools.javac.tree.TreeMaker;
 import com.sun.tools.javac.tree.TreeScanner;
 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
@@ -894,16 +895,20 @@ public class JavacHandlerUtil {
 	static class ClassSymbolMembersField {
 		private static final Field membersField;
 		private static final Method removeMethod;
+		private static final Method enterMethod;
 		
 		static {
 			Field f = null;
-			Method m = null;
+			Method r = null;
+			Method e = null;
 			try {
 				f = ClassSymbol.class.getField("members_field");
-				m = f.getType().getMethod("remove", Symbol.class);
-			} catch (Exception e) {}
+				r = f.getType().getMethod("remove", Symbol.class);
+				e = f.getType().getMethod("enter", Symbol.class);
+			} catch (Exception ex) {}
 			membersField = f;
-			removeMethod = m;
+			removeMethod = r;
+			enterMethod = e;
 		}
 		
 		static void remove(ClassSymbol from, Symbol toRemove) {
@@ -914,6 +919,15 @@ public class JavacHandlerUtil {
 				removeMethod.invoke(scope, toRemove);
 			} catch (Exception e) {}
 		}
+		
+		static void enter(ClassSymbol from, Symbol toEnter) {
+			if (from == null) return;
+			try {
+				Scope scope = (Scope) membersField.get(from);
+				if (scope == null) return;
+				enterMethod.invoke(scope, toEnter);
+			} catch (Exception e) {}
+		}
 	}
 	
 	public static void injectMethod(JavacNode typeNode, JCMethodDecl method) {
@@ -959,7 +973,7 @@ public class JavacHandlerUtil {
 		if (typeMirror == null || paramTypes == null || returnType == null) return;
 		ClassSymbol cs = (ClassSymbol) typeMirror;
 		MethodSymbol methodSymbol = new MethodSymbol(access, methodName, new MethodType(paramTypes, returnType, List.<Type>nil(), Symtab.instance(context).methodClass), cs);
-		cs.members_field.enter(methodSymbol);
+		ClassSymbolMembersField.enter(cs, methodSymbol);
 	}
 	
 	/**
@@ -1025,10 +1039,10 @@ public class JavacHandlerUtil {
 	public static void addGenerated(JCModifiers mods, JavacNode node, int pos, JCTree source, Context context) {
 		if (!LombokOptionsFactory.getDelombokOptions(context).getFormatPreferences().generateGenerated()) return;
 		
-		if (HandlerUtil.shouldAddGenerated(node, ConfigurationKeys.ADD_JAVAX_GENERATED_ANNOTATIONS)) {
+		if (HandlerUtil.shouldAddGenerated(node)) {
 			addAnnotation(mods, node, pos, source, context, "javax.annotation.Generated", node.getTreeMaker().Literal("lombok"));
 		}
-		if (HandlerUtil.shouldAddGenerated(node, ConfigurationKeys.ADD_LOMBOK_GENERATED_ANNOTATIONS)) {
+		if (Boolean.TRUE.equals(node.getAst().readConfiguration(ConfigurationKeys.ADD_LOMBOK_GENERATED_ANNOTATIONS))) {
 			addAnnotation(mods, node, pos, source, context, "lombok.Generated", null);
 		}
 	}
@@ -1233,19 +1247,9 @@ public class JavacHandlerUtil {
 		ListBuffer<JCExpression> params = new ListBuffer<JCExpression>();
 		ListBuffer<JCAnnotation> result = new ListBuffer<JCAnnotation>();
 		
-		try {
-			for (JCExpression arg : ast.args) {
-				String argName = "value";
-				if (arg instanceof JCAssign) {
-					JCAssign as = (JCAssign) arg;
-					argName = as.lhs.toString();
-				}
-				if (!argName.equals(parameterName)) continue;
-			}
-		} catch (Exception ignore) {}
-		
 		outer:
 		for (JCExpression param : ast.args) {
+			boolean allowRaw;
 			String nameOfParam = "value";
 			JCExpression valueOfParam = null;
 			if (param instanceof JCAssign) {
@@ -1257,6 +1261,15 @@ public class JavacHandlerUtil {
 				valueOfParam = assign.rhs;
 			}
 			
+			/* strip trailing underscores */ {
+				int lastIdx;
+				for (lastIdx = nameOfParam.length() ; lastIdx > 0; lastIdx--) {
+					if (nameOfParam.charAt(lastIdx - 1) != '_') break;
+				}
+				allowRaw = lastIdx < nameOfParam.length();
+				nameOfParam = nameOfParam.substring(0, lastIdx);
+			}
+			
 			if (!parameterName.equals(nameOfParam)) {
 				params.append(param);
 				continue outer;
@@ -1269,52 +1282,84 @@ public class JavacHandlerUtil {
 				String dummyAnnotationName = ((JCAnnotation) valueOfParam).annotationType.toString();
 				dummyAnnotationName = dummyAnnotationName.replace("_", "").replace("$", "").replace("x", "").replace("X", "");
 				if (dummyAnnotationName.length() > 0) {
-					annotationNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
-					continue outer;
-				}
-				for (JCExpression expr : ((JCAnnotation) valueOfParam).args) {
-					if (expr instanceof JCAssign && ((JCAssign) expr).lhs instanceof JCIdent) {
-						JCIdent id = (JCIdent) ((JCAssign) expr).lhs;
-						if ("value".equals(id.name.toString())) {
-							expr = ((JCAssign) expr).rhs;
-						} else {
-							annotationNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
-							continue outer;
-						}
+					if (allowRaw) {
+						result.append((JCAnnotation) valueOfParam);
+					} else {
+						addError(errorName, annotationNode);
+						continue outer;
 					}
-					
-					if (expr instanceof JCAnnotation) {
-						result.append((JCAnnotation) expr);
-					} else if (expr instanceof JCNewArray) {
-						for (JCExpression expr2 : ((JCNewArray) expr).elems) {
-							if (expr2 instanceof JCAnnotation) {
-								result.append((JCAnnotation) expr2);
+				} else {
+					for (JCExpression expr : ((JCAnnotation) valueOfParam).args) {
+						if (expr instanceof JCAssign && ((JCAssign) expr).lhs instanceof JCIdent) {
+							JCIdent id = (JCIdent) ((JCAssign) expr).lhs;
+							if ("value".equals(id.name.toString())) {
+								expr = ((JCAssign) expr).rhs;
 							} else {
-								annotationNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
-								continue outer;
+								addError(errorName, annotationNode);
 							}
 						}
-					} else {
-						annotationNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
-						continue outer;
+						
+						if (expr instanceof JCAnnotation) {
+							result.append((JCAnnotation) expr);
+						} else if (expr instanceof JCNewArray) {
+							for (JCExpression expr2 : ((JCNewArray) expr).elems) {
+								if (expr2 instanceof JCAnnotation) {
+									result.append((JCAnnotation) expr2);
+								} else {
+									addError(errorName, annotationNode);
+									continue outer;
+								}
+							}
+						} else {
+							addError(errorName, annotationNode);
+							continue outer;
+						}
 					}
 				}
-			} else {
-				if (valueOfParam instanceof JCNewArray && ((JCNewArray) valueOfParam).elems.isEmpty()) {
-					// Then we just remove it and move on (it's onMethod={} for example).
+			} else if (valueOfParam instanceof JCNewArray) {
+				JCNewArray arr = (JCNewArray) valueOfParam;
+				if (arr.elems.isEmpty()) {
+					// Just remove it, this is always fine.
+				} else if (allowRaw) {
+					for (JCExpression jce : arr.elems) {
+						if (jce instanceof JCAnnotation) result.append((JCAnnotation) jce);
+						else addError(errorName, annotationNode);
+					}
 				} else {
-					annotationNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
+					addError(errorName, annotationNode);
 				}
+			} else {
+				addError(errorName, annotationNode);
 			}
 		}
 		ast.args = params.toList();
 		return result.toList();
 	}
 	
-	public static List<JCTypeParameter> copyTypeParams(JavacTreeMaker maker, List<JCTypeParameter> params) {
+	private static void addError(String errorName, JavacNode node) {
+		if (node.getLatestJavaSpecSupported() < 8) {
+			node.addError("The correct format up to JDK7 is " + errorName + "=@__({@SomeAnnotation, @SomeOtherAnnotation}))");
+		} else {
+			node.addError("The correct format for JDK8+ is " + errorName + "_={@SomeAnnotation, @SomeOtherAnnotation})");
+		}
+	}
+	
+	public static List<JCTypeParameter> copyTypeParams(JavacNode source, List<JCTypeParameter> params) {
 		if (params == null || params.isEmpty()) return params;
 		ListBuffer<JCTypeParameter> out = new ListBuffer<JCTypeParameter>();
-		for (JCTypeParameter tp : params) out.append(maker.TypeParameter(tp.name, tp.bounds));
+		JavacTreeMaker maker = source.getTreeMaker();
+		Context context = source.getContext();
+		for (JCTypeParameter tp : params) {
+			List<JCExpression> bounds = tp.bounds;
+			if (bounds != null && !bounds.isEmpty()) {
+				ListBuffer<JCExpression> boundsCopy = new ListBuffer<JCExpression>();
+				for (JCExpression expr : tp.bounds) {
+					boundsCopy.append(cloneType(maker, expr, source.get(), context));
+				}
+				bounds = boundsCopy.toList();
+			}
+			out.append(maker.TypeParameter(tp.name, bounds));
+		}
 		return out.toList();
 	}