bugc: compile a void function call as a statement

irgen converted a call's type to an IR type before it checked for a
void function, whose call type is the type checker's "void function"
failure, so fromBugType threw. Check first and convert only a call
with a result.

Author: gnidan

packages/bugc/CHANGELOG.md

@@ -72,6 +72,10 @@ support. Changes to the specification itself are tracked in the root
 
 ### Fixed
 
+- A call to a function with no return type now compiles as a statement,
+  as in `bump();`, at every optimization level. The function's `return`
+  context has no `data`. Before, IR generation failed with "Cannot convert
+  type with kind fail to IR type" ([#PR]).
 - At optimization levels 2 and 3, an inlined function that starts with an
   inlined call, or returns one's result, now has its own `invoke` and
   `return` contexts, around the inner call's. Before, its `invoke` (or its
@@ -277,3 +281,4 @@ First publication.
 [#345]: https://github.com/ethdebug/format/pull/345
 [#347]: https://github.com/ethdebug/format/pull/347
 [#349]: https://github.com/ethdebug/format/pull/349
+[#PR]: https://github.com/ethdebug/format/pull/PR

packages/bugc/src/evmgen/behavioral.test.ts

@@ -429,6 +429,59 @@ code {
       }
     }
 
+    // A function with no return type, called as a statement. `n` (7)
+    // keeps the calls from folding; `out` records the effects.
+    const voidCalls = {
+      "a void call": [`function bump() { out = out + n; };`, `bump();`, 7n],
+      "a void call with arguments and an early return": [
+        `function put(x: uint256, y: uint256) {
+    if (x > y) { out = x; return; }
+    out = y;
+  };`,
+        `put(n, 3); out = out * 10; put(1, out);`,
+        70n,
+      ],
+      "void calls in a loop": [
+        `function bump() { out = out + n; };`,
+        `for (let i = 0; i < 3; i = i + 1) { bump(); }`,
+        21n,
+      ],
+      "a void call from a void function": [
+        `function bump() { out = out + n; };
+  function twice() { bump(); bump(); };`,
+        `twice();`,
+        14n,
+      ],
+      "a local across a void call": [
+        `function bump() { out = out + n; };`,
+        `let y = n + 1; bump(); out = out + y;`,
+        15n,
+      ],
+    } as const;
+
+    for (const [name, [define, body, expected]] of Object.entries(voidCalls)) {
+      for (const level of [0, 1, 2, 3] as const) {
+        it(`should make ${name} (level ${level})`, async () => {
+          const source = `name VoidCalls;
+define {
+  ${define}
+}
+storage { [0] n: uint256; [1] out: uint256; }
+create { n = 7; }
+code {
+  ${body}
+}`;
+          const result = await executeProgram(source, {
+            calldata: "",
+            optimizationLevel: level,
+          });
+
+          expect(result.callSuccess).toBe(true);
+          expect(await result.getStorage(1n)).toBe(expected);
+        });
+      }
+    }
+
     // Each parameter gets a distinct weight, so a misordered argument
     // changes the result. `n` (7) keeps the arguments from folding.
     for (const count of [6, 7, 8] as const) {

packages/bugc/src/evmgen/call-contexts.test.ts

@@ -259,6 +259,38 @@ code {
         expect(ret.data).toBeDefined();
       },
     );
+
+    it(
+      "should emit invoke and data-free return contexts " +
+        "for a void function called as a statement",
+      async () => {
+        const program = await compileProgram(`name VoidStatement;
+define {
+  function bump() { count = count + 1; };
+}
+storage { [0] count: uint256; }
+create { count = 0; }
+code { bump(); }`);
+
+        const invokeJumps = findInstructionsWithContext(
+          program,
+          "JUMP",
+          Context.isInvoke,
+        );
+        expect(invokeJumps).toHaveLength(1);
+        expect(invokeJumps[0].context.invoke.identifier).toBe("bump");
+
+        const returnJumps = findInstructionsWithContext(
+          program,
+          "JUMP",
+          Context.isReturn,
+        );
+        expect(returnJumps).toHaveLength(1);
+        const { return: ret } = returnJumps[0].context;
+        expect(ret.identifier).toBe("bump");
+        expect(ret.data).toBeUndefined();
+      },
+    );
   });
 
   describe("nested function calls", () => {

packages/bugc/src/evmgen/call-timing.test.ts

@@ -55,6 +55,19 @@ create { r = 0; }
 code { r = fact(4); }`,
     returns: [1n, 2n, 6n, 24n],
   },
+  {
+    name: "void calls",
+    source: `name Void;
+define {
+  function bump() { r = r + 1; };
+  function twice() { bump(); bump(); };
+}
+storage { [0] r: uint256; }
+create { r = 0; }
+code { twice(); }`,
+    // A void exit has no data to read
+    returns: [undefined, undefined, undefined],
+  },
 ];
 
 /** A context's invoke and return leaves, outside inlined bodies */
@@ -102,7 +115,7 @@ describe("call frame timing", () => {
         // JUMP and the callee's JUMPDEST both carry the invoke, on
         // consecutive steps: count it once.
         const frames: { name: string; step: number }[] = [];
-        const read: bigint[] = [];
+        const read: (bigint | undefined)[] = [];
         let calls = 0;
         for (let i = 0; i < steps.length; i++) {
           if (i > 0) {
@@ -122,6 +135,8 @@ describe("call frame timing", () => {
                 const cursor = await dereference(ret.data.pointer, { state });
                 const view = await cursor.view(state);
                 read.push((await view.read(view.regions[0])).asUint());
+              } else {
+                read.push(undefined);
               }
             } else if (invoke !== undefined) {
               const top = frames[frames.length - 1];

packages/bugc/src/evmgen/debug/local-variables.soundness.test.ts

@@ -753,6 +753,28 @@ code {
       k: { values: [7n] },
     },
   },
+  {
+    name: "a void call",
+    source: `name VoidCall;
+define {
+  function put(a: uint256) {
+    let b = a * 3;
+    r = b;
+  };
+}
+storage { [0] r: uint256; [1] s: uint256; }
+create { s = 5; }
+code {
+  let m = s + 1;
+  put(m);
+  s = m + r;
+}`,
+    locals: {
+      a: { values: [6n] },
+      b: { values: [18n] },
+      m: { values: [6n] },
+    },
+  },
   {
     name: "one-armed if in a function",
     source: `name PickFn;

packages/bugc/src/irgen/generate/expressions/call.ts

@@ -81,19 +81,13 @@ export const makeBuildCall = (
         argValues.push(yield* buildExpression(arg, { kind: "rvalue" }));
       }
 
-      // Generate call terminator and split block
-      const irType = fromBugType(callType);
-      let dest: string | undefined;
-
-      // Only create a destination if the function returns a value
-      // Check if it's a void function by checking if the type is a failure with "void function" message
+      // A void function's call has the type checker's "void
+      // function" failure as its type, which has no IR type: only a
+      // call with a result gets a destination
       const isVoidFunction =
-        Type.isFailure(callType) &&
-        (callType as Type.Failure).reason === "void function";
-
-      if (!isVoidFunction) {
-        dest = yield* Process.Variables.newTemp();
-      }
+        Type.isFailure(callType) && callType.reason === "void function";
+      const irType = isVoidFunction ? undefined : fromBugType(callType);
+      const dest = irType ? yield* Process.Variables.newTemp() : undefined;
 
       // Create a continuation block for after the call
       const continuationBlockId = yield* Process.Blocks.create("call_cont");
@@ -112,7 +106,7 @@ export const makeBuildCall = (
       yield* Process.Blocks.switchTo(continuationBlockId);
 
       // Return the result value or a dummy value for void functions
-      if (dest) {
+      if (dest && irType) {
         return Ir.Value.temp(dest, irType);
       }
       // Void function - return a dummy value