[fixes #2019] Lombok now properly deals with `@NonNull` specifically on the ‘type use’ of a parameter (and, in case of arrays, on the outermost dimension which is actually the first one listed. Weird corner case of the JLS).

1 files changed, 30 insertions, 9 deletions

diff --git a/src/core/lombok/eclipse/handlers/HandleNonNull.java b/src/core/lombok/eclipse/handlers/HandleNonNull.java
index ebc62909..1672618d 100644
--- a/src/core/lombok/eclipse/handlers/HandleNonNull.java
+++ b/src/core/lombok/eclipse/handlers/HandleNonNull.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 The Project Lombok Authors.
+ * Copyright (C) 2013-2019 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
@@ -33,6 +33,7 @@ import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
 import lombok.core.HandlerPriority;
 import lombok.eclipse.DeferUntilPostDiet;
+import lombok.eclipse.EclipseAST;
 import lombok.eclipse.EclipseAnnotationHandler;
 import lombok.eclipse.EclipseNode;
 
@@ -52,6 +53,7 @@ import org.eclipse.jdt.internal.compiler.ast.Statement;
 import org.eclipse.jdt.internal.compiler.ast.SynchronizedStatement;
 import org.eclipse.jdt.internal.compiler.ast.ThrowStatement;
 import org.eclipse.jdt.internal.compiler.ast.TryStatement;
+import org.eclipse.jdt.internal.compiler.ast.TypeReference;
 import org.mangosdk.spi.ProviderFor;
 
 @DeferUntilPostDiet
@@ -95,14 +97,33 @@ public class HandleNonNull extends EclipseAnnotationHandler<NonNull> {
 			return;
 		}
 		
-		if (annotationNode.up().getKind() != Kind.ARGUMENT) return;
-		
-		Argument arg;
+		Argument param;
+		EclipseNode paramNode;
 		AbstractMethodDeclaration declaration;
 		
+		switch (annotationNode.up().getKind()) {
+		case ARGUMENT:
+			paramNode = annotationNode.up();
+			break;
+		case TYPE_USE:
+			EclipseNode typeNode = annotationNode.directUp();
+			boolean ok = false;
+			ASTNode astNode = typeNode.get();
+			if (astNode instanceof TypeReference) {
+				Annotation[] anns = EclipseAST.getTopLevelTypeReferenceAnnotations((TypeReference) astNode);
+				if (anns == null) return;
+				for (Annotation ann : anns) if (ast == ann) ok = true;
+			}
+			if (!ok) return;
+			paramNode = typeNode.directUp();
+			break;
+		default:
+			return;
+		}
+		
 		try {
-			arg = (Argument) annotationNode.up().get();
-			declaration = (AbstractMethodDeclaration) annotationNode.up().up().get();
+			param = (Argument) paramNode.get();
+			declaration = (AbstractMethodDeclaration) paramNode.up().get();
 		} catch (Exception e) {
 			return;
 		}
@@ -118,7 +139,7 @@ public class HandleNonNull extends EclipseAnnotationHandler<NonNull> {
 		// and if they exist, create a new method in the class: 'private static <T> T lombok$nullCheck(T expr, String msg) {if (expr == null) throw NPE; return expr;}' and
 		// wrap all references to it in the super/this to a call to this method.
 		
-		Statement nullCheck = generateNullCheck(arg, annotationNode);
+		Statement nullCheck = generateNullCheck(param, annotationNode);
 		
 		if (nullCheck == null) {
 			// @NonNull applied to a primitive. Kinda pointless. Let's generate a warning.
@@ -129,7 +150,7 @@ public class HandleNonNull extends EclipseAnnotationHandler<NonNull> {
 		if (declaration.statements == null) {
 			declaration.statements = new Statement[] {nullCheck};
 		} else {
-			char[] expectedName = arg.name;
+			char[] expectedName = param.name;
 			/* Abort if the null check is already there, delving into try and synchronized statements */ {
 				Statement[] stats = declaration.statements;
 				int idx = 0;
@@ -162,7 +183,7 @@ public class HandleNonNull extends EclipseAnnotationHandler<NonNull> {
 			newStatements[skipOver] = nullCheck;
 			declaration.statements = newStatements;
 		}
-		annotationNode.up().up().rebuild();
+		paramNode.up().rebuild();
 	}
 	
 	public boolean isNullCheck(Statement stat) {