As we’re preparing to release v2, we want to delete the experimental editions of the Builder and Value annotations… but in case you install lombok v2 into eclipse but use an older lombok as dep in your project, we still do want to process the old annotations. Had to stringly-type a few things to make that happen, but, works now.

4 files changed, 79 insertions, 25 deletions

diff --git a/src/core/lombok/javac/handlers/HandleBuilder.java b/src/core/lombok/javac/handlers/HandleBuilder.java
index d5a342e4..0631f12a 100644
--- a/src/core/lombok/javac/handlers/HandleBuilder.java
+++ b/src/core/lombok/javac/handlers/HandleBuilder.java
@@ -21,7 +21,6 @@
  */
 package lombok.javac.handlers;
 
-import java.lang.annotation.Annotation;
 import java.util.ArrayList;
 
 import javax.lang.model.element.Modifier;
@@ -119,9 +118,7 @@ public class HandleBuilder extends JavacAnnotationHandler<Builder> {
 			if (!checkName("builderClassName", builderClassName, annotationNode)) return;
 		}
 		
-		@SuppressWarnings("deprecation")
-		Class<? extends Annotation> oldExperimentalBuilder = lombok.experimental.Builder.class;
-		deleteAnnotationIfNeccessary(annotationNode, Builder.class, oldExperimentalBuilder);
+		deleteAnnotationIfNeccessary(annotationNode, Builder.class, "lombok.experimental.Builder");
 		
 		JavacNode parent = annotationNode.up();
 		
@@ -140,8 +137,7 @@ public class HandleBuilder extends JavacAnnotationHandler<Builder> {
 			tdParent = parent;
 			JCClassDecl td = (JCClassDecl) tdParent.get();
 			ListBuffer<JavacNode> allFields = new ListBuffer<JavacNode>();
-			@SuppressWarnings("deprecation")
-			boolean valuePresent = (hasAnnotation(lombok.Value.class, parent) || hasAnnotation(lombok.experimental.Value.class, parent));
+			boolean valuePresent = (hasAnnotation(lombok.Value.class, parent) || hasAnnotation("lombok.experimental.Value", parent));
 			for (JavacNode fieldNode : HandleConstructor.findAllFields(tdParent, true)) {
 				JCVariableDecl fd = (JCVariableDecl) fieldNode.get();
 				JavacNode isDefault = findAnnotation(Builder.Default.class, fieldNode, true);
diff --git a/src/core/lombok/javac/handlers/HandleBuilderDefault.java b/src/core/lombok/javac/handlers/HandleBuilderDefault.java
index 733aea5a..dac4053e 100644
--- a/src/core/lombok/javac/handlers/HandleBuilderDefault.java
+++ b/src/core/lombok/javac/handlers/HandleBuilderDefault.java
@@ -16,12 +16,11 @@ import lombok.javac.JavacNode;
 @ProviderFor(JavacAnnotationHandler.class)
 @HandlerPriority(-1025) //HandleBuilder's level, minus one.
 public class HandleBuilderDefault extends JavacAnnotationHandler<Builder.Default> {
-	@SuppressWarnings("deprecation")
 	@Override public void handle(AnnotationValues<Builder.Default> annotation, JCAnnotation ast, JavacNode annotationNode) {
 		JavacNode annotatedField = annotationNode.up();
 		if (annotatedField.getKind() != Kind.FIELD) return;
 		JavacNode classWithAnnotatedField = annotatedField.up();
-		if (!hasAnnotation(Builder.class, classWithAnnotatedField) && !hasAnnotation(lombok.experimental.Builder.class, classWithAnnotatedField)) {
+		if (!hasAnnotation(Builder.class, classWithAnnotatedField) && !hasAnnotation("lombok.experimental.Builder", classWithAnnotatedField)) {
 			annotationNode.addWarning("@Builder.Default requires @Builder on the class for it to mean anything.");
 			deleteAnnotationIfNeccessary(annotationNode, Builder.Default.class);
 		}
diff --git a/src/core/lombok/javac/handlers/HandleValue.java b/src/core/lombok/javac/handlers/HandleValue.java
index 90f6a98d..3961085c 100644
--- a/src/core/lombok/javac/handlers/HandleValue.java
+++ b/src/core/lombok/javac/handlers/HandleValue.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2014 The Project Lombok Authors.
+ * Copyright (C) 2012-2018 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,8 +24,6 @@ package lombok.javac.handlers;
 import static lombok.core.handlers.HandlerUtil.*;
 import static lombok.javac.handlers.JavacHandlerUtil.*;
 
-import java.lang.annotation.Annotation;
-
 import lombok.AccessLevel;
 import lombok.ConfigurationKeys;
 import lombok.core.AnnotationValues;
@@ -50,12 +48,9 @@ import com.sun.tools.javac.tree.JCTree.JCModifiers;
 @HandlerPriority(-512) //-2^9; to ensure @EqualsAndHashCode and such pick up on this handler making the class final and messing with the fields' access levels, run earlier.
 public class HandleValue extends JavacAnnotationHandler<Value> {
 	@Override public void handle(AnnotationValues<Value> annotation, JCAnnotation ast, JavacNode annotationNode) {
-		@SuppressWarnings("deprecation")
-		Class<? extends Annotation> oldExperimentalValue = lombok.experimental.Value.class;
-		
 		handleFlagUsage(annotationNode, ConfigurationKeys.VALUE_FLAG_USAGE, "@Value");
 		
-		deleteAnnotationIfNeccessary(annotationNode, Value.class, oldExperimentalValue);
+		deleteAnnotationIfNeccessary(annotationNode, Value.class, "lombok.experimental.Value");
 		JavacNode typeNode = annotationNode.up();
 		boolean notAClass = !isClass(typeNode);
 		
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index 956ab446..f12450c6 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -162,6 +162,10 @@ public class JavacHandlerUtil {
 		return node;
 	}
 	
+	public static boolean hasAnnotation(String type, JavacNode node) {
+		return hasAnnotation(type, node, false);
+	}
+	
 	public static boolean hasAnnotation(Class<? extends Annotation> type, JavacNode node) {
 		return hasAnnotation(type, node, false);
 	}
@@ -191,6 +195,27 @@ public class JavacHandlerUtil {
 		}
 	}
 	
+	private static boolean hasAnnotation(String type, JavacNode node, boolean delete) {
+		if (node == null) return false;
+		if (type == null) return false;
+		switch (node.getKind()) {
+		case ARGUMENT:
+		case FIELD:
+		case LOCAL:
+		case TYPE:
+		case METHOD:
+			for (JavacNode child : node.down()) {
+				if (annotationTypeMatches(type, child)) {
+					if (delete) deleteAnnotationIfNeccessary(child, type);
+					return true;
+				}
+			}
+			// intentional fallthrough
+		default:
+			return false;
+		}
+	}
+	
 	static JavacNode findAnnotation(Class<? extends Annotation> type, JavacNode node, boolean delete) {
 		if (node == null) return null;
 		if (type == null) return null;
@@ -224,6 +249,17 @@ public class JavacHandlerUtil {
 	}
 	
 	/**
+	 * 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(String 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.
@@ -231,10 +267,21 @@ public class JavacHandlerUtil {
 	 * @param typeNode A type reference to check.
 	 */
 	public static boolean typeMatches(Class<?> type, JavacNode node, JCTree typeNode) {
+		return typeMatches(type.getName(), node, typeNode);
+	}
+	
+	/**
+	 * 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(String type, JavacNode node, JCTree typeNode) {
 		String typeName = typeNode.toString();
 		
 		TypeResolver resolver = new TypeResolver(node.getImportList());
-		return resolver.typeMatches(node, type.getName(), typeName);
+		return resolver.typeMatches(node, type, typeName);
 	}
 	
 	/**
@@ -346,8 +393,7 @@ public class JavacHandlerUtil {
 	 * then removes any import statement that imports this exact annotation (not star imports).
 	 * Only does this if the DeleteLombokAnnotations class is in the context.
 	 */
-	@SuppressWarnings("unchecked")
-	public static void deleteAnnotationIfNeccessary(JavacNode annotation, Class<? extends Annotation> annotationType) {
+	public static void deleteAnnotationIfNeccessary(JavacNode annotation, String annotationType) {
 		deleteAnnotationIfNeccessary0(annotation, annotationType);
 	}
 	
@@ -356,12 +402,29 @@ public class JavacHandlerUtil {
 	 * then removes any import statement that imports this exact annotation (not star imports).
 	 * Only does this if the DeleteLombokAnnotations class is in the context.
 	 */
-	@SuppressWarnings("unchecked")
+	public static void deleteAnnotationIfNeccessary(JavacNode annotation, Class<? extends Annotation> annotationType) {
+		deleteAnnotationIfNeccessary0(annotation, annotationType.getName());
+	}
+	
+	/**
+	 * Removes the annotation from javac's AST (it remains in lombok's AST),
+	 * then removes any import statement that imports this exact annotation (not star imports).
+	 * Only does this if the DeleteLombokAnnotations class is in the context.
+	 */
 	public static void deleteAnnotationIfNeccessary(JavacNode annotation, Class<? extends Annotation> annotationType1, Class<? extends Annotation> annotationType2) {
-		deleteAnnotationIfNeccessary0(annotation, annotationType1, annotationType2);
+		deleteAnnotationIfNeccessary0(annotation, annotationType1.getName(), annotationType2.getName());
+	}
+	
+	/**
+	 * Removes the annotation from javac's AST (it remains in lombok's AST),
+	 * then removes any import statement that imports this exact annotation (not star imports).
+	 * Only does this if the DeleteLombokAnnotations class is in the context.
+	 */
+	public static void deleteAnnotationIfNeccessary(JavacNode annotation, Class<? extends Annotation> annotationType1, String annotationType2) {
+		deleteAnnotationIfNeccessary0(annotation, annotationType1.getName(), annotationType2);
 	}
 	
-	private static void deleteAnnotationIfNeccessary0(JavacNode annotation, Class<? extends Annotation>... annotationTypes) {
+	private static void deleteAnnotationIfNeccessary0(JavacNode annotation, String... annotationTypes) {
 		if (inNetbeansEditor(annotation)) return;
 		if (!annotation.shouldDeleteLombokAnnotations()) return;
 		JavacNode parentNode = annotation.directUp();
@@ -390,8 +453,8 @@ public class JavacHandlerUtil {
 		}
 		
 		parentNode.getAst().setChanged();
-		for (Class<?> annotationType : annotationTypes) {
-			deleteImportFromCompilationUnit(annotation, annotationType.getName());
+		for (String annotationType : annotationTypes) {
+			deleteImportFromCompilationUnit(annotation, annotationType);
 		}
 	}
 	
@@ -1405,9 +1468,10 @@ public class JavacHandlerUtil {
 	public static void sanityCheckForMethodGeneratingAnnotationsOnBuilderClass(JavacNode typeNode, JavacNode errorNode) {
 		List<String> disallowed = List.nil();
 		for (JavacNode child : typeNode.down()) {
-			for (Class<? extends java.lang.annotation.Annotation> annType : INVALID_ON_BUILDERS) {
+			for (String annType : INVALID_ON_BUILDERS) {
 				if (annotationTypeMatches(annType, child)) {
-					disallowed = disallowed.append(annType.getSimpleName());
+					int lastIndex = annType.lastIndexOf('.');
+					disallowed = disallowed.append(lastIndex == -1 ? annType : annType.substring(lastIndex + 1));
 				}
 			}
 		}