Add Op method indexing and dependency resolution

wiedenm · wiedenm · commit 600bd5a2b14f · 2019-06-28T15:11:13.000-05:00
TODO: Dependency resolution needs some extra type inference steps at the
moment. Why? Can we get rid of this?
diff --git a/src/main/java/org/scijava/ops/OpService.java b/src/main/java/org/scijava/ops/OpService.java
@@ -29,6 +29,8 @@
 package org.scijava.ops;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.util.ArrayList;
@@ -45,11 +47,14 @@
 import org.scijava.log.LogService;
 import org.scijava.ops.core.Op;
 import org.scijava.ops.core.OpCollection;
+import org.scijava.ops.matcher.MatchingUtils;
+import org.scijava.ops.matcher.MatchingUtils.TypeInferenceException;
 import org.scijava.ops.matcher.OpCandidate;
 import org.scijava.ops.matcher.OpClassInfo;
 import org.scijava.ops.matcher.OpFieldInfo;
 import org.scijava.ops.matcher.OpInfo;
 import org.scijava.ops.matcher.OpMatchingException;
+import org.scijava.ops.matcher.OpMethodInfo;
 import org.scijava.ops.matcher.OpRef;
 import org.scijava.ops.matcher.OpTypeMatchingService;
 import org.scijava.ops.transform.OpRunner;
@@ -123,11 +128,20 @@ public void initOpCache() {
 		// Add Ops contained in an OpCollection
 		for (final PluginInfo<OpCollection> pluginInfo : pluginService.getPluginsOfType(OpCollection.class)) {
 			try {
-				final List<Field> fields = ClassUtils.getAnnotatedFields(pluginInfo.loadClass(), OpField.class);
+				final Class<? extends OpCollection> opCollectionClass = pluginInfo
+					.loadClass();
+				final List<Field> fields = ClassUtils.getAnnotatedFields(
+					opCollectionClass, OpField.class);
 				for (Field field : fields) {
 					OpInfo opInfo = new OpFieldInfo(field);
 					addToCache(opInfo, field.getAnnotation(OpField.class).names());
 				}
+				final List<Method> methods = ClassUtils.getAnnotatedMethods(
+					opCollectionClass, OpMethod.class);
+				for (final Method method : methods) {
+					OpInfo opInfo = new OpMethodInfo(method);
+					addToCache(opInfo, method.getAnnotation(OpMethod.class).names());
+				}
 			} catch (InstantiableException exc) {
 				log.error("Can't load class from plugin info: " + pluginInfo.toString(), exc);
 			}
@@ -191,13 +205,32 @@ public LogService logger() {
 	private List<Object> resolveOpDependencies(OpCandidate op)
 		throws OpMatchingException
 	{
-		final List<OpDependencyMember<?>> dependencies = op.opInfo().dependencies();
+		final OpInfo opInfo = op.opInfo();
+		final List<OpDependencyMember<?>> dependencies = opInfo.dependencies();
 		final List<Object> resolvedDependencies = new ArrayList<>(dependencies
 			.size());
 		for (final OpDependencyMember<?> dependency : dependencies) {
 			final String dependencyName = dependency.getDependencyName();
+			Map<TypeVariable<?>, Type> typeVarAssigns = op.typeVarAssigns();
+			if (opInfo instanceof OpMethodInfo) {
+				// TODO: Avoid treating Op methods differently here.
+				final Type opType = opInfo.opType();
+				if (opType instanceof ParameterizedType) {
+					typeVarAssigns = new HashMap<>(typeVarAssigns);
+					final Type[] declaredOpParamTypes = ((ParameterizedType) opType)
+						.getActualTypeArguments();
+					final Type[] actualOpParamTypes = op.getRef().getArgs();
+					try {
+						MatchingUtils.inferTypeVariables(declaredOpParamTypes,
+							actualOpParamTypes, typeVarAssigns);
+					}
+					catch (TypeInferenceException exc) {
+						// Ignore, matching will probably fail anyway. But let's try.
+					}
+				}
+			}
 			final Type mappedDependencyType = Types.mapVarToTypes(new Type[] {
-				dependency.getType() }, op.typeVarAssigns())[0];
+				dependency.getType() }, typeVarAssigns)[0];
 			final OpRef inferredRef = inferOpRef(mappedDependencyType, dependencyName,
 				op.typeVarAssigns());
 			if (inferredRef == null) {
@@ -211,7 +244,7 @@ private List<Object> resolveOpDependencies(OpCandidate op)
 			catch (final Exception e) {
 				throw new OpMatchingException(
 					"Could not find Op that matches requested Op dependency:" +
-						"\nOp class: " + op.opInfo().implementationName() + //
+						"\nOp class: " + opInfo.implementationName() + //
 						"\nDependency identifier: " + dependency.getKey() + //
 						"\n\n Attempted request:\n" + inferredRef, e);
 			}
diff --git a/src/main/java/org/scijava/ops/matcher/MatchingUtils.java b/src/main/java/org/scijava/ops/matcher/MatchingUtils.java
@@ -388,7 +388,7 @@ public static boolean isSafeAssignable(Type[] destTypes, Map<TypeVariable<?>, Ty
 	/**
 	 * Exception indicating that type vars could not be inferred.
 	 */
-	private static class TypeInferenceException extends Exception {
+	public static class TypeInferenceException extends Exception {
 		/**
 		 *
 		 */
@@ -422,7 +422,7 @@ private static <M> boolean containsNull(M[] arr) {
 	 * @param typeAssigns
 	 * @throws TypeInferenceException
 	 */
-	private static void inferTypeVariables(Type[] types, Type[] inferFrom, Map<TypeVariable<?>, Type> typeAssigns)
+	public static void inferTypeVariables(Type[] types, Type[] inferFrom, Map<TypeVariable<?>, Type> typeAssigns)
 			throws TypeInferenceException {
 		if (typeAssigns == null)
 			throw new IllegalArgumentException();
