Make typings more specific #100

Activity

1. chharvey commented on Oct 2, 2025

   

   chharvey

   on Oct 2, 2025

   Contributor

   More actions

   I agree with this so hard I was about to start my own PR to implement it. But a community effort would be great!

   It would solve problems like this:

   import binaryen from 'binaryen';
   
   declare const mod: binaryen.Module;
   
   const a: ExpressionRef = mod.i32.const(3);
   const b: ExpressionRef = mod.i32.const(4);
   
   const a_squared: ExpressionRef = mod.i32.mul(a, a);
   const b_squared: ExpressionRef = mod.i32.mul(b, b);
   
   const sum: ExpressionRef = mod.i64.add(a_squared, b_squared);
   //                                     ^ should be a TypeError: i32 not assignable to i64

   Currently, everything is just type number, so TypeScript doesn’t see a problem with the code above. This compiles, but returns an invalid WASM module at runtime.

   What we want is a “nominal” type system, where types are only assignable by name rather than by their shape — we want some numbers to not be assignable to others. TypeScript can’t do that, but we can fake it using type intersections. This example can be fixed by redefining ExpressionRef as a generic type returning an intersection with an ad hoc object type.

   type BinaryenType = "none" | "i32" | "i64" | "f32" | "f64" | ...;
   type ExpressionRef<T extends BinaryenType> = number & {_: T};

   Then the code is updated:

   import binaryen from 'binaryen';
   
   declare const mod: binaryen.Module;
   
   const TEST_TYPE_ERROR: ExpressionRef<"i64"> = mod.i32.const(1);
   //    ^ TypeError: mod.i32.const returns ExpressionRef<"i32">,
   //      which is not assignable to ExpressionRef<"i64">:
   //      {_: "i32"} is not assignable to {_: "i64"}.
   //      Test passes.
   
   const a: ExpressionRef<"i32"> = mod.i32.const(3);
   const b: ExpressionRef<"i32"> = mod.i32.const(4);
   
   const a_squared: ExpressionRef<"i32"> = mod.i32.mul(a, a);
   const b_squared: ExpressionRef<"i32"> = mod.i32.mul(b, b);
   
   const sum: ExpressionRef<"i64"> = mod.i64.add(a_squared, b_squared);
   //                                            ^ TypeError: mod.i64.add only takes ExpressionRef<"i64"> arguments
   
   const sum: ExpressionRef<"i64"> = mod.i32.add(a_squared, b_squared);
   //    ^ TypeError: mod.i32.add returns ExpressionRef<"i32">
   
   const sum: ExpressionRef<"i32"> = mod.i32.add(a_squared, b_squared); // fixed!