Given the following:
struct Foo
{
int val;
ref Foo opUnary(string op : "++")()
{
++val;
return this;
}
}
struct Bar
{
Foo _foo;
alias _foo this;
void fun() { }
}
Bar bar;
... I would like to be able to say:
(++bar).fun();
... which would be lowered to:
(*cast(Bar*) ((cast(byte*) &++bar) +
Bar.init._foo.offsetof)).fun();
... except that it would be considered @safe.
The logic is that certain operators, like pre-increment and
assignment operators and such, can be assumed to be return a
reference to the operand variable (given that the operator
returns a ref to that type). Let's call this particular set of
operators X. The rule would then be: If a call to an operator is
re-routed through alias-this to a field of the operand, and the
operator is in X, and the operator returns a ref to the type of
the field, then the return value is implicitly converted to a ref
to the operand.
