Support multiple config option types in config spec (nextflow-io#6720)

Author: bentsherman

modules/nextflow/src/main/groovy/nextflow/config/ConfigValidator.groovy

@@ -178,8 +178,11 @@ class ConfigValidator {
     }
 
     /**
-     * Determine whether a config option is a map option or a
-     * property thereof.
+     * Determine whether a config option is a map option.
+     *
+     * This method is needed to distinguish between config scopes
+     * and config options that happen to be maps, since this distinction
+     * is lost when the config is resolved.
      *
      * @param names
      */
@@ -190,7 +193,7 @@ class ConfigValidator {
 
     private static boolean isMapOption0(SpecNode.Scope scope, List<String> names) {
         final node = scope.getOption(names)
-        return node != null && node.type() == Map.class
+        return node != null && node.types().contains(Map.class)
     }
 
     /**

modules/nextflow/src/main/groovy/nextflow/plugin/spec/ConfigSpec.groovy

@@ -44,14 +44,15 @@ class ConfigSpec {
 
     private static Map<String,?> fromOption(SpecNode.Option node, String name) {
         final description = node.description().stripIndent(true).trim()
-        final type = fromType(new ClassNode(node.type()))
+        final types = node.types().collect { t -> fromType(new ClassNode(t)) }
 
         return [
             type: 'ConfigOption',
             spec: [
                 name: name,
                 description: description,
-                type: type
+                type: types.head(),
+                additionalTypes: types.tail()
             ]
         ]
     }

modules/nextflow/src/test/groovy/nextflow/config/ConfigValidatorTest.groovy

@@ -112,6 +112,28 @@ class ConfigValidatorTest extends Specification {
     }
 
     def 'should support map options' () {
+        when:
+        new ConfigValidator().validate([
+            k8s: [
+                pod: [env: 'MESSAGE', value: 'hello world']
+            ]
+        ])
+        then:
+        !capture.toString().contains('Unrecognized config option')
+
+        when:
+        new ConfigValidator().validate([
+            process: [
+                publishDir: [
+                    path: { "results/foo" },
+                    mode: 'copy',
+                    saveAs: { filename -> filename }
+                ]
+            ]
+        ])
+        then:
+        !capture.toString().contains('Unrecognized config option')
+
         when:
         new ConfigValidator().validate([
             process: [

modules/nextflow/src/test/groovy/nextflow/plugin/spec/PluginSpecTest.groovy

@@ -59,7 +59,8 @@ class PluginSpecTest extends Specification {
                         spec: [
                             name: 'message',
                             description: 'Message to print to standard output when the plugin is enabled.',
-                            type: 'String'
+                            type: 'String',
+                            additionalTypes: []
                         ]
                     ]
                 ]

modules/nf-lang/src/main/java/nextflow/config/spec/SpecNode.java

@@ -19,6 +19,7 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -58,9 +59,9 @@ private static SpecNode nextflowScope() {
             var simpleName = names[names.length - 1];
             var desc = annotatedDescription(field, "");
             if( fqName.startsWith("nextflow.enable.") )
-                enableOpts.put(simpleName, new Option(desc, optionType(field)));
+                enableOpts.put(simpleName, new Option(desc, optionTypes(field)));
             else if( fqName.startsWith("nextflow.preview.") )
-                previewOpts.put(simpleName, new Option(desc, optionType(field)));
+                previewOpts.put(simpleName, new Option(desc, optionTypes(field)));
             else
                 throw new IllegalArgumentException();
         }
@@ -73,6 +74,15 @@ else if( fqName.startsWith("nextflow.preview.") )
         );
     }
 
+    /**
+     * Initialize the `process` config scope from the set of
+     * process directives.
+     *
+     * Directives with multiple method overloads are treated as
+     * options with multiple supported types. Method overloads with
+     * multiple parameters are ignored because they are not supported
+     * in the configuration.
+     */
     private static SpecNode processScope() {
         var description = """
             The `process` scope allows you to specify default directives for processes in your pipeline.
@@ -81,8 +91,15 @@ private static SpecNode processScope() {
         """;
         var children = new HashMap<String, SpecNode>();
         for( var method : ProcessDsl.DirectiveDsl.class.getDeclaredMethods() ) {
-            var desc = annotatedDescription(method, "");
-            children.put(method.getName(), new Option(desc, optionType(method)));
+            if( method.getParameters().length != 1 )
+                continue;
+            if( !children.containsKey(method.getName()) ) {
+                var desc = annotatedDescription(method, "");
+                children.put(method.getName(), new Option(desc, new ArrayList<>()));
+            }
+            var option = (Option) children.get(method.getName());
+            var paramType = method.getParameterTypes()[0];
+            option.types.add(paramType);
         }
         return new Scope(description, children);
     }
@@ -92,21 +109,17 @@ private static String annotatedDescription(AnnotatedElement el, String defaultVa
         return annot != null ? annot.value() : defaultValue;
     }
 
-    private static Class optionType(AnnotatedElement element) {
-        if( element instanceof Field field ) {
-            return field.getType();
+    private static List<Class> optionTypes(Field field) {
+        var result = new ArrayList<Class>();
+        // use the field type
+        result.add(field.getType());
+        // append types from ConfigOption annotation if specified
+        var annot = field.getAnnotation(ConfigOption.class);
+        if( annot != null ) {
+            for( var type : annot.types() )
+                result.add(type);
         }
-        if( element instanceof Method method ) {
-            // use the return type if config option is not a directive
-            var returnType = method.getReturnType();
-            if( returnType != void.class )
-                return returnType;
-            // other use the type of the last parameter
-            var paramTypes = method.getParameterTypes();
-            if( paramTypes.length > 0 )
-                return paramTypes[paramTypes.length - 1];
-        }
-        return null;
+        return result;
     }
 
     /**
@@ -123,7 +136,7 @@ public static record DslOption(
      */
     public static record Option(
         String description,
-        Class type
+        List<Class> types
     ) implements SpecNode {}
 
     /**
@@ -207,7 +220,7 @@ public static Scope of(Class<? extends ConfigScope> scope, String description) {
                     if( DslScope.class.isAssignableFrom(type) )
                         children.put(name, new DslOption(desc, type));
                     else
-                        children.put(name, new Option(desc, optionType(field)));
+                        children.put(name, new Option(desc, optionTypes(field)));
                 }
                 // fields of type ConfigScope are nested config scopes
                 else if( ConfigScope.class.isAssignableFrom(type) ) {

modules/nf-lang/src/test/groovy/nextflow/config/spec/SpecNodeTest.groovy

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2024-2025, Seqera Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package nextflow.config.spec
+
+import nextflow.script.types.Duration
+import nextflow.script.types.MemoryUnit
+import spock.lang.Specification
+
+/**
+ *
+ * @author Ben Sherman <bentshermann@gmail.com>
+ */
+class SpecNodeTest extends Specification {
+
+    def 'should infer process config options from process directives' () {
+        given:
+        def scope = SpecNode.ROOT.children.get('process')
+
+        expect:
+        scope.children.get('clusterOptions').types as Set == [ String, List, String[] ] as Set
+        scope.children.get('cpus').types == [ Integer ]
+        scope.children.get('errorStrategy').types == [ String ]
+        scope.children.get('executor').types == [ String ]
+        scope.children.get('ext').types == [ Map ]
+        scope.children.get('memory').types == [ MemoryUnit ]
+        scope.children.get('publishDir').types as Set == [ Map, String, List ] as Set
+        scope.children.get('resourceLimits').types == [ Map ]
+        scope.children.get('time').types == [ Duration ]
+    }
+
+}