Refactored out references to TypeTags.

Instead they are retrieved
dynamically, with a pinch of caching during runtime. We already had some
fixes to make sure that compile time constanst were not inlined, but we
need to take into account that a lot of the Integer-based enums have
been replaced with actual enums.

Also, certain TreeMaker methods needed to be invoked dynamically with
reflection.

This needs to be reviewed, and if it turns out that these changes are too
dramatic, we should fork out a larger part of our code for specific JVM
versions.

9 files changed, 69 insertions, 61 deletions

diff --git a/src/core/lombok/javac/JavacResolution.java b/src/core/lombok/javac/JavacResolution.java
index 0a21aa58..e5d8ed38 100644
--- a/src/core/lombok/javac/JavacResolution.java
+++ b/src/core/lombok/javac/JavacResolution.java
@@ -43,7 +43,6 @@ import com.sun.tools.javac.code.Type.ArrayType;
 import com.sun.tools.javac.code.Type.CapturedType;
 import com.sun.tools.javac.code.Type.ClassType;
 import com.sun.tools.javac.code.Type.WildcardType;
-import com.sun.tools.javac.code.TypeTags;
 import com.sun.tools.javac.code.Types;
 import com.sun.tools.javac.comp.Attr;
 import com.sun.tools.javac.comp.AttrContext;
@@ -419,8 +418,8 @@ public class JavacResolution {
 		
 		TreeMaker maker = ast.getTreeMaker();
 		
-		if (type.tag == CTC_BOT) return createJavaLangObject(ast);
-		if (type.tag == CTC_VOID) return allowVoid ? primitiveToJCTree(type.getKind(), maker) : createJavaLangObject(ast);
+		if (Javac.compareCTC(type.tag,  CTC_BOT)) return createJavaLangObject(ast);
+		if (Javac.compareCTC(type.tag, CTC_VOID)) return allowVoid ? primitiveToJCTree(type.getKind(), maker) : createJavaLangObject(ast);
 		if (type.isPrimitive()) return primitiveToJCTree(type.getKind(), maker);
 		if (type.isErroneous()) throw new TypeNotConvertibleException("Type cannot be resolved");
 		
@@ -454,7 +453,7 @@ public class JavacResolution {
 				upper = type.getUpperBound();
 			}
 			if (allowCompound) {
-				if (lower == null || lower.tag == CTC_BOT) {
+				if (lower == null || Javac.compareCTC(lower.tag, CTC_BOT)) {
 					if (upper == null || upper.toString().equals("java.lang.Object")) {
 						return maker.Wildcard(maker.TypeBoundKind(BoundKind.UNBOUND), null);
 					}
@@ -479,7 +478,7 @@ public class JavacResolution {
 		String qName;
 		if (symbol.isLocal()) {
 			qName = symbol.getSimpleName().toString();
-		} else if (symbol.type != null && symbol.type.getEnclosingType() != null && symbol.type.getEnclosingType().tag == TypeTags.CLASS) {
+		} else if (symbol.type != null && symbol.type.getEnclosingType() != null && Javac.compareCTC(symbol.type.getEnclosingType().tag, Javac.getTypeTag("CLASS"))) {
 			replacement = typeToJCTree0(type.getEnclosingType(), ast, false, false);
 			qName = symbol.getSimpleName().toString();
 		} else {
@@ -515,23 +514,23 @@ public class JavacResolution {
 	private static JCExpression primitiveToJCTree(TypeKind kind, TreeMaker maker) throws TypeNotConvertibleException {
 		switch (kind) {
 		case BYTE:
-			return maker.TypeIdent(CTC_BYTE);
+			return Javac.makeTypeIdent(maker, CTC_BYTE);
 		case CHAR:
-			return maker.TypeIdent(CTC_CHAR);
+			return Javac.makeTypeIdent(maker, CTC_CHAR);
 		case SHORT:
-			return maker.TypeIdent(CTC_SHORT);
+			return Javac.makeTypeIdent(maker, CTC_SHORT);
 		case INT:
-			return maker.TypeIdent(CTC_INT);
+			return Javac.makeTypeIdent(maker, CTC_INT);
 		case LONG:
-			return maker.TypeIdent(CTC_LONG);
+			return Javac.makeTypeIdent(maker, CTC_LONG);
 		case FLOAT:
-			return maker.TypeIdent(CTC_FLOAT);
+			return Javac.makeTypeIdent(maker, CTC_FLOAT);
 		case DOUBLE:
-			return maker.TypeIdent(CTC_DOUBLE);
+			return Javac.makeTypeIdent(maker, CTC_DOUBLE);
 		case BOOLEAN:
-			return maker.TypeIdent(CTC_BOOLEAN);
+			return Javac.makeTypeIdent(maker, CTC_BOOLEAN);
 		case VOID:
-			return maker.TypeIdent(CTC_VOID);
+			return Javac.makeTypeIdent(maker, CTC_VOID);
 		case NULL:
 		case NONE:
 		case OTHER:
diff --git a/src/core/lombok/javac/handlers/HandleCleanup.java b/src/core/lombok/javac/handlers/HandleCleanup.java
index 09b4faee..c75256a5 100644
--- a/src/core/lombok/javac/handlers/HandleCleanup.java
+++ b/src/core/lombok/javac/handlers/HandleCleanup.java
@@ -26,6 +26,7 @@ import static lombok.javac.Javac.*;
 import lombok.Cleanup;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
+import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 
@@ -120,7 +121,7 @@ public class HandleCleanup extends JavacAnnotationHandler<Cleanup> {
 				maker.Apply(List.<JCExpression>nil(), cleanupMethod, List.<JCExpression>nil())));
 		
 		JCMethodInvocation preventNullAnalysis = preventNullAnalysis(maker, annotationNode, maker.Ident(decl.name));
-		JCBinary isNull = maker.Binary(CTC_NOT_EQUAL, preventNullAnalysis, maker.Literal(CTC_BOT, null));
+		JCBinary isNull = Javac.makeBinary(maker, CTC_NOT_EQUAL, preventNullAnalysis, Javac.makeLiteral(maker, CTC_BOT, null));
 		
 		JCIf ifNotNullCleanup = maker.If(isNull, maker.Block(0, cleanupCall), null);
 		
@@ -141,7 +142,7 @@ public class HandleCleanup extends JavacAnnotationHandler<Cleanup> {
 	
 	private JCMethodInvocation preventNullAnalysis(TreeMaker maker, JavacNode node, JCExpression 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)));
+		JCMethodInvocation cleanedExpr = maker.Apply(List.<JCExpression>nil(), maker.Select(singletonList, node.toName("get")) , List.<JCExpression>of(Javac.makeLiteral(maker, CTC_INT, 0)));
 		return cleanedExpr;
 	}
 	
diff --git a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
index 5f69be9d..39edb143 100644
--- a/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
+++ b/src/core/lombok/javac/handlers/HandleEqualsAndHashCode.java
@@ -30,6 +30,7 @@ import java.util.Collections;
 import lombok.EqualsAndHashCode;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
+import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 import lombok.javac.handlers.JavacHandlerUtil.FieldAccess;
@@ -39,7 +40,6 @@ 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.JCTree.JCAnnotation;
 import com.sun.tools.javac.tree.JCTree.JCArrayTypeTree;
@@ -213,7 +213,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		
 		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(CTC_INT);
+		JCExpression returnType = Javac.makeTypeIdent(maker, CTC_INT);
 		ListBuffer<JCStatement> statements = ListBuffer.lb();
 		
 		Name primeName = typeNode.toName(PRIME_NAME);
@@ -221,12 +221,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(CTC_INT), maker.Literal(31)));
+						primeName, Javac.makeTypeIdent(maker, CTC_INT), maker.Literal(31)));
 			}
 		}
 		
 		/* int result = 1; */ {
-			statements.append(maker.VarDef(maker.Modifiers(0), resultName, maker.TypeIdent(CTC_INT), maker.Literal(1)));
+			statements.append(maker.VarDef(maker.Modifiers(0), resultName, Javac.makeTypeIdent(maker, CTC_INT), maker.Literal(1)));
 		}
 		
 		if (callSuper) {
@@ -248,7 +248,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 					break;
 				case LONG: {
 						Name dollarFieldName = dollar.append(((JCVariableDecl)fieldNode.get()).name);
-						statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), dollarFieldName, maker.TypeIdent(TypeTags.LONG), fieldAccessor));
+						statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), dollarFieldName, Javac.makeTypeIdent(maker, CTC_LONG), fieldAccessor));
 						statements.append(createResultCalculation(typeNode, longToIntForHashCode(maker, maker.Ident(dollarFieldName), maker.Ident(dollarFieldName))));
 					}
 					break;
@@ -266,7 +266,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 								List.<JCExpression>nil(),
 								chainDots(typeNode, "java", "lang", "Double", "doubleToLongBits"),
 								List.of(fieldAccessor));
-						statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), dollarFieldName, maker.TypeIdent(TypeTags.LONG), init));
+						statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), dollarFieldName, Javac.makeTypeIdent(maker, CTC_LONG), init));
 						statements.append(createResultCalculation(typeNode, longToIntForHashCode(maker, maker.Ident(dollarFieldName), maker.Ident(dollarFieldName))));
 					}
 					break;
@@ -296,7 +296,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 				
 				JCExpression hcCall = maker.Apply(List.<JCExpression>nil(), maker.Select(maker.Ident(dollarFieldName), typeNode.toName("hashCode")),
 						List.<JCExpression>nil());
-				JCExpression thisEqualsNull = maker.Binary(CTC_EQUAL, maker.Ident(dollarFieldName), maker.Literal(CTC_BOT, null));
+				JCExpression thisEqualsNull = Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(dollarFieldName), Javac.makeLiteral(maker, CTC_BOT, null));
 				statements.append(createResultCalculation(typeNode, maker.Conditional(thisEqualsNull, maker.Literal(0), hcCall)));
 			}
 		}
@@ -314,17 +314,17 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		/* result = result * PRIME + (expr); */
 		TreeMaker maker = typeNode.getTreeMaker();
 		Name resultName = typeNode.toName(RESULT_NAME);
-		JCExpression mult = maker.Binary(CTC_MUL, maker.Ident(resultName), maker.Ident(typeNode.toName(PRIME_NAME)));
-		JCExpression add = maker.Binary(CTC_PLUS, mult, expr);
+		JCExpression mult = Javac.makeBinary(maker, CTC_MUL, maker.Ident(resultName), maker.Ident(typeNode.toName(PRIME_NAME)));
+		JCExpression add = Javac.makeBinary(maker, CTC_PLUS, mult, expr);
 		return maker.Exec(maker.Assign(maker.Ident(resultName), add));
 	}
 	
 	/** 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(CTC_UNSIGNED_SHIFT_RIGHT, ref1, maker.Literal(32));
-		JCExpression xorBits = maker.Binary(CTC_BITXOR, shift, ref2);
-		return maker.TypeCast(maker.TypeIdent(CTC_INT), xorBits);
+		JCExpression shift = Javac.makeBinary(maker, CTC_UNSIGNED_SHIFT_RIGHT, ref1, maker.Literal(32));
+		JCExpression xorBits = Javac.makeBinary(maker, CTC_BITXOR, shift, ref2);
+		return maker.TypeCast(Javac.makeTypeIdent(maker, CTC_INT), xorBits);
 	}
 	
 	private JCExpression createTypeReference(JavacNode type) {
@@ -358,18 +358,19 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		JCAnnotation overrideAnnotation = maker.Annotation(chainDots(typeNode, "java", "lang", "Override"), List.<JCExpression>nil());
 		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.of(overrideAnnotation));
 		JCExpression objectType = chainDots(typeNode, "java", "lang", "Object");
-		JCExpression returnType = maker.TypeIdent(CTC_BOOLEAN);
+		JCExpression returnType = Javac.makeTypeIdent(maker, CTC_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(CTC_EQUAL, maker.Ident(oName),
+			statements.append(maker.If(Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(oName),
 					maker.Ident(thisName)), returnBool(maker, true), null));
 		}
 		
 		/* if (!(o instanceof Outer.Inner.MyType) return false; */ {
-			JCUnary notInstanceOf = maker.Unary(CTC_NOT, maker.TypeTest(maker.Ident(oName), createTypeReference(typeNode)));
+			 
+			JCUnary notInstanceOf = Javac.makeUnary(maker, CTC_NOT, maker.TypeTest(maker.Ident(oName), createTypeReference(typeNode)));
 			statements.append(maker.If(notInstanceOf, returnBool(maker, false), null));
 		}
 		
@@ -404,7 +405,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 				JCExpression equalityCheck = maker.Apply(exprNil, 
 						maker.Select(maker.Ident(otherName), typeNode.toName("canEqual")),
 						List.of(castThisRef));
-				statements.append(maker.If(maker.Unary(CTC_NOT, equalityCheck), returnBool(maker, false), null));
+				statements.append(maker.If(Javac.makeUnary(maker, CTC_NOT, equalityCheck), returnBool(maker, false), null));
 			}
 		}
 		
@@ -413,7 +414,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(CTC_NOT, callToSuper);
+			JCUnary superNotEqual = Javac.makeUnary(maker, CTC_NOT, callToSuper);
 			statements.append(maker.If(superNotEqual, returnBool(maker, false), null));
 		}
 		
@@ -436,7 +437,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 				default:
 					/* if (this.fieldName != other.fieldName) return false; */
 					statements.append(
-							maker.If(maker.Binary(CTC_NOT_EQUAL, thisFieldAccessor, otherFieldAccessor), returnBool(maker, false), null));
+							maker.If(Javac.makeBinary(maker, CTC_NOT_EQUAL, thisFieldAccessor, otherFieldAccessor), returnBool(maker, false), null));
 					break;
 				}
 			} else if (fType instanceof JCArrayTypeTree) {
@@ -447,7 +448,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 				
 				JCExpression eqMethod = chainDots(typeNode, "java", "util", "Arrays", useDeepEquals ? "deepEquals" : "equals");
 				List<JCExpression> args = List.of(thisFieldAccessor, otherFieldAccessor);
-				statements.append(maker.If(maker.Unary(CTC_NOT,
+				statements.append(maker.If(Javac.makeUnary(maker, CTC_NOT,
 						maker.Apply(List.<JCExpression>nil(), eqMethod, args)), returnBool(maker, false), null));
 			} else /* objects */ {
 				/* final java.lang.Object this$fieldName = this.fieldName; */
@@ -460,12 +461,12 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 				statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), thisDollarFieldName, chainDots(typeNode, "java", "lang", "Object"), thisFieldAccessor));
 				statements.append(maker.VarDef(maker.Modifiers(Flags.FINAL), otherDollarFieldName, chainDots(typeNode, "java", "lang", "Object"), otherFieldAccessor));
 
-				JCExpression thisEqualsNull = maker.Binary(CTC_EQUAL, maker.Ident(thisDollarFieldName), maker.Literal(CTC_BOT, null));
-				JCExpression otherNotEqualsNull = maker.Binary(CTC_NOT_EQUAL, maker.Ident(otherDollarFieldName), maker.Literal(CTC_BOT, null));
+				JCExpression thisEqualsNull = Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(thisDollarFieldName), Javac.makeLiteral(maker, CTC_BOT, null));
+				JCExpression otherNotEqualsNull = Javac.makeBinary(maker, CTC_NOT_EQUAL, maker.Ident(otherDollarFieldName), Javac.makeLiteral(maker, CTC_BOT, null));
 				JCExpression thisEqualsThat = maker.Apply(List.<JCExpression>nil(),
 						maker.Select(maker.Ident(thisDollarFieldName), typeNode.toName("equals")),
 						List.<JCExpression>of(maker.Ident(otherDollarFieldName)));
-				JCExpression fieldsAreNotEqual = maker.Conditional(thisEqualsNull, otherNotEqualsNull, maker.Unary(CTC_NOT, thisEqualsThat));
+				JCExpression fieldsAreNotEqual = maker.Conditional(thisEqualsNull, otherNotEqualsNull, Javac.makeUnary(maker, CTC_NOT, thisEqualsThat));
 				statements.append(maker.If(fieldsAreNotEqual, returnBool(maker, false), null));
 			}
 		}
@@ -486,7 +487,7 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		TreeMaker maker = typeNode.getTreeMaker();
 		
 		JCModifiers mods = maker.Modifiers(Flags.PUBLIC, List.<JCAnnotation>nil());
-		JCExpression returnType = maker.TypeIdent(CTC_BOOLEAN);
+		JCExpression returnType = Javac.makeTypeIdent(maker, CTC_BOOLEAN);
 		Name canEqualName = typeNode.toName("canEqual");
 		JCExpression objectType = chainDots(typeNode, "java", "lang", "Object");
 		Name otherName = typeNode.toName("other");
@@ -503,12 +504,12 @@ public class HandleEqualsAndHashCode extends JavacAnnotationHandler<EqualsAndHas
 		/* if (Float.compare(fieldName, other.fieldName) != 0) return false; */
 		JCExpression clazz = chainDots(node, "java", "lang", isDouble ? "Double" : "Float");
 		List<JCExpression> args = List.of(thisDotField, otherDotField);
-		JCBinary compareCallEquals0 = maker.Binary(CTC_NOT_EQUAL, maker.Apply(
+		JCBinary compareCallEquals0 = Javac.makeBinary(maker, CTC_NOT_EQUAL, 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(CTC_BOOLEAN, bool ? 1 : 0));
+		return maker.Return(Javac.makeLiteral(maker, CTC_BOOLEAN, bool ? 1 : 0));
 	}
 }
diff --git a/src/core/lombok/javac/handlers/HandleGetter.java b/src/core/lombok/javac/handlers/HandleGetter.java
index bc68d5ad..2fa2a755 100644
--- a/src/core/lombok/javac/handlers/HandleGetter.java
+++ b/src/core/lombok/javac/handlers/HandleGetter.java
@@ -35,6 +35,7 @@ import lombok.Getter;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
 import lombok.core.TransformationsUtil;
+import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 import lombok.javac.handlers.JavacHandlerUtil.FieldAccess;
@@ -288,9 +289,9 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 	private static final String AR = "java.util.concurrent.atomic.AtomicReference";
 	private static final List<JCExpression> NIL_EXPRESSION = List.nil();
 	
-	private static final java.util.Map<Integer, String> TYPE_MAP;
+	private static final java.util.Map<Object, String> TYPE_MAP;
 	static {
-		Map<Integer, String> m = new HashMap<Integer, String>();
+		Map<Object, String> m = new HashMap<Object, String>();
 		m.put(CTC_INT, "java.lang.Integer");
 		m.put(CTC_DOUBLE, "java.lang.Double");
 		m.put(CTC_FLOAT, "java.lang.Float");
@@ -364,7 +365,7 @@ public class HandleGetter extends JavacAnnotationHandler<Getter> {
 						innerIfStatements.append(statement);
 					}
 					
-					JCBinary isNull = maker.Binary(CTC_EQUAL, maker.Ident(valueName), maker.Literal(CTC_BOT, null));
+					JCBinary isNull = Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(valueName), Javac.makeLiteral(maker, CTC_BOT, null));
 					JCIf ifStatement = maker.If(isNull, maker.Block(0, innerIfStatements.toList()), null);
 					synchronizedStatements.append(ifStatement);
 				}
@@ -372,7 +373,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(CTC_EQUAL, maker.Ident(valueName), maker.Literal(CTC_BOT, null));
+			JCBinary isNull = Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(valueName), Javac.makeLiteral(maker, CTC_BOT, null));
 			JCIf ifStatement = maker.If(isNull, maker.Block(0, List.<JCStatement>of(synchronizedStatement)), null);
 			statements.append(ifStatement);
 		}
diff --git a/src/core/lombok/javac/handlers/HandleSetter.java b/src/core/lombok/javac/handlers/HandleSetter.java
index c1e03c35..2136024e 100644
--- a/src/core/lombok/javac/handlers/HandleSetter.java
+++ b/src/core/lombok/javac/handlers/HandleSetter.java
@@ -35,6 +35,7 @@ import lombok.Setter;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
 import lombok.core.TransformationsUtil;
+import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 import lombok.javac.handlers.JavacHandlerUtil.FieldAccess;
@@ -253,14 +254,15 @@ public class HandleSetter extends JavacAnnotationHandler<Setter> {
 	}
 	
 	private static class JCNoType extends Type implements NoType {
-		public JCNoType(int tag) {
-			super(tag, null);
+		public JCNoType(Object tag) {
+			//FIX
+			super(1, null);
 		}
 		
 		@Override
 		public TypeKind getKind() {
-			if (tag == CTC_VOID) return TypeKind.VOID;
-			if (tag == CTC_NONE) return TypeKind.NONE;
+			if (Javac.compareCTC(tag, CTC_VOID)) return TypeKind.VOID;
+			if (Javac.compareCTC(tag, CTC_NONE)) return TypeKind.NONE;
 			throw new AssertionError("Unexpected tag: " + tag);
 		}
 		
diff --git a/src/core/lombok/javac/handlers/HandleSynchronized.java b/src/core/lombok/javac/handlers/HandleSynchronized.java
index 2bca49e9..2737eeb2 100644
--- a/src/core/lombok/javac/handlers/HandleSynchronized.java
+++ b/src/core/lombok/javac/handlers/HandleSynchronized.java
@@ -26,6 +26,7 @@ import static lombok.javac.handlers.JavacHandlerUtil.*;
 import lombok.Synchronized;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
+import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 import lombok.javac.handlers.JavacHandlerUtil.MemberExistsResult;
@@ -87,7 +88,7 @@ public class HandleSynchronized extends JavacAnnotationHandler<Synchronized> {
 			JCExpression objectType = chainDots(methodNode, ast.pos, "java", "lang", "Object");
 			//We use 'new Object[0];' because unlike 'new Object();', empty arrays *ARE* serializable!
 			JCNewArray newObjectArray = maker.NewArray(chainDots(methodNode, ast.pos, "java", "lang", "Object"),
-					List.<JCExpression>of(maker.Literal(CTC_INT, 0)), null);
+					List.<JCExpression>of(Javac.makeLiteral(maker, CTC_INT, 0)), null);
 			JCVariableDecl fieldDecl = recursiveSetGeneratedBy(maker.VarDef(
 					maker.Modifiers(Flags.PRIVATE | Flags.FINAL | (isStatic ? Flags.STATIC : 0)),
 					methodNode.toName(lockName), objectType, newObjectArray), ast);
diff --git a/src/core/lombok/javac/handlers/HandleToString.java b/src/core/lombok/javac/handlers/HandleToString.java
index 520acf62..c37fe149 100644
--- a/src/core/lombok/javac/handlers/HandleToString.java
+++ b/src/core/lombok/javac/handlers/HandleToString.java
@@ -27,6 +27,7 @@ import static lombok.javac.Javac.*;
 import lombok.ToString;
 import lombok.core.AnnotationValues;
 import lombok.core.AST.Kind;
+import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 
@@ -193,7 +194,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(CTC_PLUS, current, callToSuper);
+			current = Javac.makeBinary(maker, CTC_PLUS, current, callToSuper);
 			first = false;
 		}
 		
@@ -213,21 +214,21 @@ public class HandleToString extends JavacAnnotationHandler<ToString> {
 			} else expr = fieldAccessor;
 			
 			if (first) {
-				current = maker.Binary(CTC_PLUS, current, expr);
+				current = Javac.makeBinary(maker, CTC_PLUS, current, expr);
 				first = false;
 				continue;
 			}
 			
 			if (includeFieldNames) {
-				current = maker.Binary(CTC_PLUS, current, maker.Literal(infix + fieldNode.getName() + "="));
+				current = Javac.makeBinary(maker, CTC_PLUS, current, maker.Literal(infix + fieldNode.getName() + "="));
 			} else {
-				current = maker.Binary(CTC_PLUS, current, maker.Literal(infix));
+				current = Javac.makeBinary(maker, CTC_PLUS, current, maker.Literal(infix));
 			}
 			
-			current = maker.Binary(CTC_PLUS, current, expr);
+			current = Javac.makeBinary(maker, CTC_PLUS, current, expr);
 		}
 		
-		if (!first) current = maker.Binary(CTC_PLUS, current, maker.Literal(suffix));
+		if (!first) current = Javac.makeBinary(maker, CTC_PLUS, current, maker.Literal(suffix));
 		
 		JCStatement returnStatement = maker.Return(current);
 		
diff --git a/src/core/lombok/javac/handlers/HandleWither.java b/src/core/lombok/javac/handlers/HandleWither.java
index ba5aa72d..62ed63f1 100644
--- a/src/core/lombok/javac/handlers/HandleWither.java
+++ b/src/core/lombok/javac/handlers/HandleWither.java
@@ -31,6 +31,7 @@ import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
 import lombok.core.TransformationsUtil;
 import lombok.experimental.Wither;
+import lombok.javac.Javac;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 import lombok.javac.handlers.JavacHandlerUtil.FieldAccess;
@@ -239,7 +240,7 @@ public class HandleWither extends JavacAnnotationHandler<Wither> {
 		}
 		
 		JCNewClass newClass = maker.NewClass(null, List.<JCExpression>nil(), selfType, args.toList(), null);
-		JCExpression identityCheck = maker.Binary(CTC_EQUAL, createFieldAccessor(maker, field, FieldAccess.ALWAYS_FIELD), maker.Ident(fieldDecl.name));
+		JCExpression identityCheck = Javac.makeBinary(maker, CTC_EQUAL, createFieldAccessor(maker, field, FieldAccess.ALWAYS_FIELD), maker.Ident(fieldDecl.name));
 		JCConditional conditional = maker.Conditional(identityCheck, maker.Ident(field.toName("this")), newClass);
 		JCReturn returnStatement = maker.Return(conditional);
 		
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index c2de5b05..178b82a2 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -42,6 +42,7 @@ import lombok.core.AnnotationValues.AnnotationValue;
 import lombok.core.TransformationsUtil;
 import lombok.core.TypeResolver;
 import lombok.experimental.Accessors;
+import lombok.javac.Javac;
 import lombok.javac.JavacNode;
 
 import com.sun.tools.javac.code.BoundKind;
@@ -882,14 +883,14 @@ public class JavacHandlerUtil {
 	 * 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) {
+	public static JCStatement generateNullCheck(TreeMaker maker, JavacNode variable) {
 		JCVariableDecl varDecl = (JCVariableDecl) variable.get();
 		if (isPrimitive(varDecl.vartype)) return null;
 		Name fieldName = varDecl.name;
 		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(CTC_EQUAL, treeMaker.Ident(fieldName), treeMaker.Literal(CTC_BOT, null)), throwStatement, null);
+		JCTree exception = maker.NewClass(null, List.<JCExpression>nil(), npe, List.<JCExpression>of(maker.Literal(fieldName.toString())), null);
+		JCStatement throwStatement = maker.Throw(exception);
+		return maker.If(Javac.makeBinary(maker, CTC_EQUAL, maker.Ident(fieldName), Javac.makeLiteral(maker, CTC_BOT, null)), throwStatement, null);
 	}
 	
 	/**