More efficient, more modern, fast failing version of computation of the abstract contracts of an interface while deriving SAM (eclipse-jdt#4232)

* Fixes eclipse-jdt#4230
---------

Co-authored-by: Florian Schwabe <florian.schwabe@vector.com>

Author: srikanth-sankaran

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

@@ -23,7 +23,9 @@
 
 package org.eclipse.jdt.internal.compiler.lookup;
 
+import java.util.Arrays;
 import java.util.Set;
+import java.util.stream.Stream;
 import org.eclipse.jdt.internal.compiler.ast.Wildcard;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 
@@ -67,22 +69,10 @@ public TypeBinding clone(TypeBinding enclosingType) {
 	}
 
 	@Override
-	protected MethodBinding[] getInterfaceAbstractContracts(Scope scope, boolean replaceWildcards, boolean filterDefaultMethods) throws InvalidBindingException {
-		int typesLength = this.intersectingTypes.length;
-		MethodBinding[][] methods = new MethodBinding[typesLength][];
-		int contractsLength = 0;
-		for (int i = 0; i < typesLength; i++) {
-			methods[i] = this.intersectingTypes[i].getInterfaceAbstractContracts(scope, replaceWildcards, true);
-			contractsLength += methods[i].length;
-		}
-		MethodBinding[] contracts = new MethodBinding[contractsLength];
-		int idx = 0;
-		for (int i = 0; i < typesLength; i++) {
-			int len = methods[i].length;
-			System.arraycopy(methods[i], 0, contracts, idx, len);
-			idx += len;
-		}
-		return contracts;
+	protected Stream<MethodBinding> collateFunctionalInterfaceContracts(Scope scope, boolean replaceWildcards, Set<ReferenceBinding> visitedInterfaces) throws DysfunctionalInterfaceException {
+		return Arrays.stream(this.intersectingTypes).flatMap( //
+						intersectingType -> intersectingType.collateFunctionalInterfaceContracts(scope, replaceWildcards, visitedInterfaces) //
+		);
 	}
 
 	@Override

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

@@ -53,6 +53,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Stream;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.NullAnnotationMatching;
@@ -1730,26 +1731,28 @@ public FieldBinding[] unResolvedFields() {
 	}
 
 	@Override
-	protected MethodBinding[] getInterfaceAbstractContracts(Scope scope, boolean replaceWildcards, boolean filterDefaultMethods) throws InvalidBindingException {
+	protected Stream<MethodBinding> collateFunctionalInterfaceContracts(Scope scope, boolean replaceWildcards, Set<ReferenceBinding> visitedInterfaces) throws DysfunctionalInterfaceException {
 		if (replaceWildcards) {
 			TypeBinding[] types = getNonWildcardParameters(scope);
 			if (types == null)
-				return new MethodBinding[] { new ProblemMethodBinding(TypeConstants.ANONYMOUS_METHOD, null, ProblemReasons.NotAWellFormedParameterizedType) };
+				throw DYSFUNCTIONAL_INTERFACE_EXCEPTION;
+
 			for (int i = 0; i < types.length; i++) {
 				if (TypeBinding.notEquals(types[i], this.arguments[i])) {
 					// non-wildcard parameterization differs from this, so use it:
 					ParameterizedTypeBinding declaringType = scope.environment().createParameterizedType(this.type, types, this.type.enclosingType());
 					TypeVariableBinding [] typeParameters = this.type.typeVariables();
 					for (int j = 0, length = typeParameters.length; j < length; j++) {
 						if (!typeParameters[j].boundCheck(declaringType, types[j], scope, null).isOKbyJLS())
-							return new MethodBinding[] { new ProblemMethodBinding(TypeConstants.ANONYMOUS_METHOD, null, ProblemReasons.NotAWellFormedParameterizedType) };
+							throw DYSFUNCTIONAL_INTERFACE_EXCEPTION;
 					}
-					return declaringType.getInterfaceAbstractContracts(scope, replaceWildcards, filterDefaultMethods);
+					return declaringType.collateFunctionalInterfaceContracts(scope, replaceWildcards, visitedInterfaces);
 				}
 			}
 		}
-		return super.getInterfaceAbstractContracts(scope, replaceWildcards, filterDefaultMethods);
+		return super.collateFunctionalInterfaceContracts(scope, replaceWildcards, visitedInterfaces);
 	}
+
 	@Override
 	public MethodBinding getSingleAbstractMethod(final Scope scope, boolean replaceWildcards) {
 		return getSingleAbstractMethod(scope, replaceWildcards, -1, -1 /* do not capture */);

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

@@ -60,6 +60,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.LambdaExpression;
@@ -96,6 +98,8 @@ abstract public class ReferenceBinding extends TypeBinding {
 	int typeBits; // additional bits characterizing this type
 	protected MethodBinding [] singleAbstractMethod;
 
+	protected static final DysfunctionalInterfaceException DYSFUNCTIONAL_INTERFACE_EXCEPTION = new DysfunctionalInterfaceException("Not a functional interface"); //$NON-NLS-1$
+
 	public static final ReferenceBinding LUB_GENERIC = new ReferenceBinding() { /* used for lub computation */
 		{ this.id = TypeIds.T_undefined; }
 		@Override
@@ -2322,93 +2326,58 @@ public void detectWrapperResource() {
 	}
 }
 
-protected MethodBinding [] getInterfaceAbstractContracts(Scope scope, boolean replaceWildcards, boolean filterDefaultMethods) throws InvalidBindingException {
-
-	if (!isInterface() || !isValidBinding()) {
-		throw new InvalidBindingException("Not a functional interface"); //$NON-NLS-1$
-	}
-
-	MethodBinding [] methods = methods();
-	MethodBinding [] contracts = new MethodBinding[0];
-	int contractsCount = 0;
-	int contractsLength = 0;
-
-	ReferenceBinding [] superInterfaces = superInterfaces();
-	for (ReferenceBinding superInterface : superInterfaces) {
-		// filterDefaultMethods=false => keep default methods needed to filter out any abstract methods they may override:
-		MethodBinding [] superInterfaceContracts = superInterface.getInterfaceAbstractContracts(scope, replaceWildcards, false);
-		final int superInterfaceContractsLength = superInterfaceContracts == null  ? 0 : superInterfaceContracts.length;
-		if (superInterfaceContractsLength == 0) continue;
-		if (contractsLength < contractsCount + superInterfaceContractsLength) {
-			System.arraycopy(contracts, 0, contracts = new MethodBinding[contractsLength = contractsCount + superInterfaceContractsLength], 0, contractsCount);
-		}
-		System.arraycopy(superInterfaceContracts, 0, contracts, contractsCount,	superInterfaceContractsLength);
-		contractsCount += superInterfaceContractsLength;
-	}
+private MethodBinding[] getFunctionalInterfaceAbstractContracts(Scope scope, boolean replaceWildcards) throws DysfunctionalInterfaceException {
 
 	LookupEnvironment environment = scope.environment();
-	for (int i = 0, length = methods == null ? 0 : methods.length; i < length; i++) {
-		final MethodBinding method = methods[i];
-		if (method == null || method.isStatic() || method.redeclaresPublicObjectMethod(scope) || method.isPrivate())
-			continue;
-		if (!method.isValidBinding())
-			throw new InvalidBindingException("Not a functional interface"); //$NON-NLS-1$
-		for (int j = 0; j < contractsCount;) {
-			if ( contracts[j] != null && MethodVerifier.doesMethodOverride(method, contracts[j], environment)) {
-				contractsCount--;
-				// abstract method from super type overridden by present interface ==> contracts[j] = null;
-				if (j < contractsCount) {
-					System.arraycopy(contracts, j+1, contracts, j, contractsCount - j);
-					continue;
-				}
-			}
-			j++;
-		}
-		if (filterDefaultMethods && method.isDefaultMethod())
-			continue; // skip default method itself
-		if (contractsCount == contractsLength) {
-			System.arraycopy(contracts, 0, contracts = new MethodBinding[contractsLength += 16], 0, contractsCount);
-		}
-		if(environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) {
-			ImplicitNullAnnotationVerifier.ensureNullnessIsKnown(method, scope);
-		}
-		contracts[contractsCount++] = method;
-	}
-	// check mutual overriding of inherited methods (i.e., not from current type):
-	for (int i = 0; i < contractsCount; i++) {
-		MethodBinding contractI = contracts[i];
-		if (TypeBinding.equalsEquals(contractI.declaringClass, this))
-			continue;
-		for (int j = 0; j < contractsCount; j++) {
-			MethodBinding contractJ = contracts[j];
-			if (i == j || TypeBinding.equalsEquals(contractJ.declaringClass, this))
-				continue;
-			if (contractI == contractJ || MethodVerifier.doesMethodOverride(contractI, contractJ, environment)) {
-				contractsCount--;
-				// abstract method from one super type overridden by other super interface ==> contracts[j] = null;
-				if (j < contractsCount) {
-					System.arraycopy(contracts, j+1, contracts, j, contractsCount - j);
-				}
-				j--;
-				if (j < i)
-					i--;
-				continue;
+	boolean isAnnotationBasedNullAnalysisEnabled = environment.globalOptions.isAnnotationBasedNullAnalysisEnabled;
+	MethodBinding samCandidate = null;
+
+	MethodBinding[] methods = collateFunctionalInterfaceContracts(scope, replaceWildcards, new HashSet<>())
+		.sorted((m1, m2) -> CharOperation.compareTo(m1.selector, m2.selector))
+		.toArray(MethodBinding []::new);
+
+	for (int i = 0, length = methods.length; i < length; i++) {
+		MethodBinding method = methods[i];
+		for (int j = i + 1; j < length; j++) {
+			MethodBinding otherMethod = methods[j];
+			if (method.selector.length != otherMethod.selector.length || !CharOperation.equals(method.selector, otherMethod.selector))
+				break; // Skip comparing apple to oranges (input sorted by selector, so no viable overrides past this point)
+			if (MethodVerifier.doesMethodOverride(otherMethod, method, environment)) {
+				methods[i] = method = null;
+				break; // Skip comparing rotten apple with remaining lot: is overridden already, no use checking if is overridden also by another
 			}
 		}
-		if (filterDefaultMethods && contractI.isDefaultMethod()) {
-			contractsCount--;
-			// remove default method after it has eliminated any matching abstract methods from contracts
-			if (i < contractsCount) {
-				System.arraycopy(contracts, i+1, contracts, i, contractsCount - i);
-			}
-			i--;
+		if (method != null && method.isAbstract()) {
+			if (samCandidate == null)
+				samCandidate = method;
+			else if (!CharOperation.equals(samCandidate.selector, method.selector) || samCandidate.parameters.length != method.parameters.length)
+				throw DYSFUNCTIONAL_INTERFACE_EXCEPTION;
+			if (isAnnotationBasedNullAnalysisEnabled)
+				ImplicitNullAnnotationVerifier.ensureNullnessIsKnown(method, scope);
 		}
 	}
-	if (contractsCount < contractsLength) {
-		System.arraycopy(contracts, 0, contracts = new MethodBinding[contractsCount], 0, contractsCount);
-	}
-	return contracts;
+	return Arrays.stream(methods).filter(m -> m != null && m.isAbstract()).toArray(MethodBinding []::new);
 }
+
+protected Stream<MethodBinding> collateFunctionalInterfaceContracts(Scope scope, boolean replaceWildcards, Set<ReferenceBinding> visitedInterfaces) throws DysfunctionalInterfaceException {
+
+	if (!isInterface() || !isValidBinding())
+		throw DYSFUNCTIONAL_INTERFACE_EXCEPTION;
+
+	Predicate<MethodBinding> isContractual = m -> { // select valid public abstract || default methods
+		if (m == null || m.isStatic() || m.redeclaresPublicObjectMethod(scope) || m.isPrivate())
+			return false;
+		if (!m.isValidBinding())
+			throw DYSFUNCTIONAL_INTERFACE_EXCEPTION;
+		return true;
+	};
+
+	return Stream.concat( //
+			Arrays.stream(superInterfaces()).filter(iface->visitedInterfaces.add(iface)).flatMap(superInterface -> superInterface.collateFunctionalInterfaceContracts(scope, replaceWildcards, visitedInterfaces)), //
+			Arrays.stream(methods()).filter(isContractual)
+	);
+}
+
 @Override
 public MethodBinding getSingleAbstractMethod(Scope scope, boolean replaceWildcards) {
 
@@ -2426,7 +2395,7 @@ public MethodBinding getSingleAbstractMethod(Scope scope, boolean replaceWildcar
 		scope.compilationUnitScope().recordQualifiedReference(this.compoundName);
 	MethodBinding[] methods = null;
 	try {
-		methods = getInterfaceAbstractContracts(scope, replaceWildcards, true);
+		methods = getFunctionalInterfaceAbstractContracts(scope, replaceWildcards);
 		if (methods == null || methods.length == 0)
 			return this.singleAbstractMethod[index] = samProblemBinding;
 		int contractParameterLength = 0;
@@ -2442,7 +2411,7 @@ public MethodBinding getSingleAbstractMethod(Scope scope, boolean replaceWildcar
 					return this.singleAbstractMethod[index] = samProblemBinding;
 			}
 		}
-	} catch (InvalidBindingException e) {
+	} catch (DysfunctionalInterfaceException e) {
 		return this.singleAbstractMethod[index] = samProblemBinding;
 	}
 	if (methods.length == 1)
@@ -2677,10 +2646,9 @@ public boolean isDisjointFrom(ReferenceBinding that) {
 		}
 	}
 }
-static class InvalidBindingException extends Exception {
+static class DysfunctionalInterfaceException extends RuntimeException {
 	private static final long serialVersionUID = 1L;
-
-	InvalidBindingException(String message) {
+	DysfunctionalInterfaceException(String message) {
 		super(message);
 	}
 }