Simplify js-number interface

[eqrion]

From the overview:

Number (wasm:js-number):

    Type test: test, testI32, testU32
    Create from primitive: fromF64, fromI32, fromU32
    Extract to primitive: toF64, toI32, toU32

How would you feel about reducing this to:

js-number:test: (x: externref) -> i32
  return (typeof x == "number") ? 1 : 0

js-number:cast: (x: externref) -> f64
  if (typeof x !== "number") trap();
  return x;

js-value:from: (x: T) -> externref
  generic over any value type `T`
  equivalent to ToWebAssemblyValue(ToJSValue(x, T), 'externref')

testI32/testU32 could be replicated using test + cast + wasm arithmetic instructions. I think this sequence would be easily optimizable in a compiler for engines using a Smi representation to avoid unnecessary conversions.

fromF64/fromI32/fromU32 are basically just wrappers around ToJSValue, and so I wonder if just exposing that as js-value:from would make sense.

toF64 becomes cast and toI32/ toU32 must cast and then do a further check. Again as with testI32/testU32, I think optimizing compilers for engines using Smi's can make it optimally fast.

[sjrd]

fromF64/fromI32/fromU32 are basically just wrappers around ToJSValue, and so I wonder if just exposing that as js-value:from would make sense.

That's an interesting suggestion. There is currently no precedent for generic JS builtins. Each JS builtin has exactly one valid Wasm function type. In fact, the spec for Builtins does not really leave room for polymorphic builtins. Each builtin has one functype, which is picked up when creating builtin sets. Validation against the Wasm module's import only checks that the function types match.

If we wanted to have polymorphic builtins, we would have to significantly rearrange those steps. Assuming it's even possible to do so without breaking some particular instantiation-time semantics?

testI32/testU32 could be replicated using test + cast + wasm arithmetic instructions. I think this sequence would be easily optimizable in a compiler for engines using a Smi representation to avoid unnecessary conversions.

Is that actually realistic? The required Wasm sequence is not trivial. For example, for testI32, it would be something like

local.get $x ;; the externref we want to test
call $numberTest
if
  local.get $x ;; must be the same argument passed to $numberTest above
  call $numberCast
  local.tee $y ;; a fresh f64 that must not be used anywhere else
  i32.trunc_sat_f64_s
  f64.convert_i32_s
  i64.reinterpret_f64
  local.get $y
  i64.reinterpret_f64
  i64.eq ;; use an i64.eq test to reject -0.0
else
  i32.const 0
end

And that's one reasonable sequence for that test, but there can be others.

It seems to me that the 4 specialized builtins are a lesser effort, and more reliable, than identifying those sequences.