[feature] FieldNameConstants now works like Builder: Make whatever bits it does by hand and lombok fills in whatever is missing.

6 files changed, 109 insertions, 65 deletions

diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
index c69b3d0f..026c2383 100644
--- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
+++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
@@ -672,6 +672,16 @@ public class EclipseHandlerUtil {
 		}
 	}
 	
+	public static EclipseNode findInnerClass(EclipseNode parent, String name) {
+		char[] c = name.toCharArray();
+		for (EclipseNode child : parent.down()) {
+			if (child.getKind() != Kind.TYPE) continue;
+			TypeDeclaration td = (TypeDeclaration) child.get();
+			if (Arrays.equals(td.name, c)) return child;
+		}
+		return null;
+	}
+	
 	public static EclipseNode findAnnotation(Class<? extends java.lang.annotation.Annotation> type, EclipseNode node) {
 		if (node == null) return null;
 		if (type == null) return null;
diff --git a/src/core/lombok/eclipse/handlers/HandleBuilder.java b/src/core/lombok/eclipse/handlers/HandleBuilder.java
index 0ce1436d..fc11aff2 100644
--- a/src/core/lombok/eclipse/handlers/HandleBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleBuilder.java
@@ -802,16 +802,6 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		injectMethod(builderType, setter);
 	}
 	
-	public EclipseNode findInnerClass(EclipseNode parent, String name) {
-		char[] c = name.toCharArray();
-		for (EclipseNode child : parent.down()) {
-			if (child.getKind() != Kind.TYPE) continue;
-			TypeDeclaration td = (TypeDeclaration) child.get();
-			if (Arrays.equals(td.name, c)) return child;
-		}
-		return null;
-	}
-	
 	public EclipseNode makeBuilderClass(boolean isStatic, EclipseNode tdParent, String builderClassName, TypeParameter[] typeParams, ASTNode source) {
 		TypeDeclaration parent = (TypeDeclaration) tdParent.get();
 		TypeDeclaration builder = new TypeDeclaration(parent.compilationResult);
diff --git a/src/core/lombok/eclipse/handlers/HandleFieldNameConstants.java b/src/core/lombok/eclipse/handlers/HandleFieldNameConstants.java
index 15650490..91b7771b 100644
--- a/src/core/lombok/eclipse/handlers/HandleFieldNameConstants.java
+++ b/src/core/lombok/eclipse/handlers/HandleFieldNameConstants.java
@@ -48,7 +48,6 @@ import org.eclipse.jdt.internal.compiler.ast.Statement;
 import org.eclipse.jdt.internal.compiler.ast.StringLiteral;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
-import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
 import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
 import org.mangosdk.spi.ProviderFor;
 
@@ -75,7 +74,7 @@ public class HandleFieldNameConstants extends EclipseAnnotationHandler<FieldName
 		if (qualified.isEmpty()) {
 			errorNode.addWarning("No fields qualify for @FieldNameConstants, therefore this annotation does nothing");
 		} else {
-			createInnerTypeFieldNameConstants(typeNode, errorNode.get(), level, qualified, asEnum, innerTypeName);
+			createInnerTypeFieldNameConstants(typeNode, errorNode, errorNode.get(), level, qualified, asEnum, innerTypeName);
 		}
 	}
 	
@@ -115,53 +114,72 @@ public class HandleFieldNameConstants extends EclipseAnnotationHandler<FieldName
 		generateFieldNameConstantsForType(node, annotationNode, level, asEnum, innerTypeName, annotationInstance.onlyExplicitlyIncluded());
 	}
 	
-	private void createInnerTypeFieldNameConstants(EclipseNode typeNode, ASTNode source, AccessLevel level, List<EclipseNode> fields, boolean asEnum, String innerTypeName) {
+	private void createInnerTypeFieldNameConstants(EclipseNode typeNode, EclipseNode errorNode, ASTNode source, AccessLevel level, List<EclipseNode> fields, boolean asEnum, String innerTypeName) {
 		if (fields.isEmpty()) return;
 		
 		TypeDeclaration parent = (TypeDeclaration) typeNode.get();
-		TypeDeclaration innerType = new TypeDeclaration(parent.compilationResult);
-		innerType.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
-		innerType.modifiers = toEclipseModifier(level) | (asEnum ? ClassFileConstants.AccEnum : ClassFileConstants.AccStatic | ClassFileConstants.AccFinal);
+		EclipseNode fieldsType = findInnerClass(typeNode, innerTypeName);
+		boolean genConstr = false, genClinit = false;
 		char[] name = innerTypeName.toCharArray();
-		innerType.name = name;
-		innerType.traverse(new SetGeneratedByVisitor(source), (ClassScope) null);
-		EclipseNode innerNode = injectType(typeNode, innerType);
-		
-		ConstructorDeclaration constructor = new ConstructorDeclaration(parent.compilationResult);
-		constructor.selector = name;
-		constructor.declarationSourceStart = constructor.sourceStart = source.sourceStart;
-		constructor.declarationSourceEnd = constructor.sourceEnd = source.sourceEnd;
-		constructor.modifiers = ClassFileConstants.AccPrivate;
-		ExplicitConstructorCall superCall = new ExplicitConstructorCall(0);
-		superCall.sourceStart = source.sourceStart;
-		superCall.sourceEnd = source.sourceEnd;
-		superCall.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
-		constructor.constructorCall = superCall;
-		if (!asEnum) constructor.statements = new Statement[0];
-		
-		injectMethod(innerNode, constructor);
+		TypeDeclaration generatedInnerType = null;
+		if (fieldsType == null) {
+			generatedInnerType = new TypeDeclaration(parent.compilationResult);
+			generatedInnerType.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
+			generatedInnerType.modifiers = toEclipseModifier(level) | (asEnum ? ClassFileConstants.AccEnum : ClassFileConstants.AccStatic | ClassFileConstants.AccFinal);
+			generatedInnerType.name = name;
+			fieldsType = injectType(typeNode, generatedInnerType);
+			genConstr = true;
+			genClinit = asEnum;
+		} else {
+			TypeDeclaration builderTypeDeclaration = (TypeDeclaration) fieldsType.get();
+			if ((builderTypeDeclaration.modifiers & (ClassFileConstants.AccEnum | ClassFileConstants.AccStatic)) == 0) {
+				errorNode.addError("Existing " + innerTypeName + " must be declared as an 'enum' or a 'static class'.");
+				return;
+			}
+			genConstr = constructorExists(fieldsType) == MemberExistsResult.NOT_EXISTS;
+		}
 		
-		if (asEnum) injectMethod(innerNode, new Clinit(parent.compilationResult));
+		if (genConstr) {
+			ConstructorDeclaration constructor = new ConstructorDeclaration(parent.compilationResult);
+			constructor.selector = name;
+			constructor.declarationSourceStart = constructor.sourceStart = source.sourceStart;
+			constructor.declarationSourceEnd = constructor.sourceEnd = source.sourceEnd;
+			constructor.modifiers = ClassFileConstants.AccPrivate;
+			ExplicitConstructorCall superCall = new ExplicitConstructorCall(0);
+			superCall.sourceStart = source.sourceStart;
+			superCall.sourceEnd = source.sourceEnd;
+			superCall.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
+			constructor.constructorCall = superCall;
+			if (!asEnum) constructor.statements = new Statement[0];
+			injectMethod(fieldsType, constructor);
+		}
+		if (genClinit) {
+			Clinit cli = new Clinit(parent.compilationResult);
+			injectMethod(fieldsType, cli);
+		}
+
 		
 		for (EclipseNode fieldNode : fields) {
 			FieldDeclaration field = (FieldDeclaration) fieldNode.get();
 			char[] fName = field.name;
+			if (fieldExists(new String(fName), fieldsType) != MemberExistsResult.NOT_EXISTS) continue;
 			int pS = source.sourceStart, pE = source.sourceEnd;
 			long p = (long) pS << 32 | pE;
-			FieldDeclaration fieldConstant = new FieldDeclaration(fName, pS, pE);
-			fieldConstant.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
-			fieldConstant.modifiers = asEnum ? 0 : ClassFileConstants.AccPublic | ClassFileConstants.AccStatic | ClassFileConstants.AccFinal;
-			fieldConstant.type = asEnum ? null : new QualifiedTypeReference(TypeConstants.JAVA_LANG_STRING, new long[] {p, p, p});
+			FieldDeclaration constantField = new FieldDeclaration(fName, pS, pE);
+			constantField.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
+			constantField.modifiers = asEnum ? 0 : ClassFileConstants.AccPublic | ClassFileConstants.AccStatic | ClassFileConstants.AccFinal;
+			constantField.type = asEnum ? null : new QualifiedTypeReference(TypeConstants.JAVA_LANG_STRING, new long[] {p, p, p});
 			if (asEnum) {
 				AllocationExpression ac = new AllocationExpression();
-				ac.enumConstant = fieldConstant;
+				ac.enumConstant = constantField;
 				ac.sourceStart = source.sourceStart;
 				ac.sourceEnd = source.sourceEnd;
-				fieldConstant.initialization = ac;
+				constantField.initialization = ac;
 			} else {
-				fieldConstant.initialization = new StringLiteral(field.name, pS, pE, 0);
+				constantField.initialization = new StringLiteral(field.name, pS, pE, 0);
 			}
-			injectField(innerNode, fieldConstant);
+			constantField.traverse(new SetGeneratedByVisitor(source), null);
+			injectField(fieldsType, constantField);
 		}
 	}
 }
diff --git a/src/core/lombok/javac/handlers/HandleBuilder.java b/src/core/lombok/javac/handlers/HandleBuilder.java
index f4eabbe8..83a44cca 100644
--- a/src/core/lombok/javac/handlers/HandleBuilder.java
+++ b/src/core/lombok/javac/handlers/HandleBuilder.java
@@ -726,15 +726,6 @@ public class HandleBuilder extends JavacAnnotationHandler<Builder> {
 		injectMethod(builderType, newMethod);
 	}
 	
-	public JavacNode findInnerClass(JavacNode parent, String name) {
-		for (JavacNode child : parent.down()) {
-			if (child.getKind() != Kind.TYPE) continue;
-			JCClassDecl td = (JCClassDecl) child.get();
-			if (td.name.contentEquals(name)) return child;
-		}
-		return null;
-	}
-	
 	public JavacNode makeBuilderClass(boolean isStatic, JavacNode source, JavacNode tdParent, String builderClassName, List<JCTypeParameter> typeParams, JCAnnotation ast) {
 		JavacTreeMaker maker = tdParent.getTreeMaker();
 		int modifiers = Flags.PUBLIC;
diff --git a/src/core/lombok/javac/handlers/HandleFieldNameConstants.java b/src/core/lombok/javac/handlers/HandleFieldNameConstants.java
index 5b120948..163a82b3 100644
--- a/src/core/lombok/javac/handlers/HandleFieldNameConstants.java
+++ b/src/core/lombok/javac/handlers/HandleFieldNameConstants.java
@@ -48,7 +48,6 @@ import com.sun.tools.javac.tree.JCTree.JCModifiers;
 import com.sun.tools.javac.tree.JCTree.JCStatement;
 import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
 import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
-import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.Name;
 
@@ -75,7 +74,7 @@ public class HandleFieldNameConstants extends JavacAnnotationHandler<FieldNameCo
 		if (qualified.isEmpty()) {
 			errorNode.addWarning("No fields qualify for @FieldNameConstants, therefore this annotation does nothing");
 		} else {
-			createInnerTypeFieldNameConstants(typeNode, errorNode.get(), level, qualified, asEnum, innerTypeName);
+			createInnerTypeFieldNameConstants(typeNode, errorNode, errorNode.get(), level, qualified, asEnum, innerTypeName);
 		}
 	}
 	
@@ -122,24 +121,44 @@ public class HandleFieldNameConstants extends JavacAnnotationHandler<FieldNameCo
 		generateFieldNameConstantsForType(node, annotationNode, level, asEnum, innerTypeName, annotationInstance.onlyExplicitlyIncluded());
 	}
 	
-	private void createInnerTypeFieldNameConstants(JavacNode typeNode, DiagnosticPosition pos, AccessLevel level, java.util.List<JavacNode> fields, boolean asEnum, String innerTypeName) {
+	private void createInnerTypeFieldNameConstants(JavacNode typeNode, JavacNode errorNode, JCTree pos, AccessLevel level, java.util.List<JavacNode> fields, boolean asEnum, String innerTypeName) {
 		if (fields.isEmpty()) return;
 		
 		JavacTreeMaker maker = typeNode.getTreeMaker();
 		JCModifiers mods = maker.Modifiers(toJavacModifier(level) | (asEnum ? Flags.ENUM : Flags.STATIC | Flags.FINAL));
 		
 		Name fieldsName = typeNode.toName(innerTypeName);
-		JCClassDecl innerType = maker.ClassDef(mods, fieldsName, List.<JCTypeParameter>nil(), null, List.<JCExpression>nil(), List.<JCTree>nil());
-		JavacNode innerNode = injectType(typeNode, innerType);
 		
-		JCModifiers genConstrMods = maker.Modifiers(Flags.GENERATEDCONSTR | (asEnum ? 0L : Flags.PRIVATE));
-		JCBlock genConstrBody = maker.Block(0L, List.<JCStatement>of(maker.Exec(maker.Apply(List.<JCExpression>nil(), maker.Ident(typeNode.toName("super")), List.<JCExpression>nil()))));
-		JCMethodDecl genConstr = maker.MethodDef(genConstrMods, typeNode.toName("<init>"), null, List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), genConstrBody, null);
+		JavacNode fieldsType = findInnerClass(typeNode, innerTypeName);
+		boolean genConstr = false;
+		if (fieldsType == null) {
+			JCClassDecl innerType = maker.ClassDef(mods, fieldsName, List.<JCTypeParameter>nil(), null, List.<JCExpression>nil(), List.<JCTree>nil());
+			fieldsType = injectType(typeNode, innerType);
+			recursiveSetGeneratedBy(innerType, pos, typeNode.getContext());
+			genConstr = true;
+		} else {
+			JCClassDecl builderTypeDeclaration = (JCClassDecl) fieldsType.get();
+			long f = builderTypeDeclaration.getModifiers().flags;
+			if ((f & (Flags.STATIC | Flags.ENUM)) == 0) {
+				errorNode.addError("Existing " + innerTypeName + " must be declared as an 'enum' or a 'static class'.");
+				return;
+			}
+			genConstr = constructorExists(fieldsType) == MemberExistsResult.NOT_EXISTS;
+		}
 		
-		injectMethod(innerNode, genConstr);
+		if (genConstr) {
+			JCModifiers genConstrMods = maker.Modifiers(Flags.GENERATEDCONSTR | (asEnum ? 0L : Flags.PRIVATE));
+			JCBlock genConstrBody = maker.Block(0L, List.<JCStatement>of(maker.Exec(maker.Apply(List.<JCExpression>nil(), maker.Ident(typeNode.toName("super")), List.<JCExpression>nil()))));
+			JCMethodDecl c = maker.MethodDef(genConstrMods, typeNode.toName("<init>"), null, List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), genConstrBody, null);
+			recursiveSetGeneratedBy(c, pos, typeNode.getContext());
+			injectMethod(fieldsType, c);
+		}
 		
+		java.util.List<JCVariableDecl> generated = new ArrayList<JCVariableDecl>();
 		for (JavacNode field : fields) {
-			JCModifiers enumValueMods = maker.Modifiers(Flags.PUBLIC | Flags.STATIC | Flags.FINAL | (asEnum ? Flags.ENUM : 0L));
+			Name fName = ((JCVariableDecl) field.get()).name;
+			if (fieldExists(fName.toString(), fieldsType) != MemberExistsResult.NOT_EXISTS) continue;
+			JCModifiers constantValueMods = maker.Modifiers(Flags.PUBLIC | Flags.STATIC | Flags.FINAL | (asEnum ? Flags.ENUM : 0L));
 			JCExpression returnType;
 			JCExpression init;
 			if (asEnum) {
@@ -149,8 +168,11 @@ public class HandleFieldNameConstants extends JavacAnnotationHandler<FieldNameCo
 				returnType = chainDots(field, "java", "lang", "String");
 				init = maker.Literal(field.getName());
 			}
-			JCVariableDecl enumField = maker.VarDef(enumValueMods, ((JCVariableDecl) field.get()).name, returnType, init);
-			injectField(innerNode, enumField);
+			JCVariableDecl constantField = maker.VarDef(constantValueMods, fName, returnType, init);
+			injectField(fieldsType, constantField, false, true);
+			setGeneratedBy(constantField, pos, typeNode.getContext());
+			generated.add(constantField);
 		}
+		for (JCVariableDecl cf : generated) recursiveSetGeneratedBy(cf, pos, typeNode.getContext());
 	}
 }
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index c97c7ede..d7fae8e6 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -224,6 +224,15 @@ public class JavacHandlerUtil {
 		}
 	}
 	
+	public static JavacNode findInnerClass(JavacNode parent, String name) {
+		for (JavacNode child : parent.down()) {
+			if (child.getKind() != Kind.TYPE) continue;
+			JCClassDecl td = (JCClassDecl) child.get();
+			if (td.name.contentEquals(name)) return child;
+		}
+		return null;
+	}
+	
 	public static JavacNode findAnnotation(Class<? extends Annotation> type, JavacNode node) {
 		return findAnnotation(type, node, false);
 	}
@@ -1001,7 +1010,11 @@ public class JavacHandlerUtil {
 		return injectField(typeNode, field, false);
 	}
 
-	private static JavacNode injectField(JavacNode typeNode, JCVariableDecl field, boolean addGenerated) {
+	public static JavacNode injectField(JavacNode typeNode, JCVariableDecl field, boolean addGenerated) {
+		return injectField(typeNode, field, addGenerated, false);
+	}
+	
+	public static JavacNode injectField(JavacNode typeNode, JCVariableDecl field, boolean addGenerated, boolean specialEnumHandling) {
 		JCClassDecl type = (JCClassDecl) typeNode.get();
 		
 		if (addGenerated) {
@@ -1015,7 +1028,7 @@ public class JavacHandlerUtil {
 			boolean skip = false;
 			if (insertBefore.head instanceof JCVariableDecl) {
 				JCVariableDecl f = (JCVariableDecl) insertBefore.head;
-				if (isEnumConstant(f) || isGenerated(f)) skip = true;
+				if ((!specialEnumHandling && isEnumConstant(f)) || isGenerated(f)) skip = true;
 			} else if (insertBefore.head instanceof JCMethodDecl) {
 				if ((((JCMethodDecl) insertBefore.head).mods.flags & GENERATEDCONSTR) != 0) skip = true;
 			}