Fix runtime type reflection in plugin definitions

Signed-off-by: Ben Sherman <bentshermann@gmail.com>

Author: bentsherman

build.gradle

@@ -34,7 +34,7 @@ configurations {
 }
 
 dependencies {
-  implementation 'io.nextflow:nf-lang:26.03.1-edge'
+  implementation 'io.nextflow:nf-lang:26.03.4-edge'
   implementation 'org.apache.groovy:groovy:4.0.31'
   implementation 'org.apache.groovy:groovy-json:4.0.31'
   implementation 'org.apache.groovy:groovy-yaml:4.0.31'
@@ -46,14 +46,14 @@ dependencies {
   runtimeOnly 'org.yaml:snakeyaml:2.2'
 
   // include Nextflow runtime at build-time to extract language definitions
-  nextflowRuntime 'io.nextflow:nextflow:26.03.1-edge'
-  nextflowRuntime 'io.nextflow:nf-amazon:3.8.1'
+  nextflowRuntime 'io.nextflow:nextflow:26.03.4-edge'
+  nextflowRuntime 'io.nextflow:nf-amazon:3.9.0'
   nextflowRuntime 'io.nextflow:nf-azure:1.22.2'
-  nextflowRuntime 'io.nextflow:nf-google:1.27.1'
-  nextflowRuntime 'io.nextflow:nf-k8s:1.5.1'
-  nextflowRuntime 'io.nextflow:nf-seqera:0.16.0'
-  nextflowRuntime 'io.nextflow:nf-tower:1.23.0'
-  nextflowRuntime 'io.nextflow:nf-wave:1.19.0'
+  nextflowRuntime 'io.nextflow:nf-google:1.27.2'
+  nextflowRuntime 'io.nextflow:nf-k8s:1.5.2'
+  nextflowRuntime 'io.nextflow:nf-seqera:0.19.0'
+  nextflowRuntime 'io.nextflow:nf-tower:1.26.0'
+  nextflowRuntime 'io.nextflow:nf-wave:1.20.0'
 
   testImplementation ('org.objenesis:objenesis:3.4')
   testImplementation ('net.bytebuddy:byte-buddy:1.14.17')

src/main/java/nextflow/lsp/ast/LanguageServerASTUtils.java

@@ -23,7 +23,7 @@
 import nextflow.script.ast.IncludeEntryNode;
 import nextflow.script.ast.ProcessNode;
 import nextflow.script.ast.WorkflowNode;
-import nextflow.script.types.Types;
+import nextflow.script.dsl.Types;
 import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.ast.ClassNode;
 import org.codehaus.groovy.ast.FieldNode;

src/main/java/nextflow/lsp/services/config/ConfigAstCache.java

@@ -34,7 +34,7 @@
 import nextflow.lsp.spec.PluginSpecCache;
 import nextflow.script.control.PhaseAware;
 import nextflow.script.control.Phases;
-import nextflow.script.types.Types;
+import nextflow.script.dsl.Types;
 import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.control.CompilerConfiguration;
 import org.codehaus.groovy.control.SourceUnit;

src/main/java/nextflow/lsp/services/config/ConfigCompletionProvider.java

@@ -15,6 +15,7 @@
  */
 package nextflow.lsp.services.config;
 
+import java.lang.reflect.Type;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -28,7 +29,7 @@
 import nextflow.lsp.ast.CompletionHelper;
 import nextflow.lsp.services.CompletionProvider;
 import nextflow.lsp.util.Logger;
-import nextflow.script.types.Types;
+import nextflow.script.dsl.Types;
 import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.ast.ClassNode;
 import org.codehaus.groovy.ast.VariableScope;
@@ -227,7 +228,7 @@ private static CompletionItem configScopeBlock(String name, String description)
         return item;
     }
 
-    private static CompletionItem configOption(String name, String description, Class type) {
+    private static CompletionItem configOption(String name, String description, Type type) {
         var documentation = StringGroovyMethods.stripIndent(description, true).trim();
         var item = new CompletionItem(name);
         item.setKind(CompletionItemKind.Property);

src/main/java/nextflow/lsp/services/config/ConfigHoverProvider.java

@@ -27,7 +27,7 @@
 import nextflow.lsp.ast.LanguageServerASTUtils;
 import nextflow.lsp.services.HoverProvider;
 import nextflow.lsp.util.Logger;
-import nextflow.script.types.Types;
+import nextflow.script.dsl.Types;
 import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.ast.stmt.Statement;
 import org.codehaus.groovy.runtime.DefaultGroovyMethods;

src/main/java/nextflow/lsp/services/config/ConfigSpecVisitor.java

@@ -15,7 +15,10 @@
  */
 package nextflow.lsp.services.config;
 
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -40,6 +43,7 @@
 import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.ast.ClassHelper;
 import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.GenericsType;
 import org.codehaus.groovy.ast.expr.ClosureExpression;
 import org.codehaus.groovy.ast.expr.ConstantExpression;
 import org.codehaus.groovy.ast.expr.Expression;
@@ -168,7 +172,7 @@ public void visitConfigAssign(ConfigAssignNode node) {
         }
         // validate type
         var expectedTypes = option.types().stream()
-            .map(t -> ClassHelper.makeCached(t).getPlainNodeReference())
+            .map(t -> fromType(t))
             .toList();
         var actualType = inferredType(node.value, names);
         if( !isAnyAssignableFrom(expectedTypes, actualType) ) {
@@ -182,6 +186,23 @@ public void visitConfigAssign(ConfigAssignNode node) {
         }
     }
 
+    private ClassNode fromType(Type type) {
+        if( type instanceof Class c ) {
+            return ClassHelper.makeCached(c).getPlainNodeReference();
+        }
+
+        if( type instanceof ParameterizedType pt ) {
+            var cn = fromType(pt.getRawType());
+            var gts = Arrays.stream(pt.getActualTypeArguments())
+                .map(t -> new GenericsType(fromType(t)))
+                .toArray(GenericsType[]::new);
+            cn.setGenericsTypes(gts);
+            return cn;
+        }
+
+        return ClassHelper.dynamicType();
+    }
+
     private ClassNode inferredType(Expression node, List<String> scopes) {
         new TypeCheckingVisitorEx(sourceUnit).visit(node);
         var type = TypeCheckingUtils.getType(node);

src/main/java/nextflow/lsp/services/script/ScriptAstCache.java

@@ -44,8 +44,8 @@
 import nextflow.script.control.ScriptResolveVisitor;
 import nextflow.script.control.TypeCheckingVisitor;
 import nextflow.script.control.TypeCheckingVisitorEx;
+import nextflow.script.dsl.Types;
 import nextflow.script.parser.ScriptParserPluginFactory;
-import nextflow.script.types.Types;
 import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.ast.AnnotatedNode;
 import org.codehaus.groovy.ast.ClassNode;

src/main/java/nextflow/lsp/services/script/ScriptHoverProvider.java

@@ -24,7 +24,7 @@
 import nextflow.script.ast.FunctionNode;
 import nextflow.script.ast.ProcessNode;
 import nextflow.script.ast.WorkflowNode;
-import nextflow.script.types.Types;
+import nextflow.script.dsl.Types;
 import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.ast.MethodNode;
 import org.codehaus.groovy.ast.Variable;

src/main/java/nextflow/lsp/spec/ConfigSpecFactory.java

@@ -16,6 +16,8 @@
 package nextflow.lsp.spec;
 
 import java.io.IOException;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -111,7 +113,7 @@ private static SpecNode fromNode(Map<String,?> node) {
 
     private static SpecNode.Option fromOption(Map<String,?> spec) {
         var description = (String) spec.get("description");
-        var types = new ArrayList<Class>();
+        var types = new ArrayList<Type>();
         types.add(fromType(spec.get("type")));
         if( spec.containsKey("additionalTypes") ) {
             var additionalTypes = (List) spec.get("additionalTypes");
@@ -150,16 +152,43 @@ private static SpecNode.Scope fromScope(Map<String,?> spec) {
         Map.entry("String", String.class)
     );
 
-    private static Class fromType(Object type) {
+    private static Type fromType(Object type) {
         if( type instanceof String s ) {
-            return STANDARD_TYPES.getOrDefault(s, Object.class);
+            return rawType(s);
         }
         if( type instanceof Map m ) {
             var name = (String) m.get("name");
-            // TODO: type arguments
-            return STANDARD_TYPES.getOrDefault(name, Object.class);
+            var argumentNames = (List) m.get("typeArguments");
+            var rawType = rawType(name);
+            var typeArguments = argumentNames.stream()
+                .map(el -> (Type) rawType((String) el))
+                .toArray(Type[]::new);
+            return new ParameterizedTypeImpl(rawType, (Type[]) typeArguments);
         }
         throw new IllegalStateException();
     }
 
+    private static Class rawType(String name) {
+        return STANDARD_TYPES.getOrDefault(name, Object.class);
+    }
+
+    private static class ParameterizedTypeImpl implements ParameterizedType {
+        private Type rawType;
+        private Type[] typeArguments;
+
+        ParameterizedTypeImpl(Type rawType, Type[] typeArguments) {
+            this.rawType = rawType;
+            this.typeArguments = typeArguments;
+        }
+
+        @Override
+        public Type getOwnerType() { return null; }
+
+        @Override
+        public Type getRawType() { return rawType; }
+
+        @Override
+        public Type[] getActualTypeArguments() { return typeArguments; }
+    }
+
 }

src/main/java/nextflow/script/types/TypesEx.java

@@ -15,6 +15,8 @@
  */
 package nextflow.script.types;
 
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.file.Path;
@@ -291,7 +293,12 @@ else if( type.isResolved() ) {
 
         if( !placeholder && type.getGenericsTypes() != null ) {
             builder.append('<');
-            genericsTypeNames(type.getGenericsTypes(), builder);
+            var gts = type.getGenericsTypes();
+            for( int i = 0; i < gts.length; i++ ) {
+                if( i > 0 )
+                    builder.append(", ");
+                builder.append(getName(gts[i].getType()));
+            }
             builder.append('>');
         }
 
@@ -301,18 +308,30 @@ else if( type.isResolved() ) {
         return builder.toString();
     }
 
-    private static void genericsTypeNames(GenericsType[] genericsTypes, StringBuilder builder) {
-        for( int i = 0; i < genericsTypes.length; i++ ) {
-            if( i > 0 )
-                builder.append(", ");
-            builder.append(getName(genericsTypes[i].getType()));
-        }
+    public static String getName(Type type) {
+        return
+            type instanceof Class c ? getName(c) :
+            type instanceof ParameterizedType pt ? getName(pt) :
+            getName(type.getTypeName());
     }
 
     public static String getName(Class type) {
         return getName(normalize(type).getSimpleName());
     }
 
+    private static String getName(ParameterizedType pt) {
+        var sb = new StringBuilder();
+        sb.append(getName(pt.getRawType()));
+        sb.append('<');
+        for( int i = 0; i < pt.getActualTypeArguments().length; i++ ) {
+            if( i > 0 )
+                sb.append(", ");
+            sb.append(getName(pt.getActualTypeArguments()[i]));
+        }
+        sb.append('>');
+        return sb.toString();
+    }
+
     public static String getName(String name) {
         if( "Object".equals(name) )
             return "?";