Merge branch 'janrieke-superBuilder'

26 files changed, 1904 insertions, 204 deletions

diff --git a/src/core/lombok/Builder.java b/src/core/lombok/Builder.java
index a16717cc..d7a2a109 100644
--- a/src/core/lombok/Builder.java
+++ b/src/core/lombok/Builder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2017 The Project Lombok Authors.
+ * Copyright (C) 2013-2018 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
@@ -55,8 +55,8 @@ import java.lang.annotation.Target;
  * 
  * <pre>
  * &#064;Builder
- * class Example {
- * 	private int foo;
+ * class Example&lt;T&gt; {
+ * 	private T foo;
  * 	private final String bar;
  * }
  * </pre>
@@ -103,6 +103,8 @@ import java.lang.annotation.Target;
  * 	}
  * }
  * </pre>
+ * 
+ * @see Singular
  */
 @Target({TYPE, METHOD, CONSTRUCTOR})
 @Retention(SOURCE)
diff --git a/src/core/lombok/ConfigurationKeys.java b/src/core/lombok/ConfigurationKeys.java
index 46c3f770..f5134bbd 100644
--- a/src/core/lombok/ConfigurationKeys.java
+++ b/src/core/lombok/ConfigurationKeys.java
@@ -544,6 +544,15 @@ public class ConfigurationKeys {
 	 */
 	public static final ConfigurationKey<FlagUsageType> WITHER_FLAG_USAGE = new ConfigurationKey<FlagUsageType>("lombok.wither.flagUsage", "Emit a warning or error if @Wither is used.") {};
 	
+	// ----- SuperBuilder -----
+	
+	/**
+	 * lombok configuration: {@code lombok.superBuilder.flagUsage} = {@code WARNING} | {@code ERROR}.
+	 * 
+	 * If set, <em>any</em> usage of {@code @SuperBuilder} results in a warning / error.
+	 */
+	public static final ConfigurationKey<FlagUsageType> SUPERBUILDER_FLAG_USAGE = new ConfigurationKey<FlagUsageType>("lombok.superBuilder.flagUsage", "Emit a warning or error if @SuperBuilder is used.") {};
+
 	// ----- Configuration System -----
 	
 	/**
diff --git a/src/core/lombok/eclipse/handlers/EclipseSingularsRecipes.java b/src/core/lombok/eclipse/handlers/EclipseSingularsRecipes.java
index bc779dab..b9b9e07d 100644
--- a/src/core/lombok/eclipse/handlers/EclipseSingularsRecipes.java
+++ b/src/core/lombok/eclipse/handlers/EclipseSingularsRecipes.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2015-2017 The Project Lombok Authors.
+ * Copyright (C) 2015-2018 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
@@ -45,6 +45,9 @@ 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.Reference;
+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;
@@ -53,6 +56,7 @@ import org.eclipse.jdt.internal.compiler.ast.Wildcard;
 import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
 import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
 import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
+import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
 
 import lombok.core.LombokImmutableList;
 import lombok.core.SpiLoadUtil;
@@ -60,6 +64,14 @@ import lombok.core.TypeLibrary;
 import lombok.eclipse.EclipseNode;
 
 public class EclipseSingularsRecipes {
+	public interface TypeReferenceMaker {
+		TypeReference make();
+	}
+	
+	public interface StatementMaker {
+		Statement make();
+	}
+	
 	private static final EclipseSingularsRecipes INSTANCE = new EclipseSingularsRecipes();
 	private final Map<String, EclipseSingularizer> singularizers = new HashMap<String, EclipseSingularizer>();
 	private final TypeLibrary singularizableTypes = new TypeLibrary();
@@ -215,8 +227,36 @@ public class EclipseSingularsRecipes {
 		}
 		
 		public abstract List<EclipseNode> generateFields(SingularData data, EclipseNode builderType);
-		public abstract void generateMethods(SingularData data, boolean deprecate, EclipseNode builderType, boolean fluent, boolean chain);
-		public abstract void appendBuildCode(SingularData data, EclipseNode builderType, List<Statement> statements, char[] targetVariableName);
+		
+		/**
+		 * Generates the singular, plural, and clear methods for the given {@link SingularData}.
+		 * Uses the given {@code builderType} as return type if {@code chain == true}, {@code void} otherwise.
+		 * If you need more control over the return type and value, use
+		 * {@link #generateMethods(SingularData, boolean, EclipseNode, boolean, TypeReferenceMaker, StatementMaker)}.
+		 */
+		public void generateMethods(SingularData data, boolean deprecate, final EclipseNode builderType, boolean fluent, final boolean chain) {
+			TypeReferenceMaker returnTypeMaker = new TypeReferenceMaker() {
+				@Override public TypeReference make() {
+					return chain ? cloneSelfType(builderType) : TypeReference.baseTypeReference(TypeIds.T_void, 0);
+				}
+			};
+			
+			StatementMaker returnStatementMaker = new StatementMaker() {
+				@Override public ReturnStatement make() {
+					return chain ? new ReturnStatement(new ThisReference(0, 0), 0, 0) : null;
+				}
+			};
+			
+			generateMethods(data, deprecate, builderType, fluent, returnTypeMaker, returnStatementMaker);
+		}
+		
+		/**
+		 * Generates the singular, plural, and clear methods for the given {@link SingularData}.
+		 * Uses the given {@code returnTypeMaker} and {@code returnStatementMaker} for the generated methods.
+		 */
+		public abstract void generateMethods(SingularData data, boolean deprecate, EclipseNode builderType, boolean fluent, TypeReferenceMaker returnTypeMaker, StatementMaker returnStatementMaker);
+		
+		public abstract void appendBuildCode(SingularData data, EclipseNode builderType, List<Statement> statements, char[] targetVariableName, String builderVariable);
 		
 		public boolean requiresCleaning() {
 			try {
@@ -307,16 +347,16 @@ public class EclipseSingularsRecipes {
 		private static final char[] SIZE_TEXT = new char[] {'s', 'i', 'z', 'e'};
 		
 		/** Generates 'this.<em>name</em>.size()' as an expression; if nullGuard is true, it's this.name == null ? 0 : this.name.size(). */
-		protected Expression getSize(EclipseNode builderType, char[] name, boolean nullGuard) {
+		protected Expression getSize(EclipseNode builderType, char[] name, boolean nullGuard, String builderVariable) {
 			MessageSend invoke = new MessageSend();
-			ThisReference thisRef = new ThisReference(0, 0);
+			Reference thisRef = getBuilderReference(builderVariable);
 			FieldReference thisDotName = new FieldReference(name, 0L);
 			thisDotName.receiver = thisRef;
 			invoke.receiver = thisDotName;
 			invoke.selector = SIZE_TEXT;
 			if (!nullGuard) return invoke;
 			
-			ThisReference cdnThisRef = new ThisReference(0, 0);
+			Reference cdnThisRef = getBuilderReference(builderVariable);
 			FieldReference cdnThisDotName = new FieldReference(name, 0L);
 			cdnThisDotName.receiver = cdnThisRef;
 			NullLiteral nullLiteral = new NullLiteral(0, 0);
@@ -345,5 +385,14 @@ public class EclipseSingularsRecipes {
 			
 			return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, NULL_POSS);
 		}
+		
+		/** @return a {@code SingleNameReference} to the builder in the variable <code>builderVariable</code>. If {@ code builderVariable == "this"}, a {@code ThisReference} is returned. */
+		protected static Reference getBuilderReference(String builderVariable) {
+			if ("this".equals(builderVariable)) {
+				return new ThisReference(0, 0);
+			} else {
+				return new SingleNameReference(builderVariable.toCharArray(), 0);
+			}
+		}
 	}
 }
diff --git a/src/core/lombok/eclipse/handlers/HandleBuilder.java b/src/core/lombok/eclipse/handlers/HandleBuilder.java
index 38bd9b60..e1b1af26 100644
--- a/src/core/lombok/eclipse/handlers/HandleBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleBuilder.java
@@ -573,7 +573,7 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		
 		for (BuilderFieldData bfd : builderFields) {
 			if (bfd.singularData != null && bfd.singularData.getSingularizer() != null) {
-				bfd.singularData.getSingularizer().appendBuildCode(bfd.singularData, type, statements, bfd.name);
+				bfd.singularData.getSingularizer().appendBuildCode(bfd.singularData, type, statements, bfd.name, "this");
 			}
 		}
 		
@@ -644,7 +644,7 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		return trs;
 	}
 	
-	public MethodDeclaration generateDefaultProvider(char[] methodName, TypeParameter[] typeParameters, EclipseNode fieldNode, ASTNode source) {
+	public static MethodDeclaration generateDefaultProvider(char[] methodName, TypeParameter[] typeParameters, EclipseNode fieldNode, ASTNode source) {
 		int pS = source.sourceStart, pE = source.sourceEnd;
 		
 		MethodDeclaration out = new MethodDeclaration(((CompilationUnitDeclaration) fieldNode.top().get()).compilationResult);
diff --git a/src/core/lombok/eclipse/handlers/HandleBuilderDefault.java b/src/core/lombok/eclipse/handlers/HandleBuilderDefault.java
index be2b986d..d0c597fd 100644
--- a/src/core/lombok/eclipse/handlers/HandleBuilderDefault.java
+++ b/src/core/lombok/eclipse/handlers/HandleBuilderDefault.java
@@ -31,6 +31,7 @@ import lombok.core.AnnotationValues;
 import lombok.core.HandlerPriority;
 import lombok.eclipse.EclipseAnnotationHandler;
 import lombok.eclipse.EclipseNode;
+import lombok.experimental.SuperBuilder;
 
 @ProviderFor(EclipseAnnotationHandler.class)
 @HandlerPriority(-1025) //HandleBuilder's level, minus one.
@@ -39,8 +40,9 @@ public class HandleBuilderDefault extends EclipseAnnotationHandler<Builder.Defau
 		EclipseNode annotatedField = annotationNode.up();
 		if (annotatedField.getKind() != Kind.FIELD) return;
 		EclipseNode classWithAnnotatedField = annotatedField.up();
-		if (!hasAnnotation(Builder.class, classWithAnnotatedField) && !hasAnnotation("lombok.experimental.Builder", classWithAnnotatedField)) {
-			annotationNode.addWarning("@Builder.Default requires @Builder on the class for it to mean anything.");
+		if (!hasAnnotation(Builder.class, classWithAnnotatedField) && !hasAnnotation("lombok.experimental.Builder", classWithAnnotatedField)
+				&& !hasAnnotation(SuperBuilder.class, classWithAnnotatedField)) {
+			annotationNode.addWarning("@Builder.Default requires @Builder or @SuperBuilder on the class for it to mean anything.");
 		}
 	}
 }
diff --git a/src/core/lombok/eclipse/handlers/HandleConstructor.java b/src/core/lombok/eclipse/handlers/HandleConstructor.java
index eb7fd711..cab847e6 100644
--- a/src/core/lombok/eclipse/handlers/HandleConstructor.java
+++ b/src/core/lombok/eclipse/handlers/HandleConstructor.java
@@ -309,7 +309,6 @@ public class HandleConstructor {
 		
 		return false;
 	}
-
 	
 	private static final char[][] JAVA_BEANS_CONSTRUCTORPROPERTIES = new char[][] { "java".toCharArray(), "beans".toCharArray(), "ConstructorProperties".toCharArray() };
 	public static Annotation[] createConstructorProperties(ASTNode source, Collection<EclipseNode> fields) {
diff --git a/src/core/lombok/eclipse/handlers/HandleSetter.java b/src/core/lombok/eclipse/handlers/HandleSetter.java
index 64f7c3cf..d4df0deb 100644
--- a/src/core/lombok/eclipse/handlers/HandleSetter.java
+++ b/src/core/lombok/eclipse/handlers/HandleSetter.java
@@ -116,7 +116,7 @@ public class HandleSetter extends EclipseAnnotationHandler<Setter> {
 		createSetterForField(level, fieldNode, sourceNode, false, onMethod, onParam);
 	}
 	
-	public void handle(AnnotationValues<Setter> annotation, Annotation ast, EclipseNode annotationNode) {
+	@Override public void handle(AnnotationValues<Setter> annotation, Annotation ast, EclipseNode annotationNode) {
 		handleFlagUsage(annotationNode, ConfigurationKeys.SETTER_FLAG_USAGE, "@Setter");
 		
 		EclipseNode node = annotationNode.up();
@@ -187,22 +187,34 @@ public class HandleSetter extends EclipseAnnotationHandler<Setter> {
 		MethodDeclaration method = createSetter((TypeDeclaration) fieldNode.up().get(), false, fieldNode, setterName, null, shouldReturnThis, modifier, sourceNode, onMethod, onParam);
 		injectMethod(fieldNode.up(), method);
 	}
-	
+
 	static MethodDeclaration createSetter(TypeDeclaration parent, boolean deprecate, EclipseNode fieldNode, String name, char[] booleanFieldToSet, boolean shouldReturnThis, int modifier, EclipseNode sourceNode, List<Annotation> onMethod, List<Annotation> onParam) {
+		ASTNode source = sourceNode.get();
+		int pS = source.sourceStart, pE = source.sourceEnd;
+		
+		TypeReference returnType = null;
+		ReturnStatement returnThis = null;
+		if (shouldReturnThis) {
+			returnType = cloneSelfType(fieldNode, source);
+			ThisReference thisRef = new ThisReference(pS, pE);
+			returnThis = new ReturnStatement(thisRef, pS, pE);
+		}
+		
+		return createSetter(parent, deprecate, fieldNode, name, booleanFieldToSet, returnType, returnThis, modifier, sourceNode, onMethod, onParam);
+	}
+	
+	static MethodDeclaration createSetter(TypeDeclaration parent, boolean deprecate, EclipseNode fieldNode, String name, char[] booleanFieldToSet, TypeReference returnType, Statement returnStatement, int modifier, EclipseNode sourceNode, List<Annotation> onMethod, List<Annotation> onParam) {
 		FieldDeclaration field = (FieldDeclaration) fieldNode.get();
 		ASTNode source = sourceNode.get();
 		int pS = source.sourceStart, pE = source.sourceEnd;
 		long p = (long)pS << 32 | pE;
 		MethodDeclaration method = new MethodDeclaration(parent.compilationResult);
 		method.modifiers = modifier;
-		if (shouldReturnThis) {
-			method.returnType = cloneSelfType(fieldNode, source);
-		}
-		
-		if (method.returnType == null) {
+		if (returnType != null) {
+			method.returnType = returnType;
+		} else {
 			method.returnType = TypeReference.baseTypeReference(TypeIds.T_void, 0);
 			method.returnType.sourceStart = pS; method.returnType.sourceEnd = pE;
-			shouldReturnThis = false;
 		}
 		Annotation[] deprecated = null;
 		if (isFieldDeprecated(fieldNode) || deprecate) {
@@ -239,10 +251,8 @@ public class HandleSetter extends EclipseAnnotationHandler<Setter> {
 			statements.add(new Assignment(new SingleNameReference(booleanFieldToSet, p), new TrueLiteral(pS, pE), pE));
 		}
 		
-		if (shouldReturnThis) {
-			ThisReference thisRef = new ThisReference(pS, pE);
-			ReturnStatement returnThis = new ReturnStatement(thisRef, pS, pE);
-			statements.add(returnThis);
+		if (returnType != null && returnStatement != null) {
+			statements.add(returnStatement);
 		}
 		method.statements = statements.toArray(new Statement[0]);
 		param.annotations = copyAnnotations(source, nonNulls, nullables, onParam.toArray(new Annotation[0]));
diff --git a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
new file mode 100644
index 00000000..6b0275e4
--- /dev/null
+++ b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
@@ -0,0 +1,836 @@
+/*
+ * Copyright (C) 2013-2018 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package lombok.eclipse.handlers;
+
+import static lombok.core.handlers.HandlerUtil.*;
+import static lombok.eclipse.Eclipse.*;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.*;
+
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+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.ExplicitConstructorCall;
+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.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;
+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.TypeDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
+import org.eclipse.jdt.internal.compiler.ast.TypeReference;
+import org.eclipse.jdt.internal.compiler.ast.Wildcard;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
+import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
+import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
+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.Builder.ObtainVia;
+import lombok.ConfigurationKeys;
+import lombok.Singular;
+import lombok.ToString;
+import lombok.core.AST.Kind;
+import lombok.core.handlers.InclusionExclusionUtils.Included;
+import lombok.core.AnnotationValues;
+import lombok.core.HandlerPriority;
+import lombok.eclipse.Eclipse;
+import lombok.eclipse.EclipseAnnotationHandler;
+import lombok.eclipse.EclipseNode;
+import lombok.eclipse.handlers.EclipseHandlerUtil.MemberExistsResult;
+import lombok.eclipse.handlers.EclipseSingularsRecipes.EclipseSingularizer;
+import lombok.eclipse.handlers.EclipseSingularsRecipes.SingularData;
+import lombok.eclipse.handlers.EclipseSingularsRecipes.StatementMaker;
+import lombok.eclipse.handlers.EclipseSingularsRecipes.TypeReferenceMaker;
+import lombok.experimental.NonFinal;
+import lombok.experimental.SuperBuilder;
+
+@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 HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
+	private static final char[] CLEAN_FIELD_NAME = "$lombokUnclean".toCharArray();
+	private static final char[] CLEAN_METHOD_NAME = "$lombokClean".toCharArray();
+	private static final char[] SET_PREFIX = "$set".toCharArray();
+	private static final char[] SELF_METHOD_NAME = "self".toCharArray();
+	
+	private static final AbstractMethodDeclaration[] EMPTY_METHODS = {};
+	
+	private static class BuilderFieldData {
+		TypeReference type;
+		char[] rawName;
+		char[] name;
+		char[] nameOfSetFlag;
+		SingularData singularData;
+		ObtainVia obtainVia;
+		EclipseNode obtainViaNode;
+		EclipseNode originalFieldNode;
+		
+		List<EclipseNode> createdFields = new ArrayList<EclipseNode>();
+	}
+	
+	@Override
+	public void handle(AnnotationValues<SuperBuilder> annotation, Annotation ast, EclipseNode annotationNode) {
+		handleExperimentalFlagUsage(annotationNode, ConfigurationKeys.SUPERBUILDER_FLAG_USAGE, "@SuperBuilder");
+		
+		long p = (long) ast.sourceStart << 32 | ast.sourceEnd;
+		
+		SuperBuilder builderInstance = annotation.getInstance();
+		
+		String builderMethodName = builderInstance.builderMethodName();
+		String buildMethodName = builderInstance.buildMethodName();
+		
+		if (builderMethodName == null) builderMethodName = "builder";
+		if (buildMethodName == null) buildMethodName = "build";
+		
+		if (!checkName("builderMethodName", builderMethodName, annotationNode)) return;
+		if (!checkName("buildMethodName", buildMethodName, annotationNode)) return;
+		
+		EclipseNode tdParent = annotationNode.up();
+		
+		java.util.List<BuilderFieldData> builderFields = new ArrayList<BuilderFieldData>();
+		TypeReference returnType;
+		TypeParameter[] typeParams;
+		
+		boolean addCleaning = false;
+		
+		if (!(tdParent.get() instanceof TypeDeclaration)) {
+			annotationNode.addError("@SuperBuilder is only supported on types.");
+			return;
+		}
+		TypeDeclaration td = (TypeDeclaration) tdParent.get();
+		
+		// Gather all fields of the class that should be set by the builder.
+		List<EclipseNode> allFields = new ArrayList<EclipseNode>();
+		boolean valuePresent = (hasAnnotation(lombok.Value.class, tdParent) || hasAnnotation("lombok.experimental.Value", tdParent));
+		for (EclipseNode fieldNode : HandleConstructor.findAllFields(tdParent, true)) {
+			FieldDeclaration fd = (FieldDeclaration) fieldNode.get();
+			EclipseNode isDefault = findAnnotation(Builder.Default.class, fieldNode);
+			boolean isFinal = ((fd.modifiers & ClassFileConstants.AccFinal) != 0) || (valuePresent && !hasAnnotation(NonFinal.class, fieldNode));
+			
+			BuilderFieldData bfd = new BuilderFieldData();
+			bfd.rawName = fieldNode.getName().toCharArray();
+			bfd.name = removePrefixFromField(fieldNode);
+			bfd.type = fd.type;
+			bfd.singularData = getSingularData(fieldNode, ast);
+			bfd.originalFieldNode = fieldNode;
+			
+			if (bfd.singularData != null && isDefault != null) {
+				isDefault.addError("@Builder.Default and @Singular cannot be mixed.");
+				isDefault = null;
+			}
+			
+			if (fd.initialization == null && isDefault != null) {
+				isDefault.addWarning("@Builder.Default requires an initializing expression (' = something;').");
+				isDefault = null;
+			}
+			
+			if (fd.initialization != null && isDefault == null) {
+				if (isFinal) {
+					continue;
+				}
+				fieldNode.addWarning("@Builder will ignore the initializing expression entirely. If you want the initializing expression to serve as default, add @Builder.Default. If it is not supposed to be settable during building, make the field final.");
+			}
+			
+			if (isDefault != null) {
+				bfd.nameOfSetFlag = prefixWith(bfd.name, SET_PREFIX);
+				// The @Builder annotation removes the initializing expression on the field and moves
+				// it to a method called "$default$FIELDNAME". This method is then called upon building.
+				// We do NOT do this, because this is unexpected and may lead to bugs when using other 
+				// constructors (see, e.g., issue #1347).
+				// Instead, we keep the init expression and only set a new value in the builder-based
+				// constructor if it was set in the builder. Drawback is that the init expression is
+				// always executed, even if it was unnecessary because its value is overwritten by the 
+				// builder.
+				// TODO: Once the issue is resolved in @Builder, we can adapt the solution here. 
+			}
+			addObtainVia(bfd, fieldNode);
+			builderFields.add(bfd);
+			allFields.add(fieldNode);
+		}
+		
+		// Set the names of the builder classes.
+		String builderClassName = String.valueOf(td.name) + "Builder";
+		String builderImplClassName = builderClassName + "Impl";
+		
+		typeParams = td.typeParameters != null ? td.typeParameters : new TypeParameter[0];
+		returnType = namePlusTypeParamsToTypeReference(td.name, typeParams, p);
+		
+		// <C, B> are the generics for our builder.
+		String classGenericName = "C";
+		String builderGenericName = "B";
+		// If these generics' names collide with any generics on the annotated class, modify them.
+		// For instance, if there are generics <B, B2, C> on the annotated class, use "C2" and "B3" for our builder.
+		java.util.List<String> typeParamStrings = new ArrayList<String>();
+		for (TypeParameter typeParam : typeParams) typeParamStrings.add(typeParam.toString());
+		classGenericName = generateNonclashingNameFor(classGenericName, typeParamStrings);
+		builderGenericName = generateNonclashingNameFor(builderGenericName, typeParamStrings);
+		
+		TypeReference extendsClause = td.superclass;
+		TypeReference superclassBuilderClass = null;
+		TypeReference[] typeArguments = new TypeReference[] {
+				new SingleTypeReference(classGenericName.toCharArray(), 0), 
+				new SingleTypeReference(builderGenericName.toCharArray(), 0)
+		};
+		if (extendsClause instanceof QualifiedTypeReference) {
+			QualifiedTypeReference qualifiedTypeReference = (QualifiedTypeReference)extendsClause;
+			String superclassClassName = String.valueOf(qualifiedTypeReference.getLastToken());
+			String superclassBuilderClassName = superclassClassName + "Builder";
+			
+			char[][] tokens = Arrays.copyOf(qualifiedTypeReference.tokens, qualifiedTypeReference.tokens.length + 1);
+			tokens[tokens.length] = superclassBuilderClassName.toCharArray();
+			long[] poss = new long[tokens.length];
+			Arrays.fill(poss, p);
+			
+			TypeReference[] superclassTypeArgs = getTypeParametersFrom(extendsClause);
+			
+			// Every token may potentially have type args. Here, we only have
+			// type args for the last token, the superclass' builder.
+			TypeReference[][] typeArgsForTokens = new TypeReference[tokens.length][];
+			typeArgsForTokens[typeArgsForTokens.length-1] = mergeTypeReferences(superclassTypeArgs, typeArguments);
+			
+			superclassBuilderClass = new ParameterizedQualifiedTypeReference(tokens, typeArgsForTokens, 0, poss);
+		} else if (extendsClause != null) {
+			String superClass = String.valueOf(extendsClause.getTypeName()[0]);
+			String superclassBuilderClassName = superClass + "Builder";
+			
+			char[][] tokens = new char[][] {superClass.toCharArray(), superclassBuilderClassName.toCharArray()};
+			long[] poss = new long[tokens.length];
+			Arrays.fill(poss, p);
+			
+			TypeReference[] superclassTypeArgs = getTypeParametersFrom(extendsClause);
+			
+			// Every token may potentially have type args. Here, we only have
+			// type args for the last token, the superclass' builder.
+			TypeReference[][] typeArgsForTokens = new TypeReference[tokens.length][];
+			typeArgsForTokens[typeArgsForTokens.length-1] = mergeTypeReferences(superclassTypeArgs, typeArguments);
+			
+			superclassBuilderClass = new ParameterizedQualifiedTypeReference(tokens, typeArgsForTokens, 0, poss);
+		}
+		// If there is no superclass, superclassBuilderClassExpression is still == null at this point.
+		// You can use it to check whether to inherit or not.
+		
+		generateBuilderBasedConstructor(tdParent, typeParams, builderFields, annotationNode, builderClassName,
+			superclassBuilderClass != null);
+		
+		// Create the abstract builder class.
+		EclipseNode builderType = findInnerClass(tdParent, builderClassName);
+		if (builderType == null) {
+			builderType = generateBuilderAbstractClass(tdParent, builderClassName, superclassBuilderClass,
+				typeParams, ast, classGenericName, builderGenericName);
+		} else {
+			annotationNode.addError("@SuperBuilder does not support customized builders. Use @Builder instead.");
+			return;
+		}
+		
+		// Check validity of @ObtainVia fields, and add check if adding cleaning for @Singular is necessary.
+		for (BuilderFieldData bfd : builderFields) {
+			if (bfd.singularData != null && bfd.singularData.getSingularizer() != null) {
+				if (bfd.singularData.getSingularizer().requiresCleaning()) {
+					addCleaning = true;
+					break;
+				}
+			}
+			if (bfd.obtainVia != null) {
+				if (bfd.obtainVia.field().isEmpty() == bfd.obtainVia.method().isEmpty()) {
+					bfd.obtainViaNode.addError("The syntax is either @ObtainVia(field = \"fieldName\") or @ObtainVia(method = \"methodName\").");
+					return;
+				}
+				if (bfd.obtainVia.method().isEmpty() && bfd.obtainVia.isStatic()) {
+					bfd.obtainViaNode.addError("@ObtainVia(isStatic = true) is not valid unless 'method' has been set.");
+					return;
+				}
+			}
+		}
+		
+		// Generate the fields in the abstract builder class that hold the values for the instance.
+		generateBuilderFields(builderType, builderFields, ast);
+		if (addCleaning) {
+			FieldDeclaration cleanDecl = new FieldDeclaration(CLEAN_FIELD_NAME, 0, -1);
+			cleanDecl.dec