Use dependently return type in CallActivity

Author: hasithaa

ballerina/context.bal

@@ -17,15 +17,21 @@
 import ballerina/jballerina.java;
 import ballerina/time;
 
+# Record type for activity parameters.
+# Used to pass arguments to activity functions in a type-safe manner.
+public type Parameters record {|
+    anydata...;
+|};
+
 # Workflow execution context providing workflow APIs.
 # This is a client object that provides access to workflow operations.
 #
 # This client provides:
-# - Activity execution via `callActivity()` remote method
+# - Activity execution via `callActivity` remote method
 # - Durable sleep operations
 # - Workflow state queries (replaying status, workflow ID, workflow type)
 #
-# Use `check ctx.callActivity(myActivity, arg1, arg2)` to execute activities.
+# Use `check ctx->callActivity(myActivity, {"arg1": val1, "arg2": val2})` to execute activities.
 # Use Ballerina's `wait` action with event futures for signal handling.
 public client class Context {
     private handle nativeContext;
@@ -43,17 +49,24 @@ public client class Context {
     # that should only be executed once during workflow execution and not during replay.
     # The workflow runtime ensures exactly-once execution semantics for activities.
     #
+    # The return type is determined by the `T` typedesc parameter, allowing compile-time
+    # type checking when the expected return type is specified. The compiler plugin
+    # validates that the activity function's return type is compatible with `T`.
+    #
     # Example:
     # ```ballerina
-    # string result = check ctx.callActivity(sendEmailActivity, recipientEmail, subject);
+    # string result = check ctx->callActivity(sendEmailActivity, {"email": recipientEmail, "subject": subject});
     # ```
     #
     # + activityFunction - The activity function to execute (must be annotated with @Activity)
-    # + args - Variable arguments to pass to the activity function
-    # + return - The result of the activity execution, or an error if execution fails
-    remote isolated function callActivity(function activityFunction, anydata... args) returns anydata|error {
-        return callActivityNative(self.nativeContext, activityFunction, ...args);
-    }
+    # + args - Record containing the arguments to pass to the activity function
+    # + T - The expected return type (inferred from context or explicitly specified)
+    # + return - The result of the activity execution cast to type T, or an error if execution fails
+    remote isolated function callActivity(function activityFunction, Parameters args, typedesc<anydata> T = <>) 
+            returns T|error = @java:Method {
+        'class: "io.ballerina.stdlib.workflow.context.WorkflowContextNative",
+        name: "callActivity"
+    } external;
 
     # Durable sleep that survives workflow restarts.
     #
@@ -98,15 +111,6 @@ public client class Context {
 
 // Native function declarations
 
-isolated function callActivityNative(
-        handle contextHandle,
-        function activityFunction,
-        anydata... args
-) returns anydata|error = @java:Method {
-    'class: "io.ballerina.stdlib.workflow.context.WorkflowContextNative",
-    name: "callActivity"
-} external;
-
 isolated function sleepNative(
         handle contextHandle,
         int millis

ballerina/functions.bal

@@ -16,19 +16,6 @@
 
 import ballerina/jballerina.java;
 
-# Internal function to execute an activity. 
-# Users should use the callActivity remote method on the Context client instead.
-# 
-# Activities are non-deterministic operations (I/O, database calls, external APIs)
-# that should only be executed once during workflow execution and not during replay.
-# The workflow runtime ensures exactly-once execution semantics for activities.
-#
-# + activityFunction - The activity function to execute (must be annotated with @Activity)
-# + args - Variable arguments to pass to the activity function
-# + return - The result of the activity execution, or an error if execution fails
-isolated function callActivity(function activityFunction, anydata... args) returns anydata|error = @java:Method {
-    'class: "io.ballerina.stdlib.workflow.runtime.nativeimpl.WorkflowNative"
-} external;
 
 # Starts a new workflow process with the given input.
 #

ballerina/tests/test.bal

@@ -52,10 +52,10 @@ function testActivityFunction2(int value) returns int|error {
 // Test process that calls activities using Context client.
 @Process
 function processWithActivities(Context ctx, string input) returns string|error {
-    // Use Context client's callActivity remote method
-    anydata result1 = check ctx->callActivity(testActivityFunction, input);
-    anydata result2 = check ctx->callActivity(testActivityFunction2, 10);
-    return <string>result1 + " - " + (<int>result2).toString();
+    // Use Context client's callActivity remote method with Parameters record
+    string result1 = check ctx->callActivity(testActivityFunction, {"input": input});
+    int result2 = check ctx->callActivity(testActivityFunction2, {"value": 10});
+    return result1 + " - " + result2.toString();
 }
 
 // Note: Removed @test:BeforeEach that cleared registry globally.

compiler-plugin-tests/src/test/java/io/ballerina/stdlib/workflow/compiler/WorkflowCompilerPluginTest.java

@@ -154,6 +154,33 @@ public void testInvalidDirectActivityCall() {
         assertDiagnosticContains(diagnosticResult, WorkflowConstants.WORKFLOW_108);
     }
 
+    @Test(groups = "invalid")
+    public void testInvalidCallActivityMissingParam() {
+        String packagePath = "invalid_call_activity_missing_param";
+        DiagnosticResult diagnosticResult = getValidationDiagnosticResult(packagePath);
+        Assert.assertTrue(diagnosticResult.errorCount() > 0,
+                "Expected validation error for callActivity with missing required parameter");
+        assertDiagnosticContains(diagnosticResult, WorkflowConstants.WORKFLOW_109);
+    }
+
+    @Test(groups = "invalid")
+    public void testInvalidCallActivityExtraParam() {
+        String packagePath = "invalid_call_activity_extra_param";
+        DiagnosticResult diagnosticResult = getValidationDiagnosticResult(packagePath);
+        Assert.assertTrue(diagnosticResult.errorCount() > 0,
+                "Expected validation error for callActivity with extra parameter");
+        assertDiagnosticContains(diagnosticResult, WorkflowConstants.WORKFLOW_110);
+    }
+
+    @Test(groups = "invalid")
+    public void testInvalidCallActivityRestParams() {
+        String packagePath = "invalid_call_activity_rest_params";
+        DiagnosticResult diagnosticResult = getValidationDiagnosticResult(packagePath);
+        Assert.assertTrue(diagnosticResult.errorCount() > 0,
+                "Expected validation error for callActivity with activity having rest parameters");
+        assertDiagnosticContains(diagnosticResult, WorkflowConstants.WORKFLOW_111);
+    }
+
     /**
      * Get diagnostic result for the given package path.
      * Uses runCodeGenAndModifyPlugins() to run the code modifier.

compiler-plugin-tests/src/test/resources/ballerina_sources/invalid_call_activity_extra_param/Ballerina.toml

@@ -0,0 +1,8 @@
+[package]
+org = "test_samples"
+name = "invalid_call_activity_extra_param"
+version = "0.1.0"
+distribution = "2201.13.0"
+
+[build-options]
+observabilityIncluded = true

compiler-plugin-tests/src/test/resources/ballerina_sources/invalid_call_activity_extra_param/main.bal

@@ -0,0 +1,47 @@
+// Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com) All Rights Reserved.
+//
+// WSO2 LLC. licenses this file to you under the Apache License,
+// Version 2.0 (the "License"); you may not use this file except
+// in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import ballerina/workflow;
+
+type OrderInput record {|
+    string orderId;
+    int quantity;
+|};
+
+type OrderResult record {|
+    string status;
+|};
+
+// Activity function with single parameter
+@workflow:Activity
+function processOrder(string orderId) returns boolean|error {
+    return orderId.length() > 0;
+}
+
+// Invalid: Process function calling ctx->callActivity() with extra parameter
+// This should produce WORKFLOW_110 error
+@workflow:Process
+function orderProcess(workflow:Context ctx, OrderInput input) returns OrderResult|error {
+    // ERROR: Extra parameter 'quantity' - not in activity function signature
+    boolean isValid = check ctx->callActivity(processOrder, {"orderId": input.orderId, "quantity": input.quantity});
+    if !isValid {
+        return error("Invalid order");
+    }
+    
+    return {
+        status: "COMPLETED"
+    };
+}

compiler-plugin-tests/src/test/resources/ballerina_sources/invalid_call_activity_missing_param/Ballerina.toml

@@ -0,0 +1,8 @@
+[package]
+org = "test_samples"
+name = "invalid_call_activity_missing_param"
+version = "0.1.0"
+distribution = "2201.13.0"
+
+[build-options]
+observabilityIncluded = true

compiler-plugin-tests/src/test/resources/ballerina_sources/invalid_call_activity_missing_param/main.bal

@@ -0,0 +1,47 @@
+// Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com) All Rights Reserved.
+//
+// WSO2 LLC. licenses this file to you under the Apache License,
+// Version 2.0 (the "License"); you may not use this file except
+// in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+import ballerina/workflow;
+
+type OrderInput record {|
+    string orderId;
+    int quantity;
+|};
+
+type OrderResult record {|
+    string status;
+|};
+
+// Activity function with two required parameters
+@workflow:Activity
+function processOrder(string orderId, int quantity) returns boolean|error {
+    return quantity > 0;
+}
+
+// Invalid: Process function calling ctx->callActivity() with missing required parameter
+// This should produce WORKFLOW_109 error
+@workflow:Process
+function orderProcess(workflow:Context ctx, OrderInput input) returns OrderResult|error {
+    // ERROR: Missing required parameter 'quantity'
+    boolean isValid = check ctx->callActivity(processOrder, {"orderId": input.orderId});
+    if !isValid {
+        return error("Invalid order");
+    }
+    
+    return {
+        status: "COMPLETED"
+    };
+}

compiler-plugin-tests/src/test/resources/ballerina_sources/invalid_call_activity_no_annotation/main.bal

@@ -35,7 +35,7 @@ function regularFunction(OrderInput input) returns boolean|error {
 @workflow:Process
 function orderProcess(workflow:Context ctx, OrderInput input) returns OrderResult|error {
     // ERROR: regularFunction does not have @Activity annotation
-    boolean isValid = check ctx->callActivity(regularFunction, input);
+    boolean isValid = check ctx->callActivity(regularFunction, {"input": input});
     if !isValid {
         return error("Invalid order");
     }

compiler-plugin-tests/src/test/resources/ballerina_sources/invalid_call_activity_rest_params/Ballerina.toml

@@ -0,0 +1,8 @@
+[package]
+org = "test_samples"
+name = "invalid_call_activity_rest_params"
+version = "0.1.0"
+distribution = "2201.13.0"
+
+[build-options]
+observabilityIncluded = true