"var" type inferrence bug with generic wrapping

+ Ignore type bound of "? extends Object"
+ Globally change expected errors from "? extends Object" to "?"
+ Changes in AnnotatableTypeSystem are a placeholder for now

Fixes #5028

Author: stephan-herrmann

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/AnnotatableTypeSystem.java

@@ -17,6 +17,7 @@
 package org.eclipse.jdt.internal.compiler.lookup;
 
 import org.eclipse.jdt.core.compiler.CharOperation;
+import org.eclipse.jdt.internal.compiler.ast.Wildcard;
 import org.eclipse.jdt.internal.compiler.util.Util;
 
 /* AnnotatableTypeSystem: Keep track of annotated types so as to provide unique bindings for identically annotated versions identical underlying "naked" types.
@@ -187,6 +188,20 @@ public WildcardBinding getWildcard(ReferenceBinding genericType, int rank, TypeB
 		if (genericType.hasTypeAnnotations())
 			throw new IllegalStateException();
 
+		checkUnbounded: if (boundKind == Wildcard.EXTENDS && bound != null && bound.id == TypeIds.T_JavaLangObject) {
+			if ((bound.tagBits & TagBits.AnnotationNullMASK) != 0)
+				break checkUnbounded;
+			if (otherBounds != null) {
+				for (TypeBinding otherBound : otherBounds) {
+					if ((otherBound.tagBits & TagBits.AnnotationNullMASK) != 0)
+						break checkUnbounded;
+				}
+			}
+			boundKind = Wildcard.UNBOUND;
+			bound = null;
+			otherBounds = null;
+		}
+
 		WildcardBinding nakedType = null;
 		boolean useDerivedTypesOfBound = bound instanceof TypeVariableBinding || (bound instanceof ParameterizedTypeBinding && !(bound instanceof RawTypeBinding)) ;
 		TypeBinding[] derivedTypes = getDerivedTypes(useDerivedTypesOfBound ? bound : genericType);

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/TypeSystem.java

@@ -22,6 +22,7 @@
 import java.util.HashMap;
 import java.util.function.Supplier;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
+import org.eclipse.jdt.internal.compiler.ast.Wildcard;
 import org.eclipse.jdt.internal.compiler.util.SimpleLookupTable;
 import org.eclipse.jdt.internal.compiler.util.Util;
 
@@ -373,6 +374,10 @@ public RawTypeBinding getRawType(ReferenceBinding genericType, ReferenceBinding
 	public WildcardBinding getWildcard(ReferenceBinding genericType, int rank, TypeBinding bound, TypeBinding[] otherBounds, int boundKind) {
 		if (genericType == null) // pseudo wildcard denoting composite bounds for lub computation
 			genericType = ReferenceBinding.LUB_GENERIC;
+		if (boundKind == Wildcard.EXTENDS && bound != null && bound.id == TypeIds.T_JavaLangObject && otherBounds == null) {
+			boundKind = Wildcard.UNBOUND;
+			bound = null;
+		}
 
 		ReferenceBinding unannotatedGenericType = (ReferenceBinding) getUnannotatedType(genericType);
 		int otherBoundsLength = otherBounds == null ? 0: otherBounds.length;

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/problem/ProblemReporter.java

@@ -81,6 +81,7 @@
 package org.eclipse.jdt.internal.compiler.problem;
 
 import java.io.CharConversionException;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -10080,7 +10081,7 @@ public void anonymousDiamondWithNonDenotableTypeArguments(TypeReference type, Ty
 			type.sourceStart,
 			type.sourceEnd);
 }
-public void redundantSpecificationOfTypeArguments(ASTNode location, TypeBinding[] argumentTypes) {
+public void redundantSpecificationOfTypeArguments(TypeReference location, TypeBinding[] argumentTypes) {
 	int severity = computeSeverity(IProblem.RedundantSpecificationOfTypeArguments);
 	if (severity != ProblemSeverities.Ignore) {
 		int sourceStart = -1;
@@ -10090,10 +10091,36 @@ public void redundantSpecificationOfTypeArguments(ASTNode location, TypeBinding[
 		} else {
 			sourceStart = location.sourceStart;
 		}
+		String problemArguments;
+		String messageArguments;
+		class FindWildcard extends TypeBindingVisitor {
+			boolean found;
+			@Override
+			public boolean visit(WildcardBinding wildcardBinding) {
+				this.found = true;
+				return false;
+			}
+		}
+		FindWildcard find = new FindWildcard();
+		TypeBindingVisitor.visit(find, argumentTypes);
+		TypeReference[] typeArguments = null;
+		if (find.found) {
+			// when wildcards are in the mix then prefer showing type references, rather than processed bindings:
+			if (location instanceof ParameterizedSingleTypeReference pstr)
+				typeArguments = pstr.typeArguments;
+			else if (location instanceof ParameterizedQualifiedTypeReference pqtr)
+				typeArguments = pqtr.typeArguments[pqtr.typeArguments.length-1];
+		}
+		if (typeArguments != null) {
+			problemArguments = messageArguments = Arrays.stream(typeArguments).map(TypeReference::toString).collect(Collectors.joining(", ")); //$NON-NLS-1$
+		} else {
+			problemArguments = typesAsString(argumentTypes, false);
+			messageArguments = typesAsString(argumentTypes, true);
+		}
 		this.handle(
 			IProblem.RedundantSpecificationOfTypeArguments,
-			new String[] {typesAsString(argumentTypes, false)},
-			new String[] {typesAsString(argumentTypes, true)},
+			new String[] {problemArguments},
+			new String[] {messageArguments},
 			severity,
 			sourceStart,
 			location.sourceEnd);