NullPointerException during AST-Parsing (eclipse-jdt#4238)

Remove guess work from https://bugs.eclipse.org/405706 and
https://bugs.eclipse.org/413958 from the time of 1.7, which seems
obsolete in 1.8+

Fixes eclipse-jdt#4235

Author: stephan-herrmann

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

@@ -428,45 +428,6 @@ public static TypeBinding[] greaterLowerBound(TypeBinding[] types, /*@Nullable*/
 					}
 					result[j] = null;
 					removed ++;
-				} else if (!jType.isCompatibleWith(iType, scope)) {
-					// avoid creating unsatisfiable intersection types (see https://bugs.eclipse.org/405706):
-					if (iType.isParameterizedType() && jType.isParameterizedType()) {
-						// if the wider of the two types (judged by originals) has type variables
-						// substitute those with their upper bounds and re-check (see https://bugs.eclipse.org/413958):
-						ParameterizedTypeBinding wideType, narrowType;
-						if (iType.original().isCompatibleWith(jType.original(), scope)) {
-							wideType = (ParameterizedTypeBinding) jType;
-							narrowType = (ParameterizedTypeBinding) iType;
-						} else if (jType.original().isCompatibleWith(iType.original(), scope)) {
-							wideType = (ParameterizedTypeBinding) iType;
-							narrowType = (ParameterizedTypeBinding) jType;
-						} else {
-							continue;
-						}
-						if (wideType.arguments == null)
-							continue; // assume we already have an error here
-						// Skip the following check if inference variables or CaptureBinding18 are involved,
-						// hopefully during inference a contradictory glb will simply not produce a solution
-						// (should essentially be detected beforehand in CaptureBinding18.setUpperBounds()):
-						if (!narrowType.isProperType(false) || !wideType.isProperType(false))
-							continue;
-						int numTypeArgs = wideType.arguments.length;
-						TypeBinding[] bounds = new TypeBinding[numTypeArgs];
-						for (int k = 0; k < numTypeArgs; k++) {
-							TypeBinding argument = wideType.arguments[k];
-							bounds[k] = argument.isTypeVariable() ? ((TypeVariableBinding)argument).upperBound() : argument;
-						}
-						ReferenceBinding wideOriginal = (ReferenceBinding) wideType.original();
-						TypeBinding substitutedWideType =
-								environment.createParameterizedType(wideOriginal, bounds, wideOriginal.enclosingType());
-						// if the narrow type is compatible with the substituted wide type, we keep silent,
-						// substituting type variables with proper types can still satisfy all constraints,
-						// otherwise ...
-						if (!narrowType.isCompatibleWith(substitutedWideType, scope)) {
-							// ... parameterized types are incompatible due to incompatible type arguments => unsatisfiable
-							return null;
-						}
-					}
 				}
 			}
 		}

org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/GenericsRegressionTest.java

@@ -6782,5 +6782,94 @@ <T extends B<?>> void bar(T t) {}
 		"""
 	});
 }
+public void testGH4235() {
+	runConformTest(new String[] {
+			"repro/AssertJStubs.java",
+			"""
+			package repro;
+			import java.util.List;
+			public class AssertJStubs {
+				interface Descriptable<SELF> {}
+				interface ExtensionPoints<SELF extends ExtensionPoints<SELF, ACTUAL>, ACTUAL> {}
+
+				public interface Assert<SELF extends Assert<SELF, ACTUAL>, ACTUAL> extends Descriptable<SELF>, ExtensionPoints<SELF, ACTUAL> { }
+				public static abstract class AbstractAssert<SELF extends AbstractAssert<SELF, ACTUAL>, ACTUAL> implements Assert<SELF, ACTUAL> {
+					protected ACTUAL actual;
+					protected SELF myself;
+				}
+				interface AssertFactory<T, ASSERT extends Assert<?, ?>> {
+					  ASSERT createAssert(T actual);
+				}
+
+				public static class FactoryBasedNavigableListAssert<SELF extends FactoryBasedNavigableListAssert<SELF, ACTUAL, ELEMENT, ELEMENT_ASSERT>,
+				    											ACTUAL extends List<? extends ELEMENT>,
+				    											ELEMENT,
+				    											ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>>
+					extends AbstractAssert<SELF, ACTUAL> {
+					public boolean isEmpty() { return true; }
+				}
+
+				public static class Assertions {
+					public static <ACTUAL extends List<? extends ELEMENT>, ELEMENT, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>>
+					FactoryBasedNavigableListAssert<?, ACTUAL, ELEMENT, ELEMENT_ASSERT> assertThat(List<? extends ELEMENT> actual,
+							AssertFactory<ELEMENT, ELEMENT_ASSERT> assertFactory) {
+						return null;
+					}
+				}
+			}
+			""",
+			"repro/SourceType.java",
+			"""
+			package repro;
+			import java.util.List;
+
+			public interface SourceType {
+				List<TargetType> getTargets();
+			}
+			""",
+			"repro/SourceTypeAssert.java",
+			"""
+			package repro;
+			import java.util.List;
+			import repro.AssertJStubs.*;
+
+			public class SourceTypeAssert extends AbstractAssert<SourceTypeAssert, SourceType> {
+				protected SourceTypeAssert(SourceType actual, Class<?> selfType) {
+				}
+				public final FactoryBasedNavigableListAssert<?, List<? extends TargetType>, TargetType, ? extends AbstractTargetTypeAssert<?>> targets() {
+					return Assertions.assertThat(actual.getTargets(), TargetTypeAssert::new);
+				}
+				public final SourceTypeAssert hasNoTargets() {
+					targets().isEmpty();
+					return myself;
+				}
+			}
+			""",
+			"repro/TargetType.java",
+			"""
+			package repro;
+			public interface TargetType { }
+			""",
+			"repro/AbstractTargetTypeAssert.java",
+			"""
+			package repro;
+			import repro.AssertJStubs.AbstractAssert;
+
+			public abstract class AbstractTargetTypeAssert<S extends AbstractTargetTypeAssert<S>> extends AbstractAssert<S, TargetType> {
+				protected AbstractTargetTypeAssert(TargetType actual, Class<?> selfType) {
+				}
+			}
+			""",
+			"repro/TargetTypeAssert.java",
+			"""
+			package repro;
+			public class TargetTypeAssert extends AbstractTargetTypeAssert<TargetTypeAssert> {
+				protected TargetTypeAssert(TargetType actual) {
+					super(actual, TargetTypeAssert.class);
+				}
+			}
+			"""
+		});
+}
 }