Improve ExtensionMethod support in Eclipse

Add basic support for lambdas, add autoboxing support for varargs, code
completion now works if the only matching methods are extension methods,
code completion no longer shows all extension methods

3 files changed, 73 insertions, 30 deletions

diff --git a/src/eclipseAgent/lombok/eclipse/agent/ExtensionMethodCompletionProposal.java b/src/eclipseAgent/lombok/eclipse/agent/ExtensionMethodCompletionProposal.java
index 46ce63f9..e692179b 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/ExtensionMethodCompletionProposal.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/ExtensionMethodCompletionProposal.java
@@ -22,6 +22,7 @@
 package lombok.eclipse.agent;
 
 import static org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants.AccStatic;
+import static org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants.AccVarargs;
 
 import java.util.Arrays;
 
@@ -45,6 +46,10 @@ public class ExtensionMethodCompletionProposal extends InternalCompletionProposa
 		MethodBinding original = method.original();
 		TypeBinding[] parameters = Arrays.copyOf(method.parameters, method.parameters.length);
 		method.parameters = Arrays.copyOfRange(method.parameters, 1, method.parameters.length);
+		// Add proposal parameter names, sometimes its still empty...
+		if (method.parameterNames != null && method.parameterNames.length > 0) {
+			setParameterNames(Arrays.copyOfRange(method.parameterNames, 1, method.parameterNames.length));
+		}
 		TypeBinding[] originalParameters = null;
 		if (original != method) {
 			originalParameters = Arrays.copyOf(method.original().parameters, method.original().parameters.length);
@@ -76,6 +81,10 @@ public class ExtensionMethodCompletionProposal extends InternalCompletionProposa
 		setName(method.selector);
 		setCompletion(completion);
 		setFlags(method.modifiers & (~AccStatic));
+		// Remove varargs flag if it is the only parameter
+		if (method.isVarargs() && length == 0) {
+			setFlags(getFlags() & (~AccVarargs));
+		}
 		int index = node.sourceEnd + 1;
 		if (node instanceof CompletionOnQualifiedNameReference) {
 			index -= ((CompletionOnQualifiedNameReference) node).completionIdentifier.length;
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
index fcc76059..964efada 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
@@ -47,6 +47,7 @@ import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.FunctionalExpression;
 import org.eclipse.jdt.internal.compiler.ast.MessageSend;
 import org.eclipse.jdt.internal.compiler.ast.NameReference;
 import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
@@ -58,6 +59,7 @@ import org.eclipse.jdt.internal.compiler.lookup.Binding;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
 import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
+import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ProblemMethodBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 import org.eclipse.jdt.internal.compiler.lookup.Scope;
@@ -263,12 +265,30 @@ public class PatchExtensionMethod {
 				arguments.add(methodCall.receiver);
 				if (methodCall.arguments != null) arguments.addAll(Arrays.asList(methodCall.arguments));
 				List<TypeBinding> argumentTypes = new ArrayList<TypeBinding>();
-				for (Expression argument : arguments) {
-					if (argument.resolvedType != null) argumentTypes.add(argument.resolvedType);
-					// TODO: Instead of just skipping nulls entirely, there is probably a 'unresolved type' placeholder. THAT is what we ought to be adding here!
+				
+				for (int i = 0; i < arguments.size(); i++) {
+					Expression argument = arguments.get(i);
+					TypeBinding argumentType = argument.resolvedType;
+					if (argumentType == null) {
+						// Copy unresolved lamdba types
+						argumentType = methodCall.argumentTypes.length >= i ? methodCall.argumentTypes[i - 1] : null;
+					}
+					if (argumentType != null) {
+						argumentTypes.add(argumentType);
+					}
 				}
 				Expression[] originalArgs = methodCall.arguments;
 				methodCall.arguments = arguments.toArray(new Expression[0]);
+				
+				// Copy generic information. This one covers a few simple cases, more complex cases are still broken
+				int typeVariables = extensionMethod.typeVariables.length;
+				if (typeVariables > 0 && methodCall.receiver.resolvedType instanceof ParameterizedTypeBinding) {
+					ParameterizedTypeBinding parameterizedTypeBinding = (ParameterizedTypeBinding) methodCall.receiver.resolvedType;
+					if (parameterizedTypeBinding.arguments != null && parameterizedTypeBinding.arguments.length == typeVariables) {
+						methodCall.genericTypeArguments = parameterizedTypeBinding.arguments;
+					}
+				}
+				
 				MethodBinding fixedBinding = scope.getMethod(extensionMethod.declaringClass, methodCall.selector, argumentTypes.toArray(new TypeBinding[0]), methodCall);
 				if (fixedBinding instanceof ProblemMethodBinding) {
 					methodCall.arguments = originalArgs;
@@ -276,18 +296,28 @@ public class PatchExtensionMethod {
 						PostponedInvalidMethodError.invoke(scope.problemReporter(), methodCall, fixedBinding, scope);
 					}
 				} else {
+					// If the extension method uses varargs, the last fixed binding parameter is an array but 
+					// the method arguments are not. Even thought we already know that the method is fine we still
+					// have to compare each parameter with the type of the array to support autoboxing/unboxing.
+					boolean isVararg = false;
 					for (int i = 0, iend = arguments.size(); i < iend; i++) {
 						Expression arg = arguments.get(i);
-						if (fixedBinding.parameters[i].isArrayType() != arg.resolvedType.isArrayType()) break;
-						if (arg instanceof MessageSend) {
-							((MessageSend) arg).valueCast = arg.resolvedType;
+						TypeBinding[] parameters = fixedBinding.parameters;
+						TypeBinding param = isVararg ? parameters[parameters.length - 1].leafComponentType() : parameters[i];
+						// Resolve types for lambdas
+						if (arg instanceof FunctionalExpression) {
+							arg.setExpectedType(param);
+							arg.resolveType(scope);
 						}
-						if (!fixedBinding.parameters[i].isBaseType() && arg.resolvedType.isBaseType()) {
-							int id = arg.resolvedType.id;
-							arg.implicitConversion = TypeIds.BOXING | (id + (id << 4)); // magic see TypeIds
-						} else if (fixedBinding.parameters[i].isBaseType() && !arg.resolvedType.isBaseType()) {
-							int id = fixedBinding.parameters[i].id;
-							arg.implicitConversion = TypeIds.UNBOXING | (id + (id << 4)); // magic see TypeIds
+						if (arg.resolvedType != null) {
+							isVararg |= param.isArrayType() != arg.resolvedType.isArrayType();
+							if (!param.isBaseType() && arg.resolvedType.isBaseType()) {
+								int id = arg.resolvedType.id;
+								arg.implicitConversion = TypeIds.BOXING | (id + (id << 4)); // magic see TypeIds
+							} else if (param.isBaseType() && !arg.resolvedType.isBaseType()) {
+								int id = parameters[i].id;
+								arg.implicitConversion = TypeIds.UNBOXING | (id + (id << 4)); // magic see TypeIds
+							}
 						}
 					}
 					
@@ -295,6 +325,7 @@ public class PatchExtensionMethod {
 					methodCall.actualReceiverType = extensionMethod.declaringClass;
 					methodCall.binding = fixedBinding;
 					methodCall.resolvedType = methodCall.binding.returnType;
+					methodCall.statementEnd = methodCall.sourceEnd;
 					if (Reflection.argumentTypes != null) {
 						try {
 							Reflection.argumentTypes.set(methodCall, argumentTypes.toArray(new TypeBinding[0]));
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodCompletionProposal.java b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodCompletionProposal.java
index 085c903f..08a42d1c 100755
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodCompletionProposal.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethodCompletionProposal.java
@@ -65,13 +65,14 @@ public class PatchExtensionMethodCompletionProposal {
 			CompletionProposalCollector completionProposalCollector) {
 		
 		List<IJavaCompletionProposal> proposals = new ArrayList<IJavaCompletionProposal>(Arrays.asList(javaCompletionProposals));
-		if (canExtendCodeAssist(proposals)) {
-			IJavaCompletionProposal firstProposal = proposals.get(0);
-			int replacementOffset = getReplacementOffset(firstProposal);
+		if (canExtendCodeAssist()) {
 			for (Extension extension : getExtensionMethods(completionProposalCollector)) {
 				for (MethodBinding method : extension.extensionMethods) {
-					ExtensionMethodCompletionProposal newProposal = new ExtensionMethodCompletionProposal(replacementOffset);
-					copyNameLookupAndCompletionEngine(completionProposalCollector, firstProposal, newProposal);
+					if (!isMatchingProposal(method, completionProposalCollector)) {
+						continue;
+					}
+					ExtensionMethodCompletionProposal newProposal = new ExtensionMethodCompletionProposal(0);
+					copyNameLookupAndCompletionEngine(completionProposalCollector, newProposal);
 					ASTNode node = getAssistNode(completionProposalCollector);
 					newProposal.setMethodBinding(method, node);
 					createAndAddJavaCompletionProposal(completionProposalCollector, newProposal, proposals);
@@ -81,7 +82,6 @@ public class PatchExtensionMethodCompletionProposal {
 		return proposals.toArray(new IJavaCompletionProposal[0]);
 	}
 	
-	
 	private static List<Extension> getExtensionMethods(CompletionProposalCollector completionProposalCollector) {
 		List<Extension> extensions = new ArrayList<Extension>();
 		ClassScope classScope = getClassScope(completionProposalCollector);
@@ -96,6 +96,17 @@ public class PatchExtensionMethodCompletionProposal {
 		return extensions;
 	}
 	
+	private static boolean isMatchingProposal(MethodBinding method, CompletionProposalCollector completionProposalCollector) {
+		try {
+			InternalCompletionContext context = (InternalCompletionContext) Reflection.contextField.get(completionProposalCollector);
+			String searchToken = new String(context.getToken());
+			String extensionMethodName = new String(method.selector);
+			return extensionMethodName.contains(searchToken);
+		} catch (IllegalAccessException e) {
+			return true;
+		}
+	}
+	
 	static TypeBinding getFirstParameterType(TypeDeclaration decl, CompletionProposalCollector completionProposalCollector) {
 		TypeBinding firstParameterType = null;
 		ASTNode node = getAssistNode(completionProposalCollector);
@@ -149,8 +160,7 @@ public class PatchExtensionMethodCompletionProposal {
 		return scope;
 	}
 	
-	private static void copyNameLookupAndCompletionEngine(CompletionProposalCollector completionProposalCollector, IJavaCompletionProposal proposal,
-			InternalCompletionProposal newProposal) {
+	private static void copyNameLookupAndCompletionEngine(CompletionProposalCollector completionProposalCollector, InternalCompletionProposal newProposal) {
 		
 		try {
 			InternalCompletionContext context = (InternalCompletionContext) Reflection.contextField.get(completionProposalCollector);
@@ -173,17 +183,10 @@ public class PatchExtensionMethodCompletionProposal {
 		}
 	}
 	
-	private static boolean canExtendCodeAssist(List<IJavaCompletionProposal> proposals) {
-		return !proposals.isEmpty() && Reflection.isComplete();
-	}
-	
-	private static int getReplacementOffset(Object proposal) {
-		try {
-			return Reflection.replacementOffsetField.getInt(proposal);
-		} catch (Exception ignore) {
-			return 0;
-		}
+	private static boolean canExtendCodeAssist() {
+		return Reflection.isComplete();
 	}
+
 	
 	static class Reflection {
 		public static final Field replacementOffsetField;