Merge pull request #2684 from Rawi01/npe-javadoc

Fix NullPointerException during Javadoc copy

11 files changed, 120 insertions, 92 deletions

diff --git a/src/core/lombok/core/handlers/HandlerUtil.java b/src/core/lombok/core/handlers/HandlerUtil.java
index 92a9a142..9fd38720 100644
--- a/src/core/lombok/core/handlers/HandlerUtil.java
+++ b/src/core/lombok/core/handlers/HandlerUtil.java
@@ -762,12 +762,14 @@ public class HandlerUtil {
 	private static final Pattern LINE_BREAK_FINDER = Pattern.compile("(\\r?\\n)?");
 	
 	public static String stripLinesWithTagFromJavadoc(String javadoc, String regexpFragment) {
+		if (javadoc == null || javadoc.isEmpty()) return javadoc;
 		Pattern p = Pattern.compile("^\\s*\\**\\s*" + regexpFragment + "\\s*\\**\\s*$", Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
 		Matcher m = p.matcher(javadoc);
 		return m.replaceAll("");
 	}
 	
 	public static String stripSectionsFromJavadoc(String javadoc) {
+		if (javadoc == null || javadoc.isEmpty()) return javadoc;
 		Matcher sectionMatcher = SECTION_FINDER.matcher(javadoc);
 		if (!sectionMatcher.find()) return javadoc;
 		
@@ -775,6 +777,7 @@ public class HandlerUtil {
 	}
 	
 	public static String getJavadocSection(String javadoc, String sectionNameSpec) {
+		if (javadoc == null || javadoc.isEmpty()) return null;
 		String[] sectionNames = sectionNameSpec.split("\\|");
 		Matcher sectionMatcher = SECTION_FINDER.matcher(javadoc);
 		Matcher lineBreakMatcher = LINE_BREAK_FINDER.matcher(javadoc);
@@ -805,19 +808,30 @@ public class HandlerUtil {
 	private static final Pattern FIND_RETURN = Pattern.compile("^\\s*\\**\\s*@returns?\\s+.*$", Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
 	
 	public static String addReturnsThisIfNeeded(String in) {
-		if (FIND_RETURN.matcher(in).find()) return in;
+		if (in != null && FIND_RETURN.matcher(in).find()) return in;
 		
 		return addJavadocLine(in, "@return {@code this}.");
 	}
 	
 	public static String addReturnsUpdatedSelfIfNeeded(String in) {
-		if (FIND_RETURN.matcher(in).find()) return in;
+		if (in != null && FIND_RETURN.matcher(in).find()) return in;
 		
 		return addJavadocLine(in, "@return a clone of this object, except with this updated property (returns {@code this} if an identical value is passed).");
 	}
 	
 	public static String addJavadocLine(String in, String line) {
+		if (in == null) return line;
 		if (in.endsWith("\n")) return in + line + "\n";
 		return in + "\n" + line;
 	}
+
+	public static String getParamJavadoc(String methodComment, String param) {
+		if (methodComment == null || methodComment.isEmpty()) return methodComment;
+		Pattern pattern = Pattern.compile("@param " + param + " (\\S|\\s)+?(?=^ ?@)", Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
+		Matcher matcher = pattern.matcher(methodComment);
+		if (matcher.find()) {
+			return matcher.group();
+		}
+		return null;
+	}
 }
diff --git a/src/core/lombok/eclipse/EcjAugments.java b/src/core/lombok/eclipse/EcjAugments.java
index 965c4fb6..cd7173a8 100644
--- a/src/core/lombok/eclipse/EcjAugments.java
+++ b/src/core/lombok/eclipse/EcjAugments.java
@@ -28,6 +28,7 @@ import java.util.concurrent.ConcurrentMap;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
+import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 import org.eclipse.jdt.internal.core.CompilationUnit;
 import org.eclipse.jdt.internal.core.SourceMethod;
 
@@ -42,13 +43,13 @@ public final class EcjAugments {
 	public static final FieldAugment<ASTNode, Boolean> ASTNode_handled = FieldAugment.augment(ASTNode.class, boolean.class, "lombok$handled");
 	public static final FieldAugment<ASTNode, ASTNode> ASTNode_generatedBy = FieldAugment.augment(ASTNode.class, ASTNode.class, "$generatedBy");
 	public static final FieldAugment<Annotation, Boolean> Annotation_applied = FieldAugment.augment(Annotation.class, boolean.class, "lombok$applied");
+	public static final FieldAugment<ICompilationUnit, Map<String, String>> CompilationUnit_javadoc = FieldAugment.augment(ICompilationUnit.class, Map.class, "$javadoc");
 	
 	public static final class EclipseAugments {
 		private EclipseAugments() {
 			// Prevent instantiation
 		}
 		
-		public static final FieldAugment<CompilationUnit, Map<String, String>> CompilationUnit_javadoc = FieldAugment.augment(CompilationUnit.class, Map.class, "$javadoc");
 		public static final FieldAugment<CompilationUnit, ConcurrentMap<String, List<SourceMethod>>> CompilationUnit_delegateMethods = FieldAugment.augment(CompilationUnit.class, ConcurrentMap.class, "$delegateMethods");
 	}
 }
diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
index 62c71f5b..b58c2996 100644
--- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
+++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
@@ -39,7 +39,6 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
@@ -106,7 +105,6 @@ import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
 import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
 import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
-import org.eclipse.jdt.internal.core.CompilationUnit;
 
 import lombok.AccessLevel;
 import lombok.ConfigurationKeys;
@@ -125,6 +123,7 @@ import lombok.core.configuration.TypeName;
 import lombok.core.debug.ProblemReporter;
 import lombok.core.handlers.HandlerUtil;
 import lombok.core.handlers.HandlerUtil.FieldAccess;
+import lombok.eclipse.EcjAugments;
 import lombok.eclipse.Eclipse;
 import lombok.eclipse.EclipseAST;
 import lombok.eclipse.EclipseNode;
@@ -2643,42 +2642,20 @@ public class EclipseHandlerUtil {
 		return null;
 	}
 	
-	private static class EclipseOnlyUtil {
-		public static void setDocComment(CompilationUnitDeclaration cud, TypeDeclaration type, ASTNode node, String doc) {
-			if (cud.compilationResult.compilationUnit instanceof CompilationUnit) {
-				CompilationUnit compilationUnit = (CompilationUnit) cud.compilationResult.compilationUnit;
-				Map<String, String> docs = EclipseAugments.CompilationUnit_javadoc.setIfAbsent(compilationUnit, new HashMap<String, String>());
-				
-				if (node instanceof AbstractMethodDeclaration) {
-					AbstractMethodDeclaration methodDeclaration = (AbstractMethodDeclaration) node;
-					String signature = getSignature(type, methodDeclaration);
-					/* Add javadoc start marker, add leading asterisks to each line, add javadoc end marker */
-					docs.put(signature, String.format("/**%n%s%n */", doc.replaceAll("(?m)^", " * ")));
-				}
-			}
-		}
-	}
-	
-	private static Boolean eclipseMode;
-	private static boolean eclipseMode() {
-		if (eclipseMode != null) return eclipseMode.booleanValue();
-		try {
-			Class.forName("org.eclipse.jdt.internal.core.CompilationUnit");
-			eclipseMode = true;
-		} catch (Throwable t) {
-			eclipseMode = false;
-		}
-		return eclipseMode;
-	}
-	
 	public static void setDocComment(CompilationUnitDeclaration cud, EclipseNode eclipseNode, String doc) {
-		if (!eclipseMode()) return;
 		setDocComment(cud, (TypeDeclaration) upToTypeNode(eclipseNode).get(), eclipseNode.get(), doc);
 	}
 	 
 	public static void setDocComment(CompilationUnitDeclaration cud, TypeDeclaration type, ASTNode node, String doc) {
-		if (!eclipseMode()) return;
-		EclipseOnlyUtil.setDocComment(cud, type, node, doc);
+		if (doc == null) return;
+		
+		Map<String, String> docs = EcjAugments.CompilationUnit_javadoc.setIfAbsent(cud.compilationResult.compilationUnit, new HashMap<String, String>());
+		if (node instanceof AbstractMethodDeclaration) {
+			AbstractMethodDeclaration methodDeclaration = (AbstractMethodDeclaration) node;
+			String signature = getSignature(type, methodDeclaration);
+			/* Add javadoc start marker, remove trailing line break, add leading asterisks to each line, add javadoc end marker */
+			docs.put(signature, String.format("/**%n%s%n */", doc.replaceAll("$\\r?\\n", "").replaceAll("(?m)^", " * ")));
+		}
 	}
 	
 	public static String getSignature(TypeDeclaration type, AbstractMethodDeclaration methodDeclaration) {
@@ -2690,8 +2667,7 @@ public class EclipseHandlerUtil {
 		Argument[] arguments = methodDeclaration.arguments;
 		if (arguments != null) {
 			for (Argument argument : arguments) {
-				String signature = Signature.createTypeSignature(argument.type.getLastToken(), false);
-				sb.append(signature);
+				sb.append(String.valueOf(argument.type));
 			}
 		}
 		sb.append(")");
@@ -2786,10 +2762,10 @@ public class EclipseHandlerUtil {
 		try {
 			CompilationUnitDeclaration cud = ((CompilationUnitDeclaration) from.top().get());
 			String newJavadoc = copyMode.apply(cud, from);
-			if (newJavadoc != null) {
-				if (forceAddReturn) newJavadoc = addReturnsThisIfNeeded(newJavadoc);
-				setDocComment(cud, type, to, newJavadoc);
+			if (forceAddReturn) {
+				newJavadoc = addReturnsThisIfNeeded(newJavadoc);
 			}
+			setDocComment(cud, type, to, newJavadoc);
 		} catch (Exception ignore) {}
 	}
 }
diff --git a/src/core/lombok/eclipse/handlers/HandleBuilder.java b/src/core/lombok/eclipse/handlers/HandleBuilder.java
index f8eb9ed0..189c5a69 100755
--- a/src/core/lombok/eclipse/handlers/HandleBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleBuilder.java
@@ -29,8 +29,6 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
@@ -1045,14 +1043,8 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 		try {
 			CompilationUnitDeclaration cud = (CompilationUnitDeclaration) from.top().get();
 			String methodComment = getDocComment(cud, from.get());
-			if (methodComment == null) return;
-			
-			Pattern pattern = Pattern.compile("@param " + param + " (\\S|\\s)+?(?=^ ?@)", Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
-			Matcher matcher = pattern.matcher(methodComment);
-			if (matcher.find()) {
-				String newJavadoc = addReturnsThisIfNeeded(matcher.group());
-				setDocComment(cud, type, to, newJavadoc);
-			}
+			String newJavadoc = addReturnsThisIfNeeded(getParamJavadoc(methodComment, param));
+			setDocComment(cud, type, to, newJavadoc);
 		} catch (Exception ignore) {}
 	}
 	
diff --git a/src/core/lombok/javac/handlers/HandleBuilder.java b/src/core/lombok/javac/handlers/HandleBuilder.java
index 40b59183..867d6889 100644
--- a/src/core/lombok/javac/handlers/HandleBuilder.java
+++ b/src/core/lombok/javac/handlers/HandleBuilder.java
@@ -27,8 +27,6 @@ import static lombok.javac.JavacTreeMaker.TypeTag.typeTag;
 import static lombok.javac.handlers.JavacHandlerUtil.*;
 
 import java.util.ArrayList;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import javax.lang.model.element.Modifier;
 
@@ -927,16 +925,10 @@ public class HandleBuilder extends JavacAnnotationHandler<Builder> {
 		try {
 			JCCompilationUnit cu = ((JCCompilationUnit) from.top().get());
 			String methodComment = Javac.getDocComment(cu, from.get());
-			if (methodComment == null) return;
-			
-			Pattern pattern = Pattern.compile("@param " + param + " (\\S|\\s)+?(?=^ ?@)", Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
-			Matcher matcher = pattern.matcher(methodComment);
-			if (matcher.find()) {
-				String newJavadoc = addReturnsThisIfNeeded(matcher.group());
-				Javac.setDocComment(cu, to, newJavadoc);
-			}
+			String newJavadoc = addReturnsThisIfNeeded(getParamJavadoc(methodComment, param));
+			Javac.setDocComment(cu, to, newJavadoc);
 		} catch (Exception ignore) {}
-	}
+	}	
 	
 	public JavacNode makeBuilderClass(BuilderJob job) {
 		//boolean isStatic, JavacNode source, JavacNode tdParent, String builderClassName, List<JCTypeParameter> typeParams, JCAnnotation ast, AccessLevel access) {
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index df1eb438..fbde9568 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -2120,10 +2120,10 @@ public class JavacHandlerUtil {
 		try {
 			JCCompilationUnit cu = ((JCCompilationUnit) from.top().get());
 			String newJavadoc = copyMode.apply(cu, from);
-			if (newJavadoc != null) {
-				if (forceAddReturn) newJavadoc = addReturnsThisIfNeeded(newJavadoc);
-				Javac.setDocComment(cu, to, newJavadoc);
+			if (forceAddReturn) {
+				newJavadoc = addReturnsThisIfNeeded(newJavadoc);
 			}
+			Javac.setDocComment(cu, to, newJavadoc);
 		} catch (Exception ignore) {}
 	}
 	
diff --git a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
index d5077b86..171fa8a9 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
@@ -916,7 +916,7 @@ public class EclipsePatcher implements AgentLauncher.AgentLaunchable {
 				.requestExtra(StackRequest.PARAM1)
 				.build());
 		
-		sm.addScriptIfWitness(OSGI_TYPES, ScriptBuilder.replaceMethodCall()
+		sm.addScript(ScriptBuilder.replaceMethodCall()
 				.target(new MethodTarget("org.eclipse.jdt.internal.compiler.ast.TypeDeclaration", "printBody", "java.lang.StringBuffer", "int", "java.lang.StringBuffer"))
 				.methodToReplace(new Hook("org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration", "print", "java.lang.StringBuffer", "int", "java.lang.StringBuffer"))
 				.replacementMethod(new Hook("lombok.launch.PatchFixesHider$Javadoc", "printMethod", "java.lang.StringBuffer", "org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration", "int", "java.lang.StringBuffer", "org.eclipse.jdt.internal.compiler.ast.TypeDeclaration"))
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchJavadoc.java b/src/eclipseAgent/lombok/eclipse/agent/PatchJavadoc.java
index f5678154..5b34917e 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchJavadoc.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/PatchJavadoc.java
@@ -21,7 +21,7 @@
  */
 package lombok.eclipse.agent;
 
-import static lombok.eclipse.EcjAugments.EclipseAugments.CompilationUnit_javadoc;
+import static lombok.eclipse.EcjAugments.CompilationUnit_javadoc;
 
 import java.lang.reflect.Method;
 import java.util.Map;
@@ -41,7 +41,7 @@ import lombok.permit.Permit;
 
 public class PatchJavadoc {
 	
-	public static String getHTMLContentFromSource(String original, IJavaElement member) {
+	public static String getHTMLContentFromSource(String original, Object member) {
 		if (original != null) {
 			return original;
 		}
@@ -51,15 +51,14 @@ public class PatchJavadoc {
 			ICompilationUnit iCompilationUnit = sourceMethod.getCompilationUnit();
 			if (iCompilationUnit instanceof CompilationUnit) {
 				CompilationUnit compilationUnit = (CompilationUnit) iCompilationUnit;
-				
 				Map<String, String> docs = CompilationUnit_javadoc.get(compilationUnit);
 				if (docs == null) return null;
 				
-				String signature = getSignature(sourceMethod);
+				String signature = Signature.getSignature(sourceMethod);
 				String rawJavadoc = docs.get(signature);
 				if (rawJavadoc == null) return null;
 				
-				return Reflection.javadoc2HTML((IMember) member, member, rawJavadoc);
+				return Reflection.javadoc2HTML((IMember) member, (IJavaElement) member, rawJavadoc);
 			}
 		}
 		
@@ -67,33 +66,33 @@ public class PatchJavadoc {
 	}
 	
 	public static StringBuffer printMethod(AbstractMethodDeclaration methodDeclaration, Integer tab, StringBuffer output, TypeDeclaration type) {
-		if (methodDeclaration.compilationResult.compilationUnit instanceof CompilationUnit) {
-			Map<String, String> docs = CompilationUnit_javadoc.get((CompilationUnit) methodDeclaration.compilationResult.compilationUnit);
-			if (docs != null) {
-				String signature = EclipseHandlerUtil.getSignature(type, methodDeclaration);
-				String rawJavadoc = docs.get(signature);
-				if (rawJavadoc != null) {
-					for (String line : rawJavadoc.split("\r?\n")) {
-						ASTNode.printIndent(tab, output).append(line).append("\n");
-					}
+		Map<String, String> docs = CompilationUnit_javadoc.get(methodDeclaration.compilationResult.compilationUnit);
+		if (docs != null) {
+			String signature = EclipseHandlerUtil.getSignature(type, methodDeclaration);
+			String rawJavadoc = docs.get(signature);
+			if (rawJavadoc != null) {
+				for (String line : rawJavadoc.split("\r?\n")) {
+					ASTNode.printIndent(tab, output).append(line).append("\n");
 				}
 			}
 		}
 		return methodDeclaration.print(tab, output);
 	}
 	
-	private static String getSignature(SourceMethod sourceMethod) {
-		StringBuilder sb = new StringBuilder();
-		sb.append(sourceMethod.getParent().getElementName());
-		sb.append(".");
-		sb.append(sourceMethod.getElementName());
-		sb.append("(");
-		for (String type : sourceMethod.getParameterTypes()) {
-			sb.append(type);
+	private static class Signature {
+		static final String getSignature(SourceMethod sourceMethod) {
+			StringBuilder sb = new StringBuilder();
+			sb.append(sourceMethod.getParent().getElementName());
+			sb.append(".");
+			sb.append(sourceMethod.getElementName());
+			sb.append("(");
+			for (String type : sourceMethod.getParameterTypes()) {
+				sb.append(org.eclipse.jdt.core.Signature.toString(type));
+			}
+			sb.append(")");
+			
+			return sb.toString();
 		}
-		sb.append(")");
-		
-		return sb.toString();
 	}
 	
 	/**
diff --git a/src/eclipseAgent/lombok/launch/PatchFixesHider.java b/src/eclipseAgent/lombok/launch/PatchFixesHider.java
index 503b2b4a..e2d266c5 100755
--- a/src/eclipseAgent/lombok/launch/PatchFixesHider.java
+++ b/src/eclipseAgent/lombok/launch/PatchFixesHider.java
@@ -332,7 +332,7 @@ final class PatchFixesHider {
 		
 		static {
 			Class<?> shadowed = Util.shadowLoadClass("lombok.eclipse.agent.PatchJavadoc");
-			GET_HTML = Util.findMethod(shadowed, "getHTMLContentFromSource", String.class, IJavaElement.class);
+			GET_HTML = Util.findMethod(shadowed, "getHTMLContentFromSource", String.class, Object.class);
 			PRINT_METHOD = Util.findMethod(shadowed, "printMethod", AbstractMethodDeclaration.class, Integer.class, StringBuffer.class, TypeDeclaration.class);
 		}
 		
diff --git a/src/utils/lombok/core/FieldAugment.java b/src/utils/lombok/core/FieldAugment.java
index 4a32ad04..0982bcb5 100644
--- a/src/utils/lombok/core/FieldAugment.java
+++ b/src/utils/lombok/core/FieldAugment.java
@@ -24,6 +24,7 @@ package lombok.core;
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.WeakHashMap;
 
@@ -69,6 +70,10 @@ public abstract class FieldAugment<T, F> {
 		checkNotNull(fieldType, "fieldType");
 		checkNotNull(name, "name");
 		
+		if (type.isInterface()) {
+			return new InterfaceFieldAugment<T, F>(name, fieldType);
+		}
+		
 		@SuppressWarnings("unchecked")
 		F defaultValue = (F) getDefaultValue(fieldType);
 		FieldAugment<T, F> ret = tryCreateReflectionAugment(type, fieldType, name, defaultValue);
@@ -175,6 +180,54 @@ public abstract class FieldAugment<T, F> {
 	 */
 	public abstract F compareAndSet(T object, F expected, F value);
 	
+	private static final class InterfaceFieldAugment<T, F> extends FieldAugment<T, F> {
+		private final String name;
+		private final Class<? super F> fieldType;
+		
+		private Map<Class<T>, FieldAugment<T, F>> map = new HashMap<Class<T>, FieldAugment<T,F>>();
+		
+		private InterfaceFieldAugment(String name, Class<? super F> fieldType) {
+			this.name = name;
+			this.fieldType = fieldType;
+		}
+		
+		private synchronized FieldAugment<T, F> getDelegate(T object) {
+			@SuppressWarnings("unchecked")
+			Class<T> c = (Class<T>) object.getClass();
+			
+			FieldAugment<T,F> fieldAugment = map.get(c);
+			if (fieldAugment == null) {
+				fieldAugment = augment(c, fieldType, name);
+				map.put(c, fieldAugment);
+			}
+			return fieldAugment;
+		}
+		
+		@Override public F get(T object) {
+			return getDelegate(object).get(object);
+		}
+		
+		@Override public F getAndSet(T object, F value) {
+			return getDelegate(object).getAndSet(object, value);
+		}
+		
+		@Override public F clear(T object) {
+			return getDelegate(object).clear(object);
+		}
+		
+		@Override public F compareAndClear(T object, F expected) {
+			return getDelegate(object).compareAndClear(object, expected);
+		}
+		
+		@Override public F setIfAbsent(T object, F value) {
+			return getDelegate(object).setIfAbsent(object, value);
+		}
+		
+		@Override public F compareAndSet(T object, F expected, F value) {
+			return getDelegate(object).compareAndSet(object, expected, value);
+		}
+	}
+
 	private static class ReflectionFieldAugment<T, F> extends FieldAugment<T, F> {
 		private final Object lock = new Object();
 		private final Field field;
diff --git a/src/utils/lombok/javac/Javac.java b/src/utils/lombok/javac/Javac.java
index cec43705..33bd7265 100644
--- a/src/utils/lombok/javac/Javac.java
+++ b/src/utils/lombok/javac/Javac.java
@@ -281,6 +281,7 @@ public class Javac {
 	
 	@SuppressWarnings("unchecked")
 	public static void setDocComment(JCCompilationUnit cu, JCTree node, String javadoc) {
+		if (javadoc == null) return;
 		Object dc = getDocComments(cu);
 		if (dc instanceof Map) {
 			((Map<JCTree, String>) dc).put(node, javadoc);