ecj @Builder @Singular support for j.u. sets and maps.

1 files changed, 237 insertions, 85 deletions

diff --git a/src/core/lombok/eclipse/handlers/HandleBuilder.java b/src/core/lombok/eclipse/handlers/HandleBuilder.java
index 80f80ddd..365256c7 100644
--- a/src/core/lombok/eclipse/handlers/HandleBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 The Project Lombok Authors.
+ * Copyright (C) 2013-2015 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -32,49 +32,74 @@ import java.util.List;
 
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.Argument;
+import org.eclipse.jdt.internal.compiler.ast.Assignment;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.FalseLiteral;
 import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.FieldReference;
+import org.eclipse.jdt.internal.compiler.ast.IfStatement;
 import org.eclipse.jdt.internal.compiler.ast.MessageSend;
 import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
+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.QualifiedTypeReference;
 import org.eclipse.jdt.internal.compiler.ast.ReturnStatement;
 import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
 import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
 import org.eclipse.jdt.internal.compiler.ast.Statement;
+import org.eclipse.jdt.internal.compiler.ast.ThisReference;
+import org.eclipse.jdt.internal.compiler.ast.TrueLiteral;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
+import org.eclipse.jdt.internal.compiler.ast.UnaryExpression;
 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.eclipse.jdt.internal.compiler.lookup.TypeIds;
 import org.mangosdk.spi.ProviderFor;
 
 import lombok.AccessLevel;
 import lombok.Builder;
 import lombok.ConfigurationKeys;
+import lombok.Singular;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
 import lombok.core.HandlerPriority;
 import lombok.eclipse.Eclipse;
 import lombok.eclipse.EclipseAnnotationHandler;
 import lombok.eclipse.EclipseNode;
+import lombok.eclipse.handlers.EclipseSingularsRecipes.EclipseSingularizer;
+import lombok.eclipse.handlers.EclipseSingularsRecipes.SingularData;
 import lombok.eclipse.handlers.HandleConstructor.SkipIfConstructorExists;
 import lombok.experimental.NonFinal;
 
 @ProviderFor(EclipseAnnotationHandler.class)
 @HandlerPriority(-1024) //-2^10; to ensure we've picked up @FieldDefault's changes (-2048) but @Value hasn't removed itself yet (-512), so that we can error on presence of it on the builder classes.
 public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
+	private static final char[] CLEAN_FIELD_NAME = "$lombokUnclean".toCharArray();
+	private static final char[] CLEAN_METHOD_NAME = "$lombokClean".toCharArray();
+	
 	private static final boolean toBoolean(Object expr, boolean defaultValue) {
 		if (expr == null) return defaultValue;
 		return ((Boolean) expr).booleanValue();
 	}
 	
+	private static class BuilderFieldData {
+		TypeReference type;
+		char[] name;
+		SingularData singularData;
+		
+		List<EclipseNode> createdFields = new ArrayList<EclipseNode>();
+	}
+	
 	@Override public void handle(AnnotationValues<Builder> annotation, Annotation ast, EclipseNode annotationNode) {
 		handleExperimentalFlagUsage(annotationNode, ConfigurationKeys.BUILDER_FLAG_USAGE, "@Builder");
 		
@@ -102,21 +127,21 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		
 		EclipseNode parent = annotationNode.up();
 		
-		List<TypeReference> typesOfParameters = new ArrayList<TypeReference>();
-		List<char[]> namesOfParameters = new ArrayList<char[]>();
+		List<BuilderFieldData> builderFields = new ArrayList<BuilderFieldData>();
 		TypeReference returnType;
 		TypeParameter[] typeParams;
 		TypeReference[] thrownExceptions;
 		char[] nameOfStaticBuilderMethod;
 		EclipseNode tdParent;
 		
-		AbstractMethodDeclaration fillParametersFrom = null;
+		EclipseNode fillParametersFrom = parent.get() instanceof AbstractMethodDeclaration ? parent : null;
+		boolean addCleaning = false;
 		
 		if (parent.get() instanceof TypeDeclaration) {
 			tdParent = parent;
 			TypeDeclaration td = (TypeDeclaration) tdParent.get();
 			
-			List<EclipseNode> fields = new ArrayList<EclipseNode>();
+			List<EclipseNode> allFields = new ArrayList<EclipseNode>();
 			@SuppressWarnings("deprecation")
 			boolean valuePresent = (hasAnnotation(lombok.Value.class, parent) || hasAnnotation(lombok.experimental.Value.class, parent));
 			for (EclipseNode fieldNode : HandleConstructor.findAllFields(tdParent)) {
@@ -125,12 +150,15 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 				// non-final fields final, but @Value's handler hasn't done this yet, so we have to do this math ourselves.
 				// Value will only skip making a field final if it has an explicit @NonFinal annotation, so we check for that.
 				if (fd.initialization != null && valuePresent && !hasAnnotation(NonFinal.class, fieldNode)) continue;
-				namesOfParameters.add(removePrefixFromField(fieldNode));
-				typesOfParameters.add(fd.type);
-				fields.add(fieldNode);
+				BuilderFieldData bfd = new BuilderFieldData();
+				bfd.name = removePrefixFromField(fieldNode);
+				bfd.type = fd.type;
+				bfd.singularData = getSingularData(fieldNode);
+				builderFields.add(bfd);
+				allFields.add(fieldNode);
 			}
 			
-			new HandleConstructor().generateConstructor(tdParent, AccessLevel.PACKAGE, fields, null, SkipIfConstructorExists.I_AM_BUILDER, null,
+			new HandleConstructor().generateConstructor(tdParent, AccessLevel.PACKAGE, allFields, null, SkipIfConstructorExists.I_AM_BUILDER, null,
 					Collections.<Annotation>emptyList(), annotationNode);
 			
 			returnType = namePlusTypeParamsToTypeReference(td.name, td.typeParameters, p);
@@ -147,7 +175,6 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 			
 			tdParent = parent.up();
 			TypeDeclaration td = (TypeDeclaration) tdParent.get();
-			fillParametersFrom = cd;
 			returnType = namePlusTypeParamsToTypeReference(td.name, td.typeParameters, p);
 			typeParams = td.typeParameters;
 			thrownExceptions = cd.thrownExceptions;
@@ -160,7 +187,6 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 				annotationNode.addError("@Builder is only supported on types, constructors, and static methods.");
 				return;
 			}
-			fillParametersFrom = md;
 			returnType = copyType(md.returnType, ast);
 			typeParams = md.typeParameters;
 			thrownExceptions = md.thrownExceptions;
@@ -200,9 +226,14 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		}
 		
 		if (fillParametersFrom != null) {
-			if (fillParametersFrom.arguments != null) for (Argument a : fillParametersFrom.arguments) {
-				namesOfParameters.add(a.name);
-				typesOfParameters.add(a.type);
+			for (EclipseNode param : fillParametersFrom.down()) {
+				if (param.getKind() != Kind.ARGUMENT) continue;
+				BuilderFieldData bfd = new BuilderFieldData();
+				Argument arg = (Argument) param.get();
+				bfd.name = arg.name;
+				bfd.type = arg.type;
+				bfd.singularData = getSingularData(param);
+				builderFields.add(bfd);
 			}
 		}
 		
@@ -212,11 +243,23 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		} else {
 			sanityCheckForMethodGeneratingAnnotationsOnBuilderClass(builderType, annotationNode);
 		}
-		List<EclipseNode> fieldNodes = addFieldsToBuilder(builderType, namesOfParameters, typesOfParameters, ast);
-		List<AbstractMethodDeclaration> newMethods = new ArrayList<AbstractMethodDeclaration>();
-		for (EclipseNode fieldNode : fieldNodes) {
-			MethodDeclaration newMethod = makeSetterMethodForBuilder(builderType, fieldNode, annotationNode, fluent, chain);
-			if (newMethod != null) newMethods.add(newMethod);
+		
+		for (BuilderFieldData bfd : builderFields) {
+			if (bfd.singularData != null && bfd.singularData.getSingularizer() != null) {
+				if (bfd.singularData.getSingularizer().requiresCleaning()) {
+					addCleaning = true;
+					break;
+				}
+			}
+		}
+		
+		generateBuilderFields(builderType, builderFields);
+		if (addCleaning) {
+			FieldDeclaration cleanDecl = new FieldDeclaration(CLEAN_FIELD_NAME, 0, -1);
+			cleanDecl.declarationSourceEnd = -1;
+			cleanDecl.modifiers = ClassFileConstants.AccPrivate;
+			cleanDecl.type = TypeReference.baseTypeReference(TypeIds.T_boolean, 0);
+			injectField(builderType, cleanDecl);
 		}
 		
 		if (constructorExists(builderType) == MemberExistsResult.NOT_EXISTS) {
@@ -226,128 +269,181 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 			if (cd != null) injectMethod(builderType, cd);
 		}
 		
-		for (AbstractMethodDeclaration newMethod : newMethods) injectMethod(builderType, newMethod);
+		for (BuilderFieldData bfd : builderFields) {
+			makeSetterMethodsForBuilder(builderType, bfd, annotationNode, fluent, chain);
+		}
+		
 		if (methodExists(buildMethodName, builderType, -1) == MemberExistsResult.NOT_EXISTS) {
-			MethodDeclaration md = generateBuildMethod(buildMethodName, nameOfStaticBuilderMethod, returnType, namesOfParameters, builderType, ast, thrownExceptions);
+			MethodDeclaration md = generateBuildMethod(buildMethodName, nameOfStaticBuilderMethod, returnType, builderFields, builderType, thrownExceptions, addCleaning);
 			if (md != null) injectMethod(builderType, md);
 		}
 		
 		if (methodExists("toString", builderType, 0) == MemberExistsResult.NOT_EXISTS) {
+			List<EclipseNode> fieldNodes = new ArrayList<EclipseNode>();
+			for (BuilderFieldData bfd : builderFields) {
+				fieldNodes.addAll(bfd.createdFields);
+			}
 			MethodDeclaration md = HandleToString.createToString(builderType, fieldNodes, true, false, ast, FieldAccess.ALWAYS_FIELD);
 			if (md != null) injectMethod(builderType, md);
 		}
 		
+		if (addCleaning) injectMethod(builderType, generateCleanMethod(builderFields, builderType));
+		
 		if (methodExists(builderMethodName, tdParent, -1) == MemberExistsResult.NOT_EXISTS) {
 			MethodDeclaration md = generateBuilderMethod(builderMethodName, builderClassName, tdParent, typeParams, ast);
 			if (md != null) injectMethod(tdParent, md);
 		}
+		
+		builderType.get().traverse(new SetGeneratedByVisitor(ast), null);
 	}
 	
-	public MethodDeclaration generateBuilderMethod(String builderMethodName, String builderClassName, EclipseNode type, TypeParameter[] typeParams, ASTNode source) {
-		int pS = source.sourceStart, pE = source.sourceEnd;
-		long p = (long) pS << 32 | pE;
+	private MethodDeclaration generateCleanMethod(List<BuilderFieldData> builderFields, EclipseNode builderType) {
+		List<Statement> statements = new ArrayList<Statement>();
 		
-		MethodDeclaration out = new MethodDeclaration(
-				((CompilationUnitDeclaration) type.top().get()).compilationResult);
-		out.selector = builderMethodName.toCharArray();
-		out.modifiers = ClassFileConstants.AccPublic | ClassFileConstants.AccStatic;
-		out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
-		out.returnType = namePlusTypeParamsToTypeReference(builderClassName.toCharArray(), typeParams, p);
-		out.typeParameters = copyTypeParams(typeParams, source);
-		AllocationExpression invoke = new AllocationExpression();
-		invoke.type = namePlusTypeParamsToTypeReference(builderClassName.toCharArray(), typeParams, p);
-		out.statements = new Statement[] {new ReturnStatement(invoke, pS, pE)};
+		for (BuilderFieldData bfd : builderFields) {
+			if (bfd.singularData != null && bfd.singularData.getSingularizer() != null) {
+				bfd.singularData.getSingularizer().appendCleaningCode(bfd.singularData, builderType, statements);
+			}
+		}
 		
-		out.traverse(new SetGeneratedByVisitor(source), ((TypeDeclaration) type.get()).scope);
-		return out;
+		FieldReference thisUnclean = new FieldReference(CLEAN_FIELD_NAME, 0);
+		thisUnclean.receiver = new ThisReference(0, 0);
+		statements.add(new Assignment(thisUnclean, new FalseLiteral(0, 0), 0));
+		MethodDeclaration decl =new MethodDeclaration(((CompilationUnitDeclaration) builderType.top().get()).compilationResult);
+		decl.selector = CLEAN_METHOD_NAME;
+		decl.modifiers = ClassFileConstants.AccPrivate;
+		decl.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
+		decl.returnType = TypeReference.baseTypeReference(TypeIds.T_void, 0);
+		decl.statements = statements.toArray(new Statement[0]);
+		return decl;
 	}
 	
-	public MethodDeclaration generateBuildMethod(String name, char[] staticName, TypeReference returnType, List<char[]> fieldNames, EclipseNode type, ASTNode source, TypeReference[] thrownExceptions) {
-		int pS = source.sourceStart, pE = source.sourceEnd;
-		long p = (long) pS << 32 | pE;
-		
+	public MethodDeclaration generateBuildMethod(String name, char[] staticName, TypeReference returnType, List<BuilderFieldData> builderFields, EclipseNode type, TypeReference[] thrownExceptions, boolean addCleaning) {
 		MethodDeclaration out = new MethodDeclaration(
 				((CompilationUnitDeclaration) type.top().get()).compilationResult);
+		out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
+		List<Statement> statements = new ArrayList<Statement>();
+		
+		if (addCleaning) {
+			FieldReference thisUnclean = new FieldReference(CLEAN_FIELD_NAME, 0);
+			thisUnclean.receiver = new ThisReference(0, 0);
+			Expression notClean = new UnaryExpression(thisUnclean, OperatorIds.NOT);
+			MessageSend invokeClean = new MessageSend();
+			invokeClean.selector = CLEAN_METHOD_NAME;
+			statements.add(new IfStatement(notClean, invokeClean, 0, 0));
+		}
+		
+		for (BuilderFieldData bfd : builderFields) {
+			if (bfd.singularData != null && bfd.singularData.getSingularizer() != null) {
+				bfd.singularData.getSingularizer().appendBuildCode(bfd.singularData, type, statements, bfd.name);
+			}
+		}
+		
+		List<Expression> args = new ArrayList<Expression>();
+		for (BuilderFieldData bfd : builderFields) {
+			args.add(new SingleNameReference(bfd.name, 0L));
+		}
+		
+		if (addCleaning) {
+			FieldReference thisUnclean = new FieldReference(CLEAN_FIELD_NAME, 0);
+			thisUnclean.receiver = new ThisReference(0, 0);
+			statements.add(new Assignment(thisUnclean, new TrueLiteral(0, 0), 0));
+		}
 		
 		out.modifiers = ClassFileConstants.AccPublic;
-		TypeDeclaration typeDecl = (TypeDeclaration) type.get();
 		out.selector = name.toCharArray();
-		out.thrownExceptions = copyTypes(thrownExceptions, source);
+		out.thrownExceptions = copyTypes(thrownExceptions);
 		out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
 		out.returnType = returnType;
 		
-		List<Expression> assigns = new ArrayList<Expression>();
-		for (char[] fieldName : fieldNames) {
-			SingleNameReference nameRef = new SingleNameReference(fieldName, p);
-			assigns.add(nameRef);
-		}
-		
-		Statement statement;
-		
 		if (staticName == null) {
 			AllocationExpression allocationStatement = new AllocationExpression();
-			allocationStatement.type = copyType(out.returnType, source);
-			allocationStatement.arguments = assigns.isEmpty() ? null : assigns.toArray(new Expression[assigns.size()]);
-			statement = new ReturnStatement(allocationStatement, (int)(p >> 32), (int)p);
+			allocationStatement.type = copyType(out.returnType);
+			allocationStatement.arguments = args.isEmpty() ? null : args.toArray(new Expression[args.size()]);
+			statements.add(new ReturnStatement(allocationStatement, 0, 0));
 		} else {
 			MessageSend invoke = new MessageSend();
 			invoke.selector = staticName;
-			invoke.receiver = new SingleNameReference(type.up().getName().toCharArray(), p);
+			invoke.receiver = new SingleNameReference(type.up().getName().toCharArray(), 0);
 			TypeParameter[] tps = ((TypeDeclaration) type.get()).typeParameters;
 			if (tps != null) {
 				TypeReference[] trs = new TypeReference[tps.length];
 				for (int i = 0; i < trs.length; i++) {
-					trs[i] = new SingleTypeReference(tps[i].name, p);
+					trs[i] = new SingleTypeReference(tps[i].name, 0);
 				}
 				invoke.typeArguments = trs;
 			}
-			invoke.arguments = assigns.isEmpty() ? null : assigns.toArray(new Expression[assigns.size()]);
+			invoke.arguments = args.isEmpty() ? null : args.toArray(new Expression[args.size()]);
 			if (returnType instanceof SingleTypeReference && Arrays.equals(TypeConstants.VOID, ((SingleTypeReference) returnType).token)) {
-				statement = invoke;
+				statements.add(invoke);
 			} else {
-				statement = new ReturnStatement(invoke, (int)(p >> 32), (int)p);
+				statements.add(new ReturnStatement(invoke, 0, 0));
 			}
 		}
+		out.statements = statements.isEmpty() ? null : statements.toArray(new Statement[statements.size()]);
+		return out;
+	}
+	
+	public MethodDeclaration generateBuilderMethod(String builderMethodName, String builderClassName, EclipseNode type, TypeParameter[] typeParams, ASTNode source) {
+		int pS = source.sourceStart, pE = source.sourceEnd;
+		long p = (long) pS << 32 | pE;
 		
-		out.statements = new Statement[] { statement };
+		MethodDeclaration out = new MethodDeclaration(
+				((CompilationUnitDeclaration) type.top().get()).compilationResult);
+		out.selector = builderMethodName.toCharArray();
+		out.modifiers = ClassFileConstants.AccPublic | ClassFileConstants.AccStatic;
+		out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
+		out.returnType = namePlusTypeParamsToTypeReference(builderClassName.toCharArray(), typeParams, p);
+		out.typeParameters = copyTypeParams(typeParams, source);
+		AllocationExpression invoke = new AllocationExpression();
+		invoke.type = namePlusTypeParamsToTypeReference(builderClassName.toCharArray(), typeParams, p);
+		out.statements = new Statement[] {new ReturnStatement(invoke, pS, pE)};
 		
-		out.traverse(new SetGeneratedByVisitor(source), typeDecl.scope);
+		out.traverse(new SetGeneratedByVisitor(source), ((TypeDeclaration) type.get()).scope);
 		return out;
 	}
 	
-	public List<EclipseNode> addFieldsToBuilder(EclipseNode builderType, List<char[]> namesOfParameters, List<TypeReference> typesOfParameters, ASTNode source) {
-		int len = namesOfParameters.size();
-		TypeDeclaration td = (TypeDeclaration) builderType.get();
-		FieldDeclaration[] existing = td.fields;
-		if (existing == null) existing = new FieldDeclaration[0];
-		
-		List<EclipseNode> out = new ArrayList<EclipseNode>();
+	public void generateBuilderFields(EclipseNode builderType, List<BuilderFieldData> builderFields) {
+		int len = builderFields.size();
+		List<EclipseNode> existing = new ArrayList<EclipseNode>();
+		for (EclipseNode child : builderType.down()) {
+			if (child.getKind() == Kind.FIELD) existing.add(child);
+		}
 		
 		top:
 		for (int i = len - 1; i >= 0; i--) {
-			char[] name = namesOfParameters.get(i);
-			for (FieldDeclaration exists : existing) {
-				if (Arrays.equals(exists.name, name)) {
-					out.add(builderType.getNodeFor(exists));
-					continue top;
+			BuilderFieldData bfd = builderFields.get(i);
+			if (bfd.singularData != null && bfd.singularData.getSingularizer() != null) {
+				bfd.createdFields.addAll(bfd.singularData.getSingularizer().generateFields(bfd.singularData, builderType));
+			} else {
+				for (EclipseNode exists : existing) {
+					char[] n = ((FieldDeclaration) exists.get()).name;
+					if (Arrays.equals(n, bfd.name)) {
+						bfd.createdFields.add(exists);
+						continue top;
+					}
 				}
+				
+				FieldDeclaration fd = new FieldDeclaration(bfd.name, 0, 0);
+				fd.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
+				fd.modifiers = ClassFileConstants.AccPrivate;
+				fd.type = copyType(bfd.type);
+				bfd.createdFields.add(injectField(builderType, fd));
 			}
-			TypeReference fieldReference = copyType(typesOfParameters.get(i), source);
-			FieldDeclaration newField = new FieldDeclaration(name, 0, 0);
-			newField.bits |= Eclipse.ECLIPSE_DO_NOT_TOUCH_FLAG;
-			newField.modifiers = ClassFileConstants.AccPrivate;
-			newField.type = fieldReference;
-			out.add(injectField(builderType, newField));
 		}
-		
-		Collections.reverse(out);
-		
-		return out;
 	}
 	
 	private static final AbstractMethodDeclaration[] EMPTY = {};
 	
-	public MethodDeclaration makeSetterMethodForBuilder(EclipseNode builderType, EclipseNode fieldNode, EclipseNode sourceNode, boolean fluent, boolean chain) {
+	public void makeSetterMethodsForBuilder(EclipseNode builderType, BuilderFieldData bfd, EclipseNode sourceNode, boolean fluent, boolean chain) {
+		if (bfd.singularData == null || bfd.singularData.getSingularizer() == null) {
+			makeSimpleSetterMethodForBuilder(builderType, bfd.createdFields.get(0), sourceNode, fluent, chain);
+		} else {
+			bfd.singularData.getSingularizer().generateMethods(bfd.singularData, builderType, fluent, chain);
+		}
+	}
+	
+	private void makeSimpleSetterMethodForBuilder(EclipseNode builderType, EclipseNode fieldNode, EclipseNode sourceNode, boolean fluent, boolean chain) {
 		TypeDeclaration td = (TypeDeclaration) builderType.get();
 		AbstractMethodDeclaration[] existing = td.methods;
 		if (existing == null) existing = EMPTY;
@@ -358,14 +454,15 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		for (int i = 0; i < len; i++) {
 			if (!(existing[i] instanceof MethodDeclaration)) continue;
 			char[] existingName = existing[i].selector;
-			if (Arrays.equals(name, existingName)) return null;
+			if (Arrays.equals(name, existingName)) return;
 		}
 		
 		boolean isBoolean = isBoolean(fd.type);
 		String setterName = fluent ? fieldNode.getName() : toSetterName(builderType.getAst(), null, fieldNode.getName(), isBoolean);
 		
-		return HandleSetter.createSetter(td, fieldNode, setterName, chain, ClassFileConstants.AccPublic,
+		MethodDeclaration setter = HandleSetter.createSetter(td, fieldNode, setterName, chain, ClassFileConstants.AccPublic,
 				sourceNode, Collections.<Annotation>emptyList(), Collections.<Annotation>emptyList());
+		injectMethod(builderType, setter);
 	}
 	
 	public EclipseNode findInnerClass(EclipseNode parent, String name) {
@@ -388,4 +485,59 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		builder.traverse(new SetGeneratedByVisitor(source), (ClassScope) null);
 		return injectType(tdParent, builder);
 	}
+	
+	/**
+	 * Returns the explicitly requested singular annotation on this node (field
+	 * or parameter), or null if there's no {@code @Singular} annotation on it.
+	 * 
+	 * @param node The node (field or method param) to inspect for its name and potential {@code @Singular} annotation.
+	 */
+	private SingularData getSingularData(EclipseNode node) {
+		for (EclipseNode child : node.down()) {
+			if (child.getKind() == Kind.ANNOTATION && annotationTypeMatches(Singular.class, child)) {
+				char[] pluralName = node.getKind() == Kind.FIELD ? removePrefixFromField(node) : ((AbstractVariableDeclaration) node.get()).name;
+				AnnotationValues<Singular> ann = createAnnotation(Singular.class, child);
+				String explicitSingular = ann.getInstance().value();
+				if (explicitSingular.isEmpty()) {
+					explicitSingular = autoSingularize(node.getName());
+					if (explicitSingular == null) {
+						node.addError("Can't singularize this name; please specify the singular explicitly (i.e. @Singular(\"sheep\"))");
+						explicitSingular = pluralName.toString();
+					}
+				}
+				char[] singularName = explicitSingular.toCharArray();
+				
+				TypeReference type = ((AbstractVariableDeclaration) node.get()).type;
+				TypeReference[] typeArgs = null;
+				String typeName;
+				if (type instanceof ParameterizedSingleTypeReference) {
+					typeArgs = ((ParameterizedSingleTypeReference) type).typeArguments;
+					typeName = new String(((ParameterizedSingleTypeReference) type).token);
+				} else if (type instanceof ParameterizedQualifiedTypeReference) {
+					TypeReference[][] tr = ((ParameterizedQualifiedTypeReference) type).typeArguments;
+					if (tr != null) typeArgs = tr[tr.length - 1];
+					char[][] tokens = ((ParameterizedQualifiedTypeReference) type).tokens;
+					StringBuilder sb = new StringBuilder();
+					for (int i = 0; i < tokens.length; i++) {
+						if (i > 0) sb.append(".");
+						sb.append(tokens[i]);
+					}
+					typeName = sb.toString();
+				} else {
+					typeName = type.toString();
+				}
+				
+				String targetFqn = EclipseSingularsRecipes.get().toQualified(typeName);
+				EclipseSingularizer singularizer = EclipseSingularsRecipes.get().getSingularizer(targetFqn);
+				if (singularizer == null) {
+					node.addError("Lombok does not know how to create the singular-form builder methods for type '" + typeName + "'; they won't be generated.");
+					return null;
+				}
+				
+				return new SingularData(child, singularName, pluralName, typeArgs == null ? Collections.<TypeReference>emptyList() : Arrays.asList(typeArgs), targetFqn, singularizer);
+			}
+		}
+		
+		return null;
+	}
 }