Property references in Delphi - possible?

What is the worst thing about how bindings can be realized in Delphi? One may argue but I think it's the magic strings specifying what property to bind. I cannot think of any solution that could get rid of that. Using magic strings (and not only in that case) makes your software vulnerable to certain problems. Just mentioning a few:

• refactoring may break your code
• typos may break your code
• no possible compiler checks for correctness
• no code completion support

Well, a few versions ago we got method references. You prolly know how they are implemented behind the scenes but let's take a quick look at them. You can do something like (as defined in SysUtils):

type
  TFunc<T> = reference to function: T;

As you also may know this is a reference counted type. Guess how it is implemented? Correct, with an interface. This is similar to:

type
  IFunc<T> = interface
    function Invoke(): T;
  end;

You can even use those method reference types as Interface when you implement a class:

type
  TMyFuncClass = class(TInterfacedObject, TFunc<Integer>)
  public
    function Invoke: Integer;
  end;

Or you can inherit your interface from it (and of course implement that interface into your class):

type
  IFunc<T> = interface(TFunc<T>)
  end;

Ok, but we were talking about properties, right? Well a property basically is not much more than the combination of a function and a procedure - the getter and the setter.
We could define it like this:

type
  IProp<T> = interface
    function GetValue: T;
    procedure SetValue(Value: string);
    property Value: T read GetValue write SetValue;
  end;

So it is nothing more than (of course this does not work):

type
  IProp<T> = interface(TFunc<T>, TProc<T>)
    property Value: T read Invoke write Invoke;
  end;

But what you can do is this:

type
  TProp<T> = class(TInterfacedObject, TFunc<T>, TProc<T>)
  private
    function Invoke: T; overload;
    procedure Invoke(Value: T); overload;
  public
    property Value: T read Invoke write Invoke;
  end;

We can take this and use it as property reference passing it around, getting and setting values using RTTI but there we are again, how to create an instance? Yes, specifying the instance and the property by string. Another possibility would be with anonymous methods wrapping the property.

How about some built in type like this?

type
  TProp<T> = reference to property: T;

So I could write something like this:

procedure ShowAndInc(AProp: TProp<NativeInt>);
begin
  ShowMessageFmt('%d', [AProp]);
  AProp := AProp + 1; 
end;

procedure Form1Button1Click(Sender: TObject);
begin
  ShowAndInc(Self.Tag);
end;

What the compiler actually needs to do is something like this (ignoring possible read or write only properties for now):

ShowAndInc(TProp<NativeInt>.Create(
  function: NativeInt
  begin
    Result := Self.Tag;
  end,
  procedure(Value: NativeInt)
  begin
    Self.Tag := Value;
  end));

This is the code of my actual working TProp class and interface:

type
  IProp<T> = interface
    function Invoke: T; overload;
    procedure Invoke(Value: T); overload;
    property Value: T read Invoke write Invoke;
  end;

  TProp<T> = class(TInterfacedObject, IProp<T>)
  private
    FGetter: TFunc<T>;
    FSetter: TProc<T>;
    function Invoke: T; overload;
    procedure Invoke(Value: T); overload;
  public
    constructor Create(Getter: TFunc<T>; Setter: TProc<T>);
    property Value: T read Invoke write Invoke;
  end;

{ TProp<T> }

constructor TProp<T>.Create(Getter: TFunc<T>; Setter: TProc<T>);
begin
  FGetter := Getter;
  FSetter := Setter;
end;

function TProp<T>.Invoke: T;
begin
  Result := FGetter;
end;

procedure TProp<T>.Invoke(Value: T);
begin
  FSetter(Value);
end;

The compiler could do it way better by directly putting the call to the getter and setter into the right places.

So what do you think? Do you want reference to property in one of the next Delphi versions? Any drawbacks I am not seeing right now?