Function that does not return normally II (the return)

In a previous entry, i've written about declaring a method
that doesn't return normally using null,
the type of null, as return type.
A comment from Neal Gafter make me realize that i was wrong
but i now think the closure spec is wrong too.

What the closure proposal says is that a function that doesn't
return normally should use null.
Not the converse, so i agree with neal that a method that usenull as return type doesn't allow the compiler to
flag the method as "never returned", perhaps the method
always returns null.

But the closure proposal is wrong too,
if a function that never returns is typed null
its function type can't be a subtype of
the type of a function that returns a primitive type.

So the example below will not compile :

null(void) f={ throw RuntimeException(); }; int(void) g=f;

The assumption of the closure proposal is that a function that
never return has a return type that is a subtype of null.
This is clearly wrong with the current Java type system
because boxing relations are not subtyping relations.

I propose to introduce throws as
the return type of a method that never returns,
with the following subtyping rules :

Object < Integer < null < throws andint < throws

Using throws as several avantages upon null for method that doesn't return normally because :

a function that returns throws is a subtype of
a function that returns a primitive type.

users can declare methods that doesn't return normally
and the compiler can understand that.