Use destructuring syntax for tuple/record inputs

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

Author: bentsherman

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

@@ -128,11 +128,7 @@ private static String workflowToLabel(WorkflowNode node) {
         }
         for( var take : takes ) {
             fmt.appendIndent();
-            fmt.append(take.getName());
-            if( fmt.hasType(take) ) {
-                fmt.append(": ");
-                fmt.visitTypeAnnotation(take.getType());
-            }
+            typedInput(take, fmt);
             fmt.appendNewLine();
         }
         fmt.appendNewLine();
@@ -183,25 +179,7 @@ private static String processToLabel(ProcessNodeV2 node) {
         }
         for( var input : node.inputs ) {
             fmt.appendIndent();
-            if( input instanceof TupleParameter tp ) {
-                var components = Arrays.stream(tp.components)
-                    .map(p -> p.getName())
-                    .collect(Collectors.joining(", "));
-                fmt.append('(');
-                fmt.append(components);
-                fmt.append(')');
-            }
-            else {
-                fmt.append(input.getName());
-            }
-            if( fmt.hasType(input) ) {
-                fmt.append(": ");
-                var type = input.getType();
-                if( type.getNameWithoutPackage().startsWith("__Record") )
-                    processRecordToLabel(type.redirect(), fmt);
-                else
-                    fmt.visitTypeAnnotation(type);
-            }
+            typedInput(input, fmt);
             fmt.appendNewLine();
         }
         fmt.appendNewLine();
@@ -223,16 +201,32 @@ private static String processToLabel(ProcessNodeV2 node) {
         return fmt.toString();
     }
 
-    private static void processRecordToLabel(ClassNode type, Formatter fmt) {
+    private static void typedInput(Parameter input, Formatter fmt) {
+        if( input instanceof TupleParameter tp ) {
+            if( "Record".equals(tp.getType().getNameWithoutPackage()) )
+                processRecordInput(tp, fmt);
+            else
+                processTupleInput(tp, fmt);
+        }
+        else {
+            fmt.append(input.getName());
+            if( fmt.hasType(input) ) {
+                fmt.append(": ");
+                fmt.visitTypeAnnotation(input.getType());
+            }
+        }
+    }
+
+    private static void processRecordInput(TupleParameter tp, Formatter fmt) {
         fmt.append("Record {");
         fmt.appendNewLine();
         fmt.incIndent();
-        for( var fn : type.getFields() ) {
+        for( var p : tp.components ) {
             fmt.appendIndent();
-            fmt.append(fn.getName());
-            if( fmt.hasType(fn) ) {
+            fmt.append(p.getName());
+            if( fmt.hasType(p) ) {
                 fmt.append(": ");
-                fmt.append(TypesEx.getName(fn.getType()));
+                fmt.append(TypesEx.getName(p.getType()));
             }
             fmt.appendNewLine();
         }
@@ -241,6 +235,21 @@ private static void processRecordToLabel(ClassNode type, Formatter fmt) {
         fmt.append('}');
     }
 
+    private static void processTupleInput(TupleParameter tp, Formatter fmt) {
+        fmt.append("Tuple<");
+        for( int i = 0; i < tp.components.length; i++ ) {
+            var p = tp.components[i];
+            fmt.append(p.getName());
+            if( fmt.hasType(p) ) {
+                fmt.append(": ");
+                fmt.append(TypesEx.getName(p.getType()));
+            }
+            if( i < tp.components.length - 1 )
+                fmt.append(", ");
+        }
+        fmt.append(">");
+    }
+
     private static String processToLabel(ProcessNodeV1 node) {
         var fmt = new Formatter(new FormattingOptions(2, true));
         fmt.append("process ");

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

@@ -20,7 +20,6 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -172,10 +171,6 @@ private Parameter typedInput(MethodCallExpression call, List<Statement> stagers)
                 .map(mce -> typedInput(mce, stagers))
                 .toArray(Parameter[]::new);
             var type = new ClassNode(Tuple.class);
-            var genericsTypes = Arrays.stream(components)
-                .map(p -> new GenericsType(p.getType()))
-                .toArray(GenericsType[]::new);
-            type.setGenericsTypes(genericsTypes);
             return new TupleParameter(type, components);
         }
 

src/test/groovy/nextflow/lsp/services/script/ConvertScriptStaticTypesTest.groovy

@@ -151,9 +151,9 @@ class ConvertScriptStaticTypesTest extends Specification {
         checkInputs(service, INPUT, TYPED_INPUT, STAGE)
 
         where:
-        INPUT                               | TYPED_INPUT                   | STAGE
-        'tuple val(id), path(fastq)'        | '(id, fastq): Tuple<?, Path>' | null
-        "tuple val(id), path('file.txt')"   | '(id, $in1): Tuple<?, Path>'  | "stageAs \$in1, 'file.txt'"
+        INPUT                               | TYPED_INPUT               | STAGE
+        'tuple val(id), path(fastq)'        | 'tuple(id, fastq: Path)'  | null
+        "tuple val(id), path('file.txt')"   | 'tuple(id, $in1: Path)'   | "stageAs \$in1, 'file.txt'"
     }
 
     def 'should convert each inputs as val or path' () {