Refactored the source folders.

11 files changed, 1943 insertions, 0 deletions

diff --git a/src/core/lombok/javac/handlers/HandleCleanup.java b/src/core/lombok/javac/handlers/HandleCleanup.java
new file mode 100644
index 00000000..88a8e1d7
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleCleanup.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import lombok.Cleanup;
+import lombok.core.AnnotationValues;
+import lombok.core.AST.Kind;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCAssign;
+import com.sun.tools.javac.tree.JCTree.JCBlock;
+import com.sun.tools.javac.tree.JCTree.JCCase;
+import com.sun.tools.javac.tree.JCTree.JCCatch;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCExpressionStatement;
+import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
+import com.sun.tools.javac.tree.JCTree.JCIdent;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCStatement;
+import com.sun.tools.javac.tree.JCTree.JCTypeCast;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Name;
+
+/**
+ * Handles the {@code lombok.Cleanup} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleCleanup implements JavacAnnotationHandler<Cleanup> {
+	@Override public boolean handle(AnnotationValues<Cleanup> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		String cleanupName = annotation.getInstance().value();
+		if (cleanupName.length() == 0) {
+			annotationNode.addError("cleanupName cannot be the empty string.");
+			return true;
+		}
+		
+		if (annotationNode.up().getKind() != Kind.LOCAL) {
+			annotationNode.addError("@Cleanup is legal only on local variable declarations.");
+			return true;
+		}
+		
+		JCVariableDecl decl = (JCVariableDecl)annotationNode.up().get();
+		
+		if (decl.init == null) {
+			annotationNode.addError("@Cleanup variable declarations need to be initialized.");
+			return true;
+		}
+		
+		JavacNode ancestor = annotationNode.up().directUp();
+		JCTree blockNode = ancestor.get();
+		
+		final List<JCStatement> statements;
+		if (blockNode instanceof JCBlock) {
+			statements = ((JCBlock)blockNode).stats;
+		} else if (blockNode instanceof JCCase) {
+			statements = ((JCCase)blockNode).stats;
+		} else if (blockNode instanceof JCMethodDecl) {
+			statements = ((JCMethodDecl)blockNode).body.stats;
+		} else {
+			annotationNode.addError("@Cleanup is legal only on a local variable declaration inside a block.");
+			return true;
+		}
+		
+		boolean seenDeclaration = false;
+		List<JCStatement> tryBlock = List.nil();
+		List<JCStatement> newStatements = List.nil();
+		for (JCStatement statement : statements) {
+			if (!seenDeclaration) {
+				if (statement == decl) seenDeclaration = true;
+				newStatements = newStatements.append(statement);
+			} else {
+				tryBlock = tryBlock.append(statement);
+			}
+		}
+		
+		if (!seenDeclaration) {
+			annotationNode.addError("LOMBOK BUG: Can't find this local variable declaration inside its parent.");
+			return true;
+		}
+		
+		doAssignmentCheck(annotationNode, tryBlock, decl.name);
+		
+		TreeMaker maker = annotationNode.getTreeMaker();
+		JCFieldAccess cleanupCall = maker.Select(maker.Ident(decl.name), annotationNode.toName(cleanupName));
+		List<JCStatement> finalizerBlock = List.<JCStatement>of(maker.Exec(
+				maker.Apply(List.<JCExpression>nil(), cleanupCall, List.<JCExpression>nil())));
+		
+		JCBlock finalizer = maker.Block(0, finalizerBlock);
+		newStatements = newStatements.append(maker.Try(maker.Block(0, tryBlock), List.<JCCatch>nil(), finalizer));
+		
+		if (blockNode instanceof JCBlock) {
+			((JCBlock)blockNode).stats = newStatements;
+		} else if (blockNode instanceof JCCase) {
+			((JCCase)blockNode).stats = newStatements;
+		} else if (blockNode instanceof JCMethodDecl) {
+			((JCMethodDecl)blockNode).body.stats = newStatements;
+		} else throw new AssertionError("Should not get here");
+		
+		ancestor.rebuild();
+		
+		return true;
+	}
+	
+	private void doAssignmentCheck(JavacNode node, List<JCStatement> statements, Name name) {
+		for (JCStatement statement : statements) doAssignmentCheck0(node, statement, name);
+	}
+	
+	private void doAssignmentCheck0(JavacNode node, JCTree statement, Name name) {
+		if (statement instanceof JCAssign) doAssignmentCheck0(node, ((JCAssign)statement).rhs, name);
+		if (statement instanceof JCExpressionStatement) doAssignmentCheck0(node,
+				((JCExpressionStatement)statement).expr, name);
+		if (statement instanceof JCVariableDecl) doAssignmentCheck0(node, ((JCVariableDecl)statement).init, name);
+		if (statement instanceof JCTypeCast) doAssignmentCheck0(node, ((JCTypeCast)statement).expr, name);
+		if (statement instanceof JCIdent) {
+			if (((JCIdent)statement).name.contentEquals(name)) {
+				JavacNode problemNode = node.getNodeFor(statement);
+				if (problemNode != null) problemNode.addWarning(
+				"You're assigning an auto-cleanup variable to something else. This is a bad idea.");
+			}
+		}
+	}
+}
diff --git a/src/core/lombok/javac/handlers/HandleData.java b/src/core/lombok/javac/handlers/HandleData.java
new file mode 100644
index 00000000..eef7f78d
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleData.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+
+import java.lang.reflect.Modifier;
+
+import lombok.Data;
+import lombok.core.AnnotationValues;
+import lombok.core.TransformationsUtil;
+import lombok.core.AST.Kind;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+import lombok.javac.handlers.JavacHandlerUtil.MemberExistsResult;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCAssign;
+import com.sun.tools.javac.tree.JCTree.JCBlock;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
+import com.sun.tools.javac.tree.JCTree.JCIdent;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCModifiers;
+import com.sun.tools.javac.tree.JCTree.JCReturn;
+import com.sun.tools.javac.tree.JCTree.JCStatement;
+import com.sun.tools.javac.tree.JCTree.JCTypeApply;
+import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+
+/**
+ * Handles the {@code lombok.Data} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleData implements JavacAnnotationHandler<Data> {
+	@Override public boolean handle(AnnotationValues<Data> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		JavacNode typeNode = annotationNode.up();
+		JCClassDecl typeDecl = null;
+		if (typeNode.get() instanceof JCClassDecl) typeDecl = (JCClassDecl)typeNode.get();
+		long flags = typeDecl == null ? 0 : typeDecl.mods.flags;
+		boolean notAClass = (flags & (Flags.INTERFACE | Flags.ENUM | Flags.ANNOTATION)) != 0;
+		
+		if (typeDecl == null || notAClass) {
+			annotationNode.addError("@Data is only supported on a class.");
+			return false;
+		}
+		
+		List<JavacNode> nodesForConstructor = List.nil();
+		for (JavacNode child : typeNode.down()) {
+			if (child.getKind() != Kind.FIELD) continue;
+			JCVariableDecl fieldDecl = (JCVariableDecl) child.get();
+			//Skip fields that start with $
+			if (fieldDecl.name.toString().startsWith("$")) continue;
+			long fieldFlags = fieldDecl.mods.flags;
+			//Skip static fields.
+			if ((fieldFlags & Flags.STATIC) != 0) continue;
+			boolean isFinal = (fieldFlags & Flags.FINAL) != 0;
+			boolean isNonNull = !findAnnotations(child, TransformationsUtil.NON_NULL_PATTERN).isEmpty();
+			if ((isFinal || isNonNull) && fieldDecl.init == null) nodesForConstructor = nodesForConstructor.append(child);
+			new HandleGetter().generateGetterForField(child, annotationNode.get());
+			if (!isFinal) new HandleSetter().generateSetterForField(child, annotationNode.get());
+		}
+		
+		new HandleToString().generateToStringForType(typeNode, annotationNode);
+		new HandleEqualsAndHashCode().generateEqualsAndHashCodeForType(typeNode, annotationNode);
+		
+		String staticConstructorName = annotation.getInstance().staticConstructor();
+		
+		if (constructorExists(typeNode) == MemberExistsResult.NOT_EXISTS) {
+			JCMethodDecl constructor = createConstructor(staticConstructorName.equals(""), typeNode, nodesForConstructor);
+			injectMethod(typeNode, constructor);
+		}
+		
+		if (!staticConstructorName.isEmpty() && methodExists("of", typeNode) == MemberExistsResult.NOT_EXISTS) {
+			JCMethodDecl staticConstructor = createStaticConstructor(staticConstructorName, typeNode, nodesForConstructor);
+			injectMethod(typeNode, staticConstructor);
+		}
+		
+		return true;
+	}
+	
+	private JCMethodDecl createConstructor(boolean isPublic, JavacNode typeNode, List<JavacNode> fields) {
+		TreeMaker maker = typeNode.getTreeMaker();
+		JCClassDecl type = (JCClassDecl) typeNode.get();
+		
+		List<JCStatement> nullChecks = List.nil();
+		List<JCStatement> assigns = List.nil();
+		List<JCVariableDecl> params = List.nil();
+		
+		for (JavacNode fieldNode : fields) {
+			JCVariableDecl field = (JCVariableDecl) fieldNode.get();
+			List<JCAnnotation> nonNulls = findAnnotations(fieldNode, TransformationsUtil.NON_NULL_PATTERN);
+			List<JCAnnotation> nullables = findAnnotations(fieldNode, TransformationsUtil.NULLABLE_PATTERN);
+			JCVariableDecl param = maker.VarDef(maker.Modifiers(Flags.FINAL, nonNulls.appendList(nullables)), field.name, field.vartype, null);
+			params = params.append(param);
+			JCFieldAccess thisX = maker.Select(maker.Ident(fieldNode.toName("this")), field.name);
+			JCAssign assign = maker.Assign(thisX, maker.Ident(field.name));
+			assigns = assigns.append(maker.Exec(assign));
+			
+			if (!nonNulls.isEmpty()) {
+				JCStatement nullCheck = generateNullCheck(maker, fieldNode);
+				if (nullCheck != null) nullChecks = nullChecks.append(nullCheck);
+			}
+		}
+		
+		JCModifiers mods = maker.Modifiers(isPublic ? Modifier.PUBLIC : Modifier.PRIVATE);
+		return maker.MethodDef(mods, typeNode.toName("<init>"),
+				null, type.typarams, params, List.<JCExpression>nil(), maker.Block(0L, nullChecks.appendList(assigns)), null);
+	}
+	
+	private JCMethodDecl createStaticConstructor(String name, JavacNode typeNode, List<JavacNode> fields) {
+		TreeMaker maker = typeNode.getTreeMaker();
+		JCClassDecl type = (JCClassDecl) typeNode.get();
+		
+		JCModifiers mods = maker.Modifiers(Flags.STATIC | Flags.PUBLIC);
+		
+		JCExpression returnType, constructorType;
+		
+		List<JCTypeParameter> typeParams = List.nil();
+		List<JCVariableDecl> params = List.nil();
+		List<JCExpression> typeArgs1 = List.nil();
+		List<JCExpression> typeArgs2 = List.nil();
+		List<JCExpression> args = List.nil();
+		
+		if (!type.typarams.isEmpty()) {
+			for (JCTypeParameter param : type.typarams) {
+				typeArgs1 = typeArgs1.append(maker.Ident(param.name));
+				typeArgs2 = typeArgs2.append(maker.Ident(param.name));
+				typeParams = typeParams.append(maker.TypeParameter(param.name, param.bounds));
+			}
+			returnType = maker.TypeApply(maker.Ident(type.name), typeArgs1);
+			constructorType = maker.TypeApply(maker.Ident(type.name), typeArgs2);
+		} else {
+			returnType = maker.Ident(type.name);
+			constructorType = maker.Ident(type.name);
+		}
+		
+		for (JavacNode fieldNode : fields) {
+			JCVariableDecl field = (JCVariableDecl) fieldNode.get();
+			JCExpression pType;
+			if (field.vartype instanceof JCIdent) pType = maker.Ident(((JCIdent)field.vartype).name);
+			else if (field.vartype instanceof JCTypeApply) {
+				JCTypeApply typeApply = (JCTypeApply) field.vartype;
+				List<JCExpression> tArgs = List.nil();
+				for (JCExpression arg : typeApply.arguments) tArgs = tArgs.append(arg);
+				pType = maker.TypeApply(typeApply.clazz, tArgs);
+			} else {
+				pType = field.vartype;
+			}
+			List<JCAnnotation> nonNulls = findAnnotations(fieldNode, TransformationsUtil.NON_NULL_PATTERN);
+			List<JCAnnotation> nullables = findAnnotations(fieldNode, TransformationsUtil.NULLABLE_PATTERN);
+			JCVariableDecl param = maker.VarDef(maker.Modifiers(Flags.FINAL, nonNulls.appendList(nullables)), field.name, pType, null);
+			params = params.append(param);
+			args = args.append(maker.Ident(field.name));
+		}
+		JCReturn returnStatement = maker.Return(maker.NewClass(null, List.<JCExpression>nil(), constructorType, args, null));
+		JCBlock body = maker.Block(0, List.<JCStatement>of(returnStatement));
+		
+		return maker.MethodDef(mods, typeNode.toName(name), returnType, typeParams, params, List.<JCExpression>nil(), body, null);
+	}
+}
diff --git a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
new file mode 100644
index 00000000..61a4ef63
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+import lombok.EqualsAndHashCode;
+import lombok.core.AnnotationValues;
+import lombok.core.AST.Kind;
+import lombok.javac.Javac;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.BoundKind;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.TypeTags;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCArrayTypeTree;
+import com.sun.tools.javac.tree.JCTree.JCBinary;
+import com.sun.tools.javac.tree.JCTree.JCBlock;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
+import com.sun.tools.javac.tree.JCTree.JCModifiers;
+import com.sun.tools.javac.tree.JCTree.JCPrimitiveTypeTree;
+import com.sun.tools.javac.tree.JCTree.JCStatement;
+import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
+import com.sun.tools.javac.tree.JCTree.JCUnary;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Name;
+
+/**
+ * Handles the {@code lombok.EqualsAndHashCode} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleEqualsAndHashCode implements JavacAnnotationHandler<EqualsAndHashCode> {
+	private void checkForBogusFieldNames(JavacNode type, AnnotationValues<EqualsAndHashCode> annotation) {
+		if (annotation.isExplicit("exclude")) {
+			for (int i : createListOfNonExistentFields(List.from(annotation.getInstance().exclude()), type, true, true)) {
+				annotation.setWarning("exclude", "This field does not exist, or would have been excluded anyway.", i);
+			}
+		}
+		if (annotation.isExplicit("of")) {
+			for (int i : createListOfNonExistentFields(List.from(annotation.getInstance().of()), type, false, false)) {
+				annotation.setWarning("of", "This field does not exist.", i);
+			}
+		}
+	}
+	
+	@Override public boolean handle(AnnotationValues<EqualsAndHashCode> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		EqualsAndHashCode ann = annotation.getInstance();
+		List<String> excludes = List.from(ann.exclude());
+		List<String> includes = List.from(ann.of());
+		JavacNode typeNode = annotationNode.up();
+		
+		checkForBogusFieldNames(typeNode, annotation);
+		
+		Boolean callSuper = ann.callSuper();
+		if (!annotation.isExplicit("callSuper")) callSuper = null;
+		if (!annotation.isExplicit("exclude")) excludes = null;
+		if (!annotation.isExplicit("of")) includes = null;
+		
+		if (excludes != null && includes != null) {
+			excludes = null;
+			annotation.setWarning("exclude", "exclude and of are mutually exclusive; the 'exclude' parameter will be ignored.");
+		}
+		
+		return generateMethods(typeNode, annotationNode, excludes, includes, callSuper, true);
+	}
+	
+	public void generateEqualsAndHashCodeForType(JavacNode typeNode, JavacNode errorNode) {
+		for (JavacNode child : typeNode.down()) {
+			if (child.getKind() == Kind.ANNOTATION) {
+				if (Javac.annotationTypeMatches(EqualsAndHashCode.class, child)) {
+					//The annotation will make it happen, so we can skip it.
+					return;
+				}
+			}
+		}
+		
+		generateMethods(typeNode, errorNode, null, null, null, false);
+	}
+	
+	private boolean generateMethods(JavacNode typeNode, JavacNode errorNode, List<String> excludes, List<String> includes,
+			Boolean callSuper, boolean whineIfExists) {
+		boolean notAClass = true;
+		if (typeNode.get() instanceof JCClassDecl) {
+			long flags = ((JCClassDecl)typeNode.get()).mods.flags;
+			notAClass = (flags & (Flags.INTERFACE | Flags.ANNOTATION | Flags.ENUM)) != 0;
+		}
+		
+		if (notAClass) {
+			errorNode.addError("@EqualsAndHashCode is only supported on a class.");
+			return false;
+		}
+		
+		boolean isDirectDescendantOfObject = true;
+		boolean implicitCallSuper = callSuper == null;
+		if (callSuper == null) {
+			try {
+				callSuper = ((Boolean)EqualsAndHashCode.class.getMethod("callSuper").getDefaultValue()).booleanValue();
+			} catch (Exception ignore) {
+				throw new InternalError("Lombok bug - this cannot happen - can't find callSuper field in EqualsAndHashCode annotation.");
+			}
+		}
+		
+		JCTree extending = ((JCClassDecl)typeNode.get()).extending;
+		if (extending != null) {
+			String p = extending.toString();
+			isDirectDescendantOfObject = p.equals("Object") || p.equals("java.lang.Object");
+		}
+		
+		if (isDirectDescendantOfObject && callSuper) {
+			errorNode.addError("Generating equals/hashCode with a supercall to java.lang.Object is pointless.");
+			return true;
+		}
+		
+		if (!isDirectDescendantOfObject && !callSuper && implicitCallSuper) {
+			errorNode.addWarning("Generating equals/hashCode implementation but without a call to superclass, even though this class does not extend java.lang.Object. If this is intentional, add '@EqualsAndHashCode(callSuper=false)' to your type.");
+		}
+		
+		List<JavacNode> nodesForEquality = List.nil();
+		if (includes != null) {
+			for (JavacNode child : typeNode.down()) {
+				if (child.getKind() != Kind.FIELD) continue;
+				JCVariableDecl fieldDecl = (JCVariableDecl) child.get();
+				if (includes.contains(fieldDecl.name.toString())) nodesForEquality = nodesForEquality.append(child);
+			}
+		} else {
+			for (JavacNode child : typeNode.down()) {
+				if (child.getKind() != Kind.FIELD) continue;
+				JCVariableDecl fieldDecl = (JCVariableDecl) child.get();
+				//Skip static fields.
+				if ((fieldDecl.mods.flags & Flags.STATIC) != 0) continue;
+				//Skip transient fields.
+				if ((fieldDecl.mods.flags & Flags.TRANSIENT) != 0) continue;
+				//Skip excluded fields.
+				if (excludes != null && excludes.contains(fieldDecl.name.toString())) continue;
+				//Skip fields that start with $
+				if (fieldDecl.name.toString().startsWith("$")) continue;
+				nodesForEquality = nodesForEquality.append(child);
+			}
+		}
+		
+		switch (methodExists("hashCode", typeNode)) {
+		case NOT_EXISTS:
+			JCMethodDecl method = createHashCode(typeNode, nodesForEquality, callSuper);
+			injectMethod(typeNode, method);
+			break;
+		case EXISTS_BY_LOMBOK:
+			break;
+		default:
+		case EXISTS_BY_USER:
+			if (whineIfExists) {
+				errorNode.addWarning("Not generating hashCode(): A method with that name already exists");
+			}
+			break;
+		}
+		
+		switch (methodExists("equals", typeNode)) {
+		case NOT_EXISTS:
+			JCMethodDecl method = createEquals(typeNode, nodesForEquality, callSuper);
+			injectMethod(typeNode, method);
+			break;
+		case EXISTS_BY_LOMBOK:
+			break;
+		default:
+		case EXISTS_BY_USER:
+			if (whineIfExists) {
+				errorNode.addWarning("Not generating equals(Object other): A method with that name already exists");
+			}
+			break;
+		}
+		
+		return true;
+	}
+	
+	private JCMethodDecl createHashCode(JavacNode typeNode, List<JavacNode> fields, boolean callSuper) {
+		TreeMaker maker = typeNode.getTreeMaker();
+		
+		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
+		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
+		JCExpression returnType = maker.TypeIdent(TypeTags.INT);
+		List<JCStatement> statements = List.nil();
+		
+		Name primeName = typeNode.toName("PRIME");
+		Name resultName = typeNode.toName("result");
+		/* final int PRIME = 31; */ {
+			if (!fields.isEmpty() || callSuper) {
+				statements = statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL),
+						primeName, maker.TypeIdent(TypeTags.INT), maker.Literal(31)));
+			}
+		}
+		
+		/* int result = 1; */ {
+			statements = statements.append(maker.VarDef(maker.Modifiers(0), resultName, maker.TypeIdent(TypeTags.INT), maker.Literal(1)));
+		}
+		
+		List<JCExpression> intoResult = List.nil();
+		
+		if (callSuper) {
+			JCMethodInvocation callToSuper = maker.Apply(List.<JCExpression>nil(),
+					maker.Select(maker.Ident(typeNode.toName("super")), typeNode.toName("hashCode")),
+					List.<JCExpression>nil());
+			intoResult = intoResult.append(callToSuper);
+		}
+		
+		int tempCounter = 0;
+		for (JavacNode fieldNode : fields) {
+			JCVariableDecl field = (JCVariableDecl) fieldNode.get();
+			JCExpression fType = field.vartype;
+			JCExpression thisDotField = maker.Select(maker.Ident(typeNode.toName("this")), field.name);
+			JCExpression thisDotFieldClone = maker.Select(maker.Ident(typeNode.toName("this")), field.name);
+			if (fType instanceof JCPrimitiveTypeTree) {
+				switch (((JCPrimitiveTypeTree)fType).getPrimitiveTypeKind()) {
+				case BOOLEAN:
+					/* this.fieldName ? 1231 : 1237 */
+					intoResult = intoResult.append(maker.Conditional(thisDotField, maker.Literal(1231), maker.Literal(1237)));
+					break;
+				case LONG:
+					intoResult = intoResult.append(longToIntForHashCode(maker, thisDotField, thisDotFieldClone));
+					break;
+				case FLOAT:
+					/* Float.floatToIntBits(this.fieldName) */
+					intoResult = intoResult.append(maker.Apply(
+							List.<JCExpression>nil(),
+							chainDots(maker, typeNode, "java", "lang", "Float", "floatToIntBits"),
+							List.of(thisDotField)));
+					break;
+				case DOUBLE:
+					/* longToIntForHashCode(Double.doubleToLongBits(this.fieldName)) */
+					Name tempVar = typeNode.toName("temp" + (++tempCounter));
+					JCExpression init = maker.Apply(
+							List.<JCExpression>nil(),
+							chainDots(maker, typeNode, "java", "lang", "Double", "doubleToLongBits"),
+							List.of(thisDotField));
+					statements = statements.append(
+							maker.VarDef(maker.Modifiers(Flags.FINAL), tempVar, maker.TypeIdent(TypeTags.LONG), init));
+					intoResult = intoResult.append(longToIntForHashCode(maker, maker.Ident(tempVar), maker.Ident(tempVar)));
+					break;
+				default:
+				case BYTE:
+				case SHORT:
+				case INT:
+				case CHAR:
+					/* just the field */
+					intoResult = intoResult.append(thisDotField);
+					break;
+				}
+			} else if (fType instanceof JCArrayTypeTree) {
+				/* java.util.Arrays.deepHashCode(this.fieldName) //use just hashCode() for primitive arrays. */
+				boolean multiDim = ((JCArrayTypeTree)fType).elemtype instanceof JCArrayTypeTree;
+				boolean primitiveArray = ((JCArrayTypeTree)fType).elemtype instanceof JCPrimitiveTypeTree;
+				boolean useDeepHC = multiDim || !primitiveArray;
+				
+				JCExpression hcMethod = chainDots(maker, typeNode, "java", "util", "Arrays", useDeepHC ? "deepHashCode" : "hashCode");
+				intoResult = intoResult.append(
+						maker.Apply(List.<JCExpression>nil(), hcMethod, List.of(thisDotField)));
+			} else /* objects */ {
+				/* this.fieldName == null ? 0 : this.fieldName.hashCode() */
+				JCExpression hcCall = maker.Apply(List.<JCExpression>nil(), maker.Select(thisDotField, typeNode.toName("hashCode")),
+						List.<JCExpression>nil());
+				JCExpression thisEqualsNull = maker.Binary(JCTree.EQ, thisDotField, maker.Literal(TypeTags.BOT, null));
+				intoResult = intoResult.append(
+						maker.Conditional(thisEqualsNull, maker.Literal(0), hcCall));
+			}
+		}
+		
+		/* fold each intoResult entry into:
+		   result = result * PRIME + (item); */
+		for (JCExpression expr : intoResult) {
+			JCExpression mult = maker.Binary(JCTree.MUL, maker.Ident(resultName), maker.Ident(primeName));
+			JCExpression add = maker.Binary(JCTree.PLUS, mult, expr);
+			statements = statements.append(maker.Exec(maker.Assign(maker.Ident(resultName), add)));
+		}
+		
+		/* return result; */ {
+			statements = statements.append(maker.Return(maker.Ident(resultName)));
+		}
+		
+		JCBlock body = maker.Block(0, statements);
+		return maker.MethodDef(mods, typeNode.toName("hashCode"), returnType,
+				List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null);
+	}
+	
+	/** The 2 references must be clones of each other. */
+	private JCExpression longToIntForHashCode(TreeMaker maker, JCExpression ref1, JCExpression ref2) {
+		/* (int)(ref >>> 32 ^ ref) */
+		JCExpression shift = maker.Binary(JCTree.USR, ref1, maker.Literal(32));
+		JCExpression xorBits = maker.Binary(JCTree.BITXOR, shift, ref2);
+		return maker.TypeCast(maker.TypeIdent(TypeTags.INT), xorBits);
+	}
+	
+	private JCMethodDecl createEquals(JavacNode typeNode, List<JavacNode> fields, boolean callSuper) {
+		TreeMaker maker = typeNode.getTreeMaker();
+		JCClassDecl type = (JCClassDecl) typeNode.get();
+		
+		Name oName = typeNode.toName("o");
+		Name otherName = typeNode.toName("other");
+		Name thisName = typeNode.toName("this");
+		
+		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
+		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
+		JCExpression objectType = maker.Type(typeNode.getSymbolTable().objectType);
+		JCExpression returnType = maker.TypeIdent(TypeTags.BOOLEAN);
+		
+		List<JCStatement> statements = List.nil();
+		List<JCVariableDecl> params = List.of(maker.VarDef(maker.Modifiers(Flags.FINAL), oName, objectType, null));
+		
+		/* if (o == this) return true; */ {
+			statements = statements.append(maker.If(maker.Binary(JCTree.EQ, maker.Ident(oName),
+					maker.Ident(thisName)), returnBool(maker, true), null));
+		}
+		
+		/* if (o == null) return false; */ {
+			statements = statements.append(maker.If(maker.Binary(JCTree.EQ, maker.Ident(oName),
+					maker.Literal(TypeTags.BOT, null)), returnBool(maker, false), null));
+		}
+		
+		/* if (o.getClass() != this.getClass()) return false; */ {
+			Name getClass = typeNode.toName("getClass");
+			List<JCExpression> exprNil = List.nil();
+			JCExpression oGetClass = maker.Apply(exprNil, maker.Select(maker.Ident(oName), getClass), exprNil);
+			JCExpression thisGetClass = maker.Apply(exprNil, maker.Select(maker.Ident(thisName), getClass), exprNil);
+			statements = statements.append(
+					maker.If(maker.Binary(JCTree.NE, oGetClass, thisGetClass), returnBool(maker, false), null));
+		}
+		
+		/* if (!super.equals(o)) return false; */
+		if (callSuper) {
+			JCMethodInvocation callToSuper = maker.Apply(List.<JCExpression>nil(),
+					maker.Select(maker.Ident(typeNode.toName("super")), typeNode.toName("equals")),
+					List.<JCExpression>of(maker.Ident(oName)));
+			JCUnary superNotEqual = maker.Unary(JCTree.NOT, callToSuper);
+			statements = statements.append(maker.If(superNotEqual, returnBool(maker, false), null));
+		}
+		
+		/* MyType<?> other = (MyType<?>) o; */ {
+			final JCExpression selfType1, selfType2;
+			List<JCExpression> wildcards1 = List.nil();
+			List<JCExpression> wildcards2 = List.nil();
+			for (int i = 0 ; i < type.typarams.length() ; i++) {
+				wildcards1 = wildcards1.append(maker.Wildcard(maker.TypeBoundKind(BoundKind.UNBOUND), null));
+				wildcards2 = wildcards2.append(maker.Wildcard(maker.TypeBoundKind(BoundKind.UNBOUND), null));
+			}
+			
+			if (type.typarams.isEmpty()) {
+				selfType1 = maker.Ident(type.name);
+				selfType2 = maker.Ident(type.name);
+			} else {
+				selfType1 = maker.TypeApply(maker.Ident(type.name), wildcards1);
+				selfType2 = maker.TypeApply(maker.Ident(type.name), wildcards2);
+			}
+			
+			statements = statements.append(
+					maker.VarDef(maker.Modifiers(Flags.FINAL), otherName, selfType1, maker.TypeCast(selfType2, maker.Ident(oName))));
+		}
+		
+		for (JavacNode fieldNode : fields) {
+			JCVariableDecl field = (JCVariableDecl) fieldNode.get();
+			JCExpression fType = field.vartype;
+			JCExpression thisDotField = maker.Select(maker.Ident(thisName), field.name);
+			JCExpression otherDotField = maker.Select(maker.Ident(otherName), field.name);
+			if (fType instanceof JCPrimitiveTypeTree) {
+				switch (((JCPrimitiveTypeTree)fType).getPrimitiveTypeKind()) {
+				case FLOAT:
+					/* if (Float.compare(this.fieldName, other.fieldName) != 0) return false; */
+					statements = statements.append(generateCompareFloatOrDouble(thisDotField, otherDotField, maker, typeNode, false));
+					break;
+				case DOUBLE:
+					/* if (Double(this.fieldName, other.fieldName) != 0) return false; */
+					statements = statements.append(generateCompareFloatOrDouble(thisDotField, otherDotField, maker, typeNode, true));
+					break;
+				default:
+					/* if (this.fieldName != other.fieldName) return false; */
+					statements = statements.append(
+							maker.If(maker.Binary(JCTree.NE, thisDotField, otherDotField), returnBool(maker, false), null));
+					break;
+				}
+			} else if (fType instanceof JCArrayTypeTree) {
+				/* if (!java.util.Arrays.deepEquals(this.fieldName, other.fieldName)) return false; //use equals for primitive arrays. */
+				boolean multiDim = ((JCArrayTypeTree)fType).elemtype instanceof JCArrayTypeTree;
+				boolean primitiveArray = ((JCArrayTypeTree)fType).elemtype instanceof JCPrimitiveTypeTree;
+				boolean useDeepEquals = multiDim || !primitiveArray;
+				
+				JCExpression eqMethod = chainDots(maker, typeNode, "java", "util", "Arrays", useDeepEquals ? "deepEquals" : "equals");
+				List<JCExpression> args = List.of(thisDotField, otherDotField);
+				statements = statements.append(maker.If(maker.Unary(JCTree.NOT,
+						maker.Apply(List.<JCExpression>nil(), eqMethod, args)), returnBool(maker, false), null));
+			} else /* objects */ {
+				/* if (this.fieldName == null ? other.fieldName != null : !this.fieldName.equals(other.fieldName)) return false; */
+				JCExpression thisEqualsNull = maker.Binary(JCTree.EQ, thisDotField, maker.Literal(TypeTags.BOT, null));
+				JCExpression otherNotEqualsNull = maker.Binary(JCTree.NE, otherDotField, maker.Literal(TypeTags.BOT, null));
+				JCExpression thisEqualsThat = maker.Apply(
+						List.<JCExpression>nil(), maker.Select(thisDotField, typeNode.toName("equals")), List.of(otherDotField));
+				JCExpression fieldsAreNotEqual = maker.Conditional(thisEqualsNull, otherNotEqualsNull, maker.Unary(JCTree.NOT, thisEqualsThat));
+				statements = statements.append(maker.If(fieldsAreNotEqual, returnBool(maker, false), null));
+			}
+		}
+		
+		/* return true; */ {
+			statements = statements.append(returnBool(maker, true));
+		}
+		
+		JCBlock body = maker.Block(0, statements);
+		return maker.MethodDef(mods, typeNode.toName("equals"), returnType, List.<JCTypeParameter>nil(), params, List.<JCExpression>nil(), body, null);
+	}
+	
+	private JCStatement generateCompareFloatOrDouble(JCExpression thisDotField, JCExpression otherDotField,
+			TreeMaker maker, JavacNode node, boolean isDouble) {
+		/* if (Float.compare(fieldName, other.fieldName) != 0) return false; */
+		JCExpression clazz = chainDots(maker, node, "java", "lang", isDouble ? "Double" : "Float");
+		List<JCExpression> args = List.of(thisDotField, otherDotField);
+		JCBinary compareCallEquals0 = maker.Binary(JCTree.NE, maker.Apply(
+				List.<JCExpression>nil(), maker.Select(clazz, node.toName("compare")), args), maker.Literal(0));
+		return maker.If(compareCallEquals0, returnBool(maker, false), null);
+	}
+	
+	private JCStatement returnBool(TreeMaker maker, boolean bool) {
+		return maker.Return(maker.Literal(TypeTags.BOOLEAN, bool ? 1 : 0));
+	}
+	
+}
diff --git a/src/core/lombok/javac/handlers/HandleGetter.java b/src/core/lombok/javac/handlers/HandleGetter.java
new file mode 100644
index 00000000..e60e426d
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleGetter.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.core.AnnotationValues;
+import lombok.core.TransformationsUtil;
+import lombok.core.AST.Kind;
+import lombok.javac.Javac;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCBlock;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+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.List;
+import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+
+/**
+ * Handles the {@code lombok.Getter} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleGetter implements JavacAnnotationHandler<Getter> {
+	/**
+	 * Generates a getter on the stated field.
+	 * 
+	 * Used by {@link HandleData}.
+	 * 
+	 * The difference between this call and the handle method is as follows:
+	 * 
+	 * If there is a {@code lombok.Getter} annotation on the field, it is used and the
+	 * same rules apply (e.g. warning if the method already exists, stated access level applies).
+	 * If not, the getter is still generated if it isn't already there, though there will not
+	 * be a warning if its already there. The default access level is used.
+	 * 
+	 * @param fieldNode The node representing the field you want a getter for.
+	 * @param pos The node responsible for generating the getter (the {@code @Data} or {@code @Getter} annotation).
+	 */
+	public void generateGetterForField(JavacNode fieldNode, DiagnosticPosition pos) {
+		for (JavacNode child : fieldNode.down()) {
+			if (child.getKind() == Kind.ANNOTATION) {
+				if (Javac.annotationTypeMatches(Getter.class, child)) {
+					//The annotation will make it happen, so we can skip it.
+					return;
+				}
+			}
+		}
+		
+		createGetterForField(AccessLevel.PUBLIC, fieldNode, fieldNode, false);
+	}
+	
+	@Override public boolean handle(AnnotationValues<Getter> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		JavacNode fieldNode = annotationNode.up();
+		AccessLevel level = annotation.getInstance().value();
+		if (level == AccessLevel.NONE) return true;
+		
+		return createGetterForField(level, fieldNode, annotationNode, true);
+	}
+	
+	private boolean createGetterForField(AccessLevel level,
+			JavacNode fieldNode, JavacNode errorNode, boolean whineIfExists) {
+		if (fieldNode.getKind() != Kind.FIELD) {
+			errorNode.addError("@Getter is only supported on a field.");
+			return true;
+		}
+		
+		JCVariableDecl fieldDecl = (JCVariableDecl)fieldNode.get();
+		String methodName = toGetterName(fieldDecl);
+		
+		for (String altName : toAllGetterNames(fieldDecl)) {
+			switch (methodExists(altName, fieldNode)) {
+			case EXISTS_BY_LOMBOK:
+				return true;
+			case EXISTS_BY_USER:
+				if (whineIfExists) {
+					String altNameExpl = "";
+					if (!altName.equals(methodName)) altNameExpl = String.format(" (%s)", altName);
+					errorNode.addWarning(
+						String.format("Not generating %s(): A method with that name already exists%s", methodName, altNameExpl));
+				}
+				return true;
+			default:
+			case NOT_EXISTS:
+				//continue scanning the other alt names.
+			}
+		}
+		
+		long access = toJavacModifier(level) | (fieldDecl.mods.flags & Flags.STATIC);
+		
+		injectMethod(fieldNode.up(), createGetter(access, fieldNode, fieldNode.getTreeMaker()));
+		
+		return true;
+	}
+	
+	private JCMethodDecl createGetter(long access, JavacNode field, TreeMaker treeMaker) {
+		JCVariableDecl fieldNode = (JCVariableDecl) field.get();
+		JCStatement returnStatement = treeMaker.Return(treeMaker.Ident(fieldNode.getName()));
+		
+		JCBlock methodBody = treeMaker.Block(0, List.of(returnStatement));
+		Name methodName = field.toName(toGetterName(fieldNode));
+		JCExpression methodType = fieldNode.type != null ? treeMaker.Type(fieldNode.type) : fieldNode.vartype;
+		
+		List<JCTypeParameter> methodGenericParams = List.nil();
+		List<JCVariableDecl> parameters = List.nil();
+		List<JCExpression> throwsClauses = List.nil();
+		JCExpression annotationMethodDefaultValue = null;
+		
+		List<JCAnnotation> nonNulls = findAnnotations(field, TransformationsUtil.NON_NULL_PATTERN);
+		List<JCAnnotation> nullables = findAnnotations(field, TransformationsUtil.NULLABLE_PATTERN);
+		return treeMaker.MethodDef(treeMaker.Modifiers(access, nonNulls.appendList(nullables)), methodName, methodType,
+				methodGenericParams, parameters, throwsClauses, methodBody, annotationMethodDefaultValue);
+	}
+}
diff --git a/src/core/lombok/javac/handlers/HandlePrintAST.java b/src/core/lombok/javac/handlers/HandlePrintAST.java
new file mode 100644
index 00000000..4c25694b
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandlePrintAST.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintStream;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+
+import lombok.Lombok;
+import lombok.core.AnnotationValues;
+import lombok.core.PrintAST;
+import lombok.javac.JavacASTVisitor;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+/**
+ * Handles the {@code lombok.core.PrintAST} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandlePrintAST implements JavacAnnotationHandler<PrintAST> {
+	@Override public boolean handle(AnnotationValues<PrintAST> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		PrintStream stream = System.out;
+		String fileName = annotation.getInstance().outfile();
+		if (fileName.length() > 0) try {
+			stream = new PrintStream(new File(fileName));
+		} catch (FileNotFoundException e) {
+			Lombok.sneakyThrow(e);
+		}
+		
+		annotationNode.up().traverse(new JavacASTVisitor.Printer(annotation.getInstance().printContent(), stream));
+		
+		return true;
+	}
+}
diff --git a/src/core/lombok/javac/handlers/HandleSetter.java b/src/core/lombok/javac/handlers/HandleSetter.java
new file mode 100644
index 00000000..84032e9c
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleSetter.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+import lombok.AccessLevel;
+import lombok.Setter;
+import lombok.core.AnnotationValues;
+import lombok.core.TransformationsUtil;
+import lombok.core.AST.Kind;
+import lombok.javac.Javac;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCAssign;
+import com.sun.tools.javac.tree.JCTree.JCBlock;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+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.List;
+import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+
+/**
+ * Handles the {@code lombok.Setter} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleSetter implements JavacAnnotationHandler<Setter> {
+	/**
+	 * Generates a setter on the stated field.
+	 * 
+	 * Used by {@link HandleData}.
+	 * 
+	 * The difference between this call and the handle method is as follows:
+	 * 
+	 * If there is a {@code lombok.Setter} annotation on the field, it is used and the
+	 * same rules apply (e.g. warning if the method already exists, stated access level applies).
+	 * If not, the setter is still generated if it isn't already there, though there will not
+	 * be a warning if its already there. The default access level is used.
+	 * 
+	 * @param fieldNode The node representing the field you want a setter for.
+	 * @param pos The node responsible for generating the setter (the {@code @Data} or {@code @Setter} annotation).
+	 */
+	public void generateSetterForField(JavacNode fieldNode, DiagnosticPosition pos) {
+		for (JavacNode child : fieldNode.down()) {
+			if (child.getKind() == Kind.ANNOTATION) {
+				if (Javac.annotationTypeMatches(Setter.class, child)) {
+					//The annotation will make it happen, so we can skip it.
+					return;
+				}
+			}
+		}
+		
+		createSetterForField(AccessLevel.PUBLIC, fieldNode, fieldNode, false);
+	}
+	
+	@Override public boolean handle(AnnotationValues<Setter> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		JavacNode fieldNode = annotationNode.up();
+		AccessLevel level = annotation.getInstance().value();
+		if (level == AccessLevel.NONE) return true;
+		
+		return createSetterForField(level, fieldNode, annotationNode, true);
+	}
+	
+	private boolean createSetterForField(AccessLevel level,
+			JavacNode fieldNode, JavacNode errorNode, boolean whineIfExists) {
+		if (fieldNode.getKind() != Kind.FIELD) {
+			fieldNode.addError("@Setter is only supported on a field.");
+			return true;
+		}
+		
+		JCVariableDecl fieldDecl = (JCVariableDecl)fieldNode.get();
+		String methodName = toSetterName(fieldDecl);
+		
+		switch (methodExists(methodName, fieldNode)) {
+		case EXISTS_BY_LOMBOK:
+			return true;
+		case EXISTS_BY_USER:
+			if (whineIfExists) errorNode.addWarning(
+					String.format("Not generating %s(%s %s): A method with that name already exists",
+					methodName, fieldDecl.vartype, fieldDecl.name));
+			return true;
+		default:
+		case NOT_EXISTS:
+			//continue with creating the setter
+		}
+		
+		long access = toJavacModifier(level) | (fieldDecl.mods.flags & Flags.STATIC);
+		
+		injectMethod(fieldNode.up(), createSetter(access, fieldNode, fieldNode.getTreeMaker()));
+		
+		return true;
+	}
+	
+	private JCMethodDecl createSetter(long access, JavacNode field, TreeMaker treeMaker) {
+		JCVariableDecl fieldDecl = (JCVariableDecl) field.get();
+		
+		JCFieldAccess thisX = treeMaker.Select(treeMaker.Ident(field.toName("this")), fieldDecl.name);
+		JCAssign assign = treeMaker.Assign(thisX, treeMaker.Ident(fieldDecl.name));
+		
+		List<JCStatement> statements;
+		List<JCAnnotation> nonNulls = findAnnotations(field, TransformationsUtil.NON_NULL_PATTERN);
+		List<JCAnnotation> nullables = findAnnotations(field, TransformationsUtil.NULLABLE_PATTERN);
+		
+		if (nonNulls.isEmpty()) {
+			statements = List.<JCStatement>of(treeMaker.Exec(assign));
+		} else {
+			JCStatement nullCheck = generateNullCheck(treeMaker, field);
+			if (nullCheck != null) statements = List.<JCStatement>of(nullCheck, treeMaker.Exec(assign));
+			else statements = List.<JCStatement>of(treeMaker.Exec(assign));
+		}
+		
+		JCBlock methodBody = treeMaker.Block(0, statements);
+		Name methodName = field.toName(toSetterName(fieldDecl));
+		JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.FINAL, nonNulls.appendList(nullables)), fieldDecl.name, fieldDecl.vartype, null);
+		JCExpression methodType = treeMaker.Type(field.getSymbolTable().voidType);
+		
+		List<JCTypeParameter> methodGenericParams = List.nil();
+		List<JCVariableDecl> parameters = List.of(param);
+		List<JCExpression> throwsClauses = List.nil();
+		JCExpression annotationMethodDefaultValue = null;
+		
+		return treeMaker.MethodDef(treeMaker.Modifiers(access, List.<JCAnnotation>nil()), methodName, methodType,
+				methodGenericParams, parameters, throwsClauses, methodBody, annotationMethodDefaultValue);
+	}
+}
diff --git a/src/core/lombok/javac/handlers/HandleSneakyThrows.java b/src/core/lombok/javac/handlers/HandleSneakyThrows.java
new file mode 100644
index 00000000..e7879dd1
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleSneakyThrows.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import static lombok.javac.handlers.JavacHandlerUtil.chainDots;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import lombok.SneakyThrows;
+import lombok.core.AnnotationValues;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCBlock;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCStatement;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+
+/**
+ * Handles the {@code lombok.SneakyThrows} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleSneakyThrows implements JavacAnnotationHandler<SneakyThrows> {
+	@Override public boolean handle(AnnotationValues<SneakyThrows> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		Collection<String> exceptionNames = annotation.getRawExpressions("value");
+		
+		List<JCExpression> memberValuePairs = ast.getArguments();
+		if (memberValuePairs == null || memberValuePairs.size() == 0) return false;
+		
+		java.util.List<String> exceptions = new ArrayList<String>();
+		for (String exception : exceptionNames) {
+			if (exception.endsWith(".class")) exception = exception.substring(0, exception.length() - 6);
+			exceptions.add(exception);
+		}
+		
+		JavacNode owner = annotationNode.up();
+		switch (owner.getKind()) {
+		case METHOD:
+			return handleMethod(annotationNode, (JCMethodDecl)owner.get(), exceptions);
+		default:
+			annotationNode.addError("@SneakyThrows is legal only on methods and constructors.");
+			return true;
+		}
+	}
+	
+	private boolean handleMethod(JavacNode annotation, JCMethodDecl method, Collection<String> exceptions) {
+		JavacNode methodNode = annotation.up();
+		
+		if ( (method.mods.flags & Flags.ABSTRACT) != 0) {
+			annotation.addError("@SneakyThrows can only be used on concrete methods.");
+			return true;
+		}
+		
+		if (method.body == null) return false;
+		
+		List<JCStatement> contents = method.body.stats;
+		
+		for (String exception : exceptions) {
+			contents = List.of(buildTryCatchBlock(methodNode, contents, exception));
+		}
+		
+		method.body.stats = contents;
+		methodNode.rebuild();
+		
+		return true;
+	}
+
+	private JCStatement buildTryCatchBlock(JavacNode node, List<JCStatement> contents, String exception) {
+		TreeMaker maker = node.getTreeMaker();
+		
+		JCBlock tryBlock = maker.Block(0, contents);
+		
+		JCExpression varType = chainDots(maker, node, exception.split("\\."));
+		
+		JCVariableDecl catchParam = maker.VarDef(maker.Modifiers(0), node.toName("$ex"), varType, null);
+		JCExpression lombokLombokSneakyThrowNameRef = chainDots(maker, node, "lombok", "Lombok", "sneakyThrow");
+		JCBlock catchBody = maker.Block(0, List.<JCStatement>of(maker.Throw(maker.Apply(
+				List.<JCExpression>nil(), lombokLombokSneakyThrowNameRef,
+				List.<JCExpression>of(maker.Ident(node.toName("$ex")))))));
+		
+		return maker.Try(tryBlock, List.of(maker.Catch(catchParam, catchBody)), null);
+	}
+}
diff --git a/src/core/lombok/javac/handlers/HandleSynchronized.java b/src/core/lombok/javac/handlers/HandleSynchronized.java
new file mode 100644
index 00000000..c86d99c6
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleSynchronized.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.TypeTags;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCNewArray;
+import com.sun.tools.javac.tree.JCTree.JCStatement;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+
+import lombok.Synchronized;
+import lombok.core.AnnotationValues;
+import lombok.core.AST.Kind;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+/**
+ * Handles the {@code lombok.Synchronized} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleSynchronized implements JavacAnnotationHandler<Synchronized> {
+	private static final String INSTANCE_LOCK_NAME = "$lock";
+	private static final String STATIC_LOCK_NAME = "$LOCK";
+	
+	@Override public boolean handle(AnnotationValues<Synchronized> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		JavacNode methodNode = annotationNode.up();
+		
+		if (methodNode == null || methodNode.getKind() != Kind.METHOD || !(methodNode.get() instanceof JCMethodDecl)) {
+			annotationNode.addError("@Synchronized is legal only on methods.");
+			return true;
+		}
+		
+		JCMethodDecl method = (JCMethodDecl)methodNode.get();
+		
+		if ((method.mods.flags & Flags.ABSTRACT) != 0) {
+			annotationNode.addError("@Synchronized is legal only on concrete methods.");
+			return true;
+		}
+		boolean isStatic = (method.mods.flags & Flags.STATIC) != 0;
+		String lockName = annotation.getInstance().value();
+		boolean autoMake = false;
+		if (lockName.length() == 0) {
+			autoMake = true;
+			lockName = isStatic ? STATIC_LOCK_NAME : INSTANCE_LOCK_NAME;
+		}
+		
+		TreeMaker maker = methodNode.getTreeMaker();
+		
+		if (fieldExists(lockName, methodNode) == MemberExistsResult.NOT_EXISTS) {
+			if (!autoMake) {
+				annotationNode.addError("The field " + lockName + " does not exist.");
+				return true;
+			}
+			JCExpression objectType = chainDots(maker, methodNode, "java", "lang", "Object");
+			//We use 'new Object[0];' because quite unlike 'new Object();', empty arrays *ARE* serializable!
+			JCNewArray newObjectArray = maker.NewArray(chainDots(maker, methodNode, "java", "lang", "Object"),
+					List.<JCExpression>of(maker.Literal(TypeTags.INT, 0)), null);
+			JCVariableDecl fieldDecl = maker.VarDef(
+					maker.Modifiers(Flags.FINAL | (isStatic ? Flags.STATIC : 0)),
+					methodNode.toName(lockName), objectType, newObjectArray);
+			injectField(methodNode.up(), fieldDecl);
+		}
+		
+		if (method.body == null) return false;
+		
+		JCExpression lockNode = maker.Ident(methodNode.toName(lockName));
+		
+		method.body = maker.Block(0, List.<JCStatement>of(maker.Synchronized(lockNode, method.body)));
+		
+		methodNode.rebuild();
+		
+		return true;
+	}
+}
diff --git a/src/core/lombok/javac/handlers/HandleToString.java b/src/core/lombok/javac/handlers/HandleToString.java
new file mode 100644
index 00000000..f7251ab8
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleToString.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+
+import lombok.ToString;
+import lombok.core.AnnotationValues;
+import lombok.core.AST.Kind;
+import lombok.javac.Javac;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCArrayTypeTree;
+import com.sun.tools.javac.tree.JCTree.JCBlock;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
+import com.sun.tools.javac.tree.JCTree.JCModifiers;
+import com.sun.tools.javac.tree.JCTree.JCPrimitiveTypeTree;
+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.List;
+
+/**
+ * Handles the {@code ToString} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleToString implements JavacAnnotationHandler<ToString> {
+	private void checkForBogusFieldNames(JavacNode type, AnnotationValues<ToString> annotation) {
+		if (annotation.isExplicit("exclude")) {
+			for (int i : createListOfNonExistentFields(List.from(annotation.getInstance().exclude()), type, true, false)) {
+				annotation.setWarning("exclude", "This field does not exist, or would have been excluded anyway.", i);
+			}
+		}
+		if (annotation.isExplicit("of")) {
+			for (int i : createListOfNonExistentFields(List.from(annotation.getInstance().of()), type, false, false)) {
+				annotation.setWarning("of", "This field does not exist.", i);
+			}
+		}
+	}
+	
+	@Override public boolean handle(AnnotationValues<ToString> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		ToString ann = annotation.getInstance();
+		List<String> excludes = List.from(ann.exclude());
+		List<String> includes = List.from(ann.of());
+		JavacNode typeNode = annotationNode.up();
+		
+		checkForBogusFieldNames(typeNode, annotation);
+		
+		Boolean callSuper = ann.callSuper();
+		
+		if (!annotation.isExplicit("callSuper")) callSuper = null;
+		if (!annotation.isExplicit("exclude")) excludes = null;
+		if (!annotation.isExplicit("of")) includes = null;
+		
+		if (excludes != null && includes != null) {
+			excludes = null;
+			annotation.setWarning("exclude", "exclude and of are mutually exclusive; the 'exclude' parameter will be ignored.");
+		}
+		
+		return generateToString(typeNode, annotationNode, excludes, includes, ann.includeFieldNames(), callSuper, true);
+	}
+	
+	public void generateToStringForType(JavacNode typeNode, JavacNode errorNode) {
+		for (JavacNode child : typeNode.down()) {
+			if (child.getKind() == Kind.ANNOTATION) {
+				if (Javac.annotationTypeMatches(ToString.class, child)) {
+					//The annotation will make it happen, so we can skip it.
+					return;
+				}
+			}
+		}
+		
+		boolean includeFieldNames = true;
+		try {
+			includeFieldNames = ((Boolean)ToString.class.getMethod("includeFieldNames").getDefaultValue()).booleanValue();
+		} catch (Exception ignore) {}
+		generateToString(typeNode, errorNode, null, null, includeFieldNames, null, false);
+	}
+	
+	private boolean generateToString(JavacNode typeNode, JavacNode errorNode, List<String> excludes, List<String> includes,
+			boolean includeFieldNames, Boolean callSuper, boolean whineIfExists) {
+		boolean notAClass = true;
+		if (typeNode.get() instanceof JCClassDecl) {
+			long flags = ((JCClassDecl)typeNode.get()).mods.flags;
+			notAClass = (flags & (Flags.INTERFACE | Flags.ANNOTATION | Flags.ENUM)) != 0;
+		}
+		
+		if (callSuper == null) {
+			try {
+				callSuper = ((Boolean)ToString.class.getMethod("callSuper").getDefaultValue()).booleanValue();
+			} catch (Exception ignore) {}
+		}
+		
+		if (notAClass) {
+			errorNode.addError("@ToString is only supported on a class.");
+			return false;
+		}
+		
+		List<JavacNode> nodesForToString = List.nil();
+		if (includes != null) {
+			for (JavacNode child : typeNode.down()) {
+				if (child.getKind() != Kind.FIELD) continue;
+				JCVariableDecl fieldDecl = (JCVariableDecl) child.get();
+				if (includes.contains(fieldDecl.name.toString())) nodesForToString = nodesForToString.append(child);
+			}
+		} else {
+			for (JavacNode child : typeNode.down()) {
+				if (child.getKind() != Kind.FIELD) continue;
+				JCVariableDecl fieldDecl = (JCVariableDecl) child.get();
+				//Skip static fields.
+				if ((fieldDecl.mods.flags & Flags.STATIC) != 0) continue;
+				//Skip excluded fields.
+				if (excludes != null && excludes.contains(fieldDecl.name.toString())) continue;
+				//Skip fields that start with $.
+				if (fieldDecl.name.toString().startsWith("$")) continue;
+				nodesForToString = nodesForToString.append(child);
+			}
+		}
+		
+		switch (methodExists("toString", typeNode)) {
+		case NOT_EXISTS:
+			JCMethodDecl method = createToString(typeNode, nodesForToString, includeFieldNames, callSuper);
+			injectMethod(typeNode, method);
+			return true;
+		case EXISTS_BY_LOMBOK:
+			return true;
+		default:
+		case EXISTS_BY_USER:
+			if (whineIfExists) {
+				errorNode.addWarning("Not generating toString(): A method with that name already exists");
+			}
+			return true;
+		}
+
+	}
+	
+	private JCMethodDecl createToString(JavacNode typeNode, List<JavacNode> fields, boolean includeFieldNames, boolean callSuper) {
+		TreeMaker maker = typeNode.getTreeMaker();
+		
+		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
+		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
+		JCExpression returnType = chainDots(maker, typeNode, "java", "lang", "String");
+		
+		boolean first = true;
+		
+		String typeName = ((JCClassDecl) typeNode.get()).name.toString();
+		String infix = ", ";
+		String suffix = ")";
+		String prefix;
+		if (callSuper) {
+			prefix = typeName + "(super=";
+		} else if (fields.isEmpty()) {
+			prefix = typeName + "()";
+		} else if (includeFieldNames) {
+			prefix = typeName + "(" + ((JCVariableDecl)fields.iterator().next().get()).name.toString() + "=";
+		} else {
+			prefix = typeName + "(";
+		}
+		
+		JCExpression current = maker.Literal(prefix);
+		
+		if (callSuper) {
+			JCMethodInvocation callToSuper = maker.Apply(List.<JCExpression>nil(),
+					maker.Select(maker.Ident(typeNode.toName("super")), typeNode.toName("toString")),
+					List.<JCExpression>nil());
+			current = maker.Binary(JCTree.PLUS, current, callToSuper);
+			first = false;
+		}
+		
+		for (JavacNode fieldNode : fields) {
+			JCVariableDecl field = (JCVariableDecl) fieldNode.get();
+			JCExpression expr;
+			
+			if (field.vartype instanceof JCArrayTypeTree) {
+				boolean multiDim = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCArrayTypeTree;
+				boolean primitiveArray = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCPrimitiveTypeTree;
+				boolean useDeepTS = multiDim || !primitiveArray;
+				
+				JCExpression hcMethod = chainDots(maker, typeNode, "java", "util", "Arrays", useDeepTS ? "deepToString" : "toString");
+				expr = maker.Apply(List.<JCExpression>nil(), hcMethod, List.<JCExpression>of(maker.Ident(field.name)));
+			} else expr = maker.Ident(field.name);
+			
+			if (first) {
+				current = maker.Binary(JCTree.PLUS, current, expr);
+				first = false;
+				continue;
+			}
+			
+			if (includeFieldNames) {
+				current = maker.Binary(JCTree.PLUS, current, maker.Literal(infix + fieldNode.getName() + "="));
+			} else {
+				current = maker.Binary(JCTree.PLUS, current, maker.Literal(infix));
+			}
+			
+			current = maker.Binary(JCTree.PLUS, current, expr);
+		}
+		
+		if (!first) current = maker.Binary(JCTree.PLUS, current, maker.Literal(suffix));
+		
+		JCStatement returnStatement = maker.Return(current);
+		
+		JCBlock body = maker.Block(0, List.of(returnStatement));
+		
+		return maker.MethodDef(mods, typeNode.toName("toString"), returnType,
+				List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null);
+	}
+	
+}
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
new file mode 100644
index 00000000..34d8b849
--- /dev/null
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -0,0 +1,335 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.javac.handlers;
+
+import java.util.regex.Pattern;
+
+import lombok.AccessLevel;
+import lombok.core.TransformationsUtil;
+import lombok.core.AST.Kind;
+import lombok.javac.JavacNode;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.TypeTags;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCStatement;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Name;
+
+/**
+ * Container for static utility methods useful to handlers written for javac.
+ */
+public class JavacHandlerUtil {
+	private JavacHandlerUtil() {
+		//Prevent instantiation
+	}
+	
+	/**
+	 * Checks if the given expression (that really ought to refer to a type expression) represents a primitive type.
+	 */
+	public static boolean isPrimitive(JCExpression ref) {
+		String typeName = ref.toString();
+		return TransformationsUtil.PRIMITIVE_TYPE_NAME_PATTERN.matcher(typeName).matches();
+	}
+	
+	/**
+	 * Translates the given field into all possible getter names.
+	 * Convenient wrapper around {@link TransformationsUtil#toAllGetterNames(CharSequence, boolean)}.
+	 */
+	public static java.util.List<String> toAllGetterNames(JCVariableDecl field) {
+		CharSequence fieldName = field.name;
+		
+		boolean isBoolean = field.vartype.toString().equals("boolean");
+		
+		return TransformationsUtil.toAllGetterNames(fieldName, isBoolean);
+	}
+	
+	/**
+	 * @return the likely getter name for the stated field. (e.g. private boolean foo; to isFoo).
+	 * 
+	 * Convenient wrapper around {@link TransformationsUtil#toGetterName(CharSequence, boolean)}.
+	 */
+	public static String toGetterName(JCVariableDecl field) {
+		CharSequence fieldName = field.name;
+		
+		boolean isBoolean = field.vartype.toString().equals("boolean");
+		
+		return TransformationsUtil.toGetterName(fieldName, isBoolean);
+	}
+	
+	/**
+	 * @return the likely setter name for the stated field. (e.g. private boolean foo; to setFoo).
+	 * 
+	 * Convenient wrapper around {@link TransformationsUtil#toSetterName(CharSequence)}.
+	 */
+	public static String toSetterName(JCVariableDecl field) {
+		CharSequence fieldName = field.name;
+		
+		return TransformationsUtil.toSetterName(fieldName);
+	}
+	
+	/** Serves as return value for the methods that check for the existence of fields and methods. */
+	public enum MemberExistsResult {
+		NOT_EXISTS, EXISTS_BY_USER, EXISTS_BY_LOMBOK;
+	}
+	
+	/**
+	 * Checks if there is a field with the provided name.
+	 * 
+	 * @param fieldName the field name to check for.
+	 * @param node Any node that represents the Type (JCClassDecl) to look in, or any child node thereof.
+	 */
+	public static MemberExistsResult fieldExists(String fieldName, JavacNode node) {
+		while (node != null && !(node.get() instanceof JCClassDecl)) {
+			node = node.up();
+		}
+		
+		if (node != null && node.get() instanceof JCClassDecl) {
+			for (JCTree def : ((JCClassDecl)node.get()).defs) {
+				if (def instanceof JCVariableDecl) {
+					if (((JCVariableDecl)def).name.contentEquals(fieldName)) {
+						JavacNode existing = node.getNodeFor(def);
+						if (existing == null || !existing.isHandled()) return MemberExistsResult.EXISTS_BY_USER;
+						return MemberExistsResult.EXISTS_BY_LOMBOK;
+					}
+				}
+			}
+		}
+		
+		return MemberExistsResult.NOT_EXISTS;
+	}
+	
+	/**
+	 * Checks if there is a method with the provided name. In case of multiple methods (overloading), only
+	 * the first method decides if EXISTS_BY_USER or EXISTS_BY_LOMBOK is returned.
+	 * 
+	 * @param methodName the method name to check for.
+	 * @param node Any node that represents the Type (JCClassDecl) to look in, or any child node thereof.
+	 */
+	public static MemberExistsResult methodExists(String methodName, JavacNode node) {
+		while (node != null && !(node.get() instanceof JCClassDecl)) {
+			node = node.up();
+		}
+		
+		if (node != null && node.get() instanceof JCClassDecl) {
+			for (JCTree def : ((JCClassDecl)node.get()).defs) {
+				if (def instanceof JCMethodDecl) {
+					if (((JCMethodDecl)def).name.contentEquals(methodName)) {
+						JavacNode existing = node.getNodeFor(def);
+						if (existing == null || !existing.isHandled()) return MemberExistsResult.EXISTS_BY_USER;
+						return MemberExistsResult.EXISTS_BY_LOMBOK;
+					}
+				}
+			}
+		}
+		
+		return MemberExistsResult.NOT_EXISTS;
+	}
+	
+	/**
+	 * Checks if there is a (non-default) constructor. In case of multiple constructors (overloading), only
+	 * the first constructor decides if EXISTS_BY_USER or EXISTS_BY_LOMBOK is returned.
+	 * 
+	 * @param node Any node that represents the Type (JCClassDecl) to look in, or any child node thereof.
+	 */
+	public static MemberExistsResult constructorExists(JavacNode node) {
+		while (node != null && !(node.get() instanceof JCClassDecl)) {
+			node = node.up();
+		}
+		
+		if (node != null && node.get() instanceof JCClassDecl) {
+			for (JCTree def : ((JCClassDecl)node.get()).defs) {
+				if (def instanceof JCMethodDecl) {
+					if (((JCMethodDecl)def).name.contentEquals("<init>")) {
+						if ((((JCMethodDecl)def).mods.flags & Flags.GENERATEDCONSTR) != 0) continue;
+						JavacNode existing = node.getNodeFor(def);
+						if (existing == null || !existing.isHandled()) return MemberExistsResult.EXISTS_BY_USER;
+						return MemberExistsResult.EXISTS_BY_LOMBOK;
+					}
+				}
+			}
+		}
+		
+		return MemberExistsResult.NOT_EXISTS;
+	}
+	
+	/**
+	 * Turns an {@code AccessLevel} instance into the flag bit used by javac.
+	 */
+	public static int toJavacModifier(AccessLevel accessLevel) {
+		switch (accessLevel) {
+		case MODULE:
+		case PACKAGE:
+			return 0;
+		default:
+		case PUBLIC:
+			return Flags.PUBLIC;
+		case PRIVATE:
+			return Flags.PRIVATE;
+		case PROTECTED:
+			return Flags.PROTECTED;
+		}
+	}
+	
+	/**
+	 * Adds the given new field declaration to the provided type AST Node.
+	 * 
+	 * Also takes care of updating the JavacAST.
+	 */
+	public static void injectField(JavacNode typeNode, JCVariableDecl field) {
+		JCClassDecl type = (JCClassDecl) typeNode.get();
+		
+		type.defs = type.defs.append(field);
+		
+		typeNode.add(field, Kind.FIELD).recursiveSetHandled();
+	}
+	
+	/**
+	 * Adds the given new method declaration to the provided type AST Node.
+	 * Can also inject constructors.
+	 * 
+	 * Also takes care of updating the JavacAST.
+	 */
+	public static void injectMethod(JavacNode typeNode, JCMethodDecl method) {
+		JCClassDecl type = (JCClassDecl) typeNode.get();
+		
+		if (method.getName().contentEquals("<init>")) {
+			//Scan for default constructor, and remove it.
+			int idx = 0;
+			for (JCTree def : type.defs) {
+				if (def instanceof JCMethodDecl) {
+					if ((((JCMethodDecl)def).mods.flags & Flags.GENERATEDCONSTR) != 0) {
+						JavacNode tossMe = typeNode.getNodeFor(def);
+						if (tossMe != null) tossMe.up().removeChild(tossMe);
+						type.defs = addAllButOne(type.defs, idx);
+						break;
+					}
+				}
+				idx++;
+			}
+		}
+		
+		type.defs = type.defs.append(method);
+		
+		typeNode.add(method, Kind.METHOD).recursiveSetHandled();
+	}
+	
+	private static List<JCTree> addAllButOne(List<JCTree> defs, int idx) {
+		List<JCTree> out = List.nil();
+		int i = 0;
+		for (JCTree def : defs) {
+			if (i++ != idx) out = out.append(def);
+		}
+		return out;
+	}
+	
+	/**
+	 * In javac, dotted access of any kind, from {@code java.lang.String} to {@code var.methodName}
+	 * is represented by a fold-left of {@code Select} nodes with the leftmost string represented by
+	 * a {@code Ident} node. This method generates such an expression.
+	 * 
+	 * For example, maker.Select(maker.Select(maker.Ident(NAME[java]), NAME[lang]), NAME[String]).
+	 * 
+	 * @see com.sun.tools.javac.tree.JCTree.JCIdent
+	 * @see com.sun.tools.javac.tree.JCTree.JCFieldAccess
+	 */
+	public static JCExpression chainDots(TreeMaker maker, JavacNode node, String... elems) {
+		assert elems != null;
+		assert elems.length > 0;
+		
+		JCExpression e = maker.Ident(node.toName(elems[0]));
+		for (int i = 1 ; i < elems.length ; i++) {
+			e = maker.Select(e, node.toName(elems[i]));
+		}
+		
+		return e;
+	}
+	
+	/**
+	 * Searches the given field node for annotations and returns each one that matches the provided regular expression pattern.
+	 * 
+	 * Only the simple name is checked - the package and any containing class are ignored.
+	 */
+	public static List<JCAnnotation> findAnnotations(JavacNode fieldNode, Pattern namePattern) {
+		List<JCAnnotation> result = List.nil();
+		for (JavacNode child : fieldNode.down()) {
+			if (child.getKind() == Kind.ANNOTATION) {
+				JCAnnotation annotation = (JCAnnotation) child.get();
+				String name = annotation.annotationType.toString();
+				int idx = name.lastIndexOf(".");
+				String suspect = idx == -1 ? name : name.substring(idx + 1);
+				if (namePattern.matcher(suspect).matches()) {
+					result = result.append(annotation);
+				}
+			}
+		}	
+		return result;
+	}
+	
+	/**
+	 * Generates a new statement that checks if the given variable is null, and if so, throws a {@code NullPointerException} with the
+	 * variable name as message.
+	 */
+	public static JCStatement generateNullCheck(TreeMaker treeMaker, JavacNode variable) {
+		JCVariableDecl varDecl = (JCVariableDecl) variable.get();
+		if (isPrimitive(varDecl.vartype)) return null;
+		Name fieldName = varDecl.name;
+		JCExpression npe = chainDots(treeMaker, variable, "java", "lang", "NullPointerException");
+		JCTree exception = treeMaker.NewClass(null, List.<JCExpression>nil(), npe, List.<JCExpression>of(treeMaker.Literal(fieldName.toString())), null);
+		JCStatement throwStatement = treeMaker.Throw(exception);
+		return treeMaker.If(treeMaker.Binary(JCTree.EQ, treeMaker.Ident(fieldName), treeMaker.Literal(TypeTags.BOT, null)), throwStatement, null);
+	}
+	
+	/**
+	 * Given a list of field names and a node referring to a type, finds each name in the list that does not match a field within the type.
+	 */
+	public static List<Integer> createListOfNonExistentFields(List<String> list, JavacNode type, boolean excludeStandard, boolean excludeTransient) {
+		boolean[] matched = new boolean[list.size()];
+		
+		for (JavacNode child : type.down()) {
+			if (list.isEmpty()) break;
+			if (child.getKind() != Kind.FIELD) continue;
+			JCVariableDecl field = (JCVariableDecl)child.get();
+			if (excludeStandard) {
+				if ((field.mods.flags & Flags.STATIC) != 0) continue;
+				if (field.name.toString().startsWith("$")) continue;
+			}
+			if (excludeTransient && (field.mods.flags & Flags.TRANSIENT) != 0) continue;
+			
+			int idx = list.indexOf(child.getName());
+			if (idx > -1) matched[idx] = true;
+		}
+		
+		List<Integer> problematic = List.nil();
+		for (int i = 0 ; i < list.size() ; i++) {
+			if (!matched[i]) problematic = problematic.append(i);
+		}
+		
+		return problematic;
+	}
+}
diff --git a/src/core/lombok/javac/handlers/package-info.java b/src/core/lombok/javac/handlers/package-info.java
new file mode 100644
index 00000000..b08d6af3
--- /dev/null
+++ b/src/core/lombok/javac/handlers/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2009 Reinier Zwitserloot and Roel Spilker.
+ * 
+ * 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.
+ */
+
+/**
+ * Contains the classes that implement the transformations for all of lombok's various features on the javac v1.6 platform.
+ */
+package lombok.javac.handlers;