I’d really love to see Delphi empowered with GC, preferably like it’s done in the D Programming Language: Managing Object Lifetime in D, with both implicit and explicit lifetime handling.

I wasn’t aware that method references are able to hold method pointers. That fact mitigates this particular problem somewhat and I guess that’ll have to be the topic of my next post.

Method references are the union type; values of a method pointer type can be converted into a method reference type. The reverse isn’t possible because of the GC issue.

The reason VCL events can’t be changed to use method references is backward compatibility; far too much legacy code uses the method-cracking functionality of a cast to TMethod, or rely on method pointers being blittable values that don’t require initialization or finalization, whereas managed types like strings, dynamic arrays, interface references – and method references – do.

Short note on why method references need GC: multiple anonymous methods may be written which capture state from their respective environments, and all stored into locations of a single method reference type. Method references, in other words, are polymorphic, while the implementation of captured state requires storage of variable size.

That combination of features means that the captured state storage needs to be on the heap, as unbounded variable-sized values can’t be polymorphically stored in locations of a single type. That in turn means some kind of lifetime management must occur, so that the heap allocation can safely be retired when all outstanding references to the captured state, via method references, have gone out of scope.

There could be two other implementations of anonymous methods / method references which would obviate this limitation, and possibly permit method references to be stored in method pointers:

1) Prohibit variable capture by anonymous methods. This would limit their usefulness so much as to make them a questionable language addition.

2) Require manual memory management for captured state. However, since one of the raison d’etre’s of anonymous methods is that they permit creation of code, probably capturing locally-scoped state, in one module, and execution (via callback, essentially) from a completely independent module, the lifetime semantics are highly likely to require some kind of negotiation protocol – like, say, reference counts. Rather than develop such a protocol convention, and suggest that everyone follow it, it makes far mores sense if the compiler automates what needs to be done automatically.

So, yes, I’d like to make the VCL use method references by default, but it can’t happen for backward compatibility reasons. And as for a unifying type – method references are the unifying type.