Types: add isRecursiveBound method

hinerm · hinerm · commit f542358a3105 · 2024-01-26T11:10:51.000-06:00
Helper method to determine if a bound of another type is in fact
recursive, with its own type parameter equal to the bounded type.
diff --git a/scijava-types/src/main/java/org/scijava/types/Types.java b/scijava-types/src/main/java/org/scijava/types/Types.java
@@ -581,6 +581,26 @@ public static boolean isRecursive(final Type type) {
 		return false;
 	}
 
+	/**
+	 * Helper method to detect if a particular bound, {@code typeBound}, of a
+	 * reference type, {@code refType}, is a recursive type parameter: that is, if
+	 * {@code typeBound} itself has a type argument equal to {@code refType}.
+	 *
+	 *
+	 * @param refType Base type to check
+	 * @param typeBound A bound of {@code refType}
+	 * @return True if {@code typeBound} is parameterized with a type argument
+	 *         that is itself equal to {@code refType}
+	 */
+	public static boolean isRecursiveBound(final Type refType, final Type typeBound) {
+		if (typeBound instanceof ParameterizedType) {
+			for (Type boundArg : ((ParameterizedType) typeBound).getActualTypeArguments()) {
+				if (Objects.equals(refType,boundArg)) return true;
+			}
+		}
+		return false;
+	}
+
 	/**
 	 * Discerns whether it would be legal to pass a sequence of references of the
 	 * given source types to a method with parameters typed according to the
diff --git a/scijava-types/src/main/java/org/scijava/types/inference/GenericAssignability.java b/scijava-types/src/main/java/org/scijava/types/inference/GenericAssignability.java
@@ -611,7 +611,7 @@ private static void inferTypeVariables(TypeVariable<?> type, Type inferFrom,
 						throw new TypeInferenceException();
 					}
 				}
-				else {
+				else if (!Types.isRecurisveBound(type, bound)) {
 					// Else go into recursion as we encountered a new var.
 					inferTypeVariables(bound, inferFrom, typeMappings);
 				}
diff --git a/scijava-types/src/test/java/org/scijava/types/inference/InferTypeVariablesTest.java b/scijava-types/src/test/java/org/scijava/types/inference/InferTypeVariablesTest.java
@@ -248,7 +248,7 @@ public <O extends RecursiveThing<O>> void testInferRecursiveTypeVar() {
 		// We expect O = FooThing
 		TypeVariable<?> typeVarO = (TypeVariable<?>) new Nil<O>() {}.getType();
 		Map<TypeVariable<?>, TypeMapping> expected = new HashMap<>();
-		expected.put(typeVarO, new TypeMapping(typeVarO, FooThing.class, false));
+		expected.put(typeVarO, new TypeMapping(typeVarO, FooThing.class, true));
 
 		Assertions.assertEquals(expected, typeAssigns);
 	}

Original file line number	Diff line number	Diff line change
`@@ -611,7 +611,7 @@ private static void inferTypeVariables(TypeVariable<?> type, Type inferFrom,`
`611`	`611`	`throw new TypeInferenceException();`
`612`	`612`	`}`
`613`	`613`	`}`
`614`		`- else {`
	`614`	`+ else if (!Types.isRecurisveBound(type, bound)) {`
`615`	`615`	`// Else go into recursion as we encountered a new var.`
`616`	`616`	`inferTypeVariables(bound, inferFrom, typeMappings);`
`617`	`617`	`}`
Original file line number	Diff line number	Diff line change
`@@ -248,7 +248,7 @@ public <O extends RecursiveThing<O>> void testInferRecursiveTypeVar() {`
`248`	`248`	`// We expect O = FooThing`
`249`	`249`	`TypeVariable<?> typeVarO = (TypeVariable<?>) new Nil<O>() {}.getType();`
`250`	`250`	`Map<TypeVariable<?>, TypeMapping> expected = new HashMap<>();`
`251`		`- expected.put(typeVarO, new TypeMapping(typeVarO, FooThing.class, false));`
	`251`	`+ expected.put(typeVarO, new TypeMapping(typeVarO, FooThing.class, true));`
`252`	`252`
`253`	`253`	`Assertions.assertEquals(expected, typeAssigns);`
`254`	`254`	`}`