RFC: reference counted Throwable

[Walter Bright via Digitalmars-d]

On 9/19/2014 8:32 AM, Andrei Alexandrescu wrote:
> As discussed, having exception objects being GC-allocated is clearly a large
> liability that we need to address. They prevent otherwise careful functions from
> being @nogc so they affect even apps that otherwise would be okay with a little
> litter here and there.
>
> The Throwable hierarchy is somewhat separate from everything else, which makes
> it a great starting point for investigating an automated reference count
> approach. Here's what I'm thinking.
>
> First, there must be some compiler flag -nogc or something, which triggers the
> RC exceptions. All modules of an application must be compiled with this flag if
> it is to work (such that one module can throw an exception caught by the other).
> Of course a lot of refinement needs to be added here (what happens if one tries
> to link modules built with and without -nogc, allowing people to detect the flag
> programmatically by using version(nogc) etc).

Having a compiler switch to change the behavior of every module in incompatible 
ways would be a disastrous balkanization. It has to be done in such a way that 
the ARC and the existing exceptions can coexist.


> If -nogc is passed, the compiler severs the inheritance relationship between
> Throwable and Object, making it impossible to convert a Throwable to an Object.
>  From then henceforth, Throwable and Object form a two-rooted forest. (In all
> likelihood we'll later add an RCObject root that Throwable inherits.)
>
> Whenever a reference to a Throwable is copied about, passed to functions, the
> compiler inserts appropriately calls to e.g. incRef and decRef. (Compiler may
> assume they cancel each other for optimization purposes.) Implementation of
> these is up to the runtime library. Null checking may be left to either the
> compiler or the library (in the latter case, the functions must be nonmember).
> However it seems the compiler may have an advantage because it can elide some of
> these checks.
>
> Once we get this going, we should accumulate good experience that we can later
> apply to generalizing this approach to more objects. Also, if things go well we
> may as well define _always_ (whether GC or not) Throwable to be reference
> counted; seems like a good fit for all programs.
>
> Please chime in with thoughts.
>
>
> Andrei