Types: Refactor parameterizeWithOwner params

This breaks backwards compatibility. But there was a type argument
clash with the other methods called parameterize, so it's better to
rename this one to something unique, to avoid confusion.

We'll call it "new API". ;-)

Co-authored-by: Gabriel Selzer <gselzer@wisc.edu>

Author: ctrueden

pom.xml

@@ -10,7 +10,7 @@
 	</parent>
 
 	<artifactId>scijava-common</artifactId>
-	<version>2.77.1-SNAPSHOT</version>
+	<version>2.78.0-SNAPSHOT</version>
 
 	<name>SciJava Common</name>
 	<description>SciJava Common is a shared library for SciJava software. It provides a plugin framework, with an extensible mechanism for service discovery, backed by its own annotation processor, so that plugins can be loaded dynamically. It is used by downstream projects in the SciJava ecosystem, such as ImageJ and SCIFIO.</description>

src/main/java/org/scijava/util/Types.java

@@ -70,8 +70,6 @@
 import java.util.Objects;
 import java.util.Set;
 
-import org.scijava.util.FileUtils;
-
 /**
  * Utility class for working with generic types, fields and methods.
  * <p>
@@ -86,6 +84,7 @@
  * </ul>
  *
  * @author Curtis Rueden
+ * @author Gabe Selzer
  */
 public final class Types {
 
@@ -791,22 +790,22 @@ public static <T> T enumValue(final String name, final Class<T> dest) {
 	public static ParameterizedType parameterize(final Class<?> rawType,
 		final Type... typeArgs)
 	{
-		return parameterize(rawType, rawType.getDeclaringClass(), typeArgs);
+		return parameterizeWithOwner(null, rawType, typeArgs);
 	}
 
 	/**
 	 * Creates a new {@link ParameterizedType} of the given class together with
 	 * the specified type arguments.
 	 *
-	 * @param rawType The class of the {@link ParameterizedType}.
 	 * @param ownerType The owner type of the parameterized class.
+	 * @param rawType The class of the {@link ParameterizedType}.
 	 * @param typeArgs The type arguments to use in parameterizing it.
 	 * @return The newly created {@link ParameterizedType}.
 	 */
-	public static ParameterizedType parameterize(final Class<?> rawType,
-		final Type ownerType, final Type... typeArgs)
+	public static ParameterizedType parameterizeWithOwner(final Type ownerType,
+		final Class<?> rawType, final Type... typeArgs)
 	{
-		return new TypeUtils.ParameterizedTypeImpl(rawType, ownerType, typeArgs);
+		return TypeUtils.parameterizeWithOwner(ownerType, rawType, typeArgs);
 	}
 
 	/**
@@ -3206,7 +3205,7 @@ else if (isMissingTypeParameters(clazz)) {
 				Arrays.fill(arguments, UNBOUND_WILDCARD);
 				final Type owner = clazz.getDeclaringClass() == null ? null
 					: addWildcardParameters(clazz.getDeclaringClass());
-				return parameterize(clazz, owner, arguments);
+				return parameterizeWithOwner(owner, clazz, arguments);
 			}
 			else {
 				return clazz;
@@ -3584,9 +3583,9 @@ public static Type capture(final Type type) {
 				for (final CaptureTypeImpl captured : toInit) {
 					captured.init(varMap);
 				}
-				final Type ownerType = (pType.getOwnerType() == null) ? null : capture(
+				final Type ownerType = pType.getOwnerType() == null ? null : capture(
 					pType.getOwnerType());
-				return parameterize(clazz, ownerType, capturedArguments);
+				return parameterizeWithOwner(ownerType, clazz, capturedArguments);
 			}
 			return type;
 		}
@@ -3764,9 +3763,10 @@ else if (type instanceof TypeVariable) {
 			}
 			else if (type instanceof ParameterizedType) {
 				final ParameterizedType pType = (ParameterizedType) type;
-				return parameterize((Class<?>) pType.getRawType(), pType
-					.getOwnerType() == null ? pType.getOwnerType() : map(pType
-						.getOwnerType()), map(pType.getActualTypeArguments()));
+				final Type ownerType = pType.getOwnerType() == null ? //
+					pType.getOwnerType() : map(pType.getOwnerType());
+				return parameterizeWithOwner(ownerType, (Class<?>) pType.getRawType(),
+					map(pType.getActualTypeArguments()));
 			}
 			else if (type instanceof WildcardType) {
 				final WildcardType wType = (WildcardType) type;