Merge branch 'types-fixes'

This improves the Types utility class and related functionality,
to pave the way for more sophisticated type analysis in scijava-ops.

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/ClassUtils.java

@@ -352,6 +352,7 @@ public static void setValue(final Field field, final Object instance,
 
 	// -- Comparison --
 
+	// START HERE: Migrate remaining methods to Types, then deprecate this class.
 	/**
 	 * Compares two {@link Class} objects using their fully qualified names.
 	 * <p>

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

@@ -29,10 +29,6 @@
  * #L%
  */
 
-package org.scijava.util;
-
-import java.io.File;
-
 // Portions of this class were adapted from the
 // org.apache.commons.lang3.reflect.TypeUtils and
 // org.apache.commons.lang3.Validate classes of
@@ -46,6 +42,9 @@
 //
 // See NOTICE.txt for further details on third-party licenses.
 
+package org.scijava.util;
+
+import java.io.File;
 import java.io.Serializable;
 import java.lang.reflect.Array;
 import java.lang.reflect.Field;
@@ -70,8 +69,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 +83,7 @@
  * </ul>
  *
  * @author Curtis Rueden
+ * @author Gabe Selzer
  */
 public final class Types {
 
@@ -791,22 +789,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);
 	}
 
 	/**
@@ -1416,7 +1414,7 @@ private static boolean isAssignable(final Type type,
 				// parameters must either be absent from the subject type, within
 				// the bounds of the wildcard type, or be an exact match to the
 				// parameters of the target type.
-				if (fromTypeArg != null && !toTypeArg.equals(fromTypeArg) &&
+				if (fromTypeArg != null && !fromTypeArg.equals(toTypeArg) &&
 					!(toTypeArg instanceof WildcardType && isAssignable(fromTypeArg,
 						toTypeArg, typeVarAssigns)))
 				{
@@ -3206,7 +3204,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 +3582,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 +3762,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;

src/test/java/org/scijava/util/TypesTest.java

@@ -310,6 +310,12 @@ public void testBox() {
 		}
 	}
 
+	/** Tests {@link Types#unbox(Class)}. */
+	@Test
+	public void testUnbox() {
+		// TODO
+	}
+
 	/** Tests {@link Types#nullValue(Class)}. */
 	@Test
 	public void testNullValue() {
@@ -510,6 +516,31 @@ public void testIsAssignableClassToNull() {
 		Types.isAssignable(Object.class, null);
 	}
 
+	/** Tests {@link Types#isAssignable(Type, Type)} with type variable. */
+	@Test
+	public <T extends Number> void testIsAssignableT() {
+		final Type t = genericTestType("t");
+		final Type listT = genericTestType("listT");
+		final Type listNumber = genericTestType("listNumber");
+		final Type listInteger = genericTestType("listInteger");
+		final Type listExtendsNumber = genericTestType("listExtendsNumber");
+
+		assertTrue(Types.isAssignable(t, t));
+		assertTrue(Types.isAssignable(listT, listT));
+		assertTrue(Types.isAssignable(listNumber, listNumber));
+		assertTrue(Types.isAssignable(listInteger, listInteger));
+		assertTrue(Types.isAssignable(listExtendsNumber, listExtendsNumber));
+
+		assertTrue(Types.isAssignable(listT, listExtendsNumber));
+		assertTrue(Types.isAssignable(listNumber, listExtendsNumber));
+		assertTrue(Types.isAssignable(listInteger, listExtendsNumber));
+
+		assertFalse(Types.isAssignable(listNumber, listT));
+		assertFalse(Types.isAssignable(listInteger, listT));
+		assertFalse(Types.isAssignable(listExtendsNumber, listT));
+		assertFalse(Types.isAssignable(listExtendsNumber, listNumber));
+	}
+
 	/** Tests {@link Types#isInstance(Object, Class)}. */
 	@Test
 	public void testIsInstance() {
@@ -572,9 +603,28 @@ public void testEnumValueNonEnum() {
 		Types.enumValue("HOOYAH", String.class);
 	}
 
+	/** Tests {@link Types#parameterize(Class, Map)}. */
+	@Test
+	public void testParameterizeMap() {
+		// TODO
+	}
+
+	/** Tests {@link Types#parameterize(Class, Type...)}. */
+	@Test
+	public void testParameterizeTypes() {
+		// TODO
+	}
+
+	/** Tests {@link Types#parameterizeWithOwner(Type, Class, Type...)}. */
+	@Test
+	public void testParameterizeWithOwner() {
+		// TODO
+	}
+
 	// -- Helper classes --
 
 	private static class Thing<T> {
+
 		@SuppressWarnings("unused")
 		private T thing;
 	}
@@ -598,6 +648,14 @@ public static enum Words {
 		FOO, BAR, FUBAR
 	}
 
+	private interface TestTypes<T extends Number> {
+		T t();
+		List<T> listT();
+		List<Number> listNumber();
+		List<Integer> listInteger();
+		List<? extends Number> listExtendsNumber();
+	}
+
 	// -- Helper methods --
 
 	/**
@@ -671,4 +729,7 @@ private void assertAllTheSame(final List<?> list, final Object... values) {
 		}
 	}
 
+	private Type genericTestType(final String name) {
+		return Types.method(TestTypes.class, name).getGenericReturnType();
+	}
 }