Fixed inconsistent use of parentheses for outputs

Author: fegge

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "masm-decompiler"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -887,6 +887,8 @@ impl CodeDisplay for Stmt {
                     .join(", ");
                 if outs.is_empty() {
                     f.write_line(&format!("{}();", function_name("adv_load")));
+                } else if outputs.len() > 1 {
+                    f.write_line(&format!("({outs}) = {}();", function_name("adv_load")));
                 } else {
                     f.write_line(&format!("{outs} = {}();", function_name("adv_load")));
                 }
@@ -970,6 +972,8 @@ impl CodeDisplay for Stmt {
                     .join(", ");
                 if outs.is_empty() {
                     f.write_line(&format!("{}({args});", function_name("dyncall")));
+                } else if results.len() > 1 {
+                    f.write_line(&format!("({outs}) = {}({args});", function_name("dyncall")));
                 } else {
                     f.write_line(&format!("{outs} = {}({args});", function_name("dyncall")));
                 }
@@ -1006,6 +1010,8 @@ impl CodeDisplay for Stmt {
                 }
                 if outs.is_empty() {
                     f.write_line(&format!("{}({args});", function_name(name)));
+                } else if results.len() > 1 {
+                    f.write_line(&format!("({outs}) = {}({args});", function_name(name)));
                 } else {
                     f.write_line(&format!("{outs} = {}({args});", function_name(name)));
                 }
@@ -1292,6 +1298,8 @@ fn write_call_like(kind: &str, call: &Call, f: &mut CodeWriter) {
     let head = format!("{} {}", keyword(kind), function_name(&call.target));
     if outs.is_empty() {
         f.write_line(&format!("{head}({args});"));
+    } else if call.results.len() > 1 {
+        f.write_line(&format!("({outs}) = {head}({args});"));
     } else {
         f.write_line(&format!("{outs} = {head}({args});"));
     }

src/fmt/mod.rs

@@ -214,3 +214,23 @@ proc uses_adv_pipe
     push.0
     adv_pipe
 end
+
+#! Helper that returns two values.
+proc helper_two_outputs
+    push.1.2
+end
+
+#! Calls a helper that returns two values.
+proc uses_exec_multi_output
+    exec.helper_two_outputs
+end
+
+#! Helper that returns one value.
+proc helper_one_output
+    push.42
+end
+
+#! Calls a helper that returns one value.
+proc uses_exec_single_output
+    exec.helper_one_output
+end

tests/fixtures/word_mem_stack_ops.masm

@@ -204,3 +204,49 @@ fn formats_mem_stream_and_adv_pipe_intrinsics() {
     let adv_pipe_fmt = format_proc(source, "uses_adv_pipe");
     assert!(adv_pipe_fmt.contains("adv_pipe("), "{adv_pipe_fmt}");
 }
+
+#[test]
+fn parenthesizes_multi_output_intrinsics() {
+    let source = include_str!("fixtures/word_mem_stack_ops.masm");
+
+    // u32widening_add returns 2 values — outputs must be parenthesized.
+    let widening_fmt = format_proc(source, "uses_u32widening_add");
+    assert!(
+        widening_fmt.contains(") = u32widening_add("),
+        "multi-output intrinsic should parenthesize LHS: {widening_fmt}"
+    );
+
+    // u32wrapping_add3 returns 1 value — output must NOT be parenthesized.
+    let wrapping_fmt = format_proc(source, "uses_u32wrapping_add3");
+    assert!(
+        !wrapping_fmt.contains("(") || !wrapping_fmt.contains(") = u32wrapping_add3("),
+        "single-output intrinsic should not parenthesize LHS: {wrapping_fmt}"
+    );
+
+    // mem_stream returns 13 values — outputs must be parenthesized.
+    let mem_stream_fmt = format_proc(source, "uses_mem_stream");
+    assert!(
+        mem_stream_fmt.contains(") = mem_stream("),
+        "multi-output intrinsic should parenthesize LHS: {mem_stream_fmt}"
+    );
+}
+
+#[test]
+fn parenthesizes_multi_output_calls() {
+    let source = include_str!("fixtures/word_mem_stack_ops.masm");
+
+    // exec returning 2 values — outputs must be parenthesized.
+    let multi_fmt = format_proc(source, "uses_exec_multi_output");
+    assert!(
+        multi_fmt.contains(") = exec helper_two_outputs("),
+        "multi-output call should parenthesize LHS: {multi_fmt}"
+    );
+
+    // exec returning 1 value — output must NOT be parenthesized.
+    let single_fmt = format_proc(source, "uses_exec_single_output");
+    assert!(
+        single_fmt.contains(" = exec helper_one_output(")
+            && !single_fmt.contains(") = exec helper_one_output("),
+        "single-output call should not parenthesize LHS: {single_fmt}"
+    );
+}