Anonymous method as a delegate method

When using an anonymous method as a delegate the compiler should either capture referenced external variables or disallow references to them. Currently the compiler treats anonymous delegates as closures. The following script reproduces this nice feature.

Smart pascal source code


{ filename: B.pas }
unit B;

interface

uses
  SmartCL.System;

type
  TEvent = procedure;

type
  TMyClass = class
  private
    FEvent: TEvent;
  public
    constructor Create;
    procedure DoIt;
    property Event: TEvent read FEvent write FEvent;
  end;

implementation

constructor TMyClass.Create;
begin
  var
  x := 'hello';
  FEvent := procedure
    begin
      WriteLn(x); // Displays 'hello'
      WriteLn(ClassName); // Displays 'TMyClass'
    end;
end;

procedure TMyClass.DoIt;
begin
  if (Assigned(FEvent)) then
    FEvent;
end;
end. 

{ filename: uMain.pas }
var MyClass: TMyClass;
  MyClass := TMyClass.Create;
  MyClass.DoIt; // displays 'hello' 'TMyClass'


var TMyClass = {
   $ClassName:"TMyClass",$Parent:TObject
   ,$Init:function ($) {
      TObject.$Init($);
      $.FEvent = null;
   }
   ,Create$5:function(Self) {
      var x$1 = "";
      x$1 = "hello";
      Self.FEvent = function () {
         WriteLn(x$1);
         WriteLn(TObject.ClassName(Self.ClassType));
      };
      return Self
   }
   ,DoIt:function(Self) {
      if (Self.FEvent) {
         Self.FEvent();
      }
   }
   ,Destroy:TObject.Destroy
};

var TApplication = {
   $ClassName:"TApplication",$Parent:TObject
   ,$Init:function ($) {
      TObject.$Init($);
   }
   ,RunApp:function(Self) {
      var MyClass = null;
      MyClass = TMyClass.Create$5($New(TMyClass));
      TMyClass.DoIt(MyClass);
   }
   ,Destroy:TObject.Destroy
};