Add type checking utils

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

Author: bentsherman

modules/nf-lang/src/main/java/nextflow/config/control/VariableScopeVisitor.java

@@ -285,9 +285,11 @@ private void checkMethodCall(MethodCallExpression node) {
         if( !node.isImplicitThis() )
             return;
         var name = node.getMethodAsString();
-        var defNode = vsc.findDslFunction(name, node);
-        if( defNode != null )
-            node.putNodeMetaData(ASTNodeMarker.METHOD_TARGET, defNode);
+        var methods = vsc.findDslFunction(name, node);
+        if( methods.size() == 1 )
+            node.putNodeMetaData(ASTNodeMarker.METHOD_TARGET, methods.get(0));
+        else if( !methods.isEmpty() )
+            node.putNodeMetaData(ASTNodeMarker.METHOD_OVERLOADS, methods);
         else if( !KEYWORDS.contains(name) )
             vsc.addError("`" + name + "` is not defined", node.getMethod());
     }

modules/nf-lang/src/main/java/nextflow/script/ast/ASTNodeMarker.java

@@ -27,6 +27,9 @@ public enum ASTNodeMarker {
     // denotes that an assignment is an implicit declaration
     IMPLICIT_DECLARATION,
 
+    // the inferred return type of a closure expression
+    INFERRED_RETURN_TYPE,
+
     // the inferred type of an expression
     INFERRED_TYPE,
 
@@ -39,6 +42,9 @@ public enum ASTNodeMarker {
     // the verbatim text of a Groovy-style type annotation (ClassNode)
     LEGACY_TYPE,
 
+    // the list of candidate MethodNode's for a MethodCallExpression
+    METHOD_OVERLOADS,
+
     // the MethodNode targeted by a MethodCallExpression
     METHOD_TARGET,
 
@@ -48,6 +54,9 @@ public enum ASTNodeMarker {
     // denotes a nullable type annotation (ClassNode)
     NULLABLE,
 
+    // the FieldNode targeted by a PropertyExpression
+    PROPERTY_TARGET,
+
     // the starting quote sequence of a string literal or gstring expression
     QUOTE_CHAR,
 

modules/nf-lang/src/main/java/nextflow/script/ast/ASTUtils.java

@@ -18,10 +18,13 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Stream;
 
+import groovy.transform.NamedParams;
 import org.codehaus.groovy.ast.ClassHelper;
 import org.codehaus.groovy.ast.ClassNode;
 import org.codehaus.groovy.ast.AnnotatedNode;
@@ -30,9 +33,12 @@
 import org.codehaus.groovy.ast.Parameter;
 import org.codehaus.groovy.ast.PropertyNode;
 import org.codehaus.groovy.ast.Variable;
+import org.codehaus.groovy.ast.expr.AnnotationConstantExpression;
+import org.codehaus.groovy.ast.expr.ClassExpression;
 import org.codehaus.groovy.ast.expr.ClosureExpression;
 import org.codehaus.groovy.ast.expr.ConstantExpression;
 import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.ListExpression;
 import org.codehaus.groovy.ast.expr.MapExpression;
 import org.codehaus.groovy.ast.expr.MapEntryExpression;
 import org.codehaus.groovy.ast.expr.MethodCall;
@@ -145,6 +151,34 @@ public static List<MapEntryExpression> asNamedArgs(MethodCall call) {
             : Collections.emptyList();
     }
 
+    public static Map<String, AnnotationNode> asNamedParams(Parameter parameter) {
+        var namedParams = new LinkedHashMap<String, AnnotationNode>();
+        parameter.getAnnotations().stream()
+            .filter(an -> an.getClassNode().getName().equals(NamedParams.class.getName()))
+            .flatMap(an -> {
+                var value = an.getMember("value");
+                return value instanceof ListExpression le
+                    ? le.getExpressions().stream()
+                    : Stream.empty();
+            })
+            .forEach((value) -> {
+                if( !(value instanceof AnnotationConstantExpression) )
+                    return;
+                var ace = (AnnotationConstantExpression) value;
+                var namedParam = (AnnotationNode) ace.getValue();
+                var name = namedParam.getMember("value").getText();
+                namedParams.put(name, namedParam);
+            });
+        return namedParams;
+    }
+
+    public static Parameter asNamedParam(AnnotationNode node) {
+        var name = node.getMember("value").getText();
+        var typeX = (ClassExpression) node.getMember("type");
+        var type = typeX != null ? typeX.getType() : ClassHelper.dynamicType();
+        return new Parameter(type, name);
+    }
+
     public static VariableExpression asVarX(Statement statement) {
         return statement instanceof ExpressionStatement es ? asVarX(es.getExpression()) : null;
     }

modules/nf-lang/src/main/java/nextflow/script/ast/OutputNode.java

@@ -15,23 +15,20 @@
  */
 package nextflow.script.ast;
 
-import org.codehaus.groovy.ast.ASTNode;
 import org.codehaus.groovy.ast.ClassNode;
+import org.codehaus.groovy.ast.Parameter;
 import org.codehaus.groovy.ast.stmt.Statement;
 
 /**
  * An output declaration.
  *
  * @author Ben Sherman <bentshermann@gmail.com>
  */
-public class OutputNode extends ASTNode {
-    public final String name;
-    public final ClassNode type;
+public class OutputNode extends Parameter {
     public final Statement body;
 
     public OutputNode(String name, ClassNode type, Statement body) {
-        this.name = name;
-        this.type = type;
+        super(type, name);
         this.body = body;
     }
 }

modules/nf-lang/src/main/java/nextflow/script/ast/ProcessNodeV2.java

@@ -69,30 +69,28 @@ private static ClassNode dummyReturnType(Statement block) {
         if( outputs.size() == 1 ) {
             var first = outputs.get(0);
             var output = ((ExpressionStatement) first).getExpression();
-            if( outputName(output) == null )
+            if( outputTarget(output) == null )
                 return output.getType();
         }
         var cn = new ClassNode(Record.class);
         outputs.stream()
             .map(stmt -> ((ExpressionStatement) stmt).getExpression())
-            .map(output -> outputName(output))
-            .filter(name -> name != null)
-            .forEach((name) -> {
-                var type = ClassHelper.dynamicType();
-                var fn = new FieldNode(name, Modifier.PUBLIC, type, cn, null);
+            .map(output -> outputTarget(output))
+            .filter(target -> target != null)
+            .forEach((target) -> {
+                var fn = new FieldNode(target.getName(), Modifier.PUBLIC, target.getType(), cn, null);
                 fn.setDeclaringClass(cn);
                 cn.addField(fn);
             });
         return cn;
     }
 
-    private static String outputName(Expression output) {
+    private static VariableExpression outputTarget(Expression output) {
         if( output instanceof VariableExpression ve ) {
-            return ve.getName();
+            return ve;
         }
-        else if( output instanceof AssignmentExpression ae ) {
-            var target = (VariableExpression)ae.getLeftExpression();
-            return target.getName();
+        if( output instanceof AssignmentExpression ae ) {
+            return (VariableExpression)ae.getLeftExpression();
         }
         return null;
     }

modules/nf-lang/src/main/java/nextflow/script/ast/WorkflowNode.java

@@ -16,7 +16,6 @@
 package nextflow.script.ast;
 
 import java.lang.reflect.Modifier;
-import java.util.Optional;
 
 import nextflow.script.types.Record;
 import org.codehaus.groovy.ast.ClassHelper;
@@ -65,28 +64,33 @@ public boolean isCodeSnippet() {
         return getLineNumber() == -1;
     }
 
-    private static ClassNode dummyReturnType(Statement emits) {
+    private static ClassNode dummyReturnType(Statement block) {
+        var emits = asBlockStatements(block);
+        if( emits.size() == 1 ) {
+            var first = emits.get(0);
+            var emit = ((ExpressionStatement) first).getExpression();
+            if( emitTarget(emit) == null )
+                return emit.getType();
+        }
         var cn = new ClassNode(Record.class);
-        asBlockStatements(emits).stream()
+        emits.stream()
             .map(stmt -> ((ExpressionStatement) stmt).getExpression())
-            .map(emit -> emitName(emit))
-            .filter(name -> name != null)
-            .forEach((name) -> {
-                var type = ClassHelper.dynamicType();
-                var fn = new FieldNode(name, Modifier.PUBLIC, type, cn, null);
+            .map(emit -> emitTarget(emit))
+            .filter(target -> target != null)
+            .forEach((target) -> {
+                var fn = new FieldNode(target.getName(), Modifier.PUBLIC, target.getType(), cn, null);
                 fn.setDeclaringClass(cn);
                 cn.addField(fn);
             });
         return cn;
     }
 
-    private static String emitName(Expression emit) {
+    private static VariableExpression emitTarget(Expression emit) {
         if( emit instanceof VariableExpression ve ) {
-            return ve.getName();
+            return ve;
         }
-        else if( emit instanceof AssignmentExpression ae ) {
-            var left = (VariableExpression)ae.getLeftExpression();
-            return left.getName();
+        if( emit instanceof AssignmentExpression ae ) {
+            return (VariableExpression)ae.getLeftExpression();
         }
         return null;
     }

modules/nf-lang/src/main/java/nextflow/script/control/ResolveVisitor.java

@@ -150,7 +150,7 @@ private boolean resolveGenericsType(GenericsType genericsType) {
         if( genericsType.isResolved() )
             return true;
         var type = genericsType.getType();
-        resolveOrFail(type, genericsType);
+        resolve(type);
         if( resolveGenericsTypes(type.getGenericsTypes()) )
             genericsType.setResolved(genericsType.getType().isResolved());
         return genericsType.isResolved();

modules/nf-lang/src/main/java/nextflow/script/control/ScriptResolveVisitor.java

@@ -103,20 +103,20 @@ public void visitWorkflow(WorkflowNode node) {
         for( var take : node.getParameters() )
             resolver.resolveOrFail(take.getType(), take);
         resolver.visit(node.main);
-        resolveWorkflowEmits(node.emits);
+        resolveTypedOutputs(node.emits);
         resolver.visit(node.emits);
         resolver.visit(node.publishers);
         resolver.visit(node.onComplete);
         resolver.visit(node.onError);
     }
 
-    private void resolveWorkflowEmits(Statement emits) {
-        for( var stmt : asBlockStatements(emits) ) {
+    private void resolveTypedOutputs(Statement block) {
+        for( var stmt : asBlockStatements(block) ) {
             var stmtX = (ExpressionStatement)stmt;
-            var emit = stmtX.getExpression();
+            var output = stmtX.getExpression();
             var target =
-                emit instanceof AssignmentExpression ae ? ae.getLeftExpression() :
-                emit instanceof VariableExpression ve ? ve :
+                output instanceof AssignmentExpression ae ? ae.getLeftExpression() :
+                output instanceof VariableExpression ve ? ve :
                 null;
 
             if( target instanceof VariableExpression ve )
@@ -130,6 +130,7 @@ public void visitProcessV2(ProcessNodeV2 node) {
             resolver.resolveOrFail(input.getType(), input);
         resolver.visit(node.directives);
         resolver.visit(node.stagers);
+        resolveTypedOutputs(node.outputs);
         resolver.visit(node.outputs);
         resolver.visit(node.topics);
         resolver.visit(node.when);
@@ -159,6 +160,7 @@ public void visitFunction(FunctionNode node) {
 
     @Override
     public void visitOutput(OutputNode node) {
+        resolver.resolveOrFail(node.getType(), node.getType());
         resolver.visit(node.body);
     }
 

modules/nf-lang/src/main/java/nextflow/script/control/ScriptToGroovyVisitor.java

@@ -239,7 +239,7 @@ public void visitOutputs(OutputBlockNode node) {
         var statements = node.declarations.stream()
             .map((output) -> {
                 new PublishDslVisitor().visit(output.body);
-                var name = constX(output.name);
+                var name = constX(output.getName());
                 var body = closureX(null, output.body);
                 return stmt(callThisX("declare", args(name, body)));
             })