Zero value for except_ref type?

[aheejin]

The Local Variables section of Semantics in the design repo says

Local variables have value types and are initialized to the appropriate zero value for their type (0 for integers, +0. for floating-point) at the beginning of the function, except parameters which are initialized to the values of the arguments passed to the function.

Because except_ref type can be assigned to locals, we should have a zero value like nullref for except_ref type. Do we have it?

[rossberg]

It's coming with the reference type proposal. However, the long-term idea is that (most) future reference types will not include null (see e.g. the section on function refs), and that we have to find ways to cope with that anyway. It would be natural to not include null in the exception thing either.

[eholk]

A reasonable 0 value for exceptions would be one where if_except always fails to match it.

I like the idea of going along with whatever the reference type proposal comes up with. @rossberg - if there is no null, what are reference variables going to be initialized with?

[rossberg]

The most obvious solution would be that locals of non-defaultable types require an explicit initialiser.

[eholk]

Ah, right. Of course, that means we have to add initializers, but I think that makes sense. I imagine we'll want to add more types in the future where a default value doesn't make sense.

[dschuff]

That just raises the question of "what is a reasonable explicit initializer for an except_ref?" There's currently no way to generate an except_ref value other than catching. So we'd still need an instruction we could put into an initializer.

[eholk]

Ah, good point. So it seems like no matter what we'll want a default value.

Another option is to make sure no variable is read before it's assigned to as part of the Wasm module's validation phase. This is potentially expensive, but I suspect it's easier given that Wasm has only structured control flow. I don't really think this is the best idea though.

If we add a 0 exception, what would rethrowing it mean?

[rossberg]

The simpler alternative is to introduce variable definitions with tighter scope, i.e., something let-like. That avoids both null and complicated initialisation checks.

[eholk]

I think for exceptions, let would land us somewhere similar to the original rethrow problem (#30), since we want a way for exceptions to escape their catch scope. We'd have to write code like:

block $top:
  let e = try:
    ... do stuff ...
    break $top
  catch: 
    ... do other stuff, but leave exception ref on stack so it is used to initialize e ...
  end
  ... do exception handling stuff with e ...
end

[rossberg]

You could also do it the other way around, because a branch out of the catch could take the ref as an arguments.

[aheejin]

We don't have let yet anyway, and we need nullref for except_ref type locals in the current spec. The current reference-types spec has nullref, and can I assume we use that for except_ref type local's initial value?

[rossberg]

Seems fine to allow null into the exception type as a stop-gap measure for now. But I would hope that we have something akin to let in time to restrict this before finalising this proposal. In particular, the same problem comes up with typed function refs, so we'll need a proper solution soon enough.

[aheejin]

Closing this, at least we have nullref in the reference type proposal now.