Split 'return_task' function (#3914)

Author: InsertCreativityHere

tools/slicec-cs/src/generators/dispatch_generator.rs

@@ -312,7 +312,7 @@ request.DecodeArgsAsync(
 fn operation_declaration(operation: &Operation) -> CodeBlock {
     let mut builder = FunctionBuilder::new(
         "public",
-        &operation.return_task(true),
+        &operation.dispatch_return_task(),
         &operation.escape_identifier_with_suffix("Async"),
         FunctionType::Declaration,
     );

tools/slicec-cs/src/generators/proxy_generator.rs

@@ -275,7 +275,7 @@ fn proxy_operation_impl(operation: &Operation) -> CodeBlock {
     let namespace = &operation.namespace();
     let operation_name = operation.escape_identifier();
     let async_operation_name = operation.escape_identifier_with_suffix("Async");
-    let return_task = operation.return_task(false);
+    let return_task = operation.invocation_return_task("Task");
 
     let parameters = operation.non_streamed_parameters();
 
@@ -393,7 +393,7 @@ if ({features_parameter}?.Get<IceRpc.Features.ICompressFeature>() is null)
 
 fn proxy_base_operation_impl(operation: &Operation, namespace: &str) -> CodeBlock {
     let async_name = operation.escape_identifier_with_suffix("Async");
-    let return_task = operation.return_task(false);
+    let return_task = operation.invocation_return_task("Task");
     let mut operation_params = operation
         .parameters()
         .iter()
@@ -427,7 +427,7 @@ fn proxy_interface_operations(interface_def: &Interface) -> CodeBlock {
     for operation in operations {
         let mut builder = FunctionBuilder::new(
             "",
-            &operation.return_task(false),
+            &operation.invocation_return_task("Task"),
             &operation.escape_identifier_with_suffix("Async"),
             FunctionType::Declaration,
         );
@@ -517,8 +517,6 @@ fn request_class(interface_def: &Interface) -> CodeBlock {
 }
 
 fn response_class(interface_def: &Interface) -> CodeBlock {
-    let namespace = &interface_def.namespace();
-
     let mut operations = interface_def.operations();
     operations.retain(|o| {
         // We need to generate a method to decode the responses of any operations with return members or any Slice1
@@ -541,30 +539,19 @@ fn response_class(interface_def: &Interface) -> CodeBlock {
     ).add_generated_remark("static class", interface_def);
 
     for operation in operations {
-        let members = operation.return_members();
-
         let function_type = if operation.streamed_return_member().is_some() || operation.encoding == Encoding::Slice1 {
             FunctionType::BlockBody
         } else {
             FunctionType::ExpressionBody
         };
 
-        let return_type = if members.is_empty() {
-            "global::System.Threading.Tasks.ValueTask".to_owned()
-        } else {
-            format!(
-                "global::System.Threading.Tasks.ValueTask<{}>",
-                members.to_tuple_type(namespace, TypeContext::IncomingParam),
-            )
-        };
-
         let mut builder = FunctionBuilder::new(
             if function_type == FunctionType::ExpressionBody {
                 "public static"
             } else {
                 "public static async"
             },
-            &return_type,
+            &operation.invocation_return_task("ValueTask"),
             &operation.escape_identifier_with_prefix_and_suffix("Decode", "Async"),
             function_type,
         );

tools/slicec-cs/src/slicec_ext/operation_ext.rs

@@ -3,14 +3,14 @@
 use super::{EntityExt, MemberExt, ParameterExt, ParameterSliceExt};
 use crate::code_gen_util::TypeContext;
 use crate::cs_attributes::CsEncodedReturn;
-use slicec::grammar::{AttributeFunctions, Contained, Operation};
+use slicec::grammar::{AttributeFunctions, Operation};
 
 pub trait OperationExt {
     /// Returns the format that classes should be encoded with.
     fn get_class_format(&self, is_dispatch: bool) -> &str;
 
-    /// The operation return task.
-    fn return_task(&self, is_dispatch: bool) -> String;
+    fn invocation_return_task(&self, task_type: &str) -> String;
+    fn dispatch_return_task(&self) -> String;
 }
 
 impl OperationExt for Operation {
@@ -25,50 +25,35 @@ impl OperationExt for Operation {
         }
     }
 
-    fn return_task(&self, is_dispatch: bool) -> String {
+    fn invocation_return_task(&self, task_type: &str) -> String {
+        let namespace = &self.namespace();
+        let return_type = match self.return_members().as_slice() {
+            [] => "".to_owned(),
+            members => format!("<{}>", members.to_tuple_type(namespace, TypeContext::IncomingParam)),
+        };
+        format!("global::System.Threading.Tasks.{task_type}{return_type}")
+    }
+
+    fn dispatch_return_task(&self) -> String {
         let return_members = self.return_members();
         if return_members.is_empty() {
-            if is_dispatch {
-                "global::System.Threading.Tasks.ValueTask".to_owned()
-            } else {
-                "global::System.Threading.Tasks.Task".to_owned()
-            }
+            "global::System.Threading.Tasks.ValueTask".to_owned()
         } else {
-            let return_type = operation_return_type(
-                self,
-                is_dispatch,
-                if is_dispatch {
-                    TypeContext::OutgoingParam
+            let namespace = self.namespace();
+            let return_type = if self.has_attribute::<CsEncodedReturn>() {
+                if let Some(stream_member) = self.streamed_return_member() {
+                    format!(
+                        "(global::System.IO.Pipelines.PipeReader Payload, {} {})",
+                        stream_member.cs_type_string(&namespace, TypeContext::OutgoingParam),
+                        stream_member.field_name(),
+                    )
                 } else {
-                    TypeContext::IncomingParam
-                },
-            );
-            if is_dispatch {
-                format!("global::System.Threading.Tasks.ValueTask<{return_type}>")
+                    "global::System.IO.Pipelines.PipeReader".to_owned()
+                }
             } else {
-                format!("global::System.Threading.Tasks.Task<{return_type}>")
-            }
-        }
-    }
-}
-
-fn operation_return_type(operation: &Operation, is_dispatch: bool, context: TypeContext) -> String {
-    let namespace = operation.parent().namespace();
-    if is_dispatch && operation.has_attribute::<CsEncodedReturn>() {
-        if let Some(stream_member) = operation.streamed_return_member() {
-            format!(
-                "(global::System.IO.Pipelines.PipeReader Payload, {} {})",
-                stream_member.cs_type_string(&namespace, context),
-                stream_member.field_name(),
-            )
-        } else {
-            "global::System.IO.Pipelines.PipeReader".to_owned()
-        }
-    } else {
-        match operation.return_members().as_slice() {
-            [] => "void".to_owned(),
-            [member] => member.cs_type_string(&namespace, context),
-            members => members.to_tuple_type(&namespace, context),
+                return_members.to_tuple_type(&namespace, TypeContext::OutgoingParam)
+            };
+            format!("global::System.Threading.Tasks.ValueTask<{return_type}>")
         }
     }
 }