Make typings more specific

[GulgDev]

Hello! Currently, binaryen.d.ts contains definitions that don't allow TypeScript compiler to properly narrow down ExpressionInfo. It would be nice to have more specific typings. I suggest the following changes:

1. Change type of Id exports to match the corresponding enum value.
2. Change the ExpressionInfo interface to a union type with the corresponding ids.

Should I make a PR or is this behaviour intentional?

[chharvey]

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!