pretty big refactor; introduced a new source package which should be (and is) separately compilable, i.e. has no deps on any of the others.

This is preparation work for being able to access some of these from lombok.ast without creating a cyclic dependency nightmare.

12 files changed, 278 insertions, 195 deletions

diff --git a/src/core/lombok/javac/handlers/HandleCleanup.java b/src/core/lombok/javac/handlers/HandleCleanup.java
index 43dacda2..5b77554c 100644
--- a/src/core/lombok/javac/handlers/HandleCleanup.java
+++ b/src/core/lombok/javac/handlers/HandleCleanup.java
@@ -21,7 +21,7 @@
  */
 package lombok.javac.handlers;
 
-import static lombok.javac.handlers.JavacHandlerUtil.deleteAnnotationIfNeccessary;
+import static lombok.javac.handlers.JavacHandlerUtil.*;
 import lombok.Cleanup;
 import lombok.core.AnnotationValues;
 import lombok.core.AST.Kind;
@@ -122,9 +122,9 @@ public class HandleCleanup extends JavacAnnotationHandler<Cleanup> {
 		
 		JCIf ifNotNullCleanup = maker.If(isNull, maker.Block(0, cleanupCall), null);
 		
-		JCBlock finalizer = Javac.recursiveSetGeneratedBy(maker.Block(0, List.<JCStatement>of(ifNotNullCleanup)), ast);
+		JCBlock finalizer = recursiveSetGeneratedBy(maker.Block(0, List.<JCStatement>of(ifNotNullCleanup)), ast);
 		
-		newStatements.append(Javac.setGeneratedBy(maker.Try(Javac.setGeneratedBy(maker.Block(0, tryBlock.toList()), ast), List.<JCCatch>nil(), finalizer), ast));
+		newStatements.append(setGeneratedBy(maker.Try(setGeneratedBy(maker.Block(0, tryBlock.toList()), ast), List.<JCCatch>nil(), finalizer), ast));
 		
 		if (blockNode instanceof JCBlock) {
 			((JCBlock)blockNode).stats = newStatements.toList();
@@ -138,7 +138,7 @@ public class HandleCleanup extends JavacAnnotationHandler<Cleanup> {
 	}
 	
 	private JCMethodInvocation preventNullAnalysis(TreeMaker maker, JavacNode node, JCExpression expression) {
-		JCMethodInvocation singletonList = maker.Apply(List.<JCExpression>nil(), JavacHandlerUtil.chainDotsString(maker, node, "java.util.Collections.singletonList"), List.of(expression));
+		JCMethodInvocation singletonList = maker.Apply(List.<JCExpression>nil(), chainDotsString(node, "java.util.Collections.singletonList"), List.of(expression));
 		JCMethodInvocation cleanedExpr = maker.Apply(List.<JCExpression>nil(), maker.Select(singletonList, node.toName("get")) , List.<JCExpression>of(maker.Literal(TypeTags.INT, 0)));
 		return cleanedExpr;
 	}
diff --git a/src/core/lombok/javac/handlers/HandleConstructor.java b/src/core/lombok/javac/handlers/HandleConstructor.java
index 212daf16..88ff523f 100644
--- a/src/core/lombok/javac/handlers/HandleConstructor.java
+++ b/src/core/lombok/javac/handlers/HandleConstructor.java
@@ -27,12 +27,10 @@ import lombok.AllArgsConstructor;
 import lombok.NoArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import lombok.core.AnnotationValues;
+import lombok.core.TransformationsUtil;
 import lombok.core.AST.Kind;
-import lombok.core.handlers.TransformationsUtil;
-import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
-import lombok.javac.handlers.JavacHandlerUtil.MemberExistsResult;
 
 import org.mangosdk.spi.ProviderFor;
 
@@ -160,9 +158,9 @@ public class HandleConstructor {
 		if (skipIfConstructorExists) {
 			for (JavacNode child : typeNode.down()) {
 				if (child.getKind() == Kind.ANNOTATION) {
-					if (Javac.annotationTypeMatches(NoArgsConstructor.class, child) ||
-							Javac.annotationTypeMatches(AllArgsConstructor.class, child) ||
-							Javac.annotationTypeMatches(RequiredArgsConstructor.class, child))
+					if (annotationTypeMatches(NoArgsConstructor.class, child) ||
+							annotationTypeMatches(AllArgsConstructor.class, child) ||
+							annotationTypeMatches(RequiredArgsConstructor.class, child))
 						return;
 				}
 			}
@@ -181,7 +179,7 @@ public class HandleConstructor {
 	private static void addConstructorProperties(JCModifiers mods, JavacNode node, List<JavacNode> fields) {
 		if (fields.isEmpty()) return;
 		TreeMaker maker = node.getTreeMaker();
-		JCExpression constructorPropertiesType = chainDots(maker, node, "java", "beans", "ConstructorProperties");
+		JCExpression constructorPropertiesType = chainDots(node, "java", "beans", "ConstructorProperties");
 		ListBuffer<JCExpression> fieldNames = ListBuffer.lb();
 		for (JavacNode field : fields) {
 			fieldNames.append(maker.Literal(field.getName()));
@@ -221,7 +219,7 @@ public class HandleConstructor {
 		if (!suppressConstructorProperties && level != AccessLevel.PRIVATE && !isLocalType(typeNode)) {
 			addConstructorProperties(mods, typeNode, fields);
 		}
-		return Javac.recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName("<init>"),
+		return recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName("<init>"),
 				null, List.<JCTypeParameter>nil(), params.toList(), List.<JCExpression>nil(), maker.Block(0L, nullChecks.appendList(assigns).toList()), null), source);
 	}
 	
@@ -280,6 +278,6 @@ public class HandleConstructor {
 		JCReturn returnStatement = maker.Return(maker.NewClass(null, List.<JCExpression>nil(), constructorType, args.toList(), null));
 		JCBlock body = maker.Block(0, List.<JCStatement>of(returnStatement));
 		
-		return Javac.recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName(name), returnType, typeParams.toList(), params.toList(), List.<JCExpression>nil(), body, null), source);
+		return recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName(name), returnType, typeParams.toList(), params.toList(), List.<JCExpression>nil(), body, null), source);
 	}
 }
diff --git a/src/core/lombok/javac/handlers/HandleDelegate.java b/src/core/lombok/javac/handlers/HandleDelegate.java
index 0294171f..9f8e5e91 100644
--- a/src/core/lombok/javac/handlers/HandleDelegate.java
+++ b/src/core/lombok/javac/handlers/HandleDelegate.java
@@ -21,7 +21,7 @@
  */
 package lombok.javac.handlers;
 
-import static lombok.javac.handlers.JavacHandlerUtil.deleteAnnotationIfNeccessary;
+import static lombok.javac.handlers.JavacHandlerUtil.*;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -43,7 +43,6 @@ import lombok.Delegate;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
 import lombok.javac.FindTypeVarScanner;
-import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 import lombok.javac.JavacResolution;
@@ -186,7 +185,7 @@ public class HandleDelegate extends JavacAnnotationHandler<Delegate> {
 		}
 		
 		for (JCMethodDecl method : toAdd) {
-			JavacHandlerUtil.injectMethod(annotation.up().up(), method);
+			injectMethod(annotation.up().up(), method);
 		}
 	}
 	
@@ -254,7 +253,7 @@ public class HandleDelegate extends JavacAnnotationHandler<Delegate> {
 		com.sun.tools.javac.util.List<JCAnnotation> annotations;
 		if (sig.isDeprecated) {
 			annotations = com.sun.tools.javac.util.List.of(maker.Annotation(
-					JavacHandlerUtil.chainDots(maker, annotation, "java", "lang", "Deprecated"),
+					chainDots(annotation, "java", "lang", "Deprecated"),
 					com.sun.tools.javac.util.List.<JCExpression>nil()));
 		} else {
 			annotations = com.sun.tools.javac.util.List.nil();
@@ -295,7 +294,7 @@ public class HandleDelegate extends JavacAnnotationHandler<Delegate> {
 		JCStatement body = useReturn ? maker.Return(delegateCall) : maker.Exec(delegateCall);
 		JCBlock bodyBlock = maker.Block(0, com.sun.tools.javac.util.List.of(body));
 		
-		return Javac.recursiveSetGeneratedBy(maker.MethodDef(mods, sig.name, returnType, toList(typeParams), toList(params), toList(thrown), bodyBlock, null), annotation.get());
+		return recursiveSetGeneratedBy(maker.MethodDef(mods, sig.name, returnType, toList(typeParams), toList(params), toList(thrown), bodyBlock, null), annotation.get());
 	}
 	
 	private static <T> com.sun.tools.javac.util.List<T> toList(ListBuffer<T> collection) {
diff --git a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
index afd299ef..50bcdd3e 100644
--- a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
+++ b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
@@ -22,6 +22,7 @@
 package lombok.javac.handlers;
 
 import static lombok.javac.handlers.JavacHandlerUtil.*;
+import static lombok.javac.Javac.getCtcInt;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -29,7 +30,6 @@ import java.util.Collections;
 import lombok.EqualsAndHashCode;
 import lombok.core.AnnotationValues;
 import lombok.core.AST.Kind;
-import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 
@@ -103,7 +103,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 	public void generateEqualsAndHashCodeForType(JavacNode typeNode, JavacNode source) {
 		for (JavacNode child : typeNode.down()) {
 			if (child.getKind() == Kind.ANNOTATION) {
-				if (Javac.annotationTypeMatches(EqualsAndHashCode.class, child)) {
+				if (annotationTypeMatches(EqualsAndHashCode.class, child)) {
 					//The annotation will make it happen, so we can skip it.
 					return;
 				}
@@ -209,9 +209,9 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 	private JCMethodDecl createHashCode(JavacNode typeNode, List<JavacNode> fields, boolean callSuper, FieldAccess fieldAccess, JCTree source) {
 		TreeMaker maker = typeNode.getTreeMaker();
 		
-		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
+		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
 		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
-		JCExpression returnType = maker.TypeIdent(Javac.getCtcInt(TypeTags.class, "INT"));
+		JCExpression returnType = maker.TypeIdent(getCtcInt(TypeTags.class, "INT"));
 		ListBuffer<JCStatement> statements = ListBuffer.lb();
 		
 		Name primeName = typeNode.toName("PRIME");
@@ -219,12 +219,12 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		/* final int PRIME = 31; */ {
 			if (!fields.isEmpty() || callSuper) {
 				statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL),
-						primeName, maker.TypeIdent(Javac.getCtcInt(TypeTags.class, "INT")), maker.Literal(31)));
+						primeName, maker.TypeIdent(getCtcInt(TypeTags.class, "INT")), maker.Literal(31)));
 			}
 		}
 		
 		/* int result = 1; */ {
-			statements.append(maker.VarDef(maker.Modifiers(0), resultName, maker.TypeIdent(Javac.getCtcInt(TypeTags.class, "INT")), maker.Literal(1)));
+			statements.append(maker.VarDef(maker.Modifiers(0), resultName, maker.TypeIdent(getCtcInt(TypeTags.class, "INT")), maker.Literal(1)));
 		}
 		
 		ListBuffer<JCExpression> intoResult = ListBuffer.lb();
@@ -253,7 +253,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 					/* Float.floatToIntBits(this.fieldName) */
 					intoResult.append(maker.Apply(
 							List.<JCExpression>nil(),
-							chainDots(maker, typeNode, "java", "lang", "Float", "floatToIntBits"),
+							chainDots(typeNode, "java", "lang", "Float", "floatToIntBits"),
 							List.of(fieldAccessor)));
 					break;
 				case DOUBLE:
@@ -261,7 +261,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 					Name tempVar = typeNode.toName("temp" + (++tempCounter));
 					JCExpression init = maker.Apply(
 							List.<JCExpression>nil(),
-							chainDots(maker, typeNode, "java", "lang", "Double", "doubleToLongBits"),
+							chainDots(typeNode, "java", "lang", "Double", "doubleToLongBits"),
 							List.of(fieldAccessor));
 					statements.append(
 							maker.VarDef(maker.Modifiers(Flags.FINAL), tempVar, maker.TypeIdent(TypeTags.LONG), init));
@@ -282,14 +282,14 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 				boolean primitiveArray = ((JCArrayTypeTree)fType).elemtype instanceof JCPrimitiveTypeTree;
 				boolean useDeepHC = multiDim || !primitiveArray;
 				
-				JCExpression hcMethod = chainDots(maker, typeNode, "java", "util", "Arrays", useDeepHC ? "deepHashCode" : "hashCode");
+				JCExpression hcMethod = chainDots(typeNode, "java", "util", "Arrays", useDeepHC ? "deepHashCode" : "hashCode");
 				intoResult.append(
 						maker.Apply(List.<JCExpression>nil(), hcMethod, List.of(fieldAccessor)));
 			} else /* objects */ {
 				/* this.fieldName == null ? 0 : this.fieldName.hashCode() */
 				JCExpression hcCall = maker.Apply(List.<JCExpression>nil(), maker.Select(createFieldAccessor(maker, fieldNode, fieldAccess), typeNode.toName("hashCode")),
 						List.<JCExpression>nil());
-				JCExpression thisEqualsNull = maker.Binary(Javac.getCtcInt(JCTree.class, "EQ"), fieldAccessor, maker.Literal(Javac.getCtcInt(TypeTags.class, "BOT"), null));
+				JCExpression thisEqualsNull = maker.Binary(getCtcInt(JCTree.class, "EQ"), fieldAccessor, maker.Literal(getCtcInt(TypeTags.class, "BOT"), null));
 				intoResult.append(
 						maker.Conditional(thisEqualsNull, maker.Literal(0), hcCall));
 			}
@@ -298,8 +298,8 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		/* fold each intoResult entry into:
 		   result = result * PRIME + (item); */
 		for (JCExpression expr : intoResult) {
-			JCExpression mult = maker.Binary(Javac.getCtcInt(JCTree.class, "MUL"), maker.Ident(resultName), maker.Ident(primeName));
-			JCExpression add = maker.Binary(Javac.getCtcInt(JCTree.class, "PLUS"), mult, expr);
+			JCExpression mult = maker.Binary(getCtcInt(JCTree.class, "MUL"), maker.Ident(resultName), maker.Ident(primeName));
+			JCExpression add = maker.Binary(getCtcInt(JCTree.class, "PLUS"), mult, expr);
 			statements.append(maker.Exec(maker.Assign(maker.Ident(resultName), add)));
 		}
 		
@@ -308,16 +308,16 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		}
 		
 		JCBlock body = maker.Block(0, statements.toList());
-		return Javac.recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName("hashCode"), returnType,
+		return recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName("hashCode"), returnType,
 				List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null), source);
 	}
 	
 	/** 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(Javac.getCtcInt(JCTree.class, "USR"), ref1, maker.Literal(32));
-		JCExpression xorBits = maker.Binary(Javac.getCtcInt(JCTree.class, "BITXOR"), shift, ref2);
-		return maker.TypeCast(maker.TypeIdent(Javac.getCtcInt(TypeTags.class, "INT")), xorBits);
+		JCExpression shift = maker.Binary(getCtcInt(JCTree.class, "USR"), ref1, maker.Literal(32));
+		JCExpression xorBits = maker.Binary(getCtcInt(JCTree.class, "BITXOR"), shift, ref2);
+		return maker.TypeCast(maker.TypeIdent(getCtcInt(TypeTags.class, "INT")), xorBits);
 	}
 	
 	private JCMethodDecl createEquals(JavacNode typeNode, List<JavacNode> fields, boolean callSuper, FieldAccess fieldAccess, boolean needsCanEqual, JCTree source) {
@@ -328,21 +328,21 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		Name otherName = typeNode.toName("other");
 		Name thisName = typeNode.toName("this");
 		
-		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
+		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
 		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
-		JCExpression objectType = chainDots(maker, typeNode, "java", "lang", "Object");
-		JCExpression returnType = maker.TypeIdent(Javac.getCtcInt(TypeTags.class, "BOOLEAN"));
+		JCExpression objectType = chainDots(typeNode, "java", "lang", "Object");
+		JCExpression returnType = maker.TypeIdent(getCtcInt(TypeTags.class, "BOOLEAN"));
 		
 		ListBuffer<JCStatement> statements = ListBuffer.lb();
 		final List<JCVariableDecl> params = List.of(maker.VarDef(maker.Modifiers(Flags.FINAL), oName, objectType, null));
 		
 		/* if (o == this) return true; */ {
-			statements.append(maker.If(maker.Binary(Javac.getCtcInt(JCTree.class, "EQ"), maker.Ident(oName),
+			statements.append(maker.If(maker.Binary(getCtcInt(JCTree.class, "EQ"), maker.Ident(oName),
 					maker.Ident(thisName)), returnBool(maker, true), null));
 		}
 		
 		/* if (!(o instanceof MyType) return false; */ {
-			JCUnary notInstanceOf = maker.Unary(Javac.getCtcInt(JCTree.class, "NOT"), maker.TypeTest(maker.Ident(oName), maker.Ident(type.name)));
+			JCUnary notInstanceOf = maker.Unary(getCtcInt(JCTree.class, "NOT"), maker.TypeTest(maker.Ident(oName), maker.Ident(type.name)));
 			statements.append(maker.If(notInstanceOf, returnBool(maker, false), null));
 		}
 		
@@ -373,11 +373,11 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 			if (needsCanEqual) {
 				List<JCExpression> exprNil = List.nil();
 				JCExpression thisRef = maker.Ident(thisName);
-				JCExpression castThisRef = maker.TypeCast(chainDots(maker, typeNode, "java", "lang", "Object"), thisRef);
+				JCExpression castThisRef = maker.TypeCast(chainDots(typeNode, "java", "lang", "Object"), thisRef);
 				JCExpression equalityCheck = maker.Apply(exprNil, 
 						maker.Select(maker.Ident(otherName), typeNode.toName("canEqual")),
 						List.of(castThisRef));
-				statements.append(maker.If(maker.Unary(Javac.getCtcInt(JCTree.class, "NOT"), equalityCheck), returnBool(maker, false), null));
+				statements.append(maker.If(maker.Unary(getCtcInt(JCTree.class, "NOT"), equalityCheck), returnBool(maker, false), null));
 			}
 		}
 		
@@ -386,7 +386,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 			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(Javac.getCtcInt(JCTree.class, "NOT"), callToSuper);
+			JCUnary superNotEqual = maker.Unary(getCtcInt(JCTree.class, "NOT"), callToSuper);
 			statements.append(maker.If(superNotEqual, returnBool(maker, false), null));
 		}
 		
@@ -407,7 +407,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 				default:
 					/* if (this.fieldName != other.fieldName) return false; */
 					statements.append(
-							maker.If(maker.Binary(Javac.getCtcInt(JCTree.class, "NE"), thisFieldAccessor, otherFieldAccessor), returnBool(maker, false), null));
+							maker.If(maker.Binary(getCtcInt(JCTree.class, "NE"), thisFieldAccessor, otherFieldAccessor), returnBool(maker, false), null));
 					break;
 				}
 			} else if (fType instanceof JCArrayTypeTree) {
@@ -416,20 +416,20 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 				boolean primitiveArray = ((JCArrayTypeTree)fType).elemtype instanceof JCPrimitiveTypeTree;
 				boolean useDeepEquals = multiDim || !primitiveArray;
 				
-				JCExpression eqMethod = chainDots(maker, typeNode, "java", "util", "Arrays", useDeepEquals ? "deepEquals" : "equals");
+				JCExpression eqMethod = chainDots(typeNode, "java", "util", "Arrays", useDeepEquals ? "deepEquals" : "equals");
 				List<JCExpression> args = List.of(thisFieldAccessor, otherFieldAccessor);
-				statements.append(maker.If(maker.Unary(Javac.getCtcInt(JCTree.class, "NOT"),
+				statements.append(maker.If(maker.Unary(getCtcInt(JCTree.class, "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(Javac.getCtcInt(JCTree.class, "EQ"), thisFieldAccessor, maker.Literal(Javac.getCtcInt(TypeTags.class, "BOT"), null));
-				JCExpression otherNotEqualsNull = maker.Binary(Javac.getCtcInt(JCTree.class, "NE"), otherFieldAccessor, maker.Literal(Javac.getCtcInt(TypeTags.class, "BOT"), null));
+				JCExpression thisEqualsNull = maker.Binary(getCtcInt(JCTree.class, "EQ"), thisFieldAccessor, maker.Literal(getCtcInt(TypeTags.class, "BOT"), null));
+				JCExpression otherNotEqualsNull = maker.Binary(getCtcInt(JCTree.class, "NE"), otherFieldAccessor, maker.Literal(getCtcInt(TypeTags.class, "BOT"), null));
 				JCExpression equalsArg = createFieldAccessor(maker, fieldNode, fieldAccess, maker.Ident(otherName));
-				JCExpression castEqualsArg = maker.TypeCast(chainDots(maker, typeNode, "java", "lang", "Object"), equalsArg);
+				JCExpression castEqualsArg = maker.TypeCast(chainDots(typeNode, "java", "lang", "Object"), equalsArg);
 				JCExpression thisEqualsThat = maker.Apply(List.<JCExpression>nil(),
 						maker.Select(createFieldAccessor(maker, fieldNode, fieldAccess), typeNode.toName("equals")),
 						List.of(castEqualsArg));
-				JCExpression fieldsAreNotEqual = maker.Conditional(thisEqualsNull, otherNotEqualsNull, maker.Unary(Javac.getCtcInt(JCTree.class, "NOT"), thisEqualsThat));
+				JCExpression fieldsAreNotEqual = maker.Conditional(thisEqualsNull, otherNotEqualsNull, maker.Unary(getCtcInt(JCTree.class, "NOT"), thisEqualsThat));
 				statements.append(maker.If(fieldsAreNotEqual, returnBool(maker, false), null));
 			}
 		}
@@ -439,7 +439,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		}
 		
 		JCBlock body = maker.Block(0, statements.toList());
-		return Javac.recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName("equals"), returnType, List.<JCTypeParameter>nil(), params, List.<JCExpression>nil(), body, null), source);
+		return recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName("equals"), returnType, List.<JCTypeParameter>nil(), params, List.<JCExpression>nil(), body, null), source);
 	}
 
 	private JCMethodDecl createCanEqual(JavacNode typeNode, JCTree source) {
@@ -451,29 +451,29 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		JCClassDecl type = (JCClassDecl) typeNode.get();
 		
 		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.<JCAnnotation>nil());
-		JCExpression returnType = maker.TypeIdent(Javac.getCtcInt(TypeTags.class, "BOOLEAN"));
+		JCExpression returnType = maker.TypeIdent(getCtcInt(TypeTags.class, "BOOLEAN"));
 		Name canEqualName = typeNode.toName("canEqual");
-		JCExpression objectType = chainDots(maker, typeNode, "java", "lang", "Object");
+		JCExpression objectType = chainDots(typeNode, "java", "lang", "Object");
 		Name otherName = typeNode.toName("other");
 		List<JCVariableDecl> params = List.of(maker.VarDef(maker.Modifiers(Flags.FINAL), otherName, objectType, null));
 		
 		JCBlock body = maker.Block(0, List.<JCStatement>of(
 				maker.Return(maker.TypeTest(maker.Ident(otherName), maker.Ident(type.name)))));
 		
-		return Javac.recursiveSetGeneratedBy(maker.MethodDef(mods, canEqualName, returnType, List.<JCTypeParameter>nil(), params, List.<JCExpression>nil(), body, null), source);
+		return recursiveSetGeneratedBy(maker.MethodDef(mods, canEqualName, returnType, List.<JCTypeParameter>nil(), params, List.<JCExpression>nil(), body, null), source);
 	}
 	
 	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");
+		JCExpression clazz = chainDots(node, "java", "lang", isDouble ? "Double" : "Float");
 		List<JCExpression> args = List.of(thisDotField, otherDotField);
-		JCBinary compareCallEquals0 = maker.Binary(Javac.getCtcInt(JCTree.class, "NE"), maker.Apply(
+		JCBinary compareCallEquals0 = maker.Binary(getCtcInt(JCTree.class, "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(Javac.getCtcInt(TypeTags.class, "BOOLEAN"), bool ? 1 : 0));
+		return maker.Return(maker.Literal(getCtcInt(TypeTags.class, "BOOLEAN"), bool ? 1 : 0));
 	}
 }
diff --git a/src/core/lombok/javac/handlers/HandleGetter.java b/src/core/lombok/javac/handlers/HandleGetter.java
index a7e357ad..77a63839 100644
--- a/src/core/lombok/javac/handlers/HandleGetter.java
+++ b/src/core/lombok/javac/handlers/HandleGetter.java
@@ -22,6 +22,7 @@
 package lombok.javac.handlers;
 
 import static lombok.javac.handlers.JavacHandlerUtil.*;
+import static lombok.javac.Javac.*;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -31,9 +32,8 @@ import java.util.Map;
 import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.core.AnnotationValues;
+import lombok.core.TransformationsUtil;
 import lombok.core.AST.Kind;
-import lombok.core.handlers.TransformationsUtil;
-import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 import lombok.javac.handlers.JavacHandlerUtil.FieldAccess;
@@ -74,7 +74,7 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 		if (checkForTypeLevelGetter) {
 			if (typeNode != null) for (JavacNode child : typeNode.down()) {
 				if (child.getKind() == Kind.ANNOTATION) {
-					if (Javac.annotationTypeMatches(Getter.class, child)) {
+					if (annotationTypeMatches(Getter.class, child)) {
 						//The annotation will make it happen, so we can skip it.
 						return;
 					}
@@ -125,7 +125,7 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 	public void generateGetterForField(JavacNode fieldNode, DiagnosticPosition pos, AccessLevel level, boolean lazy) {
 		for (JavacNode child : fieldNode.down()) {
 			if (child.getKind() == Kind.ANNOTATION) {
-				if (Javac.annotationTypeMatches(Getter.class, child)) {
+				if (annotationTypeMatches(Getter.class, child)) {
 					//The annotation will make it happen, so we can skip it.
 					return;
 				}
@@ -242,10 +242,10 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 		
 		List<JCAnnotation> annsOnMethod = nonNulls.appendList(nullables);
 		
-		JCMethodDecl decl = Javac.recursiveSetGeneratedBy(treeMaker.MethodDef(treeMaker.Modifiers(access, annsOnMethod), methodName, methodType,
+		JCMethodDecl decl = recursiveSetGeneratedBy(treeMaker.MethodDef(treeMaker.Modifiers(access, annsOnMethod), methodName, methodType,
 				methodGenericParams, parameters, throwsClauses, methodBody, annotationMethodDefaultValue), source);
 		
-		if (toClearOfMarkers != null) Javac.recursiveSetGeneratedBy(toClearOfMarkers, null);
+		if (toClearOfMarkers != null) recursiveSetGeneratedBy(toClearOfMarkers, null);
 		
 		return decl;
 	}
@@ -260,14 +260,14 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 	private static final java.util.Map<Integer, String> TYPE_MAP;
 	static {
 		Map<Integer, String> m = new HashMap<Integer, String>();
-		m.put(Javac.getCtcInt(TypeTags.class, "INT"), "java.lang.Integer");
-		m.put(Javac.getCtcInt(TypeTags.class, "DOUBLE"), "java.lang.Double");
-		m.put(Javac.getCtcInt(TypeTags.class, "FLOAT"), "java.lang.Float");
-		m.put(Javac.getCtcInt(TypeTags.class, "SHORT"), "java.lang.Short");
-		m.put(Javac.getCtcInt(TypeTags.class, "BYTE"), "java.lang.Byte");
-		m.put(Javac.getCtcInt(TypeTags.class, "LONG"), "java.lang.Long");
-		m.put(Javac.getCtcInt(TypeTags.class, "BOOLEAN"), "java.lang.Boolean");
-		m.put(Javac.getCtcInt(TypeTags.class, "CHAR"), "java.lang.Character");
+		m.put(getCtcInt(TypeTags.class, "INT"), "java.lang.Integer");
+		m.put(getCtcInt(TypeTags.class, "DOUBLE"), "java.lang.Double");
+		m.put(getCtcInt(TypeTags.class, "FLOAT"), "java.lang.Float");
+		m.put(getCtcInt(TypeTags.class, "SHORT"), "java.lang.Short");
+		m.put(getCtcInt(TypeTags.class, "BYTE"), "java.lang.Byte");
+		m.put(getCtcInt(TypeTags.class, "LONG"), "java.lang.Long");
+		m.put(getCtcInt(TypeTags.class, "BOOLEAN"), "java.lang.Boolean");
+		m.put(getCtcInt(TypeTags.class, "CHAR"), "java.lang.Character");
 		TYPE_MAP = Collections.unmodifiableMap(m);
 	}
 	
@@ -293,14 +293,14 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 		if (field.vartype instanceof JCPrimitiveTypeTree) {
 			String boxed = TYPE_MAP.get(((JCPrimitiveTypeTree)field.vartype).typetag);
 			if (boxed != null) {
-				field.vartype = chainDotsString(maker, fieldNode, boxed);
+				field.vartype = chainDotsString(fieldNode, boxed);
 			}
 		}
 		
 		Name valueName = fieldNode.toName("value");
 		
 		/* java.util.concurrent.atomic.AtomicReference<ValueType> value = this.fieldName.get();*/ {
-			JCTypeApply valueVarType = maker.TypeApply(chainDotsString(maker, fieldNode, AR), List.of(copyType(maker, field)));
+			JCTypeApply valueVarType = maker.TypeApply(chainDotsString(fieldNode, AR), List.of(copyType(maker, field)));
 			statements.append(maker.VarDef(maker.Modifiers(0), valueName, valueVarType, callGet(fieldNode, createFieldAccessor(maker, fieldNode, FieldAccess.ALWAYS_FIELD))));
 		}
 		
@@ -316,7 +316,7 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 				/* if (value == null) { */ {
 					ListBuffer<JCStatement> innerIfStatements = ListBuffer.lb();
 					/* value = new java.util.concurrent.atomic.AtomicReference<ValueType>(new ValueType());*/ {
-						JCTypeApply valueVarType = maker.TypeApply(chainDotsString(maker, fieldNode, AR), List.of(copyType(maker, field)));
+						JCTypeApply valueVarType = maker.TypeApply(chainDotsString(fieldNode, AR), List.of(copyType(maker, field)));
 						JCNewClass newInstance = maker.NewClass(null, NIL_EXPRESSION, valueVarType, List.<JCExpression>of(field.init), null);
 						
 						JCStatement statement = maker.Exec(maker.Assign(maker.Ident(valueName), newInstance));
@@ -327,7 +327,7 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 						innerIfStatements.append(statement);
 					}
 					
-					JCBinary isNull = maker.Binary(Javac.getCtcInt(JCTree.class, "EQ"), maker.Ident(valueName), maker.Literal(Javac.getCtcInt(TypeTags.class, "BOT"), null));
+					JCBinary isNull = maker.Binary(getCtcInt(JCTree.class, "EQ"), maker.Ident(valueName), maker.Literal(getCtcInt(TypeTags.class, "BOT"), null));
 					JCIf ifStatement = maker.If(isNull, maker.Block(0, innerIfStatements.toList()), null);
 					synchronizedStatements.append(ifStatement);
 				}
@@ -335,7 +335,7 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 				synchronizedStatement = maker.Synchronized(createFieldAccessor(maker, fieldNode, FieldAccess.ALWAYS_FIELD), maker.Block(0, synchronizedStatements.toList()));
 			}
 			
-			JCBinary isNull = maker.Binary(Javac.getCtcInt(JCTree.class, "EQ"), maker.Ident(valueName), maker.Literal(Javac.getCtcInt(TypeTags.class, "BOT"), null));
+			JCBinary isNull = maker.Binary(getCtcInt(JCTree.class, "EQ"), maker.Ident(valueName), maker.Literal(getCtcInt(TypeTags.class, "BOT"), null));
 			JCIf ifStatement = maker.If(isNull, maker.Block(0, List.<JCStatement>of(synchronizedStatement)), null);
 			statements.append(ifStatement);
 		}
@@ -345,10 +345,10 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 		// update the field type and init last
 		
 		/* 	private final java.util.concurrent.atomic.AtomicReference<java.util.concurrent.atomic.AtomicReference<ValueType> fieldName = new java.util.concurrent.atomic.AtomicReference<java.util.concurrent.atomic.AtomicReference<ValueType>>(); */ {
-			field.vartype = Javac.recursiveSetGeneratedBy(
-					maker.TypeApply(chainDotsString(maker, fieldNode, AR), List.<JCExpression>of(maker.TypeApply(chainDotsString(maker, fieldNode, AR), List.of(copyType(maker, field))))),
+			field.vartype = recursiveSetGeneratedBy(
+					maker.TypeApply(chainDotsString(fieldNode, AR), List.<JCExpression>of(maker.TypeApply(chainDotsString(fieldNode, AR), List.of(copyType(maker, field))))),
 					source);
-			field.init = Javac.recursiveSetGeneratedBy(maker.NewClass(null, NIL_EXPRESSION, copyType(maker, field), NIL_EXPRESSION, null), source);
+			field.init = recursiveSetGeneratedBy(maker.NewClass(null, NIL_EXPRESSION, copyType(maker, field), NIL_EXPRESSION, null), source);
 		}
 		
 		return statements.toList();
diff --git a/src/core/lombok/javac/handlers/HandleLog.java b/src/core/lombok/javac/handlers/HandleLog.java
index 885bd538..d084e5b6 100644
--- a/src/core/lombok/javac/handlers/HandleLog.java
+++ b/src/core/lombok/javac/handlers/HandleLog.java
@@ -26,10 +26,8 @@ import static lombok.javac.handlers.JavacHandlerUtil.*;
 import java.lang.annotation.Annotation;
 
 import lombok.core.AnnotationValues;
-import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
-import lombok.javac.handlers.JavacHandlerUtil.MemberExistsResult;
 
 import org.mangosdk.spi.ProviderFor;
 
@@ -86,13 +84,13 @@ public class HandleLog {
 		TreeMaker maker = typeNode.getTreeMaker();
 		
 		// 	private static final <loggerType> log = <factoryMethod>(<parameter>);
-		JCExpression loggerType = chainDotsString(maker, typeNode, framework.getLoggerTypeName());
-		JCExpression factoryMethod = chainDotsString(maker, typeNode, framework.getLoggerFactoryMethodName());
+		JCExpression loggerType = chainDotsString(typeNode, framework.getLoggerTypeName());
+		JCExpression factoryMethod = chainDotsString(typeNode, framework.getLoggerFactoryMethodName());
 		
 		JCExpression loggerName = framework.createFactoryParameter(typeNode, loggingType);
 		JCMethodInvocation factoryMethodCall = maker.Apply(List.<JCExpression>nil(), factoryMethod, List.<JCExpression>of(loggerName));
 		
-		JCVariableDecl fieldDecl = Javac.recursiveSetGeneratedBy(maker.VarDef(
+		JCVariableDecl fieldDecl = recursiveSetGeneratedBy(maker.VarDef(
 				maker.Modifiers(Flags.PRIVATE | Flags.FINAL | Flags.STATIC),
 				typeNode.toName("log"), loggerType, factoryMethodCall), source);
 		
diff --git a/src/core/lombok/javac/handlers/HandleSetter.java b/src/core/lombok/javac/handlers/HandleSetter.java
index d899336f..e7a97214 100644
--- a/src/core/lombok/javac/handlers/HandleSetter.java
+++ b/src/core/lombok/javac/handlers/HandleSetter.java
@@ -22,6 +22,7 @@
 package lombok.javac.handlers;
 
 import static lombok.javac.handlers.JavacHandlerUtil.*;
+import static lombok.javac.Javac.*;
 
 import java.util.Collection;
 
@@ -33,11 +34,9 @@ import lombok.AccessLevel;
 import lombok.Setter;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
-import lombok.core.handlers.TransformationsUtil;
-import lombok.javac.Javac;
+import lombok.core.TransformationsUtil;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
-import lombok.javac.handlers.JavacHandlerUtil.FieldAccess;
 
 import org.mangosdk.spi.ProviderFor;
 
@@ -68,7 +67,7 @@ public class HandleSetter extends JavacAnnotationHandler<Setter> {
 		if (checkForTypeLevelSetter) {
 			if (typeNode != null) for (JavacNode child : typeNode.down()) {
 				if (child.getKind() == Kind.ANNOTATION) {
-					if (Javac.annotationTypeMatches(Setter.class, child)) {
+					if (annotationTypeMatches(Setter.class, child)) {
 						//The annotation will make it happen, so we can skip it.
 						return;
 					}
@@ -118,7 +117,7 @@ public class HandleSetter extends JavacAnnotationHandler<Setter> {
 	public void generateSetterForField(JavacNode fieldNode, DiagnosticPosition pos, AccessLevel level) {
 		for (JavacNode child : fieldNode.down()) {
 			if (child.getKind() == Kind.ANNOTATION) {
-				if (Javac.annotationTypeMatches(Setter.class, child)) {
+				if (annotationTypeMatches(Setter.class, child)) {
 					//The annotation will make it happen, so we can skip it.
 					return;
 				}
@@ -211,14 +210,14 @@ public class HandleSetter extends JavacAnnotationHandler<Setter> {
 		List<JCAnnotation> annsOnParam = nonNulls.appendList(nullables);
 		JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.FINAL, annsOnParam), fieldDecl.name, fieldDecl.vartype, null);
 		//WARNING: Do not use field.getSymbolTable().voidType - that field has gone through non-backwards compatible API changes within javac1.6.
-		JCExpression methodType = treeMaker.Type(new JCNoType(Javac.getCtcInt(TypeTags.class, "VOID")));
+		JCExpression methodType = treeMaker.Type(new JCNoType(getCtcInt(TypeTags.class, "VOID")));
 		
 		List<JCTypeParameter> methodGenericParams = List.nil();
 		List<JCVariableDecl> parameters = List.of(param);
 		List<JCExpression> throwsClauses = List.nil();
 		JCExpression annotationMethodDefaultValue = null;
 		
-		return Javac.recursiveSetGeneratedBy(treeMaker.MethodDef(treeMaker.Modifiers(access, List.<JCAnnotation>nil()), methodName, methodType,
+		return recursiveSetGeneratedBy(treeMaker.MethodDef(treeMaker.Modifiers(access, List.<JCAnnotation>nil()), methodName, methodType,
 				methodGenericParams, parameters, throwsClauses, methodBody, annotationMethodDefaultValue), source);
 	}
 	
@@ -229,8 +228,8 @@ public class HandleSetter extends JavacAnnotationHandler<Setter> {
 		
 		@Override
 		public TypeKind getKind() {
-			if (tag == Javac.getCtcInt(TypeTags.class, "VOID")) return TypeKind.VOID;
-			if (tag == Javac.getCtcInt(TypeTags.class, "NONE")) return TypeKind.NONE;
+			if (tag == getCtcInt(TypeTags.class, "VOID")) return TypeKind.VOID;
+			if (tag == getCtcInt(TypeTags.class, "NONE")) return TypeKind.NONE;
 			throw new AssertionError("Unexpected tag: " + tag);
 		}
 		
diff --git a/src/core/lombok/javac/handlers/HandleSneakyThrows.java b/src/core/lombok/javac/handlers/HandleSneakyThrows.java
index 5b20d79e..8f6e12d6 100644
--- a/src/core/lombok/javac/handlers/HandleSneakyThrows.java
+++ b/src/core/lombok/javac/handlers/HandleSneakyThrows.java
@@ -21,8 +21,7 @@
  */
 package lombok.javac.handlers;
 
-import static lombok.javac.handlers.JavacHandlerUtil.chainDots;
-import static lombok.javac.handlers.JavacHandlerUtil.deleteAnnotationIfNeccessary;
+import static lombok.javac.handlers.JavacHandlerUtil.*;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -30,7 +29,6 @@ import java.util.Collections;
 
 import lombok.SneakyThrows;
 import lombok.core.AnnotationValues;
-import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 
@@ -99,16 +97,16 @@ public class HandleSneakyThrows extends JavacAnnotationHandler<SneakyThrows> {
 	private JCStatement buildTryCatchBlock(JavacNode node, List<JCStatement> contents, String exception, JCTree source) {
 		TreeMaker maker = node.getTreeMaker();
 		
-		JCBlock tryBlock = Javac.setGeneratedBy(maker.Block(0, contents), source);
+		JCBlock tryBlock = setGeneratedBy(maker.Block(0, contents), source);
 		
-		JCExpression varType = chainDots(maker, node, exception.split("\\."));
+		JCExpression varType = chainDots(node, exception.split("\\."));
 		
 		JCVariableDecl catchParam = maker.VarDef(maker.Modifiers(Flags.FINAL), node.toName("$ex"), varType, null);
-		JCExpression lombokLombokSneakyThrowNameRef = chainDots(maker, node, "lombok", "Lombok", "sneakyThrow");
+		JCExpression lombokLombokSneakyThrowNameRef = chainDots(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 Javac.setGeneratedBy(maker.Try(tryBlock, List.of(Javac.recursiveSetGeneratedBy(maker.Catch(catchParam, catchBody), source)), null), source);
+		return setGeneratedBy(maker.Try(tryBlock, List.of(recursiveSetGeneratedBy(maker.Catch(catchParam, catchBody), source)), null), source);
 	}
 }
diff --git a/src/core/lombok/javac/handlers/HandleSynchronized.java b/src/core/lombok/javac/handlers/HandleSynchronized.java
index fa4a0474..8cdfff68 100644
--- a/src/core/lombok/javac/handlers/HandleSynchronized.java
+++ b/src/core/lombok/javac/handlers/HandleSynchronized.java
@@ -83,11 +83,11 @@ public class HandleSynchronized extends JavacAnnotationHandler<Synchronized> {
 				annotationNode.addError("The field " + lockName + " does not exist.");
 				return;
 			}
-			JCExpression objectType = chainDots(maker, methodNode, "java", "lang", "Object");
+			JCExpression objectType = chainDots(methodNode, "java", "lang", "Object");
 			//We use 'new Object[0];' because unlike 'new Object();', empty arrays *ARE* serializable!
-			JCNewArray newObjectArray = maker.NewArray(chainDots(maker, methodNode, "java", "lang", "Object"),
+			JCNewArray newObjectArray = maker.NewArray(chainDots(methodNode, "java", "lang", "Object"),
 					List.<JCExpression>of(maker.Literal(Javac.getCtcInt(TypeTags.class, "INT"), 0)), null);
-			JCVariableDecl fieldDecl = Javac.recursiveSetGeneratedBy(maker.VarDef(
+			JCVariableDecl fieldDecl = recursiveSetGeneratedBy(maker.VarDef(
 					maker.Modifiers(Flags.PRIVATE | Flags.FINAL | (isStatic ? Flags.STATIC : 0)),
 					methodNode.toName(lockName), objectType, newObjectArray), ast);
 			injectFieldSuppressWarnings(methodNode.up(), fieldDecl);
@@ -97,13 +97,13 @@ public class HandleSynchronized extends JavacAnnotationHandler<Synchronized> {
 		
 		JCExpression lockNode;
 		if (isStatic) {
-			lockNode = chainDots(maker, methodNode, methodNode.up().getName(), lockName);
+			lockNode = chainDots(methodNode, methodNode.up().getName(), lockName);
 		} else {
 			lockNode = maker.Select(maker.Ident(methodNode.toName("this")), methodNode.toName(lockName));
 		}
 		
-		Javac.recursiveSetGeneratedBy(lockNode, ast);
-		method.body = Javac.setGeneratedBy(maker.Block(0, List.<JCStatement>of(Javac.setGeneratedBy(maker.Synchronized(lockNode, method.body), ast))), ast);
+		recursiveSetGeneratedBy(lockNode, ast);
+		method.body = setGeneratedBy(maker.Block(0, List.<JCStatement>of(setGeneratedBy(maker.Synchronized(lockNode, method.body), ast))), ast);
 		
 		methodNode.rebuild();
 	}
diff --git a/src/core/lombok/javac/handlers/HandleToString.java b/src/core/lombok/javac/handlers/HandleToString.java
index 06e70e7a..80f77dc7 100644
--- a/src/core/lombok/javac/handlers/HandleToString.java
+++ b/src/core/lombok/javac/handlers/HandleToString.java
@@ -22,14 +22,13 @@
 package lombok.javac.handlers;
 
 import static lombok.javac.handlers.JavacHandlerUtil.*;
+import static lombok.javac.Javac.getCtcInt;
 
 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 lombok.javac.handlers.JavacHandlerUtil.FieldAccess;
 
 import org.mangosdk.spi.ProviderFor;
 
@@ -98,7 +97,7 @@ public class HandleToString extends JavacAnnotationHandler<ToString> {
 	public void generateToStringForType(JavacNode typeNode, JavacNode errorNode) {
 		for (JavacNode child : typeNode.down()) {
 			if (child.getKind() == Kind.ANNOTATION) {
-				if (Javac.annotationTypeMatches(ToString.class, child)) {
+				if (annotationTypeMatches(ToString.class, child)) {
 					//The annotation will make it happen, so we can skip it.
 					return;
 				}
@@ -171,9 +170,9 @@ public class HandleToString extends JavacAnnotationHandler<ToString> {
 	private JCMethodDecl createToString(JavacNode typeNode, List<JavacNode> fields, boolean includeFieldNames, boolean callSuper, FieldAccess fieldAccess, JCTree source) {
 		TreeMaker maker = typeNode.getTreeMaker();
 		
-		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(maker, typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
+		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
 		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
-		JCExpression returnType = chainDots(maker, typeNode, "java", "lang", "String");
+		JCExpression returnType = chainDots(typeNode, "java", "lang", "String");
 		
 		boolean first = true;
 		
@@ -197,7 +196,7 @@ public class HandleToString extends JavacAnnotationHandler<ToString> {
 			JCMethodInvocation callToSuper = maker.Apply(List.<JCExpression>nil(),
 					maker.Select(maker.Ident(typeNode.toName("super")), typeNode.toName("toString")),
 					List.<JCExpression>nil());
-			current = maker.Binary(Javac.getCtcInt(JCTree.class, "PLUS"), current, callToSuper);
+			current = maker.Binary(getCtcInt(JCTree.class, "PLUS"), current, callToSuper);
 			first = false;
 		}
 		
@@ -212,32 +211,32 @@ public class HandleToString extends JavacAnnotationHandler<ToString> {
 				boolean primitiveArray = ((JCArrayTypeTree)field.vartype).elemtype instanceof JCPrimitiveTypeTree;
 				boolean useDeepTS = multiDim || !primitiveArray;
 				
-				JCExpression hcMethod = chainDots(maker, typeNode, "java", "util", "Arrays", useDeepTS ? "deepToString" : "toString");
+				JCExpression hcMethod = chainDots(typeNode, "java", "util", "Arrays", useDeepTS ? "deepToString" : "toString");
 				expr = maker.Apply(List.<JCExpression>nil(), hcMethod, List.<JCExpression>of(fieldAccessor));
 			} else expr = fieldAccessor;
 			
 			if (first) {
-				current = maker.Binary(Javac.getCtcInt(JCTree.class, "PLUS"), current, expr);
+				current = maker.Binary(getCtcInt(JCTree.class, "PLUS"), current, expr);
 				first = false;
 				continue;
 			}
 			
 			if (includeFieldNames) {
-				current = maker.Binary(Javac.getCtcInt(JCTree.class, "PLUS"), current, maker.Literal(infix + fieldNode.getName() + "="));
+				current = maker.Binary(getCtcInt(JCTree.class, "PLUS"), current, maker.Literal(infix + fieldNode.getName() + "="));
 			} else {
-				current = maker.Binary(Javac.getCtcInt(JCTree.class, "PLUS"), current, maker.Literal(infix));
+				current = maker.Binary(getCtcInt(JCTree.class, "PLUS"), current, maker.Literal(infix));
 			}
 			
-			current = maker.Binary(Javac.getCtcInt(JCTree.class, "PLUS"), current, expr);
+			current = maker.Binary(getCtcInt(JCTree.class, "PLUS"), current, expr);
 		}
 		
-		if (!first) current = maker.Binary(Javac.getCtcInt(JCTree.class, "PLUS"), current, maker.Literal(suffix));
+		if (!first) current = maker.Binary(getCtcInt(JCTree.class, "PLUS"), current, maker.Literal(suffix));
 		
 		JCStatement returnStatement = maker.Return(current);
 		
 		JCBlock body = maker.Block(0, List.of(returnStatement));
 		
-		return Javac.recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName("toString"), returnType,
+		return recursiveSetGeneratedBy(maker.MethodDef(mods, typeNode.toName("toString"), returnType,
 				List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), body, null), source);
 	}
 	
diff --git a/src/core/lombok/javac/handlers/HandleVal.java b/src/core/lombok/javac/handlers/HandleVal.java
index bc70899d..b8de8996 100644
--- a/src/core/lombok/javac/handlers/HandleVal.java
+++ b/src/core/lombok/javac/handlers/HandleVal.java
@@ -21,8 +21,9 @@
  */
 package lombok.javac.handlers;
 
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+
 import lombok.val;
-import lombok.javac.Javac;
 import lombok.javac.JavacASTAdapter;
 import lombok.javac.JavacASTVisitor;
 import lombok.javac.JavacNode;
@@ -51,7 +52,7 @@ public class HandleVal extends JavacASTAdapter {
 		
 		JCTree source = local.vartype;
 		
-		if (!Javac.typeMatches(val.class, localNode, local.vartype)) return;
+		if (!typeMatches(val.class, localNode, local.vartype)) return;
 		
 		JCExpression rhsOfEnhancedForLoop = null;
 		if (local.init == null) {
@@ -77,7 +78,7 @@ public class HandleVal extends JavacASTAdapter {
 		local.mods.flags |= Flags.FINAL;
 		
 		if (!localNode.shouldDeleteLombokAnnotations()) {
-			JCAnnotation valAnnotation = Javac.recursiveSetGeneratedBy(localNode.getTreeMaker().Annotation(local.vartype, List.<JCExpression>nil()), source);
+			JCAnnotation valAnnotation = recursiveSetGeneratedBy(localNode.getTreeMaker().Annotation(local.vartype, List.<JCExpression>nil()), source);
 			local.mods.annotations = local.mods.annotations == null ? List.of(valAnnotation) : local.mods.annotations.append(valAnnotation);
 		}
 		
@@ -126,7 +127,7 @@ public class HandleVal extends JavacASTAdapter {
 			local.vartype = JavacResolution.createJavaLangObject(localNode.getTreeMaker(), localNode.getAst());
 			throw e;
 		} finally {
-			Javac.recursiveSetGeneratedBy(local.vartype, source);
+			recursiveSetGeneratedBy(local.vartype, source);
 		}
 	}
 }
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index c733304b..fedd9d47 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -21,23 +21,33 @@
  */
 package lombok.javac.handlers;
 
-import static lombok.javac.Javac.annotationTypeMatches;
+import static lombok.javac.Javac.*;
 
 import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
 import java.util.regex.Pattern;
 
 import lombok.AccessLevel;
 import lombok.Data;
 import lombok.Getter;
 import lombok.core.AnnotationValues;
+import lombok.core.TypeLibrary;
+import lombok.core.TypeResolver;
 import lombok.core.AST.Kind;
-import lombok.core.handlers.TransformationsUtil;
+import lombok.core.AnnotationValues.AnnotationValue;
 import lombok.javac.Javac;
 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.TreeScanner;
 import com.sun.tools.javac.tree.JCTree.JCLiteral;
 import com.sun.tools.javac.tree.JCTree.JCModifiers;
 import com.sun.tools.javac.tree.TreeMaker;
@@ -56,6 +66,7 @@ import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 
 /**
  * Container for static utility methods useful to handlers written for javac.
@@ -65,12 +76,142 @@ public class JavacHandlerUtil {
 		//Prevent instantiation
 	}
 	
+	private static class MarkingScanner extends TreeScanner {
+		private final JCTree source;
+		
+		MarkingScanner(JCTree source) {
+			this.source = source;
+		}
+		
+		@Override public void scan(JCTree tree) {
+			setGeneratedBy(tree, source);
+			super.scan(tree);
+		}
+	}
+	
+	private static Map<JCTree, JCTree> generatedNodes = new WeakHashMap<JCTree, JCTree>();
+	
+	public static JCTree getGeneratedBy(JCTree node) {
+		synchronized (generatedNodes) {
+			return generatedNodes.get(node);
+		}
+	}
+	
+	public static boolean isGenerated(JCTree node) {
+		return getGeneratedBy(node) != null;
+	}
+	
+	public static <T extends JCTree> T recursiveSetGeneratedBy(T node, JCTree source) {
+		setGeneratedBy(node, source);
+		node.accept(new MarkingScanner(source));
+		
+		return node;
+	}
+	
+	public static <T extends JCTree> T setGeneratedBy(T node, JCTree source) {
+		synchronized (generatedNodes) {
+			if (source == null) generatedNodes.remove(node);
+			else generatedNodes.put(node, source);
+		}
+		return node;
+	}
+	
 	/**
-	 * Checks if the given expression (that really ought to refer to a type expression) represents a primitive type.
+	 * Checks if the Annotation AST Node provided is likely to be an instance of the provided annotation type.
+	 * 
+	 * @param type An actual annotation type, such as {@code lombok.Getter.class}.
+	 * @param node A Lombok AST node representing an annotation in source code.
+	 */
+	public static boolean annotationTypeMatches(Class<? extends Annotation> type, JavacNode node) {
+		if (node.getKind() != Kind.ANNOTATION) return false;
+		return typeMatches(type, node, ((JCAnnotation)node.get()).annotationType);
+	}
+	
+	/**
+	 * Checks if the given TypeReference node is likely to be a reference to the provided class.
+	 * 
+	 * @param type An actual type. This method checks if {@code typeNode} is likely to be a reference to this type.
+	 * @param node A Lombok AST node. Any node in the appropriate compilation unit will do (used to get access to import statements).
+	 * @param typeNode A type reference to check.
+	 */
+	public static boolean typeMatches(Class<?> type, JavacNode node, JCTree typeNode) {
+		String typeName = typeNode.toString();
+		
+		TypeLibrary library = new TypeLibrary();
+		library.addType(type.getName());
+		TypeResolver resolver = new TypeResolver(library, node.getPackageDeclaration(), node.getImportStatements());
+		Collection<String> typeMatches = resolver.findTypeMatches(node, typeName);
+		
+		for (String match : typeMatches) {
+			if (match.equals(type.getName())) return true;
+		}
+		
+		return false;
+	}
+	
+	/**
+	 * Creates an instance of {@code AnnotationValues} for the provided AST Node.
+	 * 
+	 * @param type An annotation class type, such as {@code lombok.Getter.class}.
+	 * @param node A Lombok AST node representing an annotation in source code.
 	 */
-	public static boolean isPrimitive(JCExpression ref) {
-		String typeName = ref.toString();
-		return TransformationsUtil.PRIMITIVE_TYPE_NAME_PATTERN.matcher(typeName).matches();
+	public static <A extends Annotation> AnnotationValues<A> createAnnotation(Class<A> type, final JavacNode node) {
+		Map<String, AnnotationValue> values = new HashMap<String, AnnotationValue>();
+		JCAnnotation anno = (JCAnnotation) node.get();
+		List<JCExpression> arguments = anno.getArguments();
+		for (Method m : type.getDeclaredMethods()) {
+			if (!Modifier.isPublic(m.getModifiers())) continue;
+			String name = m.getName();
+			java.util.List<String> raws = new ArrayList<String>();
+			java.util.List<Object> guesses = new ArrayList<Object>();
+			java.util.List<Object> expressions = new ArrayList<Object>();
+			final java.util.List<DiagnosticPosition> positions = new ArrayList<DiagnosticPosition>();
+			boolean isExplicit = false;
+			
+			for (JCExpression arg : arguments) {
+				String mName;
+				JCExpression rhs;
+				
+				if (arg instanceof JCAssign) {
+					JCAssign assign = (JCAssign) arg;
+					mName = assign.lhs.toString();
+					rhs = assign.rhs;
+				} else {
+					rhs = arg;
+					mName = "value";
+				}
+				
+				if (!mName.equals(name)) continue;
+				isExplicit = true;
+				if (rhs instanceof JCNewArray) {
+					List<JCExpression> elems = ((JCNewArray)rhs).elems;
+					for (JCExpression inner : elems) {
+						raws.add(inner.toString());
+						expressions.add(inner);
+						guesses.add(calculateGuess(inner));
+						positions.add(inner.pos());
+					}
+				} else {
+					raws.add(rhs.toString());
+					expressions.add(rhs);
+					guesses.add(calculateGuess(rhs));
+					positions.add(rhs.pos());
+				}
+			}
+			
+			values.put(name, new AnnotationValue(node, raws, expressions, guesses, isExplicit) {
+				@Override public void setError(String message, int valueIdx) {
+					if (valueIdx < 0) node.addError(message);
+					else node.addError(message, positions.get(valueIdx));
+				}
+				@Override public void setWarning(String message, int valueIdx) {
+					if (valueIdx < 0) node.addWarning(message);
+					else node.addWarning(message, positions.get(valueIdx));
+				}
+			});
+		}
+		
+		return new AnnotationValues<A>(type, values, node);
 	}
 	
 	/**
@@ -133,56 +274,6 @@ public class JavacHandlerUtil {
 		return newAnnotations.toList();
 	}
 	
-	/**
-	 * 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);
-	}
-	
-	/**
-	 * Translates the given field into all possible setter names.
-	 * Convenient wrapper around {@link TransformationsUtil#toAllSetterNames(CharSequence, boolean)}.
-	 */
-	public static java.util.List<String> toAllSetterNames(JCVariableDecl field) {
-		CharSequence fieldName = field.name;
-		
-		boolean isBoolean = field.vartype.toString().equals("boolean");
-		
-		return TransformationsUtil.toAllSetterNames(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, boolean)}.
-	 */
-	public static String toSetterName(JCVariableDecl field) {
-		CharSequence fieldName = field.name;
-		
-		boolean isBoolean = field.vartype.toString().equals("boolean");
-		
-		return TransformationsUtil.toSetterName(fieldName, isBoolean);
-	}
-	
 	/** Serves as return value for the methods that check for the existence of fields and methods. */
 	public enum MemberExistsResult {
 		NOT_EXISTS, EXISTS_BY_LOMBOK, EXISTS_BY_USER;
@@ -203,7 +294,7 @@ public class JavacHandlerUtil {
 			for (JCTree def : ((JCClassDecl)node.get()).defs) {
 				if (def instanceof JCVariableDecl) {
 					if (((JCVariableDecl)def).name.contentEquals(fieldName)) {
-						return Javac.getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
+						return getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
 					}
 				}
 			}
@@ -234,7 +325,7 @@ public class JavacHandlerUtil {
 				if (def instanceof JCMethodDecl) {
 					String name = ((JCMethodDecl)def).name.toString();
 					boolean matches = caseSensitive ? name.equals(methodName) : name.equalsIgnoreCase(methodName);
-					if (matches) return Javac.getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
+					if (matches) return getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
 				}
 			}
 		}
@@ -258,7 +349,7 @@ public class JavacHandlerUtil {
 				if (def instanceof JCMethodDecl) {
 					if (((JCMethodDecl)def).name.contentEquals("<init>")) {
 						if ((((JCMethodDecl)def).mods.flags & Flags.GENERATEDCONSTR) != 0) continue;
-						return Javac.getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
+						return getGeneratedBy(def) == null ? MemberExistsResult.EXISTS_BY_USER : MemberExistsResult.EXISTS_BY_LOMBOK;
 					}
 				}
 			}
@@ -318,7 +409,7 @@ public class JavacHandlerUtil {
 		
 		for (JavacNode child : field.down()) {
 			if (child.getKind() == Kind.ANNOTATION && annotationTypeMatches(Getter.class, child)) {
-				AnnotationValues<Getter> ann = Javac.createAnnotation(Getter.class, child);
+				AnnotationValues<Getter> ann = createAnnotation(Getter.class, child);
 				if (ann.getInstance().value() == AccessLevel.NONE) return null;   //Definitely WONT have a getter.
 				hasGetterAnnotation = true;
 			}
@@ -333,7 +424,7 @@ public class JavacHandlerUtil {
 			if (containingType != null) for (JavacNode child : containingType.down()) {
 				if (child.getKind() == Kind.ANNOTATION && annotationTypeMatches(Data.class, child)) hasGetterAnnotation = true;
 				if (child.getKind() == Kind.ANNOTATION && annotationTypeMatches(Getter.class, child)) {
-					AnnotationValues<Getter> ann = Javac.createAnnotation(Getter.class, child);
+					AnnotationValues<Getter> ann = createAnnotation(Getter.class, child);
 					if (ann.getInstance().value() == AccessLevel.NONE) return null;   //Definitely WONT have a getter.
 					hasGetterAnnotation = true;
 				}
@@ -359,8 +450,8 @@ public class JavacHandlerUtil {
 		// If @Getter(lazy = true) is used, then using it is mandatory.
 		for (JavacNode child : field.down()) {
 			if (child.getKind() != Kind.ANNOTATION) continue;
-			if (Javac.annotationTypeMatches(Getter.class, child)) {
-				AnnotationValues<Getter> ann = Javac.createAnnotation(Getter.class, child);
+			if (annotationTypeMatches(Getter.class, child)) {
+				AnnotationValues<Getter> ann = createAnnotation(Getter.class, child);
 				if (ann.getInstance().lazy()) return true;
 			}
 		}
@@ -440,7 +531,7 @@ public class JavacHandlerUtil {
 	private static void injectField(JavacNode typeNode, JCVariableDecl field, boolean addSuppressWarnings) {
 		JCClassDecl type = (JCClassDecl) typeNode.get();
 		
-		if (addSuppressWarnings) addSuppressWarningsAll(field.mods, typeNode, field.pos, Javac.getGeneratedBy(field));
+		if (addSuppressWarnings) addSuppressWarningsAll(field.mods, typeNode, field.pos, getGeneratedBy(field));
 		type.defs = type.defs.append(field);
 		
 		typeNode.add(field, Kind.FIELD);
@@ -471,7 +562,7 @@ public class JavacHandlerUtil {
 			}
 		}
 		
-		addSuppressWarningsAll(method.mods, typeNode, method.pos, Javac.getGeneratedBy(method));
+		addSuppressWarningsAll(method.mods, typeNode, method.pos, getGeneratedBy(method));
 		type.defs = type.defs.append(method);
 		
 		typeNode.add(method, Kind.METHOD);
@@ -479,11 +570,11 @@ public class JavacHandlerUtil {
 	
 	private static void addSuppressWarningsAll(JCModifiers mods, JavacNode node, int pos, JCTree source) {
 		TreeMaker maker = node.getTreeMaker();
-		JCExpression suppressWarningsType = chainDots(maker, node, "java", "lang", "SuppressWarnings");
+		JCExpression suppressWarningsType = chainDots(node, "java", "lang", "SuppressWarnings");
 		JCLiteral allLiteral = maker.Literal("all");
 		suppressWarningsType.pos = pos;
 		allLiteral.pos = pos;
-		JCAnnotation annotation = Javac.recursiveSetGeneratedBy(maker.Annotation(suppressWarningsType, List.<JCExpression>of(allLiteral)), source);
+		JCAnnotation annotation = recursiveSetGeneratedBy(maker.Annotation(suppressWarningsType, List.<JCExpression>of(allLiteral)), source);
 		annotation.pos = pos;
 		mods.annotations = mods.annotations.append(annotation);
 	}
@@ -507,13 +598,13 @@ public class JavacHandlerUtil {
 	 * @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) {
+	public static JCExpression chainDots(JavacNode node, String... elems) {
 		assert elems != null;
 		assert elems.length > 0;
 		
-		JCExpression e = maker.Ident(node.toName(elems[0]));
+		JCExpression e = node.getTreeMaker().Ident(node.toName(elems[0]));
 		for (int i = 1 ; i < elems.length ; i++) {
-			e = maker.Select(e, node.toName(elems[i]));
+			e = node.getTreeMaker().Select(e, node.toName(elems[i]));
 		}
 		
 		return e;
@@ -530,8 +621,8 @@ public class JavacHandlerUtil {
 	 * @see com.sun.tools.javac.tree.JCTree.JCIdent
 	 * @see com.sun.tools.javac.tree.JCTree.JCFieldAccess
 	 */
-	public static JCExpression chainDotsString(TreeMaker maker, JavacNode node, String elems) {
-		return chainDots(maker, node, elems.split("\\."));	
+	public static JCExpression chainDotsString(JavacNode node, String elems) {
+		return chainDots(node, elems.split("\\."));	
 	}
 	
 	/**
@@ -563,7 +654,7 @@ public class JavacHandlerUtil {
 		JCVariableDecl varDecl = (JCVariableDecl) variable.get();
 		if (isPrimitive(varDecl.vartype)) return null;
 		Name fieldName = varDecl.name;
-		JCExpression npe = chainDots(treeMaker, variable, "java", "lang", "NullPointerException");
+		JCExpression npe = chainDots(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(Javac.getCtcInt(JCTree.class, "EQ"), treeMaker.Ident(fieldName), treeMaker.Literal(Javac.getCtcInt(TypeTags.class, "BOT"), null)), throwStatement, null);