Merge remote-tracking branch 'rzwitserloot/master'

8 files changed, 132 insertions, 94 deletions

diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
index f822e095..4726b17e 100644
--- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
+++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
@@ -1345,10 +1345,10 @@ public class EclipseHandlerUtil {
 	
 	public static Annotation[] addGenerated(EclipseNode node, ASTNode source, Annotation[] originalAnnotationArray) {
 		Annotation[] result = originalAnnotationArray;
-		if (HandlerUtil.shouldAddGenerated(node, ConfigurationKeys.ADD_JAVAX_GENERATED_ANNOTATIONS)) {
+		if (HandlerUtil.shouldAddGenerated(node)) {
 			result = addAnnotation(source, result, JAVAX_ANNOTATION_GENERATED, new StringLiteral(LOMBOK, 0, 0, 0));
 		}
-		if (HandlerUtil.shouldAddGenerated(node, ConfigurationKeys.ADD_LOMBOK_GENERATED_ANNOTATIONS)) {
+		if (Boolean.TRUE.equals(node.getAst().readConfiguration(ConfigurationKeys.ADD_LOMBOK_GENERATED_ANNOTATIONS))) {
 			result = addAnnotation(source, result, LOMBOK_GENERATED, null);
 		}
 		return result;
@@ -1616,6 +1616,14 @@ public class EclipseHandlerUtil {
 		return true;
 	}
 	
+	public static void addError(String errorName, EclipseNode node) {
+		if (node.getLatestJavaSpecSupported() < 8) {
+			node.addError("The correct format is " + errorName + "_={@SomeAnnotation, @SomeOtherAnnotation})");
+		} else {
+			node.addError("The correct format is " + errorName + "=@__({@SomeAnnotation, @SomeOtherAnnotation}))");
+		}
+	}
+	
 	public static List<Annotation> unboxAndRemoveAnnotationParameter(Annotation annotation, String annotationName, String errorName, EclipseNode errorNode) {
 		if ("value".equals(annotationName)) {
 			// We can't unbox this, because SingleMemberAnnotation REQUIRES a value, and this method
@@ -1638,51 +1646,70 @@ public class EclipseHandlerUtil {
 		
 		char[] nameAsCharArray = annotationName.toCharArray();
 		
+		top:
 		for (int i = 0; i < pairs.length; i++) {
-			if (pairs[i].name == null || !Arrays.equals(nameAsCharArray, pairs[i].name)) continue;
+			boolean allowRaw;
+			char[] name = pairs[i].name;
+			if (name == null) continue;
+			if (name.length < nameAsCharArray.length) continue;
+			for (int j = 0; j < nameAsCharArray.length; j++) {
+				if (name[j] != nameAsCharArray[j]) continue top;
+			}
+			allowRaw = name.length > nameAsCharArray.length;
+			for (int j = nameAsCharArray.length; j < name.length; j++) {
+				if (name[j] != '_') continue top;
+			}
+			// If we're still here it's the targeted annotation param.
 			Expression value = pairs[i].value;
 			MemberValuePair[] newPairs = new MemberValuePair[pairs.length - 1];
 			if (i > 0) System.arraycopy(pairs, 0, newPairs, 0, i);
 			if (i < pairs.length - 1) System.arraycopy(pairs, i + 1, newPairs, i, pairs.length - i - 1);
 			normalAnnotation.memberValuePairs = newPairs;
-			// We have now removed the annotation parameter and stored '@__({... annotations ...})',
-			// which we must now unbox.
-			if (!(value instanceof Annotation)) {
-				errorNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
-				return Collections.emptyList();
-			}
-			
-			Annotation atDummyIdentifier = (Annotation) value;
-			if (!(atDummyIdentifier.type instanceof SingleTypeReference) ||
-					!isAllValidOnXCharacters(((SingleTypeReference) atDummyIdentifier.type).token)) {
-				errorNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
-				return Collections.emptyList();
-			}
-			
-			if (atDummyIdentifier instanceof MarkerAnnotation) {
-				// It's @Getter(onMethod=@__). This is weird, but fine.
-				return Collections.emptyList();
-			}
+			// We have now removed the annotation parameter and stored the value,
+			// which we must now unbox. It's either annotations, or @__(annotations).
 			
 			Expression content = null;
 			
-			if (atDummyIdentifier instanceof NormalAnnotation) {
-				MemberValuePair[] mvps = ((NormalAnnotation) atDummyIdentifier).memberValuePairs;
-				if (mvps == null || mvps.length == 0) {
-					// It's @Getter(onMethod=@__()). This is weird, but fine.
+			if (value instanceof ArrayInitializer) {
+				if (!allowRaw) {
+					addError(errorName, errorNode);
 					return Collections.emptyList();
 				}
-				if (mvps.length == 1 && Arrays.equals("value".toCharArray(), mvps[0].name)) {
-					content = mvps[0].value;
+				content = value;
+			} else if (!(value instanceof Annotation)) {
+				addError(errorName, errorNode);
+				return Collections.emptyList();
+			} else {
+				Annotation atDummyIdentifier = (Annotation) value;
+				if (atDummyIdentifier.type instanceof SingleTypeReference && isAllValidOnXCharacters(((SingleTypeReference) atDummyIdentifier.type).token)) {
+					if (atDummyIdentifier instanceof MarkerAnnotation) {
+						return Collections.emptyList();
+					} else if (atDummyIdentifier instanceof NormalAnnotation) {
+						MemberValuePair[] mvps = ((NormalAnnotation) atDummyIdentifier).memberValuePairs;
+						if (mvps == null || mvps.length == 0) {
+							return Collections.emptyList();
+						}
+						if (mvps.length == 1 && Arrays.equals("value".toCharArray(), mvps[0].name)) {
+							content = mvps[0].value;
+						}
+					} else if (atDummyIdentifier instanceof SingleMemberAnnotation) {
+						content = ((SingleMemberAnnotation) atDummyIdentifier).memberValue;
+					} else {
+						addError(errorName, errorNode);
+						return Collections.emptyList();
+					}
+				} else {
+					if (allowRaw) {
+						content = atDummyIdentifier;
+					} else {
+						addError(errorName, errorNode);
+						return Collections.emptyList();
+					}
 				}
 			}
 			
-			if (atDummyIdentifier instanceof SingleMemberAnnotation) {
-				content = ((SingleMemberAnnotation) atDummyIdentifier).memberValue;
-			}
-			
 			if (content == null) {
-				errorNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
+				addError(errorName, errorNode);
 				return Collections.emptyList();
 			}
 			
@@ -1694,13 +1721,13 @@ public class EclipseHandlerUtil {
 				if (expressions != null) for (Expression ex : expressions) {
 					if (ex instanceof Annotation) result.add((Annotation) ex);
 					else {
-						errorNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
+						addError(errorName, errorNode);
 						return Collections.emptyList();
 					}
 				}
 				return result;
 			} else {
-				errorNode.addError("The correct format is " + errorName + "@__({@SomeAnnotation, @SomeOtherAnnotation}))");
+				addError(errorName, errorNode);
 				return Collections.emptyList();
 			}
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleBuilder.java b/src/core/lombok/eclipse/handlers/HandleBuilder.java
index afa03538..8c200a94 100644
--- a/src/core/lombok/eclipse/handlers/HandleBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleBuilder.java
@@ -189,7 +189,7 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 				allFields.add(fieldNode);
 			}
 			
-			new HandleConstructor().generateConstructor(tdParent, AccessLevel.PACKAGE, allFields, false, null, SkipIfConstructorExists.I_AM_BUILDER, null,
+			new HandleConstructor().generateConstructor(tdParent, AccessLevel.PACKAGE, allFields, false, null, SkipIfConstructorExists.I_AM_BUILDER,
 				Collections.<Annotation>emptyList(), annotationNode);
 			
 			returnType = namePlusTypeParamsToTypeReference(td.name, td.typeParameters, p);
@@ -395,7 +395,7 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		
 		if (constructorExists(builderType) == MemberExistsResult.NOT_EXISTS) {
 			ConstructorDeclaration cd = HandleConstructor.createConstructor(
-				AccessLevel.PACKAGE, builderType, Collections.<EclipseNode>emptyList(), false, null,
+				AccessLevel.PACKAGE, builderType, Collections.<EclipseNode>emptyList(), false,
 				annotationNode, Collections.<Annotation>emptyList());
 			if (cd != null) injectMethod(builderType, cd);
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleConstructor.java b/src/core/lombok/eclipse/handlers/HandleConstructor.java
index a3b0585d..49b09231 100644
--- a/src/core/lombok/eclipse/handlers/HandleConstructor.java
+++ b/src/core/lombok/eclipse/handlers/HandleConstructor.java
@@ -93,9 +93,9 @@ public class HandleConstructor {
 			boolean force = ann.force();
 			
 			List<EclipseNode> fields = force ? findFinalFields(typeNode) : Collections.<EclipseNode>emptyList();
-			List<Annotation> onConstructor = unboxAndRemoveAnnotationParameter(ast, "onConstructor", "@NoArgsConstructor(onConstructor=", annotationNode);
+			List<Annotation> onConstructor = unboxAndRemoveAnnotationParameter(ast, "onConstructor", "@NoArgsConstructor(onConstructor", annotationNode);
 			
-			new HandleConstructor().generateConstructor(typeNode, level, fields, force, staticName, SkipIfConstructorExists.NO, null, onConstructor, annotationNode);
+			new HandleConstructor().generateConstructor(typeNode, level, fields, force, staticName, SkipIfConstructorExists.NO, onConstructor, annotationNode);
 		}
 	}
 	
@@ -110,18 +110,15 @@ public class HandleConstructor {
 			AccessLevel level = ann.access();
 			if (level == AccessLevel.NONE) return;
 			String staticName = ann.staticName();
-			Boolean suppressConstructorProperties = null;
 			if (annotation.isExplicit("suppressConstructorProperties")) {
-				@SuppressWarnings("deprecation")
-				boolean suppress = ann.suppressConstructorProperties();
-				suppressConstructorProperties = suppress;
+				annotationNode.addError("This deprecated feature is no longer supported. Remove it; you can create a lombok.config file with 'lombok.anyConstructor.suppressConstructorProperties = true'.");
 			}
 			
-			List<Annotation> onConstructor = unboxAndRemoveAnnotationParameter(ast, "onConstructor", "@RequiredArgsConstructor(onConstructor=", annotationNode);
+			List<Annotation> onConstructor = unboxAndRemoveAnnotationParameter(ast, "onConstructor", "@RequiredArgsConstructor(onConstructor", annotationNode);
 			
 			new HandleConstructor().generateConstructor(
 				typeNode, level, findRequiredFields(typeNode), false, staticName, SkipIfConstructorExists.NO,
-				suppressConstructorProperties, onConstructor, annotationNode);
+				onConstructor, annotationNode);
 		}
 	}
 	
@@ -172,18 +169,15 @@ public class HandleConstructor {
 			AccessLevel level = ann.access();
 			if (level == AccessLevel.NONE) return;
 			String staticName = ann.staticName();
-			Boolean suppressConstructorProperties = null;
 			if (annotation.isExplicit("suppressConstructorProperties")) {
-				@SuppressWarnings("deprecation")
-				boolean suppress = ann.suppressConstructorProperties();
-				suppressConstructorProperties = suppress;
+				annotationNode.addError("This deprecated feature is no longer supported. Remove it; you can create a lombok.config file with 'lombok.anyConstructor.suppressConstructorProperties = true'.");
 			}
 			
-			List<Annotation> onConstructor = unboxAndRemoveAnnotationParameter(ast, "onConstructor", "@AllArgsConstructor(onConstructor=", annotationNode);
+			List<Annotation> onConstructor = unboxAndRemoveAnnotationParameter(ast, "onConstructor", "@AllArgsConstructor(onConstructor", annotationNode);
 			
 			new HandleConstructor().generateConstructor(
 				typeNode, level, findAllFields(typeNode), false, staticName, SkipIfConstructorExists.NO,
-				suppressConstructorProperties, onConstructor, annotationNode);
+				onConstructor, annotationNode);
 		}
 	}
 	
@@ -205,14 +199,14 @@ public class HandleConstructor {
 			EclipseNode typeNode, AccessLevel level, String staticName, SkipIfConstructorExists skipIfConstructorExists,
 			List<Annotation> onConstructor, EclipseNode sourceNode) {
 		
-		generateConstructor(typeNode, level, findRequiredFields(typeNode), false, staticName, skipIfConstructorExists, null, onConstructor, sourceNode);
+		generateConstructor(typeNode, level, findRequiredFields(typeNode), false, staticName, skipIfConstructorExists, onConstructor, sourceNode);
 	}
 	
 	public void generateAllArgsConstructor(
 			EclipseNode typeNode, AccessLevel level, String staticName, SkipIfConstructorExists skipIfConstructorExists,
 			List<Annotation> onConstructor, EclipseNode sourceNode) {
 		
-		generateConstructor(typeNode, level, findAllFields(typeNode), false, staticName, skipIfConstructorExists, null, onConstructor, sourceNode);
+		generateConstructor(typeNode, level, findAllFields(typeNode), false, staticName, skipIfConstructorExists, onConstructor, sourceNode);
 	}
 	
 	public enum SkipIfConstructorExists {
@@ -221,7 +215,7 @@ public class HandleConstructor {
 	
 	public void generateConstructor(
 		EclipseNode typeNode, AccessLevel level, List<EclipseNode> fields, boolean allToDefault, String staticName, SkipIfConstructorExists skipIfConstructorExists,
-		Boolean suppressConstructorProperties, List<Annotation> onConstructor, EclipseNode sourceNode) {
+		List<Annotation> onConstructor, EclipseNode sourceNode) {
 		
 		ASTNode source = sourceNode.get();
 		boolean staticConstrRequired = staticName != null && !staticName.equals("");
@@ -256,7 +250,7 @@ public class HandleConstructor {
 		
 		ConstructorDeclaration constr = createConstructor(
 			staticConstrRequired ? AccessLevel.PRIVATE : level, typeNode, fields, allToDefault,
-			suppressConstructorProperties, sourceNode, onConstructor);
+			sourceNode, onConstructor);
 		injectMethod(typeNode, constr);
 		if (staticConstrRequired) {
 			MethodDeclaration staticConstr = createStaticConstructor(level, staticName, typeNode, allToDefault ? Collections.<EclipseNode>emptyList() : fields, source);
@@ -298,7 +292,7 @@ public class HandleConstructor {
 	
 	public static ConstructorDeclaration createConstructor(
 		AccessLevel level, EclipseNode type, Collection<EclipseNode> fields, boolean allToDefault,
-		Boolean suppressConstructorProperties, EclipseNode sourceNode, List<Annotation> onConstructor) {
+		EclipseNode sourceNode, List<Annotation> onConstructor) {
 		
 		ASTNode source = sourceNode.get();
 		TypeDeclaration typeDeclaration = ((TypeDeclaration) type.get());
@@ -308,12 +302,11 @@ public class HandleConstructor {
 		
 		if (isEnum) level = AccessLevel.PRIVATE;
 		
-		if (suppressConstructorProperties == null) {
-			if (fields.isEmpty()) {
-				suppressConstructorProperties = false;
-			} else {
-				suppressConstructorProperties = Boolean.TRUE.equals(type.getAst().readConfiguration(ConfigurationKeys.ANY_CONSTRUCTOR_SUPPRESS_CONSTRUCTOR_PROPERTIES));
-			}
+		boolean suppressConstructorProperties;
+		if (fields.isEmpty()) {
+			suppressConstructorProperties = false;
+		} else {
+			suppressConstructorProperties = Boolean.TRUE.equals(type.getAst().readConfiguration(ConfigurationKeys.ANY_CONSTRUCTOR_SUPPRESS_CONSTRUCTOR_PROPERTIES));
 		}
 		
 		ConstructorDeclaration constructor = new ConstructorDeclaration(((CompilationUnitDeclaration) type.top().get()).compilationResult);
diff --git a/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
index a56eee89..ceef3d3c 100644
--- a/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
+++ b/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
@@ -67,6 +67,7 @@ import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.NameReference;
 import org.eclipse.jdt.internal.compiler.ast.NullLiteral;
 import org.eclipse.jdt.internal.compiler.ast.OperatorIds;
+import org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;
 import org.eclipse.jdt.internal.compiler.ast.ParameterizedSingleTypeReference;
 import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
 import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
@@ -128,7 +129,7 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
 		List<String> includes = Arrays.asList(ann.of());
 		EclipseNode typeNode = annotationNode.up();
 		
-		List<Annotation> onParam = unboxAndRemoveAnnotationParameter(ast, "onParam", "@EqualsAndHashCode(onParam=", annotationNode);
+		List<Annotation> onParam = unboxAndRemoveAnnotationParameter(ast, "onParam", "@EqualsAndHashCode(onParam", annotationNode);
 		checkForBogusFieldNames(typeNode, annotation);
 		
 		Boolean callSuper = ann.callSuper();
@@ -458,7 +459,14 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
 		return assignment;
 	}
 	
-	public TypeReference createTypeReference(EclipseNode type, long p) {
+	/**
+	 * @param type Type to 'copy' into a typeref
+	 * @param p position
+	 * @param addWildcards If false, all generics are cut off. If true, replaces all genericparams with a ?.
+	 * @return
+	 */
+	public TypeReference createTypeReference(EclipseNode type, long p, ASTNode source, boolean addWildcards) {
+		int pS = source.sourceStart; int pE = source.sourceEnd;
 		List<String> list = new ArrayList<String>();
 		list.add(type.getName());
 		EclipseNode tNode = type.up();
@@ -468,21 +476,44 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
 		}
 		Collections.reverse(list);
 		
-		if (list.size() == 1) return new SingleTypeReference(list.get(0).toCharArray(), p);
+		TypeDeclaration typeDecl = (TypeDeclaration) type.get();
+		int typeParamCount = typeDecl.typeParameters == null ? 0 : typeDecl.typeParameters.length;
+		if (typeParamCount == 0) addWildcards = false;
+		TypeReference[] typeArgs = null;
+		if (addWildcards) {
+			typeArgs = new TypeReference[typeParamCount];
+			for (int i = 0; i < typeParamCount; i++) {
+				typeArgs[i] = new Wildcard(Wildcard.UNBOUND);
+				typeArgs[i].sourceStart = pS; typeArgs[i].sourceEnd = pE;
+				setGeneratedBy(typeArgs[i], source);
+			}
+		}
+		
+		if (list.size() == 1) {
+			if (addWildcards) {
+				return new ParameterizedSingleTypeReference(list.get(0).toCharArray(), typeArgs, 0, p);
+			} else {
+				return new SingleTypeReference(list.get(0).toCharArray(), p);
+			}
+		}
 		long[] ps = new long[list.size()];
 		char[][] tokens = new char[list.size()][];
 		for (int i = 0; i < list.size(); i++) {
 			ps[i] = p;
 			tokens[i] = list.get(i).toCharArray();
 		}
-		
-		return new QualifiedTypeReference(tokens, ps);
+		if (addWildcards) {
+			TypeReference[][] typeArgs2 = new TypeReference[tokens.length][];
+			typeArgs2[typeArgs2.length - 1] = typeArgs;
+			return new ParameterizedQualifiedTypeReference(tokens, typeArgs2, 0, ps);
+		} else {
+			return new QualifiedTypeReference(tokens, ps);
+		}
 	}
 	
 	public MethodDeclaration createEquals(EclipseNode type, Collection<EclipseNode> fields, boolean callSuper, ASTNode source, FieldAccess fieldAccess, boolean needsCanEqual, List<Annotation> onParam) {
 		int pS = source.sourceStart; int pE = source.sourceEnd;
 		long p = (long)pS << 32 | pE;
-		TypeDeclaration typeDecl = (TypeDeclaration)type.get();
 		
 		MethodDeclaration method = new MethodDeclaration(
 				((CompilationUnitDeclaration) type.top().get()).compilationResult);
@@ -528,7 +559,7 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
 			SingleNameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
 			setGeneratedBy(oRef, source);
 			
-			TypeReference typeReference = createTypeReference(type, p);
+			TypeReference typeReference = createTypeReference(type, p, source, false);
 			setGeneratedBy(typeReference, source);
 
 			InstanceOfExpression instanceOf = new InstanceOfExpression(oRef, typeReference);
@@ -551,30 +582,15 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
 		
 		char[] otherName = "other".toCharArray();
 		
-		/* MyType<?> other = (MyType<?>) o; */ {
+		/* Outer.Inner.MyType<?> other = (Outer.Inner.MyType<?>) o; */ {
 			if (!fields.isEmpty() || needsCanEqual) {
 				LocalDeclaration other = new LocalDeclaration(otherName, pS, pE);
 				other.modifiers |= ClassFileConstants.AccFinal;
 				setGeneratedBy(other, source);
-				char[] typeName = typeDecl.name;
-				TypeReference targetType;
-				if (typeDecl.typeParameters == null || typeDecl.typeParameters.length == 0) {
-					targetType = new SingleTypeReference(typeName, p);
-					setGeneratedBy(targetType, source);
-					other.type = new SingleTypeReference(typeName, p);
-					setGeneratedBy(other.type, source);
-				} else {
-					TypeReference[] typeArgs = new TypeReference[typeDecl.typeParameters.length];
-					for (int i = 0; i < typeArgs.length; i++) {
-						typeArgs[i] = new Wildcard(Wildcard.UNBOUND);
-						typeArgs[i].sourceStart = pS; typeArgs[i].sourceEnd = pE;
-						setGeneratedBy(typeArgs[i], source);
-					}
-					targetType = new ParameterizedSingleTypeReference(typeName, typeArgs, 0, p);
-					setGeneratedBy(targetType, source);
-					other.type = new ParameterizedSingleTypeReference(typeName, copyTypes(typeArgs, source), 0, p);
-					setGeneratedBy(other.type, source);
-				}
+				TypeReference targetType = createTypeReference(type, p, source, true);
+				setGeneratedBy(targetType, source);
+				other.type = createTypeReference(type, p, source, true);
+				setGeneratedBy(other.type, source);
 				NameReference oRef = new SingleNameReference(new char[] { 'o' }, p);
 				setGeneratedBy(oRef, source);
 				other.initialization = makeCastExpression(oRef, targetType, source);
@@ -772,7 +788,7 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
 		SingleNameReference otherRef = new SingleNameReference(otherName, p);
 		setGeneratedBy(otherRef, source);
 		
-		TypeReference typeReference = createTypeReference(type, p);
+		TypeReference typeReference = createTypeReference(type, p, source, false);
 		setGeneratedBy(typeReference, source);
 		
 		InstanceOfExpression instanceOf = new InstanceOfExpression(otherRef, typeReference);
diff --git a/src/core/lombok/eclipse/handlers/HandleGetter.java b/src/core/lombok/eclipse/handlers/HandleGetter.java
index 77d678f2..c11303f3 100644
--- a/src/core/lombok/eclipse/handlers/HandleGetter.java
+++ b/src/core/lombok/eclipse/handlers/HandleGetter.java
@@ -148,7 +148,7 @@ public class HandleGetter extends EclipseAnnotationHandler<Getter> {
 		
 		if (node == null) return;
 		
-		List<Annotation> onMethod = unboxAndRemoveAnnotationParameter(ast, "onMethod", "@Getter(onMethod=", annotationNode);
+		List<Annotation> onMethod = unboxAndRemoveAnnotationParameter(ast, "onMethod", "@Getter(onMethod", annotationNode);
 		
 		switch (node.getKind()) {
 		case FIELD:
diff --git a/src/core/lombok/eclipse/handlers/HandleSetter.java b/src/core/lombok/eclipse/handlers/HandleSetter.java
index 1fcf751d..7e7ea121 100644
--- a/src/core/lombok/eclipse/handlers/HandleSetter.java
+++ b/src/core/lombok/eclipse/handlers/HandleSetter.java
@@ -125,8 +125,8 @@ public class HandleSetter extends EclipseAnnotationHandler<Setter> {
 		AccessLevel level = annotation.getInstance().value();
 		if (level == AccessLevel.NONE || node == null) return;
 		
-		List<Annotation> onMethod = unboxAndRemoveAnnotationParameter(ast, "onMethod", "@Setter(onMethod=", annotationNode);
-		List<Annotation> onParam = unboxAndRemoveAnnotationParameter(ast, "onParam", "@Setter(onParam=", annotationNode);
+		List<Annotation> onMethod = unboxAndRemoveAnnotationParameter(ast, "onMethod", "@Setter(onMethod", annotationNode);
+		List<Annotation> onParam = unboxAndRemoveAnnotationParameter(ast, "onParam", "@Setter(onParam", annotationNode);
 		
 		switch (node.getKind()) {
 		case FIELD:
diff --git a/src/core/lombok/eclipse/handlers/HandleUtilityClass.java b/src/core/lombok/eclipse/handlers/HandleUtilityClass.java
index 199ce102..959c1d20 100644
--- a/src/core/lombok/eclipse/handlers/HandleUtilityClass.java
+++ b/src/core/lombok/eclipse/handlers/HandleUtilityClass.java
@@ -49,6 +49,7 @@ import org.mangosdk.spi.ProviderFor;
 
 import lombok.ConfigurationKeys;
 import lombok.core.AnnotationValues;
+import lombok.core.HandlerPriority;
 import lombok.core.AST.Kind;
 import lombok.eclipse.EclipseAnnotationHandler;
 import lombok.eclipse.EclipseNode;
@@ -57,6 +58,7 @@ import lombok.experimental.UtilityClass;
 /**
  * Handles the {@code lombok.experimental.UtilityClass} annotation for eclipse.
  */
+@HandlerPriority(-4096) //-2^12; to ensure @FieldDefaults picks up on the 'static' we set here.
 @ProviderFor(EclipseAnnotationHandler.class)
 public class HandleUtilityClass extends EclipseAnnotationHandler<UtilityClass> {
 	@Override public void handle(AnnotationValues<UtilityClass> annotation, Annotation ast, EclipseNode annotationNode) {
diff --git a/src/core/lombok/eclipse/handlers/HandleWither.java b/src/core/lombok/eclipse/handlers/HandleWither.java
index d8ac8df6..200ebde7 100644
--- a/src/core/lombok/eclipse/handlers/HandleWither.java
+++ b/src/core/lombok/eclipse/handlers/HandleWither.java
@@ -127,8 +127,8 @@ public class HandleWither extends EclipseAnnotationHandler<Wither> {
 		AccessLevel level = annotation.getInstance().value();
 		if (level == AccessLevel.NONE || node == null) return;
 		
-		List<Annotation> onMethod = unboxAndRemoveAnnotationParameter(ast, "onMethod", "@Wither(onMethod=", annotationNode);
-		List<Annotation> onParam = unboxAndRemoveAnnotationParameter(ast, "onParam", "@Wither(onParam=", annotationNode);
+		List<Annotation> onMethod = unboxAndRemoveAnnotationParameter(ast, "onMethod", "@Wither(onMethod", annotationNode);
+		List<Annotation> onParam = unboxAndRemoveAnnotationParameter(ast, "onParam", "@Wither(onParam", annotationNode);
 		
 		switch (node.getKind()) {
 		case FIELD: