Report type checking errors for unsupported/legacy patterns

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

Author: bentsherman

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

@@ -226,6 +226,8 @@ private static ClassNode asDataflowType(ClassNode type, ClassNode sourceType) {
     public void visitProcessV2(ProcessNodeV2 node) {
         visitProcessDirectives(node.directives);
         visit(node.stagers);
+        if( !(node.when instanceof EmptyExpression) )
+            addError("Process `when` section is not supported with static typing -- use conditinal logic in the calling workflow instead", node.when);
         visit(node.when);
         visit(node.exec);
         visit(node.stub);
@@ -539,7 +541,7 @@ private void checkOperatorCall(MethodCallExpression node) {
 
         var method = (MethodNode) node.getNodeMetaData(ASTNodeMarker.METHOD_TARGET);
         if( findAnnotation(method, Deprecated.class).isPresent() )
-            addSoftError("Operator `" + method.getName() + "` is discouraged from use with static typing", node);
+            addSoftError("Operator `" + method.getName() + "` is discouraged from use with static typing", node.getMethod());
 
         var lhsType = elementType(receiverType);
         var arguments = asMethodCallArguments(node);
@@ -1199,6 +1201,12 @@ private boolean checkRecordCast(ClassNode targetType, ClassNode sourceType, ASTN
     public void visitPropertyExpression(PropertyExpression node) {
         super.visitPropertyExpression(node);
 
+        var mn = asMethodOutput(node);
+        if( mn instanceof ProcessNode || mn instanceof WorkflowNode ) {
+            addError("Using the `.out` property to access process/workflow outputs is not supported with static typing -- assign the output to a variable instead", node);
+            return;
+        }
+
         var receiver = node.getObjectExpression();
         var receiverType = getType(receiver);
         if( ClassHelper.isDynamicTyped(receiverType) )
@@ -1217,15 +1225,8 @@ public void visitPropertyExpression(PropertyExpression node) {
             return;
         }
 
-        var mn = asMethodNamedOutput(node);
         var property = node.getPropertyAsString();
-        if( mn instanceof ProcessNode pn ) {
-            addError("Unrecognized output `" + property + "` for process `" + pn.getName() + "`", node);
-        }
-        else if( mn instanceof WorkflowNode wn ) {
-            addError("Unrecognized output `" + property + "` for workflow `" + wn.getName() + "`", node);
-        }
-        else if( TypesEx.isEqual(receiverType, PARAMS_TYPE) ) {
+        if( TypesEx.isEqual(receiverType, PARAMS_TYPE) ) {
             if( hasParamsBlock )
                 addError("Unrecognized parameter `" + property + "`", node);
         }
@@ -1274,12 +1275,6 @@ private void checkSpreadProperty(PropertyExpression node) {
         }
     }
 
-    private static MethodNode asMethodNamedOutput(PropertyExpression node) {
-        if( node.getObjectExpression() instanceof PropertyExpression pe )
-            return asMethodOutput(pe);
-        return null;
-    }
-
     public void addWarning(String message, String tokenText, ASTNode node) {
         var token = new Token(0, tokenText, node.getLineNumber(), node.getColumnNumber()); // ASTNode to CSTNode
         sourceUnit.getErrorCollector().addWarning(WarningMessage.POSSIBLE_ERRORS, message, token, sourceUnit);

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

@@ -472,6 +472,7 @@ public static MethodNode asDummyMethod(ClassNode receiverType, MethodNode method
             ClassNode.EMPTY_ARRAY,
             method.getCode() );
         result.setDeclaringClass(receiverType != null ? receiverType : method.getDeclaringClass());
+        result.addAnnotations(method.getAnnotations());
         return result;
     }
 

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

@@ -924,6 +924,29 @@ class TypeCheckingTest extends Specification {
         TypesEx.getName(type) == 'Value<Record {\n    target: String\n    message: String\n}>'
     }
 
+    def 'should report error for process .out property' () {
+        expect:
+        check(
+            '''
+            nextflow.preview.types = true
+
+            process hello {
+                output:
+                stdout()
+
+                script:
+                ''
+            }
+
+            workflow {
+                hello()
+                hello.out
+            }
+            ''',
+            'Using the `.out` property to access process/workflow outputs is not supported with static typing -- assign the output to a variable instead'
+        )
+    }
+
     def 'should resolve record type' () {
         when:
         def exp = parseExpression(