the most intense debugging journey of my whole career

Author: dimitropoulos

packages/conformance-tests/from-wat/memory-grow.dump

@@ -0,0 +1,114 @@
+Module {
+    span: Span {
+        offset: 1,
+    },
+    id: None,
+    name: None,
+    kind: Text(
+        [
+            Memory(
+                Memory {
+                    span: Span {
+                        offset: 11,
+                    },
+                    id: Some(
+                        "memory",
+                    ),
+                    name: None,
+                    exports: InlineExport {
+                        names: [
+                            "memory",
+                        ],
+                    },
+                    kind: Normal(
+                        B32 {
+                            limits: Limits {
+                                min: 42,
+                                max: None,
+                            },
+                            shared: false,
+                        },
+                    ),
+                },
+            ),
+            Func(
+                Func {
+                    span: Span {
+                        offset: 52,
+                    },
+                    id: Some(
+                        "entry",
+                    ),
+                    name: None,
+                    exports: InlineExport {
+                        names: [
+                            "entry",
+                        ],
+                    },
+                    kind: Inline {
+                        locals: [],
+                        expression: Expression {
+                            instrs: [
+                                MemorySize(
+                                    MemoryArg {
+                                        mem: Num(
+                                            0,
+                                            Span {
+                                                offset: 117,
+                                            },
+                                        ),
+                                    },
+                                ),
+                                I32Const(
+                                    27,
+                                ),
+                                MemoryGrow(
+                                    MemoryArg {
+                                        mem: Num(
+                                            0,
+                                            Span {
+                                                offset: 205,
+                                            },
+                                        ),
+                                    },
+                                ),
+                                MemorySize(
+                                    MemoryArg {
+                                        mem: Num(
+                                            0,
+                                            Span {
+                                                offset: 258,
+                                            },
+                                        ),
+                                    },
+                                ),
+                            ],
+                        },
+                    },
+                    ty: TypeUse {
+                        index: None,
+                        inline: Some(
+                            FunctionType {
+                                params: [],
+                                results: [
+                                    I32,
+                                    I32,
+                                    I32,
+                                ],
+                            },
+                        ),
+                    },
+                },
+            ),
+        ],
+    ),
+}
+
+
+
+
+{
+    "MemorySize": 2,
+    "I32Const": 1,
+    "MemoryGrow": 1,
+}

packages/conformance-tests/from-wat/memory-grow.test.ts

@@ -0,0 +1,18 @@
+import type { Expect, Equal } from 'type-testing';
+import type { entry } from "./memory-grow"
+
+import { getWasm } from '../utils'
+import { expect, test } from 'vitest';
+
+const name = 'memory-grow';
+test(name, async () => {
+  const entry = await getWasm("from-wat", name);
+  expect(entry()).toStrictEqual([42, 42, 69]);
+});
+
+type result = entry<[]>;
+//   ^?
+
+type testCases = [
+  Expect<Equal<result, [42, 42, 69]>>,
+]

packages/conformance-tests/from-wat/memory-grow.ts

@@ -0,0 +1,36 @@
+import type { Func, bootstrap } from 'wasm-to-typescript-types'
+
+type $entry = Satisfies<Func, {
+  kind: 'func';
+  params: [];
+  paramsTypes: [];
+  resultTypes: ['i32', 'i32', 'i32'];
+  locals: [];
+  instructions: [
+    { kind: 'MemorySize' },
+    { kind: 'Const'; value: '00000000000000000000000000011011' },
+    { kind: 'MemoryGrow' },
+    { kind: 'MemorySize' },
+  ];
+}>
+
+export type funcs = {
+  $entry: $entry;
+}
+
+export type entry<
+  arguments extends [],
+  debugMode extends boolean = false,
+  stopAt extends number = number,
+> = bootstrap<
+  {
+    arguments: arguments;
+    funcs: funcs;
+    globals: {};
+    memory: {};
+    memorySize: '00000000000000000000000000101010';
+    indirect: {};
+  },
+  debugMode,
+  stopAt
+>

packages/conformance-tests/from-wat/memory-grow.wasm

@@ -0,0 +1,10 @@
+(module
+  (memory $memory (export "memory") 42)
+
+  (func $entry (export "entry") (result i32 i32 i32)
+    memory.size  ;; pushes 42 to the stack
+    i32.const 27 ;; we will grow by 27 pages
+    memory.grow  ;; grows and pushes 69 to the stack
+    memory.size  ;; pushes 69 to the stack
+  )
+)

packages/conformance-tests/from-wat/memory-grow.wat

@@ -81,7 +81,21 @@ export type MemoryGrow<
   instruction extends IMemoryGrow, // unused
   state extends ProgramState
 > = Satisfies<ProgramState,
-  state // noop
+  state['stack'] extends [
+    ...infer remaining extends WasmValue[],
+    infer growBy extends WasmValue
+  ]
+  ? State.Stack.set<
+      [
+        ...remaining,
+        state['memorySize']
+      ],
+      State.Memory.grow<
+        state,
+        growBy
+      >
+    >
+  : State.error<"stack exhausted", instruction, state>
 >
 
 export type Load<

packages/wasm-to-typescript-types/instructions/memory.ts

@@ -492,6 +492,31 @@ export namespace State {
       }
       // >
     >
+
+    export type grow<
+      state extends ProgramState,
+      growBy extends WasmValue,
+    > = Satisfies<ProgramState,
+      {
+        count: state['count']; 
+        stack: state['stack'];
+        activeFuncId: state['activeFuncId'];
+        activeStackDepth: state['activeStackDepth'];
+        activeLocals: state['activeLocals'];
+        instructions: state['instructions'];
+        activeBranches: state['activeBranches'];
+        L1Cache: state['L1Cache'];
+        memory: state['memory'];
+        executionContexts: state['executionContexts'];
+        funcs: state['funcs'];
+        garbageCollection: state['garbageCollection'];
+        globals: state['globals'];
+        memorySize: I32AddBinary<state['memorySize'], growBy>; // increment
+        indirect: state['indirect'];
+        results: state['results'];
+        callHistory: state['callHistory'];
+      }
+    >
   }
 
   export namespace GarbageCollection {