[fixes projectlombok#2648] Reset inference context, remove generic in…

…formation copy In Java >= 8 ecj uses the inference context to resolve the generic information. This one is already set before lombok tries rewrite the method call. Simply copying the information does not cover all the different cases but reseting the inference contexts and running type inference again does.
Rawi01 · Nov 25, 2020 · db80bb0 · db80bb0
1 parent e1f82ac
commit db80bb0
Show file tree

Hide file tree

Showing 7 changed files with 154 additions and 13 deletions.
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java b/src/eclipseAgent/lombok/eclipse/agent/PatchExtensionMethod.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2014 The Project Lombok Authors.
+ * Copyright (C) 2012-2020 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
@@ -58,7 +58,6 @@
 import org.eclipse.jdt.internal.compiler.lookup.Binding;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 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;
@@ -304,12 +303,13 @@ public static Object resolveType(Object resolvedType, MessageSend methodCall, Bl
 					argumentTypes.add(argumentType);
 				}
 
-				// 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;
+				if (methodCall.receiver instanceof MessageSend) {
+					if (Reflection.inferenceContexts != null) {
+						try {
+							Permit.set(Reflection.inferenceContexts, methodCall.receiver, null);
+						} catch (IllegalAccessException ignore) {
+							// ignore
+						}
 					}
 				}
 
@@ -402,6 +402,7 @@ private static NameReference createNameRef(TypeBinding typeBinding, ASTNode sour
 	private static final class Reflection {
 		public static final Field argumentTypes = Permit.permissiveGetField(MessageSend.class, "argumentTypes");
 		public static final Field argumentsHaveErrors = Permit.permissiveGetField(MessageSend.class, "argumentsHaveErrors");
+		public static final Field inferenceContexts = Permit.permissiveGetField(MessageSend.class, "inferenceContexts");
 		private static final Class<?> functionalExpression;
 		private static final Constructor<?> polyTypeBindingConstructor;
 

diff --git a/test/transform/resource/after-delombok/ExtensionMethodFunctional.java b/test/transform/resource/after-delombok/ExtensionMethodFunctional.java
@@ -1,12 +1,17 @@
-import java.util.function.Function;
 import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 class ExtensionMethodFunctional {
 	public void test() {
 		String test = "test";
 		test = ExtensionMethodFunctional.Extensions.map(test, s -> ExtensionMethodFunctional.Extensions.reverse(s));
 		ExtensionMethodFunctional.Extensions.consume(test, s -> System.out.println("1: " + s), s -> System.out.println("2: " + s));
 		ExtensionMethodFunctional.Extensions.consume(test, System.out::println, System.out::println);
+		ExtensionMethodFunctional.Extensions.toList(Stream.of("a", "b", "c").map(String::toUpperCase));
+		List<Integer> i2 = ExtensionMethodFunctional.Extensions.toList2(Stream.of("a", "b", "c").map(String::toUpperCase));
 	}
 
 	static class Extensions {
@@ -24,5 +29,13 @@ public static <T> void consume(T o, Consumer<T>... consumer) {
 				consumer[i].accept(o);
 			}
 		}
+
+		public static <T> List<T> toList(Stream<T> stream) {
+			return (List<T>) stream.collect(Collectors.toList());
+		}
+
+		public static <T, U> List<U> toList2(Stream<T> stream) {
+			return null;
+		}
 	}
 }
diff --git a/test/transform/resource/after-delombok/ExtensionMethodGeneric.java b/test/transform/resource/after-delombok/ExtensionMethodGeneric.java
@@ -0,0 +1,33 @@
+import java.util.List;
+import java.util.Map;
+
+class ExtensionMethodGeneric {
+	public void test() {
+		List<String> stringList = null;
+		List<Number> numberList = null;
+		ExtensionMethodGeneric.Extensions.test(stringList);
+		ExtensionMethodGeneric.Extensions.test(stringList, numberList);
+		ExtensionMethodGeneric.Extensions.test(ExtensionMethodGeneric.Extensions.test(stringList, stringList), numberList);
+		Integer i = ExtensionMethodGeneric.Extensions.test2(stringList);
+		Map<String, Integer> map = null;
+		List<String> l = ExtensionMethodGeneric.Extensions.test(map, stringList, numberList);
+	}
+
+	static class Extensions {
+		public static <T> List<T> test(List<String> obj, List<T> list) {
+			return null;
+		}
+
+		public static <K, V> K test(Map<String, Integer> obj, K k, V v) {
+			return k;
+		}
+
+		public static <T> T test(List<T> list) {
+			return null;
+		}
+
+		public static <T, U> U test2(List<T> list) {
+			return null;
+		}
+	}
+}
diff --git a/test/transform/resource/after-ecj/ExtensionMethodFunctional.java b/test/transform/resource/after-ecj/ExtensionMethodFunctional.java
@@ -1,7 +1,10 @@
-import java.util.function.Function;
 import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import lombok.experimental.ExtensionMethod;
-@ExtensionMethod(ExtensionMethodFunctional.Extensions.class) class ExtensionMethodFunctional {
+@ExtensionMethod(value = ExtensionMethodFunctional.Extensions.class,suppressBaseMethods = false) class ExtensionMethodFunctional {
   static class Extensions {
     Extensions() {
       super();
@@ -18,6 +21,12 @@ public static String reverse(String string) {
           consumer[i].accept(o);
         }
     }
+    public static <T>List<T> toList(Stream<T> stream) {
+      return (List<T>) stream.collect(Collectors.toList());
+    }
+    public static <T, U>List<U> toList2(Stream<T> stream) {
+      return null;
+    }
   }
   ExtensionMethodFunctional() {
     super();
@@ -27,5 +36,7 @@ public void test() {
     test = ExtensionMethodFunctional.Extensions.map(test, (<no type> s) -> ExtensionMethodFunctional.Extensions.reverse(s));
     ExtensionMethodFunctional.Extensions.consume(test, (<no type> s) -> System.out.println(("1: " + s)), (<no type> s) -> System.out.println(("2: " + s)));
     ExtensionMethodFunctional.Extensions.consume(test, System.out::println, System.out::println);
+    ExtensionMethodFunctional.Extensions.toList(Stream.of("a", "b", "c").map(String::toUpperCase));
+    List<Integer> i2 = ExtensionMethodFunctional.Extensions.toList2(Stream.of("a", "b", "c").map(String::toUpperCase));
   }
 }
diff --git a/test/transform/resource/after-ecj/ExtensionMethodGeneric.java b/test/transform/resource/after-ecj/ExtensionMethodGeneric.java
@@ -0,0 +1,35 @@
+import java.util.List;
+import java.util.Map;
+import lombok.experimental.ExtensionMethod;
+@ExtensionMethod(ExtensionMethodGeneric.Extensions.class) class ExtensionMethodGeneric {
+  static class Extensions {
+    Extensions() {
+      super();
+    }
+    public static <T>List<T> test(List<String> obj, List<T> list) {
+      return null;
+    }
+    public static <K, V>K test(Map<String, Integer> obj, K k, V v) {
+      return k;
+    }
+    public static <T>T test(List<T> list) {
+      return null;
+    }
+    public static <T, U>U test2(List<T> list) {
+      return null;
+    }
+  }
+  ExtensionMethodGeneric() {
+    super();
+  }
+  public void test() {
+    List<String> stringList = null;
+    List<Number> numberList = null;
+    ExtensionMethodGeneric.Extensions.test(stringList);
+    ExtensionMethodGeneric.Extensions.test(stringList, numberList);
+    ExtensionMethodGeneric.Extensions.test(ExtensionMethodGeneric.Extensions.test(stringList, stringList), numberList);
+    Integer i = ExtensionMethodGeneric.Extensions.test2(stringList);
+    Map<String, Integer> map = null;
+    List<String> l = ExtensionMethodGeneric.Extensions.test(map, stringList, numberList);
+  }
+}
diff --git a/test/transform/resource/before/ExtensionMethodFunctional.java b/test/transform/resource/before/ExtensionMethodFunctional.java
@@ -1,17 +1,23 @@
 // version 8:
-import java.util.function.Function;
 import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import lombok.experimental.ExtensionMethod;
 
-@ExtensionMethod(ExtensionMethodFunctional.Extensions.class)
+@ExtensionMethod(value = ExtensionMethodFunctional.Extensions.class, suppressBaseMethods = false)
 class ExtensionMethodFunctional {
 	public void test() {
 		String test = "test";
 		test = test.map(s -> s.reverse());
 
 		test.consume(s -> System.out.println("1: " + s), s -> System.out.println("2: " + s));
 		test.consume(System.out::println, System.out::println);
+
+		Stream.of("a", "b", "c").map(String::toUpperCase).toList();
+		List<Integer> i2 = Stream.of("a", "b", "c").map(String::toUpperCase).toList2();
 	}
 
 	static class Extensions {
@@ -29,5 +35,13 @@ public static <T> void consume(T o, Consumer<T>... consumer) {
 				consumer[i].accept(o);
 			}
 		}
+
+		public static <T> List<T> toList(Stream<T> stream) {
+			return (List<T>) stream.collect(Collectors.toList());
+		}
+
+		public static <T, U> List<U> toList2(Stream<T> stream) {
+			return null;
+		}
 	}
 }
diff --git a/test/transform/resource/before/ExtensionMethodGeneric.java b/test/transform/resource/before/ExtensionMethodGeneric.java
@@ -0,0 +1,34 @@
+import java.util.List;
+import java.util.Map;
+
+import lombok.experimental.ExtensionMethod;
+
+@ExtensionMethod(ExtensionMethodGeneric.Extensions.class)
+class ExtensionMethodGeneric {
+	public void test() {
+		List<String> stringList = null;
+		List<Number> numberList = null;
+		stringList.test();
+		stringList.test(numberList);
+		stringList.test(stringList).test(numberList);
+		Integer i = stringList.test2();
+
+		Map<String, Integer> map = null;
+		List<String> l = map.test(stringList, numberList);
+	}
+
+	static class Extensions {
+		public static <T> List<T> test(List<String> obj, List<T> list) {
+			return null;
+		}
+		public static <K,V> K test(Map<String, Integer> obj, K k, V v) {
+			return k;
+		}
+		public static <T> T test(List<T> list) {
+			return null;
+		}
+		public static <T,U> U test2(List<T> list) {
+			return null;
+		}
+	}
+}