Fix type checking for output path directive

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

Author: bentsherman

src/main/java/nextflow/script/control/TypeCheckingVisitorEx.java

@@ -128,6 +128,8 @@ public void visit() {
                 visitProcess(processNode);
             for( var workflowNode : sn.getWorkflows() )
                 visitWorkflow(workflowNode);
+            if( sn.getOutputs() != null )
+                visitOutputs(sn.getOutputs());
         }
     }
 
@@ -327,18 +329,24 @@ private boolean checkPublishStatements(MethodCallExpression node, ClassNode elem
             closure.getParameters()[0].setType(elementType);
         }
         var code = (BlockStatement) closure.getCode();
+        boolean checkPublish = code.getStatements().stream().anyMatch(stmt -> (
+            asPublishStatement(stmt) != null
+        ));
         for( var stmt : code.getStatements() ) {
-            if( checkPublishStatement(stmt) )
-                continue;
-            visit(stmt);
+            if( checkPublish )
+                checkPublishStatement(stmt);
+            else
+                visit(stmt);
         }
         return true;
     }
 
-    private boolean checkPublishStatement(Statement node) {
+    private void checkPublishStatement(Statement node) {
         var publish = asPublishStatement(node);
-        if( publish == null )
-            return false;
+        if( publish == null ) {
+            addError("Statement is not a valid publish statement (hint: make sure right-hand side of `>>` expression is wrapped in parentheses)", node);
+            return;
+        }
         var source = publish.getLeftExpression();
         var target = publish.getRightExpression();
         visit(source);
@@ -349,7 +357,6 @@ private boolean checkPublishStatement(Statement node) {
         var targetType = getType(target);
         if( !TypesEx.isAssignableFrom(ClassHelper.STRING_TYPE, targetType) )
             addError("Publish target should be a String but was specified as a " + TypesEx.getName(targetType), target);
-        return true;
     }
 
     private BinaryExpression asPublishStatement(Statement node) {
@@ -405,32 +412,21 @@ else if( target instanceof TupleExpression te )
     }
 
     private void applyTupleAssignment(TupleExpression target, ClassNode sourceType) {
+        if( !TUPLE_TYPE.equals(sourceType) ) {
+            addError("Tuple assignment is not compatible with type " + TypesEx.getName(sourceType), target);
+            return;
+        }
+        
         var vars = target.getExpressions();
-
-        if( TUPLE_TYPE.equals(sourceType) ) {
-            var gts = sourceType.getGenericsTypes();
-            if( gts == null )
-                return;
-            if( vars.size() == gts.length ) {
-                for( int i = 0; i < vars.size(); i++ )
-                    vars.get(i).putNodeMetaData(ASTNodeMarker.INFERRED_TYPE, gts[i].getType());
-            }
-            else {
-                addError("Assignment target with " + vars.size() + " components cannot be assigned to tuple with " + gts.length + " components", target);
-            }
+        var gts = sourceType.getGenericsTypes();
+        if( gts == null )
+            return;
+        if( vars.size() == gts.length ) {
+            for( int i = 0; i < vars.size(); i++ )
+                vars.get(i).putNodeMetaData(ASTNodeMarker.INFERRED_TYPE, gts[i].getType());
         }
-
-        if( RECORD_TYPE.equals(sourceType) ) {
-            var fields = sourceType.getFields();
-            if( fields.size() == 0 )
-                return;
-            if( vars.size() == fields.size() ) {
-                for( int i = 0; i < vars.size(); i++ )
-                    vars.get(i).putNodeMetaData(ASTNodeMarker.INFERRED_TYPE, fields.get(i).getType());
-            }
-            else {
-                addError("Assignment target with " + vars.size() + " components cannot be assigned to record with " + fields.size() + " fields", target);
-            }
+        else {
+            addError("Assignment target with " + vars.size() + " components cannot be assigned to tuple with " + gts.length + " components", target);
         }
     }
 

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

@@ -407,10 +407,15 @@ public static Class normalize(Class type) {
         return type;
     }
 
+    private static final List<Class> STATEFUL_TYPES = List.of(
+        ParamsMap.class,    // don't normalize since param fields are injected by params block
+        Record.class        // don't normalize since record fields are injected during type inference
+    );
+
     public static ClassNode normalize(ClassNode cn) {
         if( cn == null || !cn.isResolved() )
             return cn;
-        if( cn.getTypeClass() == ParamsMap.class || cn.getTypeClass() == Record.class )
+        if( STATEFUL_TYPES.contains(cn.getTypeClass()) )
             return cn;
         var result = ClassHelper.makeCached(normalize(cn.getTypeClass())).getPlainNodeReference();
         if( cn.getGenericsTypes() != null )

src/main/java/nextflow/script/types/shim/Float.java

@@ -25,6 +25,7 @@
 """)
 @Ops(FloatOps.class)
 public interface Float {
+    Integer intValue();
 }
 
 interface FloatOps {

src/test/groovy/nextflow/script/types/TypeCheckingTest.groovy

@@ -167,6 +167,78 @@ class TypeCheckingTest extends Specification {
         errors.size() == 0
     }
 
+    def 'should check output path directive' () {
+        when:
+        def errors = getErrors(
+            '''\
+            nextflow.preview.types = true
+
+            workflow {
+                main:
+                ch_samples = channel.empty()
+
+                publish:
+                samples = ch_samples
+            }
+
+            output {
+                samples: Channel<Sample> {
+                    path { s ->
+                        s.id >> 42
+                        s.fastq >> params.save_fastq ? 'fastq' : null
+                    }
+                }
+            }
+
+            record Sample {
+                id: String
+                fastq: Path
+            }
+            '''
+        )
+        then:
+        errors.size() == 3
+        errors[0].getStartLine() == 14
+        errors[0].getStartColumn() == 13
+        errors[0].getOriginalMessage() == "Publish source should be a Path or Iterable<Path> but was specified as a String"
+        errors[1].getStartLine() == 14
+        errors[1].getStartColumn() == 21
+        errors[1].getOriginalMessage() == "Publish target should be a String but was specified as a Integer"
+        errors[2].getStartLine() == 15
+        errors[2].getStartColumn() == 13
+        errors[2].getOriginalMessage().contains "Statement is not a valid publish statement"
+
+        when:
+        errors = getErrors(
+            '''\
+            nextflow.preview.types = true
+
+            workflow {
+                main:
+                ch_samples = channel.empty()
+
+                publish:
+                samples = ch_samples
+            }
+
+            output {
+                samples: Channel<Sample> {
+                    path { s ->
+                        s.fastq >> (params.save_fastq ? 'fastq' : null)
+                    }
+                }
+            }
+
+            record Sample {
+                id: String
+                fastq: Path
+            }
+            '''
+        )
+        then:
+        errors.size() == 0
+    }
+
     def 'should check a return statement' () {
         when:
         def errors = getErrors(