Sometimes the way how anonymous methods work is just annoying...

Sometimes the way how anonymous methods work is just annoying...

type
ITest = interface
procedure Subscribe(const proc: TProc);
end;

TTest = class(TInterfacedObject, ITest)
private
fProc: TProc;
public
procedure Subscribe(const proc: TProc);
end;

procedure TTest.Subscribe(const proc: TProc);
begin
fProc := proc;
end;

procedure Main;
var
t: ITest;
p: TProc;
begin
t := TTest.Create;

t.Subscribe(procedure begin end);

p := procedure begin if t = nil then end;
end;

Leak or no leak? And if leak, why?

SPOILER:

Because the compiler backs all anonymous methods inside of the same routine into the same instance this code just creates a circular reference of t to itself. In the code it looks like t just takes a reference to that do nothing TProc and then we have another almost do nothing TProc that captures t. Both should go away at the end of the routine, right? Well, no. Since both anonymous methods are in the same instance t implicitly keeps itself alive. You can only solve this by adding t := nil before the end. This will clear the captured variable and resolve the circular reference. Bloody annoying!

I think this has been reported before (probably by myself because I trapped into that some years ago already) but I cannot find the entry right now.

I cannot think of a good solution given how anonymous methods and variable capturing works. In this case only one of them captures a variable but multiple anonymous methods can capture the same variables so they need to be in a place that both of them can access and kept alive as long as one of the anonymous methods are alive.